Tutoriel NumPy

NumPy (Numerical Python) est la bibliothèque de référence pour le calcul numérique en Python. Elle introduit le ndarray — un tableau multidimensionnel rapide à type fixe — et l'associe à des centaines de fonctions mathématiques opérant sur des tableaux entiers en une seule fois. Pratiquement toutes les bibliothèques scientifiques Python (Pandas, SciPy, Matplotlib, scikit-learn) sont construites sur NumPy.

Ce chapitre couvre :

• Ce qu'est NumPy et pourquoi il est plus rapide que les listes Python classiques
• L'installation de NumPy et la convention d'import standard
• La création de tableaux avec np.array, np.zeros, np.ones, np.arange et np.linspace
• L'indexation, le découpage et le masquage booléen
• Le redimensionnement et la transposition
• Le broadcasting — opérer sur des tableaux de formes différentes
• Les fonctions d'agrégation (sum, mean, std, min, max)
• Les calculs élément par élément et l'algèbre linéaire
• Les fonctions utilitaires courantes (sort, unique, where, concatenate)

Qu'est-ce que NumPy ?

NumPy est une bibliothèque Python open-source qui fournit :

1. Un puissant objet array N-dimensionnel (ndarray).
2. Des fonctions mathématiques vectorisées (ufuncs) qui s'appliquent à chaque élément d'un array en code C compilé plutôt que dans une boucle Python.
3. Des routines d'algèbre linéaire, de transformées de Fourier et de génération de nombres aléatoires.

Pourquoi NumPy est plus rapide que les listes Python

Une liste Python peut contenir des éléments de n'importe quel type, si bien que chaque élément stocke un tag de type et un pointeur vers la valeur réelle. Les tableaux NumPy stockent des données numériques brutes dans un bloc de mémoire contigu — sans pointeurs, sans recherche de type. Combiné à des boucles C vectorisées (ufuncs), les opérations sur un tableau NumPy d'un million d'éléments s'exécutent généralement 10 à 100 fois plus vite que le code Python équivalent avec une boucle for.

Installer NumPy

NumPy est inclus dans la distribution Anaconda. Pour l'installer manuellement avec pip :

pip install numpy

Importer NumPy

La convention universelle est d'importer NumPy sous l'alias np :

import numpy as np

Tous les exemples de ce chapitre supposent que cet import est déjà effectué.

Créer des tableaux

À partir d'une liste Python

Passez n'importe quelle liste (ou liste de listes) à np.array() :

[1 2 3 4 5]
int64
(5,)

Un tableau 2-D (matrice) utilise une liste de listes :

[[1 2 3]
 [4 5 6]
 [7 8 9]]
(3, 3)

Raccourcis de création de tableaux

import numpy as np

print(np.zeros((2, 3)))
print(np.ones(4, dtype=int))
print(np.arange(0, 10, 2))
print(np.linspace(0, 1, 5))

[[0. 0. 0.]
 [0. 0. 0.]]
[1 1 1 1]
[0 2 4 6 8]
[0.   0.25 0.5  0.75 1.  ]

np.linspace est particulièrement utile quand vous avez besoin d'un nombre précis de points — par exemple pour préparer un axe des abscisses pour un graphique. Consultez le chapitre Introduction à Matplotlib pour savoir comment l'associer aux fonctions de tracé.

Indexation et découpage

Indexation et découpage 1-D

NumPy utilise la même syntaxe [start:stop:step] que les listes Python, mais il prend également en charge les indices négatifs et les pas.

import numpy as np

a = np.array([10, 20, 30, 40, 50])

print(a[0])      # first element
print(a[-1])     # last element
print(a[1:4])    # elements at index 1, 2, 3
print(a[::2])    # every other element

10
50
[20 30 40]
[10 30 50]

Indexation 2-D

Pour un tableau 2-D, fournissez [ligne, colonne] :

import numpy as np

b = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

print(b[1, 2])    # row 1, col 2 → 6
print(b[0, :])    # first row  → [1 2 3]
print(b[:, 1])    # second column → [2 5 8]
print(b[0:2, 1:3])  # sub-matrix

6
[1 2 3]
[2 5 8]
[[2 3]
 [5 6]]

Masquage booléen

Passez un array booléen comme index pour ne sélectionner que les éléments où la condition est True :

import numpy as np

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

print(a[a > 3])        # elements greater than 3
print(a[a % 2 == 0])   # even elements

[4 5]
[2 4]

Les masques booléens sont le remplacement idiomatique NumPy des compréhensions de liste filtrées et sont bien plus rapides sur des tableaux de grande taille.

Redimensionnement et transposition

Redimensionnement

np.reshape() (ou la méthode .reshape()) retourne une vue des données avec une nouvelle forme. Le nombre total d'éléments doit rester identique.

[[1 2 3]
 [4 5 6]]

Utilisez -1 pour une dimension que vous souhaitez que NumPy déduise automatiquement :

import numpy as np

a = np.arange(12)
print(a.reshape(3, -1))   # 3 rows, NumPy infers 4 columns

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

Transposition

.T ou np.transpose() permute les axes (lignes ↔ colonnes pour les tableaux 2-D) :

[[1 3 5]
 [2 4 6]]
(2, 3)

Ajout et suppression d'éléments

Ajouter des éléments

