Numpy 45 méthodes essentielles

NumPy (ou Numeric Python) est au cœur de tout projet de science des données (data science) et d’apprentissage automatique (machine learning).

L’ensemble de l’écosystème de la donnée repose, d’une manière ou d’une autre, sur NumPy et ses fonctions essentielles. Cela en fait l’une des bibliothèques les plus importantes et les plus révolutionnaires jamais développées en Python.

Étant donné les vastes applications de NumPy dans l’industrie comme dans le monde universitaire, une bonne maîtrise de ses méthodes et de sa syntaxe est une nécessité absolue pour les programmeurs Python.

Cependant, si tu es débutant et que tu essayes de prendre en main la bibliothèque NumPy, les choses peuvent rapidement paraître intimidantes et complexes, surtout si tu commences par la documentation officielle.

Étant moi-même passé par là, cet article a pour but de t’aider à bien démarrer avec NumPy.

En d’autres termes, dans cet article, je vais m’appuyer sur mes années d’expérience avec NumPy pour te partager les 45 méthodes spécifiques que j’ai utilisées presque tout le temps.

C’est parti ! 🚀

Importer la bibliothèque

Bien sûr, si tu veux utiliser la bibliothèque NumPy, tu dois d’abord l’importer.

La convention largement adoptée consiste à définir l’alias de numpy comme np. Nous utiliserons également pandas çà et là, alors importons-le aussi.

import numpy as np
import pandas as pd
Python

1–10) Méthodes de création d’un tableau NumPy

Ci-dessous figurent quelques-unes des méthodes les plus courantes pour créer un tableau NumPy.

#1) À partir d’une liste Python

Pour convertir une liste Python en tableau NumPy, utilise la méthode np.array() :

a = [1, 2, 3]
np.array(a)
Python
array([1, 2, 3])

Tu peux vérifier le type d’objet créé à l’aide de la méthode type disponible en Python :

a = [1, 2, 3]
type(np.array(a))
Python
numpy.ndarray

Dans l’exemple ci-dessus, nous avons créé un tableau unidimensionnel.

Tableau unidimensionnel
Tableau unidimensionnel

Cependant, tu peux également créer un tableau NumPy multidimensionnel en utilisant une liste de listes avec la méthode np.array() :

a = [[1,2,3], [4,5,6]]
np.array(a)
Python
array([[1, 2, 3],
       [4, 5, 6]])
Tableau bidimensionnel
Tableau bidimensionnel

Pour créer un tableau NumPy avec un type de données spécifique, utilise l’argument dtype :

a = [[1,2,3], [4,5,6]]
np.array(a, dtype = np.float32)
Python
array([[1., 2., 3.],
       [4., 5., 6.]], dtype=float32)

#2) Créer un tableau NumPy plein de zéros

Il est courant de créer un tableau NumPy rempli de zéros. Cela est possible en utilisant la méthode np.zeros() comme suit :

np.zeros(5)
Python
array([0., 0., 0., 0., 0.])

Pour les tableaux NumPy multidimensionnels :

np.zeros((2, 3))
Python
array([[0., 0., 0.],
       [0., 0., 0.]])

#3) Créer un tableau NumPy plein de 1

Si tu souhaites créer un tableau rempli de 1 au lieu de 0, utilise la méthode np.ones() :

np.ones((2, 3))
Python
array([[1., 1., 1.],
       [1., 1., 1.]])

#4) Créer une matrice identité NumPy

Dans une matrice identité, la diagonale contient des “1” et toutes les autres entrées sont des “0”, comme illustré ci-dessous :

Matrice identité
Matrice identité

Utilise la méthode np.eye() pour créer une matrice identité :

np.eye(3)
Python
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

#5) Créer un tableau NumPy avec des valeurs espacées à intervalles réguliers

Tableau numpy espacement égal

