Tableaux NumPy : une introduction [avec exemples]
Publié: 2022-12-08Vous cherchez à démarrer avec NumPy ? Ce guide vous apprendra les bases des tableaux NumPy en Python.
Dans un premier temps, vous apprendrez comment les tableaux NumPy fonctionnent différemment des listes Python. Vous apprendrez ensuite plusieurs façons de créer des tableaux NumPy et d'effectuer des opérations de base sur ceux-ci.
Commençons!
Principes de base des tableaux NumPy
NumPy est l'une des bibliothèques Python les plus populaires pour le calcul scientifique et l'analyse de données. Les structures de données de base dans NumPy sont des tableaux à N dimensions (tableaux ND). Ils ont des capacités de diffusion et nous permettent de vectoriser les opérations pour la vitesse et d'utiliser des fonctions mathématiques intégrées pour l'amélioration des performances.
Pour commencer à travailler avec NumPy, vous devez d'abord installer la bibliothèque et l'importer dans votre environnement de travail. Il est disponible sous la forme d'un package PyPI installable via pip.
Pour installer NumPy, ouvrez votre terminal et exécutez la commande suivante :
pip3 install numpy Après avoir installé NumPy, vous pouvez l'importer dans votre environnement de travail sous un alias. L'alias habituel est np .
import numpy as npRemarque : L'importation de NumPy sous l'alias
npn'est pas une obligation, mais une convention recommandée.
Listes Python vs tableaux NumPy
Considérez la liste de nombres Python suivante :
py_list = [1,2,3,4] Vous pouvez obtenir un tableau NumPy à partir d'une liste existante en appelant la fonction np.array() avec la liste comme argument.
np_arr1 = np.array(py_list) print(np_arr1) [1 2 3 4] Pour vérifier le type de np_arr1 , vous appelez la fonction intégrée type() , vous verrez qu'il s'agit de ndarray , la structure de données fondamentale de NumPy.
type(np_arr1) # numpy.ndarrayBien que la liste Python et le tableau NumPy puissent sembler similaires, il existe certaines différences :
- Une liste Python peut contenir des objets de différents types de données, alors qu'un tableau NumPy contient des éléments du même type de données. Le type de données par défaut est float avec une précision de 64 bits (float64).
- Les éléments d'une liste Python ne sont pas nécessairement stockés dans des emplacements contigus en mémoire. Cependant, les éléments d'un tableau NumPy sont stockés dans un bloc contigu en mémoire. Par conséquent, il est plus rapide de rechercher et d'accéder aux éléments.
Passons en revue quelques autres différences.
Diffusion
Une fonctionnalité puissante des tableaux NumPy est la diffusion. Supposons que nous souhaitions ajouter 2 à tous les éléments de np_arr1 et py_list .
Essayons d'ajouter 2 à py_list et voyons ce qui se passe :
>>> py_list + 2Nous voyons que nous obtenons une TypeError indiquant que nous ne pouvons concaténer que deux listes, et l'ajout de py_list + 2 comme celui-ci n'est pas pris en charge.
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-5-c0f9974899df> in <module> ----> 1 py_list + 2 TypeError: can only concatenate list (not "int") to list Essayons la même opération sur le tableau, np_arr1 .
>>> np_arr1 + 2Dans le résultat, nous voyons que 2 a été ajouté à chaque élément du tableau.
array([3, 4, 5, 6])En effet, NumPy a implicitement diffusé le scalaire 2 dans un tableau de forme compatible pour obtenir ce résultat.
Vectorisation
Les tableaux NumPy prennent en charge la vectorisation pour des opérations plus rapides par élément. Supposons que nous souhaitions trouver la somme par élément des deux tableaux.
Utiliser une simple opération + sur la liste renverrait la concaténation des deux listes (ce qui n'est pas ce que nous voulons !).
>>> py_list + py_list # [1, 2, 3, 4, 1, 2, 3, 4] Mais la même opération sur le tableau NumPy, np_arr1 , renvoie la somme élément par élément de np_arr1 avec lui-même.
>>> np_arr1 + np_arr1 # array([2, 4, 6, 8])De même, les listes imbriquées peuvent avoir une structure similaire à un tableau NumPy à N dimensions. Cependant, les différences discutées jusqu'à présent tiennent.
nested_list = [[1,2],[3,4],[5,6]] np_arr2 = np.array(nested_list) print(np_arr2) [[1 2] [3 4] [5 6]]Comment créer des tableaux NumPy
Vous pouvez toujours créer des tableaux NumPy à partir de listes Python existantes à l'aide np.array(list-obj) . Cependant, ce n'est pas le moyen le plus efficace.
Au lieu de cela, vous pouvez utiliser plusieurs fonctions intégrées qui vous permettent de créer des tableaux d'une forme spécifique. La forme du tableau est un tuple qui indique la taille du tableau le long de chaque dimension. Par exemple, la forme d'un tableau 2 × 2 avec deux lignes et deux colonnes est (2,2). Dans cette section, nous allons apprendre à utiliser certaines de ces fonctions intégrées.
Création de tableaux de zéros et de uns
Il est souvent utile de créer un tableau de dimensions spécifiques contenant uniquement des zéros ou des uns. Ensuite, utilisez-les et modifiez-les dans les étapes suivantes du programme.
Nous pouvons utiliser la fonction zeros() pour créer un tableau de zéros. Transmettez la forme du tableau requis sous forme de tuple : np.zeros(shape) .
array0 = np.zeros((3,3)) print(array0)Voici le résultat, un tableau 2D de zéros :
[[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]] Vous pouvez accéder aux attributs du tableau NumPy, appeler des attributs tels que dtype et shape , en utilisant la notation par points, comme indiqué ci-dessous :
print(array0.dtype) # float64 print(array0.shape) # (3, 3) Pour obtenir un tableau de uns, vous pouvez utiliser la fonction np.ones() .
array1 = np.ones((3,3)) print(array1) [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]Création d'une matrice d'identité
La matrice d'identité est largement utilisée dans plusieurs applications en algèbre linéaire. Et vous pouvez utiliser la fonction np.eye() pour créer une matrice d'identité. La fonction np.eye() ne prend qu'un seul argument : l'ordre de la matrice ( n ).
arrayi = np.eye(3) print(arrayi) [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]Création de tableaux de nombres aléatoires
Vous pouvez également créer des tableaux d'une forme spécifique remplis de nombres aléatoires tirés de distributions spécifiques. Les distributions de probabilité couramment utilisées sont la distribution uniforme et la distribution normale standard.
La fonction randn() , qui fait partie du module random de NumPy, peut être utilisée pour générer des tableaux de nombres échantillonnés à partir d'une distribution normale standard . La distribution normale standard est une distribution gaussienne avec une moyenne nulle et une variance unitaire.
std_arr = np.random.randn(3,4) print(std_arr) [[-0.13604072 1.21884359 2.06850932 0.78212093] [ 0.44314719 -0.78084801 -0.70517138 1.17984949] [ 1.13214829 1.02339351 0.15317809 1.83191128]] np.random.rand() renvoie un tableau d'échantillons de nombres à partir d'une distribution uniforme sur l'intervalle [0,1).
uniform_arr = np.random.rand(2,3) print(uniform_arr) [[0.90470384 0.18877441 0.10021817] [0.741 0.10657658 0.71334643]] Vous pouvez également créer un tableau d'entiers aléatoires à l'aide de la fonction randint() qui fait partie du module random de NumPy. np.random.randint(low, high, size) renvoie un tableau d'entiers. La forme du tableau est déduite de l'argument size et les entiers prennent des valeurs dans l'intervalle [low,high) .
Voici un exemple :
int_arr = np.random.randint(1,100,(2,3)) print(int_arr) [[53 89 33] [24 85 33]]Autres fonctions intégrées utiles
Ensuite, passons en revue quelques autres fonctions utiles pour créer des tableaux NumPy.
La fonction arange() renvoie un tableau de nombres entre une valeur de start et une valeur d' stop par pas d'une valeur de step : start , start + step , start + 2*step up to mais non inclus stop . Les valeurs de start et de step sont facultatives . La taille de pas par défaut est 1 et la valeur de départ par défaut est 0.
Dans cet exemple, array_a est un tableau de nombres commençant à 1 et allant jusqu'à 10 sans l'inclure par pas de 0,5.
array_a = np.arange(1,10,0.5) print(array_a) [1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5] Vous pouvez également créer des tableaux de nombres régulièrement espacés à l'aide np.linspace() . Utilisez np.linspace(start, stop, num) pour obtenir un tableau de num nombres régulièrement espacés entre les valeurs de start et stop .
Ici, arr_lin est un tableau de 5 nombres régulièrement espacés dans l'intervalle [1,10].
array_lin = np.linspace(1,10,5) print(array_lin) [ 1. 3.25 5.5 7.75 10. ] De même, arr_lin2 est un tableau de 10 nombres régulièrement espacés dans l'intervalle [1,20].
array_lin2 = np.linspace(1,20,10) print(array_lin2) [ 1. 3.11111111 5.22222222 7.33333333 9.44444444 11.55555556 13.66666667 15.77777778 17.88888889 20. ] Contrairement à la fonction arange() , la fonction linspace() inclut le point de terminaison par défaut.
Opérations de base sur les tableaux NumPy
Ensuite, passons en revue certaines des opérations de base sur les tableaux NumPy.
Recherche des éléments minimum et maximum
Chaque fois que nous utilisons des fonctions du module random de NumPy pour créer des tableaux, nous obtenons un résultat différent à chaque exécution du code. Pour obtenir des résultats reproductibles, nous devons définir une graine : np.random.seed(seed_value) .
Dans l'exemple suivant, j'ai défini la graine pour la reproductibilité, int_arr1 est un tableau de sept entiers aléatoires dans l'intervalle [1 100).
np.random.seed(27) int_arr1 = np.random.randint(1,100,7) print(int_arr1) # [20 57 73 32 57 38 25]- Pour trouver l'élément maximum dans le tableau, vous pouvez appeler la méthode
max()sur l'objet tableau,int_arr1, et - Pour trouver l'élément minimum dans le tableau, vous pouvez appeler la méthode
min()sur l'objet tableau,int_arr1.
int_arr1.max() # 73 int_arr1.min() # 20Trouver l'indice des éléments maximum et minimum
Parfois, vous devrez peut-être trouver l'index des éléments maximum et minimum. Pour ce faire, vous pouvez appeler les méthodes argmax() et argmin() sur l'objet tableau.
Ici, l'élément maximum 73 se produit à l'indice 2.
int_arr1.argmax() # 2Et l'élément minimum 20 se produit à l'indice 0.
int_arr1.argmin() # 0Vous pouvez également utiliser
np.argmax(array)etnp.argmin(array)pour trouver les indices des éléments maximum et minimum, respectivement. En savoir plus sur la fonction NumPyargmax().
Comment concaténer des tableaux NumPy
Une autre opération courante que vous pouvez effectuer avec les tableaux NumPy est la concaténation.
Concaténation verticale à l'aide de vstack
Vous pouvez concaténer des tableaux verticalement à l'aide de la fonction vstack() .
Voici un exemple. arr1 est un tableau de uns avec deux lignes et trois colonnes et arr2 est un tableau de zéros sur deux lignes et trois colonnes.
arr1 = np.ones((2,3)) arr2 = np.zeros((2,3)) Nous pouvons concaténer ces deux tableaux verticalement en utilisant la fonction vstack() comme indiqué :
np.vstack((arr1,arr2)) array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]])Comme l'empilement se produit verticalement, les deux tableaux doivent avoir le même nombre de colonnes .
arr2 pour qu'il ait la forme (2,2). Il a maintenant deux lignes et deux colonnes.
arr1 = np.ones((2,3)) arr2 = np.zeros((2,2)) np.vstack((arr1,arr2))Par conséquent, la concaténation verticale n'est pas possible et nous obtenons une ValueError.
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-21-d5d3bf37fc21> in <module> ----> 1 np.vstack((arr1,arr2)) ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 3 and the array at index 1 has size 2Concaténation horizontale à l'aide de hstack
Vous pouvez concaténer des tableaux NumPy horizontalement à l'aide de la fonction hstack() , comme indiqué ci-dessous.
arr1 = np.ones((3,3)) arr2 = np.zeros((3,2)) np.hstack((arr1,arr2)) Étant donné que l'empilement se produit horizontalement, les tableaux d'entrée doivent avoir le même nombre de lignes . Ici, arr1 et arr2 ont trois lignes.
array([[1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.]])Utiliser la concaténation
Vous pouvez également utiliser des tableaux NumPy concaténés le long d'un axe spécifique à l'aide de la fonction concatenate() . Définissez l'argument d' axis facultatif sur l'axe que vous souhaitez concaténer ; la valeur par défaut de l'axe est zéro.
Voici quelques exemples:
arr1 = np.ones((2,3)) arr2 = np.zeros((2,3)) Lorsque nous ne spécifions pas l'axe à concaténer, les tableaux sont concaténés le long de l'axe 0. Dans le tableau résultant, le deuxième tableau arr2 est ajouté (sous forme de lignes) sous le premier tableau.
np.concatenate((arr1,arr2)) array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]]) Lorsque nous spécifions axis = 1 , nous obtenons le résultat suivant. arr2 est concaténé (en colonnes) à côté du premier tableau, arr1 .
np.concatenate((arr1,arr2),axis=1) array([[1., 1., 1., 0., 0., 0.], [1., 1., 1., 0., 0., 0.]]) Comme pour les hstack() et vstack() , les dimensions des tableaux le long de l'axe de concaténation doivent correspondre .
Conclusion
Dans ce didacticiel, vous avez appris les différences entre les tableaux NumPy et les listes Python, en mettant l'accent sur les avantages des tableaux à N dimensions en termes de vitesse et d'efficacité.
Vous avez également appris plusieurs fonctions utiles pour créer des tableaux d'une dimension particulière et effectuer des opérations courantes, telles que la recherche des éléments minimum et maximum, la concaténation de tableaux, etc.
Ensuite, apprenez à remodeler les tableaux NumPy.