🔢 NumPy – Le Calcul Numérique Fondamental

L'installation se fait via pip ou conda. (Un environnement virtuel Python venv est fortement recommandé).

# 1. Installation (via pip)
pip install numpy

# 2. Installation (via Conda)
conda install -c anaconda numpy

Import (Convention)

L'alias np est la convention universelle (tout comme pd pour Pandas).

import numpy as np

print(np.__version__)

L'ndarray est un conteneur N-dimensionnel (Array) pour des types **homogènes** (ex: que des float64).

Ses attributs (.) sont essentiels :

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

// Attributs
print(arr_2d.shape) // (2, 3) (2 lignes, 3 colonnes)
print(arr_2d.ndim)  // 2 (2 dimensions)
print(arr_2d.dtype) // float32
print(arr_2d.size)  // 6 (Nombre total d'éléments)
print(arr_2d.itemsize) // 4 (Nb d'octets par élément, 32bits/8=4)

L'accès aux données utilise la syntaxe [start:stop:step] (stop est exclusif).

Important : Les "Slices" (vues) NumPy ne sont **pas** des copies (contrairement aux listes Python). Modifier un slice modifie l'original (pour la performance). Utilisez .copy() pour une copie.

1D (Vecteur)

arr = np.arange(10) // [0, 1, ..., 9]

arr[0]      // 0
arr[2:5]    // [2, 3, 4]
arr[:5]     // [0, 1, 2, 3, 4]
arr[5:]     // [5, 6, 7, 8, 9]
arr[-1]     // 9 (Dernier élément)

2D (Matrice)

Syntaxe : arr[row_slice, col_slice]

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

// 1. Élément unique (Ligne 0, Col 1)
arr_2d[0, 1] // 2

// 2. Ligne entière (Ligne 1, toutes les cols)
arr_2d[1, :] // [4, 5, 6]
// (Raccourci: arr_2d[1])

// 3. Colonne entière (Toutes les lignes, Col 0)
arr_2d[:, 0] // [1, 4, 7]

// 4. Sous-matrice
arr_2d[0:2, 1:3]
// [[2, 3],
//  [5, 6]]

C'est la méthode de filtrage la plus puissante. On passe un array booléen (le "masque") de même shape.

1. Créer le Masque

arr = np.array([1, 2, -5, 0, 8, -1])

// (1. Créer le masque (opération vectorisée))
mask = arr > 0
// [True, True, False, False, True, False]

// 2. Appliquer le masque
// (Retourne une *copie* des éléments où mask=True)
result = arr[mask]
// [1, 2, 8]

2. Conditions Multiples (&, |)

(Utiliser & (ET) et | (OU). Ne pas utiliser and/or. Parenthèses obligatoires).

mask_multi = (arr > 0) & (arr < 5)
// [True, True, False, False, False, False]

result_multi = arr[mask_multi]
// [1, 2]

On peut passer une liste (ou un array) d'index pour sélectionner des éléments dans un ordre spécifique.

1D

arr = np.array([10, 20, 30, 40, 50])
index_list = [0, 2, 4]

// (Sélectionne les index 0, 2, 4)
result = arr[index_list]
// [10, 30, 50]

2D

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

// (Sélectionne les lignes 0 et 2)
result_rows = arr_2d[[0, 2]]
// [[1, 2, 3],
//  [7, 8, 9]]

La vectorisation est l'art d'effectuer des opérations "element-wise" (élément par élément) sans écrire de boucle for Python. La boucle est effectuée en C.

Exemple (Python vs NumPy)

// Python (LENT)
list_a = [1, 2, 3]
list_b = [4, 5, 6]
result = []
for i in range(len(list_a)):
    result.append(list_a[i] + list_b[i])
// result = [5, 7, 9]

// NumPy (RAPIDE)
arr_a = np.array([1, 2, 3])
arr_b = np.array([4, 5, 6])
result = arr_a + arr_b
// result = array([5, 7, 9])

// (Ceci s'applique à toutes les ops: +, -, *, /, **, ...)
result_mult = arr_a * arr_b
// result_mult = array([ 4, 10, 18])

Le Broadcasting est le mécanisme qui permet à NumPy d'effectuer des opérations sur des arrays de **shapes (formes) différentes**.