Pour générer des valeurs régulièrement espacées dans un intervalle donné, utilise la méthode np.arange() :

  • Générer des valeurs de start = 0 à stop = 10 avec step = 1 :
np.arange(10)
Python
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  • Générer des valeurs de start = 5 à stop = 11 avec step = 1 :
np.arange(5, 11)
Python
array([ 5,  6,  7,  8,  9, 10])
  • Générer des valeurs de start = 5 à step = 11 avec step = 2.
np.arange(5, 11, 2)
Python
array([5, 7, 9])

La valeur de stop n’est pas incluse dans le tableau final et, par défaut, step = 1.

#6) Créer un tableau NumPy avec un nombre donné de valeurs régulièrement espacées

Ceci est similaire à np.arange(), mais avec np.linspace(), tu peux générer un nombre précis de valeurs dans un intervalle qui sont également espacées :

np.linspace(start = 10, stop = 20, num = 5)
Python
array([10. , 12.5, 15. , 17.5, 20. ])

#7–8) Générer un tableau NumPy aléatoire

  • Pour générer un tableau aléatoire d’entiers, utilise la méthode np.random.randint() :
np.random.randint(low = 5, high = 16, size = 5)
Python
array([12,  9,  8,  8, 13])
  • Pour générer des échantillons flottants aléatoires, utilise la méthode np.random.random() :
np.random.random(size = 10)
Python
array([0.13011502, 0.13624477, 0.63199788, 0.62565385, 0.47521946,
       0.31121428, 0.11785969, 0.49575226, 0.77330761, 0.77047183])

#9–10) Générer un tableau NumPy à partir d’une série Pandas

Si tu souhaites convertir une série Pandas en tableau NumPy, tu peux le faire en utilisant soit la méthode np.array() soit np.asarray() :

s = pd.Series([1,2,3,4], name = "col")
np.array(s)
Python
array([1, 2, 3, 4])
s = pd.Series([1,2,3,4], name = "col")
np.asarray(s)
Python
array([1, 2, 3, 4])

11–21) Méthodes de manipulation de tableaux NumPy

Ensuite, nous aborderons certaines des méthodes les plus largement utilisées pour manipuler un tableau NumPy.

#11) Forme du tableau NumPy

Tu peux déterminer la forme du tableau NumPy en utilisant la méthode np.shape() ou l’attribut ndarray.shape du tableau NumPy comme suit :

a = np.ones((2, 3))
print("Forme du tableau - Méthode 1 :", np.shape(a))
print("Forme du tableau - Méthode 2 :", a.shape)
Python
Forme du tableau - Méthode 1 : (2, 3)
Forme du tableau - Méthode 2 : (2, 3)

#12) Redimensionner le tableau NumPy

Le redimensionnement consiste à donner une nouvelle forme à ton tableau NumPy sans changer ses données.

Remodeler tableau

Tu peux modifier la forme en utilisant la méthode np.reshape() :

a = np.arange(10)
a.reshape((2, 5))
Python
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

#13–14) Transposer le tableau NumPy

Transposer tableau

Si tu veux transposer un tableau NumPy, tu peux le faire en utilisant la méthode np.transpose() ou ndarray.T comme démontré ci-dessous :

a = np.arange(12).reshape((6, 2))
a.transpose()
Python
array([[ 0,  2,  4,  6,  8, 10],
       [ 1,  3,  5,  7,  9, 11]])
a = np.arange(12).reshape((6, 2))
a.T
Python
array([[ 0,  2,  4,  6,  8, 10],
       [ 1,  3,  5,  7,  9, 11]])

#15–17) Concaténer plusieurs tableaux NumPy pour former un seul tableau NumPy

Tu peux utiliser la méthode np.concatenate() pour joindre une séquence de tableaux et obtenir un nouveau tableau NumPy :

Concaténer tableaux
## Concaténer en ligne
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
np.concatenate((a, b), axis=0)
Python
array([[1, 2],
       [3, 4],
       [5, 6]])