np.append() retourne un nouveau tableau aplati — il ne modifie pas l'original en place (contrairement à list.append).

[1 2 3 4 5 6]

Pour des ajouts répétés dans une boucle, il est bien plus efficace de construire une liste Python et de la convertir une seule fois avec np.array() à la fin plutôt que d'appeler np.append() de manière répétée.

Supprimer des éléments

np.delete(arr, indices) retourne un nouveau tableau avec les indices spécifiés supprimés :

[1 2 5]

Concaténer des tableaux

np.concatenate() joint deux tableaux ou plus le long d'un axe existant :

import numpy as np

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

[1 2 3 4]

Broadcasting

Le broadcasting est la règle de NumPy pour appliquer des opérations entre des tableaux de formes différentes — sans copier les données. L'exemple classique est l'ajout d'un scalaire à un tableau :

import numpy as np

a = np.array([1, 2, 3])
print(a + 10)    # 10 is broadcast across all elements

[11 12 13]

Un cas plus puissant : ajouter un tableau 1-D à chaque ligne d'un tableau 2-D :

import numpy as np

matrix = np.array([[1, 2, 3],
                   [4, 5, 6]])
row    = np.array([10, 20, 30])

print(matrix + row)

[[11 22 33]
 [14 25 36]]

NumPy compare les formes de droite à gauche : (2, 3) + (3,) est valide car les dimensions finales correspondent ; row est conceptuellement étendu en un tableau (2, 3) sans aucune allocation mémoire.

Opérations mathématiques

Arithmétique élément par élément

Tous les opérateurs standard (+, -, *, /, **) fonctionnent élément par élément sur des tableaux de même forme. Les fonctions nommées équivalentes (np.add, np.subtract, np.multiply, np.divide) peuvent être utiles pour passer des opérations en arguments.

[5 7 9]
[ 4 10 18]
[1 4 9]

Fonctions mathématiques universelles (ufuncs)

NumPy fournit des versions vectorisées de toutes les fonctions mathématiques standard :

import numpy as np

a = np.array([0, 1, 4, 9, 16], dtype=float)

print(np.sqrt(a))
print(np.log(np.array([1, np.e, np.e**2])))   # natural log
print(np.sin(np.array([0, np.pi/2, np.pi])))

[0. 1. 2. 3. 4.]
[0. 1. 2.]
[ 0.000e+00  1.000e+00 -8.742e-08]

La toute petite valeur proche de zéro pour sin(π) est un arrondi en virgule flottante normal — np.pi est une approximation de π.

Fonctions d'agrégation

Les fonctions d'agrégation réduisent un tableau (ou l'un de ses axes) à une valeur unique :

import numpy as np

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

print(np.sum(a))    # 15
print(np.mean(a))   # 3.0
print(np.std(a))    # 1.4142135623730951
print(np.min(a))    # 1
print(np.max(a))    # 5

15
3.0
1.4142135623730951
1
5

Pour les tableaux 2-D, passez axis=0 pour agréger le long des colonnes ou axis=1 pour agréger le long des lignes :

import numpy as np

m = np.array([[1, 2, 3],
              [4, 5, 6]])

print(np.sum(m, axis=0))   # column totals: [5 7 9]
print(np.sum(m, axis=1))   # row totals:    [6 15]

[5 7 9]
[ 6 15]

Algèbre linéaire

np.dot() de NumPy calcule le produit scalaire de deux vecteurs 1-D ou le produit matriciel de deux tableaux 2-D. Pour la multiplication matricielle, l'opérateur @ (Python 3.5+) est le raccourci moderne.

import numpy as np

a = np.array([1, 2])
b = np.array([3, 4])
print(np.dot(a, b))     # 1*3 + 2*4 = 11

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B)            # matrix product

11
[[19 22]
 [43 50]]

np.linalg contient des opérations plus avancées :

Fonctions utilitaires

Tri

import numpy as np

a = np.array([3, 1, 4, 1, 5, 9, 2, 6])
print(np.sort(a))         # returns a sorted copy
print(np.argsort(a))      # indices that would sort the array

[1 1 2 3 4 5 6 9]
[1 3 6 0 2 4 7 5]

Valeurs uniques

import numpy as np

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

[1 2 3]

Sélection conditionnelle avec np.where

np.where(condition, x, y) retourne x là où la condition est True et y ailleurs :

import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(np.where(a > 2, a, 0))

[0 0 3 4 5]

NumPy avec Matplotlib

NumPy et Matplotlib sont conçus pour fonctionner ensemble. np.linspace génère les valeurs x ; les ufuncs NumPy calculent y ; Matplotlib trace le résultat :

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2 * np.pi, 200)
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.legend()
plt.title('Sine and Cosine')
plt.show()

Cet exemple nécessite que Matplotlib soit installé (pip install matplotlib) et un affichage ou un backend Agg pour les environnements sans interface graphique. Consultez le chapitre Introduction à Matplotlib pour une présentation détaillée.

Ce qu'il faut apprendre ensuite

• Tutoriel SciPy — calcul scientifique de niveau supérieur (intégration, optimisation, traitement du signal) construit sur les tableaux NumPy.
• Introduction à Matplotlib — visualisez des tableaux NumPy sous forme de graphiques en courbes, nuages de points, histogrammes et plus encore.
• Tracé avec Matplotlib — affinez la mise en page des figures, les axes et les styles.