Règles (simplifiées) :
1. Si les rangs (ndim) diffèrent, le plus petit est "rembourré" (padded) avec des 1 à gauche. (ex: (3,) devient (1, 3)).
2. Les dimensions sont compatibles si : elles sont **égales** OU si l'une d'elles est **1**.

Diagramme ((3,3) + (3,))

  A (3, 3)    +    B (3,)
[[1, 1, 1],
 [2, 2, 2],         [10, 20, 30]
 [3, 3, 3]]
 
     | (Règle 1: B (3,) -> (1, 3))
     ▼
  A (3, 3)    +    B (1, 3)
[[1, 1, 1],
 [2, 2, 2],         [[10, 20, 30]]
 [3, 3, 3]]

     | (Règle 2: B (1,3) est "étiré" (broadcasté) en (3,3))
     ▼
  A (3, 3)    +    B_broadcast (3, 3)
[[1, 1, 1],         [[10, 20, 30],
 [2, 2, 2],    +     [10, 20, 30],
 [3, 3, 3]]          [10, 20, 30]]
 
     | (Opération Element-wise)
     ▼
  Résultat (3, 3)
[[11, 21, 31],
 [12, 22, 32],
 [13, 23, 33]]

Réduire un array à un scalaire (ou moins de dimensions).

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

arr.sum()   // 10
arr.mean()  // 2.0
arr.std()   // 1.41...
arr.max()   // 4
arr.min()   // 0

arr.argmin() // 0 (Index de la valeur min)
arr.argmax() // 4 (Index de la valeur max)

// (Forme fonctionnelle np.* identique)
np.sum(arr)
np.mean(arr)

L'argument axis spécifie la dimension sur laquelle l'opération (agrégation) doit être **effectuée (réduite/effondrée)**.

Pour un array 2D (Lignes, Colonnes) :

• axis=0 : Réduit/Effondre les **Lignes** ("vers le bas", "down the rows"). Calcule une statistique *par colonne*.
• axis=1 : Réduit/Effondre les **Colonnes** ("vers le côté", "across the columns"). Calcule une statistique *par ligne*.

Diagramme

arr = np.array([[1, 2, 3],
                [4, 5, 6]])
// Shape: (2, 3)

// 1. axis=0 (Effondre les lignes)
// (Moyenne "verticale")
// ( (1+4)/2 , (2+5)/2 , (3+6)/2 )
result = arr.mean(axis=0) 
// [2.5, 3.5, 4.5] (Shape: (3,))

// 2. axis=1 (Effondre les colonnes)
// (Moyenne "horizontale")
// ( (1+2+3)/3 , (4+5+6)/3 )
result = arr.mean(axis=1)
// [2., 5.] (Shape: (2,))

* (astérisque) = Multiplication Element-wise.
@ (arobase) = Multiplication de Matrices (Dot Product).

@ (Matmul)

a = np.ones((2, 3))
b = np.ones((3, 2))

// (2, 3) @ (3, 2) -> (2, 2)
c = a @ b
// (Équivalent à np.dot(a, b))

np.linalg (Linear Algebra)

from numpy import linalg as la

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

// Inverse
la.inv(m)

// Déterminant
la.det(m)

// Valeurs propres / Vecteurs propres
la.eig(m)

Les "Ufuncs" sont des fonctions qui opèrent de manière "element-wise" (vectorisées) sur des arrays.

arr = np.array([0, np.pi/2, np.pi])

// Fonctions trigo
np.sin(arr)
// [0.        , 1.        , 1.22e-16]

// Exponentielles / Log
arr_exp = np.exp(arr)
arr_log = np.log(arr_exp)

np.nan (Not a Number) est la valeur "flottante" utilisée pour les données manquantes. (NaN "infecte" les calculs).

arr = np.array([1.0, 2.0, np.nan, 4.0])

// 1. Les aggrégations standard échouent
arr.mean() // nan

// 2. Détection
np.isnan(arr) // [False, False, True, False]
arr[~np.isnan(arr)] // Filtre les NaN

// 3. Agrégations "Nan-safe" (Ignoré)
np.nansum(arr) // 7.0
np.nanmean(arr) // 2.33...

NumPy est la **fondation**. Quasiment toutes les bibliothèques de Data Science, ML et IA en Python dépendent de NumPy.

Ressources pour apprendre et travailler avec NumPy.

NumPy = Calcul. Pandas = Analyse.