Concaténer par ligne
## Concaténer en colonnes
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
np.concatenate((a, b.T), axis=1)
Python
array([[1, 2, 5],
       [3, 4, 6]])
## Concaténer pour générer un tableau NumPy applati
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
np.concatenate((a, b), axis=None)
Python
array([1, 2, 3, 4, 5, 6])

#18) Aplatir un tableau NumPy

Aplatir tableau

Si tu veux réduire l’ensemble du tableau NumPy à une seule dimension, tu peux utiliser la méthode ndarray.flatten() comme montré ci-dessous :

a = np.array([[1,2], [3,4]])
a.flatten()
Python
array([1, 2, 3, 4])

#19) Éléments uniques d’un tableau NumPy

Pour déterminer les éléments uniques d’un tableau NumPy, utilise la méthode np.unique() comme démontré ci-dessous :

a = np.array([[1, 2], [2, 3]])
np.unique(a)
Python
array([1, 2, 3])
## Retourner les lignes uniques
a = np.array([[1, 2, 3], [1, 2, 3], [2, 3, 4]])
np.unique(a, axis=0)
Python
array([[1, 2, 3],
       [2, 3, 4]])
## Retourner les colonnes uniques
a = np.array([[1, 1, 3], [1, 1, 3], [1, 1, 4]])
np.unique(a, axis=1)
Python
array([[1, 3],
       [1, 3],
       [1, 4]])

#20) Comprimer un tableau NumPy

Si tu veux supprimer les axes de longueur un de ton tableau NumPy, utilise la méthode np.squeeze(). Ceci est illustré ci-dessous : 

x = np.array([[[0], [1], [2]]])

>>> x.shape
(1, 3, 1)

np.squeeze(x).shape
Python
(3,)

#21) Transformer un tableau NumPy en liste Python

Pour obtenir une liste Python à partir d’un tableau NumPy, utilise la méthode ndarray.tolist() comme montré ci-dessous :

a = np.array([[1, 1, 3], [1, 1, 3], [1, 1, 4]])
a.tolist()
Python
[[1, 1, 3], [1, 1, 3], [1, 1, 4]]

22–33) Opérations mathématiques sur les tableaux NumPy

NumPy offre une large variété de fonctions mathématiques élément par élément que vous pouvez appliquer aux tableaux NumPy. Tu peux lire toutes les opérations mathématiques disponibles ici. Ci-dessous, discutons de certaines des plus couramment utilisées.

#22–24) Fonctions trigonométriques

a = np.array([1,2,3])
print("Sinus trigonométrique :", np.sin(a))
print("Cosinus trigonométrique :", np.cos(a))
print("Tangente trigonométrique :", np.tan(a))
Python
Sinus trigonométrique : [0.84147098 0.90929743 0.14112001]
Cosinus trigonométrique : [ 0.54030231 -0.41614684 -0.9899925 ]
Tangente trigonométrique : [ 1.55740772 -2.18503986 -0.14254654]

#25–28) Fonctions d’arrondi

  • Retourner la partie entière inférieure élément par élément en utilisant la méthode np.floor().
  • Retourner la partie entière supérieure élément par élément en utilisant la méthode np.ceil().
  • Arrondir à l’entier le plus proche en utilisant la méthode np.rint().
>>> a = np.linspace(1, 2, 5)
array([1.  , 1.25, 1.5 , 1.75, 2.  ])

>>> np.floor(a)
array([1., 1., 1., 1., 2.])

>>> np.ceil(a)
array([1., 2., 2., 2., 2.])

>>> np.rint(a)
array([1., 1., 2., 2., 2.])
Python
  • Arrondir à un nombre donné de décimales en utilisant la méthode np.round_() :
a = np.linspace(1, 2, 7)
np.round_(a, 2) # 2 décimales
Python
array([1.  , 1.17, 1.33, 1.5 , 1.67, 1.83, 2.  ])

