Leçon 1 sur 5
Python scientifique : NumPy et tableaux
Je sais créer, découper et transformer des tableaux NumPy, et remplacer les boucles Python par des calculs vectorisés sur des lignes, des colonnes ou des tableaux entiers.
- 1 h 20
- 6 exercices corrigés
- QCM de 7 questions
À la fin de la leçon, vous saurez :
- Expliquer ce qu'est un tableau NumPy (ndarray) et en quoi il diffère d'une liste Python
- Créer des tableaux avec array, zeros, arange, linspace et reshape
- Sélectionner des éléments par indices, tranches et masques booléens
- Calculer avec des opérations vectorisées, des agrégats selon un axe et la diffusion (broadcasting)
- Distinguer produit terme à terme et produit matriciel
Avant de commencer : Algorithmique et programmation en Python (L1) ; algèbre linéaire (matrices, L1).
1Je découvre
Mariama vient de commencer son stage dans un petit bureau d'études de Conakry qui travaille sur la gestion de l'eau. Son responsable lui confie un fichier de relevés : la pluie mensuelle (en millimètres) mesurée pendant une année à trois stations, Labé, Kankan et N'Zérékoré. Dans cette leçon, les valeurs sont supposées (elles servent d'exemple, ce ne sont pas des données officielles).
Mariama connaît Python. Elle écrit d'abord une liste de listes et trois boucles for imbriquées pour calculer le total annuel de chaque station, la moyenne de chaque mois et les mois de forte pluie. Le code fait trente lignes, il est lent dès que le fichier contient des relevés journaliers sur vingt ans, et une erreur d'indice s'y est glissée.
Son responsable lui montre la même chose en trois lignes avec NumPy, la bibliothèque de base du calcul scientifique en Python. Mariama travaillera avec cet outil pendant tout son stage : graphiques (leçon 2), précision des calculs (leçon 3), systèmes d'équations (leçon 4) et équations différentielles (leçon 5).
Comment représenter des données numériques en Python pour calculer vite, juste et sans boucles ?
2Je comprends
1. Le tableau NumPy (ndarray)
On importe la bibliothèque par convention sous le nom np :
import numpy as npL'objet central est le tableau à n dimensions, de type ndarray. Il diffère d'une liste Python sur trois points :
| Liste Python | Tableau NumPy | |
|---|---|---|
| Contenu | éléments de types quelconques | éléments tous du même type (dtype) |
| Stockage | références vers des objets dispersés | bloc contigu en mémoire |
+ | concatène deux listes | additionne terme à terme |
* 2 | répète la liste deux fois | multiplie chaque élément par 2 |
| Vitesse sur un calcul | boucle interprétée, lente | boucle compilée (en C), beaucoup plus rapide |
Chaque tableau possède des attributs utiles : shape (la forme, un tuple de tailles), ndim (le nombre de dimensions), size (le nombre total d'éléments) et dtype (le type des éléments, par exemple int64 ou float64).
Exemple
Les données de Mariama (mm, valeurs supposées), une ligne par station, une colonne par mois (janvier à décembre) :
P = np.array([[ 2, 3, 15, 45, 150, 260, 340, 380, 290, 140, 20, 3], # Labé
[ 1, 5, 20, 60, 120, 200, 280, 320, 260, 120, 15, 2], # Kankan
[15, 50, 120, 150, 180, 220, 210, 260, 300, 200, 90, 25]]) # N'Zérékoré
P.shape donne (3, 12) : 3 lignes, 12 colonnes.
P.ndim donne 2.
P.size donne 36.
P.dtype donne int64 : on n'a écrit que des entiers.
Si l'on écrit une seule valeur décimale (2.0), tout le tableau devient float64.
2. Créer des tableaux
| Fonction | Résultat | Exemple |
|---|---|---|
np.array(liste) | tableau à partir d'une liste | np.array([1, 2, 3]) |
np.zeros(n) ou np.zeros((m, n)) | tableau de zéros (float) | np.zeros((2, 3)) |
np.ones((m, n)) | tableau de uns | np.ones(4) |
np.arange(début, fin, pas) | valeurs espacées d'un pas, fin exclue | np.arange(0, 1, 0.25) donne [0. 0.25 0.5 0.75] |
np.linspace(a, b, n) | n valeurs régulièrement espacées, b inclus | np.linspace(0, 1, 5) donne [0. 0.25 0.5 0.75 1.] |
np.eye(n) | matrice identité In | np.eye(3) |
t.reshape(m, n) | même données, autre forme (m × n = taille) | np.arange(12).reshape(3, 4) |
Règle pratique : pour discrétiser un intervalle [a, b] en vue d'un graphique ou d'une intégration, préférez linspace, qui garantit le nombre de points et inclut b. Avec arange et un pas décimal, le nombre de points peut varier à cause des arrondis (leçon 3).
Le pas de linspace(a, b, n) vaut h = b - an - 1. Par exemple np.linspace(0, 2, 5) donne [0. 0.5 1. 1.5 2.], de pas h = 0,5.
3. Indexer, découper, filtrer
Les indices commencent à 0. Pour un tableau à deux dimensions, t[i, j] désigne la ligne i, colonne j. Les tranches début:fin:pas excluent la fin.
Exemple
a = np.arange(12).reshape(3, 4)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
a[1, 2] donne 6 (ligne 1, colonne 2)
a[1] donne [4 5 6 7] (toute la ligne 1)
a[:, 2] donne [ 2 6 10] (toute la colonne 2)
a[1:, ::2] donne [[ 4 6]
[ 8 10]] (lignes 1 et 2, une colonne sur deux)
a[-1, -1] donne 11 (les indices négatifs partent de la fin)
Vue ou copie ? Une tranche est une vue : elle partage la mémoire du tableau d'origine. Modifier la vue modifie l'original. Pour obtenir un tableau indépendant, on écrit b = a[1:].copy().
Masques booléens. Une comparaison sur un tableau donne un tableau de booléens, qui sert à filtrer :
masque = P > 300 # tableau (3, 12) de True / False
P[masque] # array([340, 380, 320]) : les valeurs > 300
(P > 300).sum(axis=1) # array([2, 1, 0]) : nombre de mois > 300 mm par station
P[P < 10] = 0 # remplace les très faibles valeurs par 0 (modifie P)Pour combiner des conditions, on utilise & (et), | (ou), ~ (non), avec des parenthèses : P[(P > 100) & (P < 200)].
4. Calculer sans boucle : vectorisation, axes et diffusion
Les opérations arithmétiques (+ - * / ) et les fonctions universelles (np.sqrt, np.exp, np.log, np.sin…) s'appliquent élément par élément : c'est la vectorisation**.
Les agrégats (sum, mean, std, min, max, argmax, cumsum) acceptent un argument axis :
axis=0: on agrège le long des lignes, il reste un résultat par colonne ;axis=1: on agrège le long des colonnes, il reste un résultat par ligne ;- sans
axis: on agrège tout le tableau.
Exemple
Avec le tableau P de forme (3, 12) :
P.sum(axis=1) donne [1648 1403 1820] : total annuel de Labé, Kankan, N'Zérékoré (mm).
P.mean(axis=1) donne [137.33 116.92 151.67] : moyenne mensuelle par station (arrondie).
P.argmax(axis=1) donne [7 7 8] : indice du mois le plus pluvieux.
7 correspond à août (janvier = 0), 8 à septembre.
P.sum(axis=0) donne 12 valeurs : la pluie cumulée des trois stations, mois par mois.
P[:, 5:9].sum(axis=1) donne [1270 1060 990] : pluie de juin à septembre (colonnes 5 à 8).
Vérification à la main pour Labé : 2 + 3 + 15 + 45 + 150 + 260 + 340 + 380 + 290 + 140 + 20 + 3 = 1648.
Diffusion (broadcasting). NumPy sait combiner des tableaux de formes différentes lorsque les formes sont compatibles : on compare les dimensions en partant de la droite ; deux tailles sont compatibles si elles sont égales ou si l'une vaut 1. La dimension de taille 1 est alors « étirée ».
Méthode
Pour exprimer chaque mois en pourcentage du total annuel de sa station :
- Calculez les totaux en gardant la dimension : tot = P.sum(axis=1, keepdims=True), de forme (3, 1).
- Vérifiez la compatibilité : (3, 12) et (3, 1) ; à droite 12 et 1 sont compatibles, à gauche 3 et 3 aussi.
- Divisez : pct = P / tot * 100, de forme (3, 12).
- Contrôlez : pct.sum(axis=1) doit donner 100 pour chaque station (à l'arrondi près).
Résultat pour le mois d'août (colonne 7) : environ 23,1 % ; 22,8 % ; 14,3 %.
Sans keepdims=True, P.sum(axis=1) a la forme (3,), que NumPy aligne à droite avec (3, 12) : il compare 3 et 12, qui sont incompatibles, et lève une erreur ValueError.
5. Matrices : produit terme à terme et produit matriciel
Pour deux tableaux de même forme, A * B est le produit terme à terme (produit de Hadamard). Le produit matriciel AB, défini par (AB)ij = Σk aik bkj, s'écrit A @ B (ou np.dot(A, B)). La transposée s'écrit A.T.
Exemple
A = np.array([[1, 2], [3, 4]]) B = np.array([[0, 1], [1, 0]])
A * B donne [[0 2] (1×0, 2×1 ; 3×1, 4×0)
[3 0]]
A @ B donne [[2 1] ligne 1 : (1×0 + 2×1, 1×1 + 2×0) = (2, 1)
[4 3]] ligne 2 : (3×0 + 4×1, 3×1 + 4×0) = (4, 3)
A.T donne [[1 3]
[2 4]]
Le module np.linalg fournit les outils d'algèbre linéaire : np.linalg.solve (systèmes, leçon 4), np.linalg.det, np.linalg.norm, np.linalg.eig.
Pour lire des données réelles, np.loadtxt("pluie.csv", delimiter=",", skiprows=1) charge un fichier texte en tableau ; np.savetxt fait l'inverse. Pour des tableaux avec des colonnes de types différents (dates, noms, nombres), on utilise plutôt la bibliothèque pandas, construite sur NumPy.
3Je retiens
Je retiens
Un ndarray contient des éléments d'un seul type, rangés de façon contiguë : calculs rapides.
Attributs : shape (forme), ndim, size, dtype.
arange exclut la fin et fixe le pas ; linspace inclut la fin et fixe le nombre de points.
Indices à partir de 0 ; t[i, j] ; tranches début:fin:pas, fin exclue ; une tranche est une vue.
Un masque booléen filtre : t[t > s] ; conditions combinées avec &, |, ~ et des parenthèses.
axis=0 donne un résultat par colonne, axis=1 un résultat par ligne.
Diffusion : tailles égales ou égales à 1, en comparant les formes depuis la droite.
A * B est terme à terme ; A @ B est le produit matriciel.
4Erreurs fréquentes
- Écrire une boucle for sur les éléments d'un tableau là où une opération vectorisée suffit.
- Oublier que les indices commencent à 0 : août est la colonne 7, pas la colonne 8.
- Modifier une tranche en croyant travailler sur une copie : utilisez .copy().
- Écrire P > 100 and P < 200 : sur un tableau, il faut (P > 100) & (P < 200).
- Confondre A * B (terme à terme) et A @ B (produit matriciel).
- Diviser P par P.sum(axis=1) sans keepdims=True : formes (3, 12) et (3,) incompatibles.
5Je m’exerce
1Exercice 1
(Questions de cours) a) Citez deux différences entre une liste Python et un tableau NumPy. b) Que donnent np.arange(2, 10, 3) et np.linspace(2, 10, 3) ? c) Que signifie axis=0 dans t.sum(axis=0) ?
Voir le corrigéCacher le corrigé
a) Un tableau NumPy contient des éléments d'un seul type, rangés de façon contiguë en mémoire ; une liste peut mélanger les types. Sur un tableau, + additionne terme à terme, alors que sur des listes + concatène. b) np.arange(2, 10, 3) donne [2 5 8] (pas de 3, 10 exclu) ; np.linspace(2, 10, 3) donne [ 2. 6. 10.] (3 points, 10 inclus, pas 10 - 22 = 4). c) On somme le long des lignes : on obtient une valeur par colonne.
2Exercice 2
Les températures maximales (°C, valeurs supposées) relevées pendant une semaine à Kankan sont T = np.array([34, 36, 38, 37, 35, 33, 32]).
a) Calculez la moyenne de la semaine.
b) Convertissez le tableau en degrés Fahrenheit (F = 95C + 32) sans boucle.
c) Écrivez l'instruction qui donne les températures strictement supérieures à 35 °C, et celle qui compte ces jours.
d) Que renvoie np.diff(T) ? Interprétez.
Voir le corrigéCacher le corrigé
T.mean() # 35.0
F = T * 9 / 5 + 32 # [93.2 96.8 100.4 98.6 95. 91.4 89.6]
T[T > 35] # array([36, 38, 37])
(T > 35).sum() # 3 jours (True compte pour 1)
np.diff(T) # array([ 2, 2, -1, -2, -2, -1])a) 34 + 36 + 38 + 37 + 35 + 33 + 327 = 2457 = 35 °C. b) Par exemple 95 × 38 + 32 = 100,4 °F. d) np.diff renvoie les différences entre jours successifs : la température monte de 2 °C deux jours de suite, puis baisse chaque jour jusqu'à la fin de la semaine.
3Exercice 3
Soit a = np.arange(12).reshape(3, 4). Donnez sans ordinateur le résultat de : a) a[2, 1] ; b) a[:, -1] ; c) a[0:2, 1:3] ; d) a.sum(axis=0) ; e) a[a % 2 == 0].
Voir le corrigéCacher le corrigé
a) 9. b) [ 3 7 11]. c) [[1 2] [5 6]]. d) [12 15 18 21] (par exemple 0 + 4 + 8 = 12). e) [ 0 2 4 6 8 10].
4Exercice 4
On exécute :
a = np.arange(5)
b = a[1:4]
b[0] = 100Que contient a ? Corrigez le code pour que a ne soit pas modifié.
Voir le corrigéCacher le corrigé
b est une vue sur a[1:4] : b[0] est l'élément a[1]. Donc a vaut [ 0 100 2 3 4]. Correction : b = a[1:4].copy() ; alors a reste [0 1 2 3 4].
5Exercice 5
Dites si les formes suivantes sont compatibles pour la diffusion et, si oui, donnez la forme du résultat : a) (3, 12) et (12,) ; b) (3, 12) et (3,) ; c) (4, 1) et (1, 5) ; d) (2, 3) et (3, 2).
Voir le corrigéCacher le corrigé
a) Compatibles : à droite 12 et 12 ; le tableau (12,) est répété pour chaque ligne ; résultat (3, 12). b) Incompatibles : 12 et 3 diffèrent et aucun ne vaut 1 (il faut (3, 1)). c) Compatibles : 1 et 5, puis 4 et 1 ; résultat (4, 5). d) Incompatibles : 3 et 2 diffèrent.
6Exercice 6
(Type examen) On reprend le tableau P des pluies de Mariama (forme (3, 12), une ligne par station).
a) Écrivez l'instruction qui donne le cumul de la pluie de Labé depuis janvier, mois par mois. Quel est le cumul à fin juin ?
b) Écrivez l'instruction qui donne, pour chaque mois, la moyenne des trois stations, puis l'écart de chaque station à cette moyenne (tableau (3, 12)).
c) Écrivez une fonction mois_humides(P, seuil) qui renvoie, pour chaque station, le nombre de mois où la pluie dépasse seuil. Que renvoie-t-elle pour seuil = 200 ?
d) Calculez A @ A.T pour A = np.array([[1, 2], [3, 4]]) et vérifiez que le résultat est symétrique.
Voir le corrigéCacher le corrigé
a)
cumul = np.cumsum(P[0])
cumul[5] # fin juin = indice 5 : 475Vérification : 2 + 3 + 15 + 45 + 150 + 260 = 475 mm.
b)
moy = P.mean(axis=0) # forme (12,)
ecart = P - moy # (3, 12) - (12,) : diffusion, forme (3, 12)Par exemple pour août : moyenne 380 + 320 + 2603 = 320 ; écarts 60, 0, -60 mm.
c)
def mois_humides(P, seuil):
return (P > seuil).sum(axis=1)
mois_humides(P, 200) # array([4, 3, 4])Labé : juin 260, juillet 340, août 380, septembre 290, soit 4 mois. Kankan : juillet 280, août 320, septembre 260, soit 3 mois (juin vaut exactement 200, non compté). N'Zérékoré : juin 220, juillet 210, août 260, septembre 300, soit 4 mois.
d) AAT = beginpmatrix 1 & 2
3 & 4 endpmatrixbeginpmatrix 1 & 3
2 & 4 endpmatrix = beginpmatrix 5 & 11
11 & 25 endpmatrix. Il est symétrique : (AAT)T = (AT)T AT = AAT. En Python : np.array_equal(A @ A.T, (A @ A.T).T) renvoie True.
Cherchez d’abord seul, sur votre cahier, puis ouvrez le corrigé pour comparer.
6Je vérifie
Choisissez une réponse pour chaque question : la correction s’affiche aussitôt.
Karamö, votre enseignant
Il a lu cette leçon. Posez-lui votre question : il vous répond ici.
Connectez-vous pour poser vos questions à Karamö.
Avec un compte Kharandi gratuit, vous cochez les leçons terminées et vous suivez votre progression, cours par cours.