Cheat Sheet NumPy : Référence rapide pour l’entreprise

pip install numpy

import numpy as np

# À partir de listes

np.array([1, 2, 3])                      # 1D array

np.array([[1, 2, 3], [4, 5, 6]])         # 2D array

# Arrays prédéfinis

np.zeros((3, 3))                         # Array de zéros (3x3)

np.ones((2, 4))                          # Array de uns (2x4)

np.eye(3)                                # Matrice identité (3x3)

np.empty((2, 3))                         # Array non initialisé

np.full((2, 2), 7)                       # Array rempli avec la valeur 7

# Séquences

np.arange(10)                            # Comme range() => [0, 1, ..., 9]

np.arange(2, 10, 2)                      # [2, 4, 6, 8]

np.linspace(0, 1, 5)                     # 5 points équidistants entre 0 et 1

# Génération aléatoire

np.random.random((2, 2))                 # Valeurs uniformes entre [0, 1)

np.random.normal(0, 1, (2, 2))           # Distribution normale (µ=0, σ=1)

np.random.randint(0, 10, (3, 3))         # Entiers aléatoires entre [0, 10)

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

a.shape                                  # Dimensions (2, 3)

a.ndim                                   # Nombre de dimensions (2)

a.size                                   # Nombre total d'éléments (6)

a.dtype                                  # Type de données (int64)

a.itemsize                               # Taille en octets d'un élément

a.nbytes                                 # Taille totale en octets

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

a[0, 0]                              # Premier élément (1)

a[1, 2]                              # Élément à la position (1,2) => 6

a[0]                                 # Première ligne => [1, 2, 3]

a[:, 1]                              # Deuxième colonne => [2, 5, 8]

a[0:2, 1:3]                          # Sous-array 2x2 => [[2, 3], [5, 6]]

a[1:, :]                             # Lignes 1 et 2 => [[4, 5, 6], [7, 8, 9]]

a[a > 5]                             # Éléments > 5 => [6, 7, 8, 9]

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

a.reshape(4, 1)                          # Reformer en 4x1

a.reshape(1, 4)                          # Reformer en 1x4

a.flatten()                              # Aplatir en 1D => [1, 2, 3, 4]

a.T                                      # Transposer => [[1, 3], [2, 4]]

np.expand_dims(a, axis=0)                # Ajouter dimension => [[[1, 2], [3, 4]]]

np.squeeze(np.expand_dims(a, axis=0))    # Supprimer dimensions de taille 1

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

b = np.array([4, 5, 6])

# Opérations élément par élément

a + b                                # Addition

a - b                                # Soustraction

a * b                                # Multiplication

a / b                                # Division

a ** 2                               # Puissance

np.sqrt(a)                           # Racine carrée

np.exp(a)                            # Exponentielle

np.log(a)                            # Logarithme naturel

np.sin(a), np.cos(a), np.tan(a)      # Fonctions trigonométriques

# Agrégations

np.sum(a)                            # Somme de tous les éléments

np.mean(a)                           # Moyenne

np.median(a)                         # Médiane

np.min(a), np.max(a)                 # Minimum, maximum

np.std(a)                            # Écart-type

np.var(a)                            # Variance

np.argmin(a), np.argmax(a)           # Indices du min/max

# Produits

np.dot(a, b)                         # Produit scalaire

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

d = np.array([[5, 6], [7, 8]])

np.matmul(c, d)                      # Produit matriciel (ou c @ d)

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

b = np.array([4, 5, 6])

np.concatenate([a, b])               # [1, 2, 3, 4, 5, 6]

np.vstack([a, b])                    # [[1, 2, 3], [4, 5, 6]]

np.hstack([a.reshape(-1, 1), b.reshape(-1, 1)])  # [[1, 4], [2, 5], [3, 6]]

np.column_stack([a, b])              # [[1, 4], [2, 5], [3, 6]]

np.dstack([a, b])                    # [[[1, 4], [2, 5], [3, 6]]]

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

np.split(a, 3)                       # [array([1, 2]), array([3, 4]), array([5, 6])]

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

np.vsplit(b, 3)                      # 3 arrays 1x3

np.hsplit(b, 3)                      # 3 arrays 3x1

a > 3     # Comparaison

(a > 2) & (a < 5) # Conditions combinées avec `&`

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

a + 1                            # Ajouter 1 à chaque élément

a * 2                            # Multiplier chaque élément par 2

a + np.array([10, 20, 30])       # Ajoute à chaque ligne

# Manipulation de données

np.sort(a)                           # Trier

np.argsort(a)                        # Indices de tri

np.unique(a)                         # Valeurs uniques

np.where(a > 5)                      # Indices où la condition est vraie

np.clip(a, 2, 5)                     # Limiter les valeurs entre 2 et 5

np.isnan(a)                          # Détecter les NaN

# Génération

np.meshgrid(np.arange(3), np.arange(3))  # Grille 2D

# E/S

np.save('array.npy', a)              # Sauvegarder

np.load('array.npy')                 # Charger

np.savetxt('array.txt', a)           # Sauvegarder en texte

np.loadtxt('array.txt')              # Charger depuis texte

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

mask = a > 2

a[mask]                      # [3, 4, 5]

a[a % 2 == 0]                # [2, 4]

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

np.mean(a)                           # Moyenne (3.0)

np.std(a)                            # Écart-type

np.percentile(a, 50)                 # Médiane (50e percentile)

np.histogram(a, bins=2)              # Histogramme

np.corrcoef([1, 2, 3], [4, 5, 6])    # Matrice de corrélation

np.cov([1, 2, 3], [4, 5, 6])         # Matrice de covariance

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

np.linalg.det(a)                     # Déterminant

np.linalg.inv(a)                     # Inverse de la matrice

np.linalg.eig(a)                     # Valeurs/vecteurs propres

np.linalg.svd(a)                     # Décomposition SVD

np.linalg.norm(a)                    # Norme

np.linalg.solve(a, [1, 2])           # Résoudre équation Ax = b