Je vais parcourir la documentation Numpy. Cette fois, c'est une partie assez basique. Si vous voulez lire le document directement, veuillez vérifier ici!
J'ai téléchargé Python depuis Anaconda, donc Numpy a été inclus dès le début.
Si vous ne l'avez pas, veuillez le télécharger depuis ici.
--array.ndim: représente les dimensions de la matrice. Cela correspond au nombre de "[" suivis au début. --array.shape: renvoie la forme de la matrice sous forme de tuple. --array.size: Le nombre total d'éléments dans la matrice. --array.dtype: représente le type de données de l'élément. En plus des types de données que Python peut gérer, il existe également des types de données spécifiques à numpy, tels que np.int64. De plus, dtype = 'complex' représente un nombre complexe. --array.itemsize: représente le nombre d'octets dans chaque élément. S'il est de type int64, il est de 8 octets.
--Créez une matrice à partir des types de données Python.
np.array([[1, 2, 3], [4, 5, 6]])
>>> array([1, 2, 3],
[4, 5, 6]])
--np.zeros (forme matricielle): prend un taple comme argument et renvoie une matrice avec tous les éléments 0 --np.ones (forme matricielle): Ceci renvoie une matrice dans laquelle tous les éléments sont 1.
np.zeros((3, 4))
>>> array([0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]])
--np.empty (forme matricielle): Crée une matrice avec des éléments aléatoires
np.empty((4, 5))
>>> array([[ 0.1 , 0.15, 0.2 , 0.25, 0.3 ],
[ 0.4 , 0.5 , 0.6 , 0.8 , 1. ],
[ 1.5 , 2. , 2.5 , 3. , 4. ],
[ 5. , 6. , 8. , 10. , 15. ]])
--np.arange (nombre d'éléments): similaire à range () de Python. Créez une matrice unidimensionnelle. --np.arange (a, b, c): Dans une telle forme, il commence par a, a des éléments ajoutés par c et continue jusqu'à ce que la valeur maximale inférieure à b soit prise.
np.arange(12)
>>> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
np.arange(10, 30, 5)
>>> array([10, 15, 20, 25])
--np.linspace (a, b, c): Renvoie une matrice linéaire avec c éléments à intervalles réguliers de a à b.
np.linspace(0, 2.0, 9)
>>> array([0., 0.25, 0.5, 0.75, 1., 1.25, 1.5, 1.75, 2.])
--np.random.rand (forme matricielle): renvoie une matrice dans laquelle chaque élément vaut 0 ou plus et 1 ou moins sous la forme donnée. --np.random.randn (forme matricielle): identique à ci-dessus, mais avec des éléments entiers.
--np.fromfunction (fonction, forme matricielle [, type de données]): Peut exprimer la relation entre le nombre de lignes et le nombre de colonnes.
np.fromfunction(lambda i,j: i+j, (3, 3), dtype='int64')
>>> array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4]])
Vous pouvez utiliser la méthode d'impression de python pour afficher une matrice propre sans virgules.
print(np.arange(12).reshape(3, 4))
>>> [[0 1 2 3]
[4 5 6 7]
[8 9 10 11]]
Lorsque vous ajoutez ou multipliez une matrice, l'opération est appliquée à tous les éléments.
a = np.array([10, 20, 30, 40])
b = np.array([1, 2, 3, 4])
a - b >>> array([9, 18, 27, 36])
b * 2 >>> array([2, 4, 6, 8])
a < 35 >>> array([True, True, True, False])
Si vous voulez le produit des matrices, utilisez la fonction dot ().
A = np.array([[1, 1], [0, 1]])
B = np.array([[2, 0], [3, 4]])
A * B >>> array([[2, 0],
[0, 4]]) #La multiplication des éléments correspondants est effectuée.
A.dot(B) / np.dot(A, B) >>> array([[5, 4],
[3, 4]])
Les valeurs totale, maximale et minimale peuvent être obtenues avec np.sum (), np.max () et np.min ().
Vous pouvez sélectionner l'axe que vous souhaitez utiliser.
a = np.arange(12).reshape(3, 4) >>> array([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11]])
a.sum(axis=0) >>> array([12, 15, 18, 21]) #Direction verticale
a.min(axis=1) >>> array([0, 4, 8]) #direction horizontale
Non seulement les matrices linéaires, mais aussi les matrices à dimensions multiples peuvent être gérées de la même manière que List en Python. Cependant, lorsque vous traitez une matrice à plusieurs dimensions comme un itérateur, utilisez l'attribut flat. C'est similaire à utiliser items () pour traiter un dictionnaire comme un itérateur!
A = np.arange(12).reshape(3, 4)
A[(0, 2)] >>> 2 #indice
A[1:2, 0:2] >>> array([[4, 5]]) #tranche
for element in A.flat:
print(element) >>> 0~Jusqu'à 11 sont imprimés
--np.floor (matrice): arrondissez chaque élément. (Je ne pense pas que cela ait quoi que ce soit à voir avec la forme, mais c'était écrit ici dans le document lol)
--np.ravel (matrice): convertit une matrice en une dimension. --array.reshape (matrice, nouvelle forme [, ordre]): remodèle la matrice à la forme désirée (l'ordre sera décrit plus tard). --array.T: donne la matrice de translocation.
order
The elements of a are read using this index order. ‘C’ means to index the elements in row-major, C-style order, with the last axis index changing fastest, back to the first axis index changing slowest. ‘F’ means to index the elements in column-major, Fortran-style order, with the first index changing fastest, and the last index changing slowest. Note that the ‘C’ and ‘F’ options take no account of the memory layout of the underlying array, and only refer to the order of axis indexing. ‘A’ means to read the elements in Fortran-like index order if a is Fortran contiguous in memory, C-like order otherwise. ‘K’ means to read the elements in the order they occur in memory, except for reversing the data when strides are negative. By default, ‘C’ index order is used.
Comme écrit, «C-style» donne la priorité à l'ordre des lignes, et «F-style» donne la priorité à l'ordre des colonnes.
A = np.arange(12).reshape(3, 4)
np.reshape(A, (2, 6), 'C') >>> array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
np.reshape(A, (2, 6), 'F') >>> array([[ 0, 8, 5, 2, 10, 7],
[ 4, 1, 9, 6, 3, 11]])
De plus, il y a des "A-style" et "K-style", mais je pense que ce ne sont pas les bases, donc je les expliquerai dans les prochains articles si j'en ai l'occasion.
--np.vstack ((matrice 1, matrice 2)): Combiner verticalement. --np.hstack ((matrice 1, matrice 2)): fusionne horizontalement.
--np.column_stack ((matrice 1, matrice 2)): Crée une matrice bidimensionnelle pour une combinaison de matrices linéaires, et se comporte de la même manière que hstack pour un ensemble multidimensionnel.
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.array([[1, 2], [3, 4]])
d = np.array([[5, 6], [7, 8]])
np.vstack((a, b)) >>> array([[1, 2, 3],
[4, 5, 6]])
np.hstack((a, b)) >>> array([1, 2, 3, 4, 5, 6])
np.column_stack((a, b)) >>> array([[1, 4],
[2, 5],
[3, 6]])
np.column_stack((c, d)) >>> array([[1, 2, 5, 6],
[3, 4, 7, 8]])
--np.newaxis: crée une nouvelle dimension.
a = np.array([4, 2])
b = np.array([[1, 2], [3, 4]])
a[:, np.newaxis] >>> array([[4],
[2]])
b[:, np.newaxis] >>> array([[[1, 2]],
[[3,4]]])
--np.hsplit (matrice, nombre): divise horizontalement en le nombre spécifié. --np.vsplit (matrice, nombre): divise verticalement en le nombre spécifié.
--array.view (): copie superficielle en Python. Je ne pense pas que je l'utilise beaucoup. --array.copy (): copie profonde en Python.
Recommended Posts