Introduction détaillée à l'utilisation courante de numpy

Introduction à numpy

L'existence de numpy permet à python de puissantes capacités de calcul matriciel, pas moins que matlab.
Document officiel (https://docs.scipy.org/doc/numpy-dev/user/quickstart.html)

Introduction aux divers usages

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

Quelques propriétés de ndarray

ndarray.ndim
le nombre d'axes (dimensions) du tableau. le nombre de dimensions est appelé rang.
ndarray.shape
les dimensions du tableau Il s'agit d'un tuple d'entiers indiquant la taille du tableau dans chacun dimension. Pour une matrice avec n lignes et m colonnes, la forme sera (n,m). La longueur du tuple de forme est donc le rang, ou nombre de dimensions, ndim.
ndarray.size<.>le nombre total d'éléments du tableau. Celui-ci est égal au produit des éléments de forme.
ndarray.dtype
un objet décrivant le type des éléments dans le tableau. On peut créer ou spécifier des types en utilisant des types Python standard. De plus, NumPy fournit ses propres types numpy.int32, numpy.int16 et numpy.float
64 en sont quelques exemples.ndarray.itemsize
la taille en octets de chaque élément du tableau Par exemple, un tableau d'éléments de type float64 a une taille d'élément de 8 (=64/8), tandis que
l'un des éléments. le type complex32 a itemsize 4 (=32/8). C'est équivalent à ndarray.dtype.itemsize.ndarray.data
le tampon contenant les éléments réels du tableau. nous n'aurons pas besoin d'utiliser cet attribut car nous accéderons aux éléments d'un tableau à l'aide de fonctionnalités d'indexation 🎜>
Spécifiez le type lors de la création

Créez des matrices spéciales

>>> 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')

Créer des matrices avec des motifs spécifiques

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

Quelques opérations de base

Addition, soustraction, multiplication et division trigonométrique

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

Fonction

Opérations logiques

>>> 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]])

Opérations matricielles

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

>>> 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)

Mais dans numpy, si vous utilisez, -, les opérations matricielles donneront la priorité aux opérations entre éléments

Si des opérations matricielles doivent être effectuées, il s'agit généralement d'une multiplication matricielle

Certaines

>>> 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)

fonctions globales couramment utilisées

Parcours de tranche d'index matriciel

>>> 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])

Parcours de la matrice

>>> 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

Opérations spéciales de la matriceChanger la forme de la matrice --reshape

>>> 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.])

La différence entre redimensionner et remodeler

>>> 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

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

>>> 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

fusionner les matrices

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!