Numpy [basique]

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!

0. À propos de l'installation

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.

1. Attributs de base

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

2.Faites une matrice

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

3. Imprimez la matrice

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

4. Les opérations mathématiques s'appliquent à tous les éléments

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

5. Itération par tranche d'index de la matrice

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

6. Changer la forme de la matrice

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

7. Synthétiser la matrice

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

8. Divisez la matrice

--np.hsplit (matrice, nombre): divise horizontalement en le nombre spécifié. --np.vsplit (matrice, nombre): divise verticalement en le nombre spécifié.

9. Copiez la matrice

--array.view (): copie superficielle en Python. Je ne pense pas que je l'utilise beaucoup. --array.copy (): copie profonde en Python.

Recommended Posts

Numpy [basique]
Mémo de calcul de base Numpy
Python Basic --Pandas, Numpy-
pratique numpy 1
numpy partie 1
Principes de base de NumPy
Mémorandum Numpy _ Matrice
astuces numpy
À propos de numpy
Commandes de base
Axe NumPy
Utilisez Numpy
numpy partie 2
Mon Numpy (Python)
Programmation réseau (basique)
où de numpy
RF Python Basic_01
Commande Linux <Basic 2>
Notes de base de Theano
test unitaire numpy
Mémo de base Flask
Fonctionnement du tableau NumPy (3)
list et numpy
Écriture de base Python
Fonction universelle NumPy
mémorandum numpy 1 / np.pad
Commandes LINUX de base
Les bases de #Python (#Numpy 1/2)
Les bases de #Python (#Numpy 2/2)
recherche d'index numpy
Grammaire de base Python3
Fonctionnement du tableau NumPy (1)
Commande Linux <Basic 1>
[Numpy] Shuffle ndarray
RF Python Basic_02
Principes de base de Python #Numpy
technique non basique de numpy
À propos de la diffusion Numpy
Mémorandum de base de Django
[PyTorch] Exemple ① ~ NUMPY ~
Installation de Numpy + Atlas
Certification Flask Basic
[Python] Mémo Numpy