Share
Numérique est un paquet qui a été à l'origine développé par Jim Hugunin. Il est considéré comme l'ancêtre de NumPy, une bibliothèque Python et un projet open-source créé par Travis Oliphant, qui signifie Numerical Python. Travis a créé NumPy en intégrant les fonctionnalités du Numarray package en numérique.
L'idée fondamentale de NumPy est le support des tableaux multidimensionnels. Ainsi, NumPy peut être considéré comme la base du calcul numérique en Python et a été créé pour permettre à Python d'être utilisé dans la résolution de problèmes mathématiques et scientifiques. Le module NumPy nous fournit des centaines de fonctions mathématiques utiles en plus de constantes telles que la base des logarithmes naturels (e) et pi (π).
Ce tutoriel montre comment utiliser NumPy pour travailler avec des tableaux multidimensionnels et décrit l'objet ndarray, un objet fondamental de la bibliothèque..
Puisque Python n’est pas fourni avec NumPy, la première étape pour utiliser cette bibliothèque est de l’installer et de l’installer. Cela peut être fait simplement en exécutant la commande suivante dans votre invite de commande:
pip installer numpy
Pour vous assurer que NumPy a été installé avec succès, exécutez les commandes suivantes dans IDLE de Python:
Si la importation instruction au moins fonctionne avec succès, alors vous êtes tous ensemble!
le Ndarray est un objet fondamental de NumPy. Cet objet est un N-tableau dimensionnel, ce qui signifie qu'il contient une collection d'éléments du même type indexés à l'aide de N (dimensions du tableau) entiers.
Les principaux attributs de Ndarray sont le type de données (type), forme, Taille, articlesize, Les données, et ndim. Apprenons ce que chaque attribut signifie à travers un exemple.
Dans cet exemple, nous allons utiliser NumPy pour créer un tableau. Je ne donnerai pas les dimensions du tableau et d'autres informations, car nous verrons qu'en utilisant les attributs ci-dessus.
Notez que nous avons utilisé le tableau fonction pour créer un tableau. La sortie du script ci-dessus est la suivante:
Revenons maintenant à nos attributs.
le type attribut peut être exécuté comme indiqué dans la déclaration suivante:
data_type = my_array.dtype
La déclaration ci-dessus va retourner int32 comme type de données. Cela signifie que les éléments du tableau sont de type int32. Je suis en train 32 comme j'utilise un Python 32 bits. Si vous utilisez un Python 64 bits, vous obtiendrez int64, mais nous avons affaire à des entiers à la fin.
NumPy étant utilisé en informatique scientifique, il comporte de nombreux types de données, comme indiqué dans la documentation. Notez que la majorité des types de données NumPy se terminent par un nombre, qui indique le nombre de bits associés à ce type (cela a été mentionné brièvement dans le paragraphe ci-dessus)..
Les exemples suivants montrent comment convertir un type en un autre:
bool (35) bool (0) bool (-1) float (True) int (67.7) float (87)
Les déclarations ci-dessus renvoient ce qui suit:
Vrai faux vrai 1,0 67 87,0
Bien que nous puissions convertir un type en un autre, il est important de noter que nous ne pouvons pas convertir un nombre complexe en entier ou en virgule flottante..
L'attribut shape renvoie un tuple des dimensions du tableau. Donc, la déclaration suivante:
array_shape = my_array.shape
reviendra (4,4), ce qui signifie que notre tableau est composé de 4 rangées et 4 des colonnes.
le Taille attribut renvoie le nombre d'éléments dans le tableau. Donc, si on tape:
array_size = my_array.size
Nous obtiendrons 16 à la suite, ce qui signifie que nous avons 16 éléments de notre tableau.
le articlesize attribut renvoie la taille d'un élément de tableau en octets. La déclaration suivante:
array_item_size = my_array.itemsize
reviendra 4. Cela signifie que chaque élément du tableau a une taille de 4 octets..
le Les données attribut est un objet tampon Python qui pointe au début des données du tableau. Si nous tapons ce qui suit:
array_location = my_array.data
nous aurons le suivant:
L'attribut ndim renverra le nombre de dimensions du tableau. Donc, en tapant la déclaration suivante:
array_dimension = my_array.ndim
reviendra 2, c'est le tableau se compose de deux dimensions.
Après avoir compris ce que les différents Ndarray attributs signifient, jetons un coup d'oeil à quelques exemples d'utilisation Ndarray.
Supposons que nous voulions créer un nouveau tableau avec une ligne et cinq colonnes. Nous ferions cela comme suit:
my_array = np.array ((1, 2, 3, 4, 5))
Le résultat de la déclaration ci-dessus est: [1 2 3 4 5].
Dans cet exemple, je vais réécrire le premier exemple de ce tutoriel, mais en utilisant [] au lieu de (), comme suit:
Cet exemple montre comment nous utilisons un type de données structuré, où nous déclarons le nom du champ et le type de données correspondant:
Accentsconagua
import numpy comme np height_type = np.dtype ([('height', np.float)])Si nous print (type_données), nous aurons le suivant:
[('la taille', 'Nous pouvons appliquer le type_hauteur à un Ndarray objet, comme suit:
import numpy comme np height_type = np.dtype ([('height', np.float)]) my_array = np.array ([1.78,), (1.69,), (1.88,)], dtype = height_type) # accéder au contenu de la colonne height print (my_array ['height'])Sélection d'éléments
Dans cette section, je vais vous montrer comment sélectionner des éléments spécifiques dans le tableau. Pour notre tableau présenté ci-dessus sous la section "ndarry Object", supposons que nous voulions sélectionner l'élément situé sur la troisième ligne et la quatrième colonne. Nous ferons cela comme suit:
my_array [2,3]
Rappelez-vous que l'indexation commence ici à 0, et c'est pourquoi nous avons écrit [2,3] au lieu de [3,4].
En savoir plus sur les tableaux NumPy
Dans cette section, nous allons approfondir les tableaux NumPy.
Tableaux vides (non initialisés)
Nous pouvons créer un tableau vide en utilisant numpy.empty avec la syntaxe suivante:
numpy.empty (forme, type, ordre)
Les significations des paramètres dans le constructeur ci-dessus sont les suivantes
- Forme: la forme (dimensions) du tableau vide.
- dtype: le type de sortie souhaité, facultatif.
- Ordre: si vous voulez un tableau de style C (ligne-majeur), vous devez taper
C; si vous voulez un tableau de style FORTRAN (column-major), vous devez taper F.
Alors créons un vide [2,2] tableau de type int. Nous pouvons le faire comme suit:
importer numpy comme np empty_array = np.empty ([2,2], dtype = int) print (empty_array)
Le script ci-dessus renverra les valeurs aléatoires suivantes, car le tableau n'a pas été initialisé:
[[1852795252 111218] [7500288 53018624]]
Tableau rempli de zéros
Afin de créer un tableau où les éléments sont tous des zéros, nous utilisons numpy.zeros. Le constructeur a la même syntaxe et les mêmes paramètres que dans numpy.empty. Donc, si on veut créer un [2,2] tableau de zéros de type int, nous pouvons le faire comme suit:
importer numpy en tant que np zeros_array = np.zeros ([2,2], dtype = int) print (zeros_array)
Le script ci-dessus renverra ce qui suit:
[[0 0] [0 0]]
Un tableau avec tous les éléments ayant la valeur 1 peut être simplement créé de la même manière que ci-dessus, mais avec numpy.ones.
Matrices avec des valeurs régulièrement espacées dans une plage donnée
On peut utiliser numpy.arange pour créer un tableau avec des valeurs régulièrement espacées dans une plage spécifiée. Le constructeur a le format suivant:
numpy.arange (start, stop, step, dtype)
Ci-dessous la signification de chaque paramètre:
- Début: c'est ici que commence l'intervalle. La valeur par défaut est
0. - Arrêtez: la fin de l'intervalle, à condition que ce nombre ne soit pas inclus.
- Étape: l'espacement entre les valeurs. La valeur par défaut est
1. - dtype: le type de données de la sortie. Si non spécifié, le type de données sera le même que celui de l'entrée.
Prenons un exemple de numpy.arange.
importer numpy en tant que np my_array = np.arange (1,10) print (my_array)
Le résultat du script ci-dessus est:
[1 2 3 4 5 6 7 8 9]
Remodeler un tableau
Afin de remodeler un tableau, nous utilisons le numpy.reshape une fonction. Cette fonction donne une nouvelle forme à un tableau sans changer ses données. Comme indiqué dans la documentation, la fonction possède les attributs suivants: numpy.reshape (a, newshape, order = "C"), où une est le tableau que nous aimerions remodeler, nouvelle forme est la nouvelle forme souhaitée à condition que la nouvelle forme soit compatible avec la forme d'origine, et ordre est un argument optionnel qui fait référence à l'ordre d'index que nous aimerions utiliser pour lire le tableau une et comment nous aimerions placer les éléments dans le tableau remodelé.
C signifie lire / écrire les éléments en utilisant l'ordre d'index de type C; F signifie lire / écrire les éléments en utilisant l'ordre d'index de type Fortran, et UNE signifie lire / écrire les éléments dans l'ordre d'index de type Fortran si une le Fortran est-il contigu en mémoire, sinon comme dans l'ordre C.
Je sais que j'ai beaucoup couvert dans le paragraphe ci-dessus, mais le concept est très simple. Prenons notre tableau d'origine my_array et essayez de le remodeler. Rappelez-vous que le nouveau tableau (tableau remodelé) doit être compatible avec le tableau d'origine. Par exemple, my_array a la forme (4,4), c'est nous avons 16 éléments dans le tableau, et le nouveau tableau doit avoir ce nombre d'éléments.
Nous pouvons remodeler my_array en le configurant pour avoir huit lignes et deux colonnes, comme suit:
import numpy comme np my_array = np.array (((6, 12, 93, 2), (5, 26, 78, 90), (3, 12, 16, 22), (5, 3, 1, 16) )) my_array_reshaped = np.reshape (my_array, (8,2))
Dans ce cas, nous aurions la sortie suivante, où nous avons aussi 16 éléments.
[[6 12] [93 2] [5 26] [78 90] [3 12] [16 22] [5 3] [1 16]]
Que faire si nous écrivons la déclaration reshape comme suit?
my_array_reshaped = np.reshape (my_array, (8,3))
Dans ce cas, vous obtiendrez l'erreur suivante:
ValueError: impossible de remettre en forme un tableau de taille 16 (8,3)
Concaténer des tableaux
Si nous voulons joindre deux ou plusieurs tableaux de même forme le long d’un axe spécifique, nous pouvons utiliser le numpy.concatenate une fonction. La syntaxe de cette fonction est la suivante: numnumpy.concatenate ((a1, a2,…), axis = 0) y.concatenate. a1 et a2 sont des tableaux ayant la même forme, et axe est l’axe le long duquel les tableaux seront joints, à condition que la valeur par défaut soit 0.
Encore une fois, prenons un exemple pour simplifier le concept. Dans cet exemple, nous allons joindre (concaténer) trois tableaux.
import numpy en tant que np array_1 = np.array (((1, 2), (3, 4))) array_2 = np.array (((5, 6), (7, 8))) array_3 = np.array ( ((9, 10), (11, 12))) contact_array = np.concatenate ((array_1, array_2, array_3)) print ('Premier tableau:') print (array_1) print ('Second tableau:') print ( array_2) print ('Third Array:') print (array_3) print ('Concatenated Array:') print (contact_array)La sortie du code ci-dessus est la suivante:
Premier tableau: [[1 2] [3 4]] Deuxième tableau: [[5 6] [7 8]] Troisième tableau: [[9 10] [11 12]] Tableau concaténé: [[1 2] [3 4 ] [5 6] [7 8] [9 10] [11 12]]
Fractionner des tableaux
Contrairement à la jonction de tableaux, comme indiqué dans la section ci-dessus, voyons comment diviser (diviser) un tableau en plusieurs sous-tableaux. Cela peut être fait en utilisant la fonction suivante:
numpy.split (ary, indices_ou_sections, axe = 0)
ary est le tableau à diviser en sous-tableaux. En ce qui concerne indices_ou_sections, si c'est un entier N, le tableau sera divisé en N tableaux égaux le long du axe. S'il s'agit d'un tableau 1-D d'entiers triés, les entrées indiquent où, le long du axe le tableau est divisé. axe est l'axe le long duquel se fendre.
L'exemple suivant inversera ce que nous avons fait dans l'exemple précédent, à savoir renvoyer le tableau concaténé dans ses trois constituants:
import numpy sous np concatenated_array = np.array (((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12))) split_array = np.split (concatenated_array, 3) print ('Tableau original:') print (concatenated_array) print ('Fractionner les sous-tableaux:') print ('Premier sous-tableau') print (split_array [0]) print ('Second Sous-tableau ') print (split_array [1]) print (' Troisième sous-tableau ') print (split_array [2])La sortie du script ci-dessus est:
Tableau d'origine: [[1 2] [3 4] [5 6] [7 8] [9 10] [11 12]] Sous-tableaux divisés: premier sous-tableau [[1 2] [3 4]] deuxième sous-tableau tableau [[5 6] [7 8]] troisième sous-tableau [[9 10] [11 12]]
Conclusion
Comme nous l'avons vu dans ce didacticiel, NumPy rend le travail avec les tableaux très flexible. Le tutoriel était juste une égratignure à la surface de cette intéressante bibliothèque Python. NumPy a encore de nombreuses fonctionnalités à explorer pour tirer le meilleur parti de cette bibliothèque. Guide complet sur le sujet, rédigé par le créateur de NumPy: Guide to NumPy.
De plus, voyez ce que nous avons à vendre et à étudier sur le marché, et n'hésitez pas à poser des questions et à fournir vos précieux commentaires en utilisant le flux ci-dessous.