#29–30) Exponentielles et logarithmes

  • Calculer l’exponentielle élément par élément en utilisant la méthode np.exp().
  • Calculer le logarithme naturel élément par élément en utilisant la méthode np.log().
>>> a = np.arange(1, 6)
array([1, 2, 3, 4, 5])

>>> np.exp(a).round(2)
array([  2.72,   7.39,  20.09,  54.6 , 148.41])

>>> np.log(a).round(2)
array([0.  , 0.69, 1.1 , 1.39, 1.61])
Python

#31–32) Somme et produit

  • Utilise la méthode np.sum() pour calculer la somme des éléments du tableau :
a = np.array([[1, 2], [3, 4]])

>>> np.sum(a)
10

>>> np.sum(a, axis = 0)
array([4, 6])

>>> np.sum(a, axis = 1)
array([3, 7])
Python
  • Utilise la méthode np.prod() pour calculer le produit des éléments du tableau :
a = np.array([[1, 2], [3, 4]])

>>> np.prod(a)
24

>>> np.prod(a, axis = 0)
array([3, 8])

>>> np.sum(a, axis = 1)
array([2, 12])
Python

#33) Racine carrée

Utilise la méthode np.sqrt() pour calculer la racine carrée des éléments du tableau :

a = np.array([[1, 2], [3, 4]])
np.sqrt(a)
Python
array([[1.        , 1.41421356],
       [1.73205081, 2.        ]])

34–36) Opérations matricielles et vectorielles

#34) Produit scalaire

Si tu veux calculer le produit scalaire de deux tableaux NumPy, utilise la méthode np.dot() :

a = np.array([[1, 2], [3, 4]])
b = np.array([[1, 1], [1, 1]])
np.dot(a, b)
Python
array([[3, 3],
       [7, 7]])

#35) Produit matriciel

Pour calculer le produit matriciel de deux tableaux NumPy, utilise np.matmul() ou l’opérateur @ en Python :

a = np.array([[1, 2], [3, 4]])
b = np.array([[1, 1], [1, 1]])

>>> np.matmul(a, b)
array([[3, 3],
       [7, 7]])

>>> a@b
array([[3, 3],
       [7, 7]])
Python

Note : Le résultat de np.matmul() et np.dot() sont identiques dans ce cas mais ils peuvent différer significativement. Tu peux lire leurs différences ici.

#36) Norme vectorielle

Les normes vectorielles représentent un ensemble de fonctions utilisées pour mesurer la longueur d’un vecteur.

Utilise la méthode np.linalg.norm() pour trouver la norme matricielle ou vectorielle :

a = np.arange(-4, 5)

>>> np.linalg.norm(a) ## Norme L2
7.745966692414834

>>> np.linalg.norm(a, 1) ## Norme L1
20.0
Python

37–38) Méthodes de tri

#37) Trier un tableau NumPy

Pour trier le tableau en place (in-place), utilise la méthode ndarray.sort().

a = np.array([[1,4],[3,1]])

>>> np.sort(a) ## trier en fonction des lignes
array([[1, 4],
       [1, 3]])

>>> np.sort(a, axis=None) ## trier le tableau aplati
array([1, 1, 3, 4])

>>> np.sort(a, axis=0) ## trier en fonction des colonnes
array([[1, 1],
       [3, 4]])
Python

#38) Ordre des indices dans un tableau NumPy trié

Pour retourner l’ordre des indices qui trieraient le tableau, utilisez la méthode np.argsort() :

x = np.array([3, 1, 2])
np.argsort(x)
Python
array([1, 2, 0])

39–42) Méthodes de recherche

#39) Indices correspondant aux valeurs maximales

Pour retourner les indices des valeurs maximales le long d’un axe, utilise la méthode np.argmax() comme démontré ci-dessous :

