Aide-mémoire NumPy
Dernière mise à jour
Créer des tableaux
Un tableau contient des valeurs d'un seul type, dans une grille à autant de dimensions que tu veux.
| Tâche | Code |
|---|---|
| Importer NumPy | import numpy as np |
| À partir d'une liste | np.array([1, 2, 3]) |
| En 2D à partir de listes imbriquées | np.array([[1, 2, 3], [4, 5, 6]]) |
| Zéros, uns, une valeur de remplissage | np.zeros((2, 3)), np.ones(4), np.full((2, 2), 7) |
| Plage avec un pas (fin exclue) | np.arange(0, 10, 2) # [0 2 4 6 8] |
| n points régulièrement espacés (fin incluse) | np.linspace(0, 1, 5) # [0. 0.25 0.5 0.75 1.] |
| Matrice identité | np.eye(3) |
| Même forme qu'un autre tableau | np.zeros_like(m), np.ones_like(m) |
| Choisir le type des éléments | np.array([1, 2, 3], dtype=np.float32) |
| Grilles de coordonnées | xx, yy = np.meshgrid(np.arange(3), np.arange(2)) |
Inspecter un tableau
| Tâche | Code |
|---|---|
| Forme : taille de chaque dimension | m.shape # (3, 4) |
| Nombre de dimensions | m.ndim # 2 |
| Nombre d'éléments | m.size # 12 |
| Type des éléments | m.dtype # int64 |
| Convertir le type | m.astype(np.float64) |
| Longueur de la première dimension | len(m) # 3 |
| Revenir à une liste Python | m.tolist() |
| Afficher moins de décimales | np.set_printoptions(precision=3, suppress=True) |
Indexer et découper
Les tranches sont des vues : elles partagent la mémoire du tableau d'origine. Les masques et les listes d'indices renvoient des copies.
| Tâche | Code |
|---|---|
| Premier et dernier élément | a[0], a[-1] |
| Tranche début:fin (fin exclue) | a[1:4] # [20 30 40] |
| Un élément sur deux, inversé | a[::2], a[::-1] |
| Un élément d'un tableau 2D | m[1, 2] # 6 |
| Une ligne, une colonne | m[0], m[:, 1] |
| Un bloc de lignes et de colonnes | m[:2, 1:3] |
| Éléments qui vérifient une condition | a[a > 25] # [30 40 50] |
| Combiner des conditions | a[(a > 15) & (a < 45)] |
| Choisir via une liste de positions | a[[0, 2, 4]] |
| Positions qui correspondent | np.flatnonzero(a > 25) # [2 3 4] |
| Choisir élément par élément | np.where(a > 25, a, 0) |
| Copier avant de modifier une tranche | part = a[1:3].copy() |
| Modifier des valeurs avec un masque | a[a > 40] = 0 |
Calcul et broadcasting
Les opérateurs agissent élément par élément. Le broadcasting étire un scalaire, une ligne ou une colonne pour l'adapter à la forme de l'autre tableau.
| Tâche | Code |
|---|---|
| Arithmétique élément par élément | x + y, x - y, x * y, x / y, x ** 2 |
| Avec un scalaire | x * 10 |
| Racine carrée, exponentielle, log | np.sqrt(x), np.exp(x), np.log(x) |
| Valeur absolue, arrondi | np.abs(x - 5), np.round(x / 3, 2) |
| Limiter les valeurs à un intervalle | np.clip(x, 2, 8) |
| Maximum élément par élément | np.maximum(x, 3) |
| Produit scalaire | x @ y # 37.0 |
| Centrer chaque colonne (broadcast d'une ligne) | m - m.mean(axis=0) |
| Mettre à l'échelle chaque ligne (broadcast d'une colonne) | m / m.sum(axis=1, keepdims=True) |
| Comparer des flottants sans risque | np.isclose(0.1 + 0.2, 0.3) # True, np.allclose(x, y) |
| Trigonométrie et pi | np.sin(np.pi / 2) # 1.0 |
Agréger selon un axe
axis=0 parcourt les lignes vers le bas et donne un résultat par colonne. axis=1 parcourt les colonnes et donne un résultat par ligne.
| Tâche | Code |
|---|---|
| Somme de tous les éléments | m.sum() # 21 |
| Un résultat par colonne | m.sum(axis=0) # [5 7 9] |
| Un résultat par ligne | m.sum(axis=1) # [ 6 15] |
| Moyenne et écart-type | m.mean(), m.std(), m.mean(axis=0) |
| Minimum, maximum | m.min(), m.max(axis=1) |
| Position du maximum | m.argmax(), m.argmax(axis=1) |
| Médiane et percentiles | np.median(m), np.percentile(m, [25, 50, 75]) |
| Somme cumulée | np.cumsum(m, axis=1) |
| Produit de tous les éléments | m.prod() # 720 |
| Au moins un, tous, nombre | (m > 4).any(), (m > 0).all(), np.count_nonzero(m > 2) |
Remodeler et combiner
Un reshape garde les éléments et change la forme : la taille totale doit donc rester la même.
| Tâche | Code |
|---|---|
| Nouvelle forme | a.reshape(2, 3) |
| Laisser NumPy calculer une taille | a.reshape(3, -1), a.reshape(-1, 1) |
| Aplatir en 1D | m.ravel(), m.flatten() |
| Transposer | m.T |
| Ajouter une dimension | a[:, np.newaxis], np.expand_dims(a, axis=0) |
| Supprimer les dimensions de taille 1 | np.squeeze(np.ones((1, 3, 1))) |
| Concaténer selon un axe existant | np.concatenate([a, a]) |
| Empiler des lignes ou des colonnes | np.vstack([m, m]), np.hstack([m, m]) |
| Tableaux 1D en colonnes | np.column_stack([a, a ** 2]) |
| Empiler selon un nouvel axe | np.stack([a, a], axis=0) # shape (2, 6) |
| Découper en morceaux | np.split(a, 3), np.array_split(a, 4) |
| Répéter ou paver | np.repeat([1, 2], 2) # [1 1 2 2], np.tile([1, 2], 2) # [1 2 1 2] |
Trier, chercher et valeurs uniques
| Tâche | Code |
|---|---|
| Copie triée | np.sort(a) |
| Les plus grands d'abord | np.sort(a)[::-1] |
| Positions qui trieraient le tableau | np.argsort(a) |
| Les trois plus grandes valeurs | np.sort(a)[-3:] |
| Valeurs uniques et leurs effectifs | values, counts = np.unique(a, return_counts=True) |
Noms NumPy 2 (unique_values peut être non trié) | np.unique_values(a), np.unique_counts(a) |
| Chaque élément est-il dans une liste ? | np.isin(a, [1, 9]) |
| Position d'insertion dans un tableau trié | np.searchsorted([1, 3, 5, 7], 4) # 2 |
| Opérations ensemblistes | np.intersect1d(a, [1, 2, 10]), np.union1d(a, [10]), np.setdiff1d(a, [1]) |
| Trier les lignes selon une colonne | m[m[:, 1].argsort()] |
Nombres aléatoires
Crée un seul Generator avec une graine et tire tout depuis lui, pour obtenir les mêmes résultats à chaque exécution.
| Tâche | Code |
|---|---|
| Générateur avec graine | rng = np.random.default_rng(42) |
| Flottants dans [0, 1) | rng.random(3) |
| Entiers, borne haute exclue | rng.integers(1, 7, size=10) |
| Loi normale | rng.normal(loc=0, scale=1, size=(2, 3)) |
| Flottants uniformes dans un intervalle | rng.uniform(5, 10, size=4) |
| Tirer dans une liste | rng.choice(["a", "b", "c"], size=5) |
| Tirer sans remise | rng.choice(10, size=3, replace=False) |
| Tirer avec des poids | rng.choice(["H", "T"], size=10, p=[0.7, 0.3]) |
| Copie mélangée, mélange sur place | rng.permutation(a), rng.shuffle(a) |
| Tirages binomiaux et de Poisson | rng.binomial(10, 0.5, size=5), rng.poisson(3, size=5) |
Algèbre linéaire
| Tâche | Code |
|---|---|
| Produit matriciel | A @ A |
| Résoudre Ax = b | np.linalg.solve(A, b) # [0.8 1.4] |
| Inverse et déterminant | np.linalg.inv(A), np.linalg.det(A) |
| Norme d'un vecteur | np.linalg.norm(b) |
| Valeurs propres et vecteurs propres | values, vectors = np.linalg.eig(A) |
| Ajuster une droite | slope, intercept = np.polyfit(x, y, 1) |
| Produit extérieur | np.outer([1, 2], [3, 4]) |
| Diagonale et trace | np.diag(A), np.trace(A) |
Valeurs manquantes et spéciales
np.nan marque un flottant manquant. Tout calcul qui l'implique donne nan : utilise donc les fonctions nan ou un masque.
| Tâche | Code |
|---|---|
| Valeur manquante | np.nan |
| Trouver les valeurs manquantes | np.isnan(v), np.isnan(v).sum() |
| Supprimer les valeurs manquantes | v[~np.isnan(v)] |
| Remplacer les valeurs manquantes et infinies | np.nan_to_num(v, nan=0.0, posinf=0.0) |
| Tester l'infini et les valeurs finies | np.inf, np.isfinite(v) |
| Statistiques qui ignorent NaN | np.nanmean(v[:3]) # 2.0, np.nanmax(v) |
Enregistrer et charger
| Tâche | Code |
|---|---|
| Un tableau, fichier binaire | np.save("data.npy", m), m = np.load("data.npy") |
| Plusieurs tableaux dans un fichier | np.savez("data.npz", x=x, y=y), np.load("data.npz")["x"] |
| Écrire du texte CSV | np.savetxt("data.csv", m, delimiter=",", fmt="%d") |
| Lire du texte CSV | np.loadtxt("data.csv", delimiter=",") |
NumPy 2 : anciens noms et quoi écrire maintenant
NumPy 2 a supprimé de nombreux alias : le code copié d'anciens tutoriels peut donc échouer avec une AttributeError.
| Tâche | NumPy 2 | Ancienne syntaxe |
|---|---|---|
| Valeur manquante | np.nan | np.NaN |
| Infini | np.inf | np.Inf |
| Type flottant 64 bits | np.float64 | np.float_ |
| Aire sous une courbe | np.trapezoid(y, x) | np.trapz(y, x) |
| Chaque élément est-il dans un autre tableau ? | np.isin(a, b) | np.in1d(a, b) |
| Empiler des lignes | np.vstack([a, a]) | np.row_stack([a, a]) |
| Produit | np.prod(a) | np.product(a) |
| Nombres aléatoires | rng = np.random.default_rng(0)
rng.random(3) | np.random.seed(0)
np.random.rand(3) |
Les appels NumPy sur lesquels repose le code de data science, classés par tâche : créer des tableaux, les inspecter, indexer et découper, faire des calculs élément par élément, agréger selon un axe, remodeler et combiner, trier et chercher, tirer des nombres aléatoires et résoudre des problèmes d'algèbre linéaire. Chaque ligne donne un court extrait à copier-coller, avec une phrase qui explique ce qu'il fait.
Tout est écrit pour NumPy 2, la version utilisée par Coddy, et le dernier tableau liste les noms supprimés par NumPy 2, à côté de ce qu'il faut écrire à la place. La plupart des exemples utilisent a = np.array([3, 1, 4, 1, 5, 9, 2, 6]) et m = np.arange(12).reshape(3, 4). Tu débutes en Python ? Commence par l'aide-mémoire Python et le playground Python, et garde les aide-mémoire pandas, Matplotlib et scikit-learn à portée de main.
FAQ de l'aide-mémoire NumPy
Cet aide-mémoire NumPy est-il gratuit ?
Oui. Cet aide-mémoire NumPy est entièrement gratuit, sans inscription. Ajoute-le à tes favoris ou imprime-le en PDF depuis ton navigateur, et reviens dès que tu as besoin de l'appel exact pour un reshape, une somme selon un axe ou un tirage aléatoire.
Quelle version de NumPy cet aide-mémoire couvre-t-il ?
NumPy 2. Chaque extrait fonctionne avec NumPy 2.4, la version utilisée par Coddy. NumPy 2 a supprimé des alias comme
np.NaN, np.float_, np.trapz et np.in1d : le dernier tableau montre donc chacun d'eux à côté de son nom actuel.Que signifie axis=0 dans NumPy ?
L'axe est la dimension qui est réduite. Dans un tableau 2D,
axis=0 parcourt les lignes vers le bas, donc m.sum(axis=0) renvoie un total par colonne. axis=1 parcourt les colonnes et renvoie un total par ligne. Sans axe, la fonction utilise tous les éléments.Quelle est la différence entre une vue et une copie ?
Une tranche comme
a[1:3] est une vue : elle partage la mémoire de a, donc modifier la tranche modifie a. Les masques booléens et les listes d'indices comme a[a > 2] ou a[[0, 2]] renvoient des copies. Appelle .copy() quand tu as besoin d'un tableau indépendant.Pourquoi utiliser un tableau NumPy plutôt qu'une liste Python ?
Les tableaux stockent un seul type dans un seul bloc de mémoire : les calculs sur un tableau entier tournent donc en code compilé et sont souvent bien plus rapides qu'une boucle Python.
a * 2 double chaque élément, alors que [1, 2] * 2 répète la liste. pandas et scikit-learn reposent sur les tableaux NumPy.Faut-il utiliser np.random.seed ou default_rng ?
Utilise
rng = np.random.default_rng(seed) et appelle les méthodes de rng, comme rng.normal() ou rng.integers(). C'est l'API recommandée, avec de meilleurs flux aléatoires et aucun état global caché. np.random.seed et np.random.rand fonctionnent encore, mais c'est l'ancienne interface.Puis-je exécuter du code NumPy en ligne ?
Oui. Le playground Matplotlib gratuit exécute Python avec NumPy, pandas, Matplotlib et scikit-learn dans ton navigateur : tu peux coller n'importe quel extrait de cet aide-mémoire et le lancer sans rien installer. Le cours Machine Learning de Coddy enseigne NumPy pas à pas, en travaillant sur de vraies données.
Ressources connexes
Plus d'aide-mémoires
