Introduction récapitulative à l'utilisation des méthodes NumPy

NumPy est une extension de calcul numérique open source pour Python. Cet outil peut être utilisé pour stocker et traiter de grandes matrices et est beaucoup plus efficace que la propre structure list imbriquée de Python (qui peut également être utilisée pour représenter des matrices). NumPy (Numeric Python) fournit de nombreux outils de programmation numérique avancés, tels que : matrice type de données , traitement vectoriel et bibliothèques arithmétiques sophistiquées. Conçu pour une analyse rigoureuse des chiffres. Il est principalement utilisé par de nombreuses grandes sociétés financières, ainsi que par des organisations de calcul scientifique de base telles que Lawrence Livermore, et la NASA l'utilise pour gérer certaines tâches initialement effectuées à l'aide de C, Fortran ou Matlab.

Le type de données dans numpy, le type ndarray, est différent de array.array dans la bibliothèque standard.

Création de ndarray

>>> import numpy as np
>>> a = np.array([2,3,4])
>>> a
array([2, 3, 4])
>>> a.dtype
dtype('int64')
>>> b = np.array([1.2, 3.5, 5.1])
>>> b.dtype
dtype('float64')

Tableau bidimensionnel

>>> b = np.array([(1.5,2,3), (4,5,6)])
>>> b
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])

Spécifiez le type lors de la création

>>> c = np.array( [ [1,2], [3,4] ], dtype=complex )
>>> c
array([[ 1.+0.j,  2.+0.j],
       [ 3.+0.j,  4.+0.j]])

Créer des matrices spéciales

>>> np.zeros( (3,4) )
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
>>> np.ones( (2,3,4), dtype=np.int16 )                # dtype can also be specified
array([[[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]],
       [[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]]], dtype=int16)
>>> np.empty( (2,3) )                                 # uninitialized, output may vary
array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
       [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

Créer des matrices avec des règles spécifiques

>>> np.arange( 10, 30, 5 )
array([10, 15, 20, 25])
>>> np.arange( 0, 2, 0.3 )                 # it accepts float arguments
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])
>>> from numpy import pi
>>> np.linspace( 0, 2, 9 )                 # 9 numbers from 0 to 2
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
>>> x = np.linspace( 0, 2*pi, 100 )        # useful to evaluate function at lots of points
>>> f = np.sin(x)

Quelques opérations de base

Addition, soustraction, multiplication et division trigonométriquesFonctions Opérations logiques

>>> a = np.array( [20,30,40,50] )
>>> b = np.arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*np.sin(a)
array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a<35
array([ True, True, False, False], dtype=bool)

Opérations matricielles

Il y a .*,./ etc. dans matlab

Mais dans numpy, si vous utilisez,-,× ,/ a priorité Ce qui est effectué c'est l'addition, la soustraction, la multiplication et la division entre chaque point

Si deux matrices (matrices carrées) peuvent à la fois effectuer des opérations entre éléments et effectuer des opérations matricielles, les opérations entre éléments seront effectuées en premier

>>> import numpy as np
>>> A = np.arange(10,20)
>>> B = np.arange(20,30)
>>> A + B
array([30, 32, 34, 36, 38, 40, 42, 44, 46, 48])
>>> A * B
array([200, 231, 264, 299, 336, 375, 416, 459, 504, 551])
>>> A / B
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
>>> B / A
array([2, 1, 1, 1, 1, 1, 1, 1, 1, 1])

Si vous devez effectuer des opérations matricielles, il s'agit généralement d'une multiplication matricielle

>>> A = np.array([1,1,1,1])
>>> B = np.array([2,2,2,2])
>>> A.reshape(2,2)
array([[1, 1],
       [1, 1]])
>>> B.reshape(2,2)
array([[2, 2],
       [2, 2]])
>>> A * B
array([2, 2, 2, 2])
>>> np.dot(A,B)
8
>>> A.dot(B)
8

Certaines fonctions globales couramment utilisées

>>> B = np.arange(3)
>>> B
array([0, 1, 2])
>>> np.exp(B)
array([ 1.        ,  2.71828183,  7.3890561 ])
>>> np.sqrt(B)
array([ 0.        ,  1.        ,  1.41421356])
>>> C = np.array([2., -1., 4.])
>>> np.add(B, C)
array([ 2.,  0.,  6.])

Parcours de fragments d'index de matrice

>>> a = np.arange(10)**3
>>> a
array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
>>> a[2]
8
>>> a[2:5]
array([ 8, 27, 64])
>>> a[:6:2] = -1000    # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
>>> a
array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,   729])
>>> a[ : :-1]                                 # reversed a
array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1, -1000])
>>> for i in a:
...     print(i**(1/3.))
...
nan
1.0
nan
3.0
nan
5.0
6.0
7.0
8.0
9.0

Parcours de matrice

>>> import numpy as np
>>> b = np.arange(16).reshape(4, 4)
>>> for row in b:
...  print(row)
... 
[0 1 2 3]
[4 5 6 7]
[ 8  9 10 11]
[12 13 14 15]
>>> for node in b.flat:
...  print(node)
... 
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Opérations spéciales de la matrice

Changer la forme de la matrice - remodeler

>>> a = np.floor(10 * np.random.random((3,4)))
>>> a
array([[ 6.,  5.,  1.,  5.],
       [ 5.,  5.,  8.,  9.],
       [ 5.,  5.,  9.,  7.]])
>>> a.ravel()
array([ 6.,  5.,  1.,  5.,  5.,  5.,  8.,  9.,  5.,  5.,  9.,  7.])
>>> a
array([[ 6.,  5.,  1.,  5.],
       [ 5.,  5.,  8.,  9.],
       [ 5.,  5.,  9.,  7.]])

La différence entre redimensionner et remodeler

redimensionner changera la matrice d'origine, remodeler ne fera pas

>>> a
array([[ 6.,  5.,  1.,  5.],
       [ 5.,  5.,  8.,  9.],
       [ 5.,  5.,  9.,  7.]])
>>> a.reshape(2,-1)
array([[ 6.,  5.,  1.,  5.,  5.,  5.],
       [ 8.,  9.,  5.,  5.,  9.,  7.]])
>>> a
array([[ 6.,  5.,  1.,  5.],
       [ 5.,  5.,  8.,  9.],
       [ 5.,  5.,  9.,  7.]])
>>> a.resize(2,6)
>>> a
array([[ 6.,  5.,  1.,  5.,  5.,  5.],
       [ 8.,  9.,  5.,  5.,  9.,  7.]])

fusionner les matrices

>>> a = np.floor(10*np.random.random((2,2)))
>>> a
array([[ 8.,  8.],
       [ 0.,  0.]])
>>> b = np.floor(10*np.random.random((2,2)))
>>> b
array([[ 1.,  8.],
       [ 0.,  4.]])
>>> np.vstack((a,b))
array([[ 8.,  8.],
       [ 0.,  0.],
       [ 1.,  8.],
       [ 0.,  4.]])
>>> np.hstack((a,b))
array([[ 8.,  8.,  1.,  8.],
       [ 0.,  0.,  0.,  4.]])

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!