Aller au contenu
Calcul scientifique avec Python · L2

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 np

L'objet central est le tableau à n dimensions, de type ndarray. Il diffère d'une liste Python sur trois points :

Liste PythonTableau NumPy
Contenuéléments de types quelconqueséléments tous du même type (dtype)
Stockageréférences vers des objets dispersésbloc contigu en mémoire
+concatène deux listesadditionne terme à terme
* 2répète la liste deux foismultiplie chaque élément par 2
Vitesse sur un calculboucle interprétée, lenteboucle 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

FonctionRésultatExemple
np.array(liste)tableau à partir d'une listenp.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 unsnp.ones(4)
np.arange(début, fin, pas)valeurs espacées d'un pas, fin excluenp.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 inclusnp.linspace(0, 1, 5) donne [0. 0.25 0.5 0.75 1.]
np.eye(n)matrice identité Innp.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 :

  1. Calculez les totaux en gardant la dimension : tot = P.sum(axis=1, keepdims=True), de forme (3, 1).
  2. Vérifiez la compatibilité : (3, 12) et (3, 1) ; à droite 12 et 1 sont compatibles, à gauche 3 et 3 aussi.
  3. Divisez : pct = P / tot * 100, de forme (3, 12).
  4. 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] = 100

Que 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 : 475

Vé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.

1Que vaut np.linspace(0, 1, 5) ?
Voir la réponse

Réponse B : [0. 0.25 0.5 0.75 1.]. linspace donne 5 points régulièrement espacés, extrémité 1 incluse : pas de 0,25.

2Pour un tableau t de forme (3, 12), t.mean(axis=1) a pour forme :
Voir la réponse

Réponse B : (3,). axis=1 agrège le long des colonnes : il reste une valeur par ligne.

3Quelle instruction sélectionne les valeurs comprises strictement entre 100 et 200 ?
Voir la réponse

Réponse C : t[(t > 100) & (t < 200)]. Sur un tableau, on combine les masques avec & et des parenthèses.

4Après b = a[2:5] puis b[:] = 0, le tableau a :
Voir la réponse

Réponse A : est modifié, car b est une vue. Une tranche partage la mémoire de l'original ; il faut .copy() pour l'éviter.

5Les formes (4, 1) et (3,) sont-elles compatibles pour la diffusion ?
Voir la réponse

Réponse A : oui, le résultat a la forme (4, 3). On aligne à droite : 1 et 3 sont compatibles, puis 4 face à une dimension absente ; résultat (4, 3).

6Pour deux matrices carrées A et B, le produit matriciel s'écrit :
Voir la réponse

Réponse B : A @ B. * multiplie terme à terme ; @ calcule le produit matriciel.

7Quel est le dtype de np.array([1, 2, 3.5]) ?
Voir la réponse

Réponse B : float64. Un seul élément décimal suffit : tous les éléments sont convertis en flottants.

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ö.

Vous avez fini la leçon ?

Avec un compte Kharandi gratuit, vous cochez les leçons terminées et vous suivez votre progression, cours par cours.

Karamö
Un point pas clair ? Dites à Karamö ce qui vous bloque dans cette leçon : il vous l’explique autrement, pas à pas, sans faire le travail à votre place. Demander à Karamö
Signaler une erreur dans cette leçon

Toutes les leçons de Calcul scientifique avec Python

Pose ta question à Karamö