>>> a = np.random.randint(1, 20, 10).reshape(2,5)
array([[15, 13, 10,  1, 18],
       [14, 19, 19, 17,  8]])

>>> np.argmax(a) ## index dans un tableau aplati
6

>>> np.argmax(a, axis=0) ## indices le long des colonnes
array([0, 1, 1, 1, 0])

>>> np.argmax(a, axis=1) ## indices le long des lignes
array([4, 1])
Python

Pour trouver l’index dans un tableau non-aplati, tu peux faire ceci :

ind = np.unravel_index(np.argmax(a), a.shape)
ind
Python
(1, 1)

#40) Indices correspondant aux valeurs minimales

De même, si tu veux retourner les indices des valeurs minimales le long d’un axe, utilise la méthode np.argmin() comme démontré ci-dessous :

>>> a = np.random.randint(1, 20, 10).reshape(2,5)
array([[15, 13, 10,  1, 18],
       [14, 19, 19, 17,  8]])

>>> np.argmin(a) ## index dans un tableau aplati
3

>>> np.argmin(a, axis=0) ## indices le long des colonnes
array([1, 0, 0, 0, 1])

>>> np.argmin(a, axis=1) ## indices le long des lignes
array([3, 4])
Python

#41) Recherche basée sur une condition

Si tu veux sélectionner entre deux tableaux basés sur une condition, utilise la méthode np.where() comme montré ci-dessous :

>>> a = np.random.randint(-10, 10, 10)
array([ 2, -3,  6, -3, -8,  4, -6, -2,  6, -4])

>>> np.where(a < 0, 0, a)
array([2, 0, 6, 0, 0, 4, 0, 0, 6, 0])
"""
if element < 0:
    return 0
else:
    return element
"""
Python

#42) Indices des éléments non-nuls

Pour déterminer les indices des éléments non-nuls dans un tableau NumPy, utilise la méthode np.nonzero() :

a = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
np.nonzero(a)
Python
(array([0, 1, 2, 2]), array([0, 1, 0, 1]))

43–45) Méthodes statistiques

Ensuite, regardons les méthodes pour calculer les statistiques standards sur les tableaux NumPy. Tu peux trouver toutes les techniques statistiques supportées par NumPy ici.

#43) Moyenne

Pour trouver la moyenne des valeurs dans un tableau NumPy le long d’un axe, utilise la méthode np.mean() comme démontré ci-dessous :

a = np.array([[1, 2], [3, 4]])

>>> np.mean(a)
2.5

>>> np.mean(a, axis = 1) ## le long de l'axe des lignes
array([1.5, 3.5])

>>> np.mean(a, axis = 0) ## le long de l'axe de la colonne
array([2., 3.])
Python

#44) Médiane

Pour calculer la médiane d’un tableau NumPy, utilise la méthode np.median().

a = np.array([[1, 2], [3, 4]])

>>> np.median(a)
2.5

>>> np.median(a, axis = 1) ## le long de l'axe des lignes
array([1.5, 3.5])

>>> np.median(a, axis = 0) ## le long de l'axe de la colonne
array([2., 3.])
Python

#45) Écart-type

Pour calculer l’écart-type d’un tableau NumPy le long d’un axe spécifié, utilise la méthode np.std().

a = np.array([[1, 2], [3, 4]])

>>> np.std(a)
1.118033988749895

>>> np.std(a, axis = 1) ## le long de l'axe des lignes
array([0.5, 0.5])

>>> np.std(a, axis = 0) ## le long de l'axe de la colonne
array([1., 1.])
Python

Félicitations 🎊, tu viens d’apprendre les 45 méthodes les plus utiles de NumPy.

Je peux affirmer avec confiance que tu utiliseras probablement ces méthodes 90 % du temps en travaillant avec NumPy.

Cette affirmation est soutenue par ma propre expérience ainsi que par le travail avec d’autres data scientists.

Étiquettes de la publication :

Publications similaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *