NumPy : calculer vite et bien sur des tableaux

NumPy introduit un type de données central, le ndarray (tableau à N dimensions), et un ensemble d’opérations vectorisées qui remplacent avantageusement les boucles Python.

Créer un tableau

import numpy as np

temperatures = np.array([18.5, 21.2, 19.8, 23.1, 17.4, 22.0, 20.3])
print(temperatures)
print("shape:", temperatures.shape, "dtype:", temperatures.dtype)

[18.5 21.2 19.8 23.1 17.4 22.  20.3]
shape: (7,) dtype: float64

Un tableau NumPy a une forme (shape) et un type (dtype) uniques pour tous ses éléments — contrairement à une liste Python, qui peut mélanger les types.

Indexation et slicing

print("3 premiers jours:", temperatures[:3])
print("dernier jour:", temperatures[-1])
print("un jour sur deux:", temperatures[::2])

3 premiers jours: [18.5 21.2 19.8]
dernier jour: 20.3
un jour sur deux: [18.5 19.8 17.4 20.3]

Indexation booléenne

On peut indexer un tableau directement avec un tableau de booléens de même taille — c’est l’un des outils les plus utilisés en data science pour filtrer :

masque = temperatures > 20
print("masque (>20°C):", masque)
print("jours chauds:", temperatures[masque])
print("nb jours chauds:", masque.sum())

masque (>20°C): [False  True False  True False  True  True]
jours chauds: [21.2 23.1 22.  20.3]
nb jours chauds: 4

masque.sum() fonctionne parce que Python traite True comme 1 et False comme 0 — un idiome extrêmement courant pour compter combien d’éléments vérifient une condition.

Le broadcasting

Le broadcasting permet d’appliquer une opération entre tableaux de tailles différentes, sans boucle explicite, tant que leurs formes sont compatibles :

temperatures_fahrenheit = temperatures * 9 / 5 + 32
print("en Fahrenheit:", np.round(temperatures_fahrenheit, 1))

en Fahrenheit: [65.3 70.2 67.6 73.6 63.3 71.6 68.5]

Ici, un tableau de 7 valeurs est multiplié et additionné à des scalaires (9/5 et 32) : NumPy « étend » implicitement le scalaire à la forme du tableau. Le même principe s’applique à des tableaux à deux dimensions, via l’opérateur @ (produit matriciel) :

prix_kg = np.array([2.0, 7.0, 5.0])
quantites = np.array([[3, 1, 2], [0, 2, 4], [5, 0, 1]])  # 3 clients x 3 fruits
total_par_client = quantites @ prix_kg
print("total par client:", total_par_client)

total par client: [23. 34. 15.]

Cette même opération (X @ theta) sera au cœur du module 3 : un modèle de régression linéaire n’est rien d’autre qu’un produit matriciel entre une matrice de données et un vecteur de paramètres.

Statistiques vectorisées

print("moyenne:", temperatures.mean())
print("ecart-type:", round(temperatures.std(), 3))
print("moyenne par colonne (axis=0):", quantites.mean(axis=0))
print("somme par ligne (axis=1):", quantites.sum(axis=1))

moyenne: 20.328571428571426
ecart-type: 1.83
moyenne par colonne (axis=0): [2.66666667 1.         2.33333333]
somme par ligne (axis=1): [6 6 6]

Le paramètre axis mérite d’être mémorisé : axis=0 agrège verticalement (une valeur par colonne), axis=1 agrège horizontalement (une valeur par ligne). Cette même logique se retrouve à l’identique dans pandas (leçon suivante).

Prochaine étape

👉 pandas : manipuler des tables de données

---

Junior TSAFACK – 12/09/2026