Tableaux NumPy en Python : calcul vectorisé, broadcasting et indexation

Le moteur de tableaux sous pandas et scikit-learn — remplacez les boucles Python par des calculs rapides et vectorisés.

Apprenez les tableaux NumPy depuis la base : créez des tableaux, comprenez le dtype et la shape, faites de l’arithmétique élément par élément (vectorisée), maîtrisez le broadcasting, et sélectionnez des données par slicing, masques booléens et indexation avancée — sans oublier les agrégations et le redimensionnement.

AstucePoints clés

• Un tableau est une grille d’un seul type — dtype fixe, shape fixe. C’est cette uniformité qui le rend rapide et compact en mémoire, contrairement à une liste Python.
• Vectorisez, ne bouclez pas — écrivez a + b ou np.sqrt(a) sur des tableaux entiers et NumPy exécute la boucle en C. C’est le même calcul sans le for de Python, et souvent 50 à 100× plus rapide.
• Le broadcasting étire les shapes pour vous — un scalaire, une ligne ou une colonne est automatiquement adapté à un tableau plus grand, si bien que matrix + row fonctionne tout simplement (quand les shapes sont compatibles).
• Trois façons de sélectionner — le slicing (a[1:3]), le masquage booléen (a[a > 0]) et l’indexation avancée (a[[0, 2, 4]]) couvrent presque tout ce dont vous aurez besoin.
• Agrégez le long d’un axe — a.sum(), a.mean(axis=0), a.std(axis=1) : axis est la dimension que vous réduisez, pas celle que vous conservez.
• Une slice est une vue, pas une copie — modifier une slice modifie l’original. Utilisez .copy() quand vous avez besoin d’indépendance.

Introduction

Presque tous les outils numériques de Python reposent sur NumPy. Les DataFrames pandas sont des tableaux en dessous ; scikit-learn reçoit et renvoie des tableaux ; matplotlib les trace. Apprendre NumPy n’est donc pas une quête annexe — c’est le socle sur lequel tout le reste est bâti.

Tout l’intérêt de NumPy tient en une idée : arrêter d’écrire des boucles sur des nombres. Une simple liste Python vous oblige à traiter les éléments un par un, dans du bytecode Python lent. Un tableau NumPy stocke ses nombres dans un bloc de mémoire compact, tous du même type, si bien que NumPy peut exécuter la boucle en C compilé et utiliser les instructions vectorielles de votre processeur. Vous écrivez a * 2 ; NumPy fait le travail — plus rapide, plus court et plus lisible.

Cette leçon construit ce socle : créer des tableaux, leur dtype et leur shape, l’arithmétique vectorisée, le broadcasting (la partie sur laquelle tout le monde trébuche), les trois façons d’indexer, les agrégations et le redimensionnement.

Chaque résultat sur cette page est réel — et vous pouvez l’exécuter vous-même sans rien installer : cliquez sur Try ▸ sous n’importe quel bloc pour l’exécuter en direct dans votre navigateur (Python démarre au premier Run, puis c’est instantané), ou modifiez la cellule Essayez en direct vers la fin et appuyez sur Run.

Pourquoi des tableaux : la boucle contre la ligne unique

Voici le contraste qui motive tout le reste. Supposons que vous vouliez doubler chaque nombre d’une collection d’un million d’éléments. La façon « liste Python » est une boucle explicite :

data = list(range(1_000_000))

doubled = []
for x in data:
    doubled.append(x * 2)

print(doubled[:5])

[0, 2, 4, 6, 8]

Ça fonctionne, mais chaque multiplication et chaque .append() s’exécute dans l’interpréteur Python — un million d’allers-retours. La façon NumPy est une expression unique sur le tableau entier :

import numpy as np

arr = np.arange(1_000_000)
doubled = arr * 2          # the loop happens in C, not Python

print(doubled[:5])

[0 2 4 6 8]

Même résultat, sans for. C’est la vectorisation : une opération écrite une seule fois, appliquée à chaque élément à la vitesse native. Vérifions que c’est bel et bien plus rapide :

import numpy as np

py_list = list(range(1_000_000))
np_arr = np.arange(1_000_000)

import timeit
loop_time = timeit.timeit(lambda: [x * 2 for x in py_list], number=5) / 5
vec_time = timeit.timeit(lambda: np_arr * 2, number=5) / 5

print(f"Python loop: {loop_time*1000:.1f} ms")
print(f"NumPy vectorized: {vec_time*1000:.1f} ms")
print(f"Speed-up: {loop_time/vec_time:.0f}x")

Python loop: 41.9 ms
NumPy vectorized: 1.4 ms
Speed-up: 31x

La version vectorisée est radicalement plus rapide, et l’écart se creuse à mesure que les données grandissent. Ce gain de vitesse est la raison d’être de NumPy — et la raison pour laquelle vous n’écrirez presque plus jamais de boucle for numérique.

Créer des tableaux

Vous créerez des tableaux de plusieurs façons. La plus directe est np.array() à partir d’une liste Python :

import numpy as np

a = np.array([1, 2, 3, 4])          # from a list → 1D array
b = np.array([[1, 2, 3], [4, 5, 6]]) # list of lists → 2D array (a matrix)

print(a)
print(b)

[1 2 3 4]
[[1 2 3]
 [4 5 6]]

Pour les plages et les grilles, NumPy vous fournit des générateurs pour vous éviter de saisir les valeurs à la main. arange est comme range mais renvoie un tableau ; linspace vous donne un nombre fixe de points régulièrement espacés (parfait pour tracer) ; zeros, ones et full construisent des tableaux pré-remplis d’une shape donnée :

import numpy as np

print(np.arange(0, 10, 2))        # start, stop (excluded), step → 0 2 4 6 8
print(np.linspace(0, 1, 5))       # 5 points evenly spaced from 0 to 1 inclusive
print(np.zeros(3))                # three zeros
print(np.ones((2, 3)))            # a 2×3 grid of ones
print(np.full((2, 2), 7))         # a 2×2 grid filled with 7

[0 2 4 6 8]
[0.   0.25 0.5  0.75 1.  ]
[0. 0. 0.]
[[1. 1. 1.]
 [1. 1. 1.]]
[[7 7]
 [7 7]]

Pour des données aléatoires — simulations, jeux de test, mélanges — utilisez un générateur. Le graine (seed) rend la sortie reproductible (vous obtenez les mêmes nombres « aléatoires » à chaque exécution, ce qui est précisément ce que l’on veut dans une leçon ou un test) :

import numpy as np

rng = np.random.default_rng(seed=42)   # seeded → reproducible

print(rng.random(4))                    # 4 floats in [0, 1)
print(rng.integers(1, 7, size=5))       # 5 dice rolls (1–6)
print(rng.normal(loc=0, scale=1, size=4)) # 4 draws from a normal distribution

[0.77395605 0.43887844 0.85859792 0.69736803]
[2 1 4 6 5]
[-0.31624259 -0.01680116 -0.85304393  0.87939797]

dtype et shape : ce que chaque tableau sait sur lui-même

Deux attributs décrivent n’importe quel tableau. Le dtype est l’unique type partagé par chaque élément (int64, float64, bool, …) — cette uniformité est exactement ce qui rend les tableaux rapides. La shape est un tuple donnant la taille le long de chaque dimension :

import numpy as np

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

print("dtype:", b.dtype)   # int64 — every element is an integer
print("shape:", b.shape)   # (2, 3) — 2 rows, 3 columns
print("ndim: ", b.ndim)    # 2 — it's two-dimensional
print("size: ", b.size)    # 6 — total number of elements

dtype: int64
shape: (2, 3)
ndim:  2
size:  6

Vous pouvez fixer le dtype au moment de créer un tableau, ou convertir avec .astype(). Observez ce qui arrive aux décimales lorsque vous forcez le type entier :

import numpy as np

floats = np.array([1.7, 2.9, 3.1])
ints = floats.astype(int)      # converting to int TRUNCATES — it does not round

print(ints)                    # [1 2 3], not [2 3 3]

[1 2 3]

Cette troncature est une surprise classique — .astype(int) coupe la décimale, il n’arrondit pas. Utilisez np.round() d’abord si vous voulez arrondir.

Arithmétique vectorisée

L’arithmétique sur les tableaux est élément par élément : l’opérateur est appliqué à chaque paire d’éléments correspondants, sans aucune boucle de votre côté. Des tableaux de même shape se combinent position par position :

import numpy as np

a = np.array([10, 20, 30, 40])
b = np.array([1, 2, 3, 4])

print(a + b)     # [11 22 33 44]
print(a * b)     # [10 40 90 160]
print(a / b)     # [10. 10. 10. 10.]
print(a ** 2)    # [100 400 900 1600]

[11 22 33 44]
[ 10  40  90 160]
[10. 10. 10. 10.]
[ 100  400  900 1600]

Il en va de même pour les fonctions mathématiques de NumPy — np.sqrt, np.exp, np.log, np.sin agissent toutes sur chaque élément d’un coup :

import numpy as np

x = np.array([1, 4, 9, 16])

print(np.sqrt(x))   # [1. 2. 3. 4.]
print(np.log(x))    # natural log of each element

[1. 2. 3. 4.]
[0.         1.38629436 2.19722458 2.77258872]

Les comparaisons sont elles aussi vectorisées, et elles renvoient un tableau booléen — un True/False par élément. Retenez bien ceci ; c’est le moteur derrière le masquage booléen plus bas :

import numpy as np

scores = np.array([55, 90, 72, 48, 88])

print(scores >= 60)   # [False  True  True False  True]

[False  True  True False  True]

Broadcasting : du calcul entre shapes différentes

Jusqu’ici les tableaux concordaient. Le broadcasting est la règle qui permet à NumPy de combiner des tableaux de shapes différentes en étirant automatiquement le plus petit — sans jamais copier les données. C’est la fonctionnalité qui rend NumPy si fluide, et celle qui mérite d’être comprise avec précision.

Le cas le plus simple est un scalaire et un tableau. Le scalaire est traité comme s’il était étiré jusqu’à chaque position :

import numpy as np

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

print(a + 100)    # 100 is added to every element → [101 102 103 104]
print(a * 0.5)    # every element halved

[101 102 103 104]
[0.5 1.  1.5 2. ]

Le cas intéressant est une ligne ajoutée à une matrice. Voici un exemple détaillé sur les shapes. Nous avons une matrice (3, 4) et une ligne de longueur 4, et nous voulons soustraire cette ligne de chaque ligne de la matrice — pensez à « soustraire les moyennes de colonnes de chaque ligne » :

import numpy as np

matrix = np.array([[10, 20, 30, 40],
                   [11, 21, 31, 41],
                   [12, 22, 32, 42]])   # shape (3, 4)

row = np.array([1, 2, 3, 4])            # shape (4,)

result = matrix - row
print(result)

[[ 9 18 27 36]
 [10 19 28 37]
 [11 20 29 38]]

Pourquoi cela fonctionne-t-il ? NumPy aligne les shapes en partant de la droite et les compare dimension par dimension. Deux dimensions sont compatibles si elles sont égales ou si l’une d’elles vaut 1 (ou est absente). Ici :

matrix:  (3, 4)
row:        (4,)   →  treated as (1, 4)
            -----
result:  (3, 4)    →  the length-1 first dim is stretched to 3

La première dimension absente de la ligne est traitée comme 1, puis étirée à 3 — si bien que la même ligne est soustraite des trois lignes de la matrice. Pas de boucle, pas de copie. Si les dimensions de fin ne concordent pas (et qu’aucune ne vaut 1), vous obtenez une ValueError — c’est l’erreur de discordance de shape que vous rencontrerez dans la section suivante.

Pour diffuser une colonne à la place, donnez-lui la shape (3, 1) afin qu’elle s’étire sur les colonnes :

import numpy as np

matrix = np.array([[1, 2, 3],
                   [4, 5, 6]])          # shape (2, 3)

col = np.array([[10], [20]])            # shape (2, 1) — a column

print(matrix + col)                     # 10 added to row 0, 20 to row 1

[[11 12 13]
 [24 25 26]]

Indexation et slicing

Extraire des données d’un tableau commence de la même façon qu’avec une liste Python. Pour le 1D, indexez à partir de 0 (les négatifs comptent depuis la fin) et découpez avec start:stop:step (stop exclu) :

import numpy as np

a = np.array([10, 20, 30, 40, 50])

print(a[0])      # 10  — first
print(a[-1])     # 50  — last
print(a[1:4])    # [20 30 40] — items 1,2,3
print(a[::2])    # [10 30 50] — every other item

10
50
[20 30 40]
[10 30 50]

Pour le 2D, utilisez un indice par dimension à l’intérieur des crochets : arr[row, col]. Un : signifie « toute cette dimension », c’est ainsi que l’on récupère une ligne ou une colonne entière :

import numpy as np

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

print(m[0, 2])    # 3  — row 0, column 2
print(m[1])       # [4 5 6] — the whole second row
print(m[:, 0])    # [1 4 7] — the whole first column
print(m[0:2, 1:]) # top-right block: rows 0–1, columns 1+

3
[4 5 6]
[1 4 7]
[[2 3]
 [5 6]]

Masquage booléen : sélectionner par condition

C’est celui que vous utiliserez constamment. Une comparaison vous donne un tableau booléen (de la section sur l’arithmétique) ; renvoyez ce masque dans les crochets et vous obtenez uniquement les éléments où il vaut True :

import numpy as np

scores = np.array([55, 90, 72, 48, 88, 61])

passed = scores >= 60          # the boolean mask
print(passed)                  # [False  True  True False  True  True]
print(scores[passed])          # [90 72 88 61] — only the passing scores
print(scores[scores >= 60])    # same thing in one line — the idiom you'll write

[False  True  True False  True  True]
[90 72 88 61]
[90 72 88 61]

Vous pouvez aussi affecter à travers un masque — une façon propre de plafonner ou de remplacer des valeurs sur place. Ici nous ramenons à 0 chaque score en échec :

import numpy as np

scores = np.array([55, 90, 72, 48, 88, 61])
scores[scores < 60] = 0        # set every sub-60 score to 0
print(scores)

[ 0 90 72  0 88 61]

Combinez les conditions avec & (et) et | (ou) — avec des parenthèses autour de chacune, car les opérateurs de NumPy ont une priorité élevée :

import numpy as np

scores = np.array([55, 90, 72, 48, 88, 61])
print(scores[(scores >= 60) & (scores < 85)])   # 60 ≤ score < 85

[72 61]

Indexation avancée : sélectionner par liste de positions

Passez une liste d’indices pour extraire exactement ces éléments, dans exactement cet ordre — répétitions comprises :

import numpy as np

a = np.array([10, 20, 30, 40, 50])

print(a[[0, 2, 4]])     # [10 30 50] — items at those positions
print(a[[4, 4, 0]])     # [50 50 10] — order and repeats are honored

[10 30 50]
[50 50 10]

Agrégations le long d’un axe

Réduire un tableau à un résumé — somme, moyenne, écart-type, min, max — est un appel de méthode. Sur le tableau entier vous obtenez un seul nombre :

import numpy as np

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

print(m.sum())    # 21 — every element
print(m.mean())   # 3.5
print(m.std())    # spread of all six values

21
3.5
1.707825127659933

La partie utile est axis. La règle qui garde tout le monde sur les rails : axis est la dimension que vous réduisez, pas celle que vous conservez. Pour un tableau 2D, axis=0 réduit les lignes (vous obtenez donc un résultat par colonne), et axis=1 réduit les colonnes (un résultat par ligne) :

import numpy as np

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

print(m.sum(axis=0))   # [5 7 9]  — column sums (rows collapsed)
print(m.sum(axis=1))   # [6 15]   — row sums (columns collapsed)
print(m.mean(axis=0))  # [2.5 3.5 4.5] — column means

[5 7 9]
[ 6 15]
[2.5 3.5 4.5]

Si vous oubliez lequel est lequel, rappelez-vous la shape de la réponse : axis=0 sur un tableau (2, 3) laisse la shape (3,) — le nombre de colonnes survit.

Redimensionnement

Les mêmes données peuvent revêtir différentes shapes. .reshape() réorganise les éléments en de nouvelles dimensions tant que le nombre total concorde ; -1 signifie « déduis cette dimension pour moi » :

import numpy as np

a = np.arange(12)          # 0..11, shape (12,)

print(a.reshape(3, 4))     # 3 rows, 4 columns
print(a.reshape(2, -1))    # 2 rows, NumPy infers 6 columns

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

Deux autres que vous emploierez : .ravel() aplatit n’importe quel tableau en 1D, et .T transpose (échange les lignes et les colonnes) :

import numpy as np

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

print(m.ravel())   # [1 2 3 4 5 6] — flattened to 1D
print(m.T)         # transposed → 3 rows, 2 columns

[1 2 3 4 5 6]
[[1 4]
 [2 5]
 [3 6]]

Un graphique rapide : une fonction vectorisée

Pour voir la vectorisation payer visuellement, construisez un axe x avec linspace, appliquez np.sin à tout le tableau d’un coup, et tracez le résultat. Pas de boucle — un tableau en entrée, un tableau en sortie :

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 4 * np.pi, 200)   # 200 evenly spaced points
y = np.sin(x)                         # np.sin applied to the whole array

fig, ax = plt.subplots(figsize=(7, 3))
ax.plot(x, y, color="#3a86d4", linewidth=2)
ax.set_title("y = sin(x), computed on a NumPy array")
ax.set_xlabel("x")
ax.set_ylabel("sin(x)")
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()

Figure 1

Chaque point de cette courbe est issu d’un seul appel vectorisé — np.sin(x) — et non d’une boucle Python sur 200 angles.

🟢 Avec un agent IA

Collez votre boucle for Python lente sur des nombres et demandez à Prova « vectorise ceci avec NumPy » — elle réécrit la boucle en une expression de tableau unique. Comme le runtime est juste là, vous exécutez les deux versions et vérifiez qu’elles concordent avec np.allclose(loop_result, vec_result), de sorte que vous faites confiance à la réécriture au lieu d’accepter une réponse plausible sur parole. The runtime is the judge. Demander à Prova →

Essayez en direct

Les blocs ci-dessus ont été exécutés au moment de la génération. Modifiez celui-ci et appuyez sur Run pour essayer NumPy par vous-même — il s’exécute dans votre navigateur via Pyodide (sans installation). Ou cliquez sur Try ▸ sous n’importe quel bloc ci-dessus pour y déposer son code.

Problèmes courants

Discordance de shape dans le broadcasting. Combiner des tableaux dont les dimensions de fin ne s’alignent pas (et ne valent pas 1) lève ValueError: operands could not be broadcast together. La solution est de vérifier .shape des deux côtés et de redimensionner pour que les dimensions soient égales ou que l’une vaille 1 :

import numpy as np

a = np.array([1, 2, 3])        # shape (3,)
b = np.array([1, 2, 3, 4])     # shape (4,)
a + b                          # 3 vs 4 — not compatible

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[26], line 5
      3 a = np.array([1, 2, 3])        # shape (3,)
      4 b = np.array([1, 2, 3, 4])     # shape (4,)
----> 5 a + b                          # 3 vs 4 — not compatible

ValueError: operands could not be broadcast together with shapes (3,) (4,) 

Surprises de dtype entier contre flottant. Un tableau d’entiers reste entier, si bien que la division entière tronque vers le bas et que vous ne pouvez pas y stocker de décimale. Si vous affectez 3.7 dans un tableau int, il est tronqué à 3. Créez le tableau en float (np.array([1, 2, 3], dtype=float)) lorsque vous y conserverez des décimales.

import numpy as np

a = np.array([1, 2, 3])    # dtype int64
a[0] = 9.9                 # silently truncated to 9
print(a)

[9 2 3]

Une slice est une vue, pas une copie. Le slicing renvoie une fenêtre sur la même mémoire — modifier la slice modifie le tableau d’origine. Utilisez .copy() quand vous avez besoin d’un morceau indépendant :

import numpy as np

a = np.array([1, 2, 3, 4, 5])
view = a[1:4]
view[0] = 99               # changes a too!
print("original:", a)      # [ 1 99  3  4  5]

a = np.array([1, 2, 3, 4, 5])
safe = a[1:4].copy()       # an independent copy
safe[0] = 99
print("with copy:", a)     # untouched

original: [ 1 99  3  4  5]
with copy: [1 2 3 4 5]

array == array renvoie un tableau, pas un seul True/False. Comparer deux tableaux vous donne un tableau booléen élément par élément, il ne peut donc pas être utilisé directement dans un if. Réduisez-le avec .all() (« tous les éléments égaux ») ou .any() (« au moins un »), ou utilisez np.array_equal(a, b) pour comparer des tableaux entiers :

import numpy as np

a = np.array([1, 2, 3])
b = np.array([1, 9, 3])
print(a == b)              # [ True False  True] — an array
print((a == b).all())      # False — now it's a single bool
print(np.array_equal(a, b))# False — whole-array comparison

[ True False  True]
False
False

Questions fréquentes

NotePourquoi NumPy est-il plus rapide qu’une boucle Python ?

Une liste Python stocke des objets encapsulés dispersés en mémoire, et une boucle for les traite un par un à travers l’interpréteur. Un tableau NumPy stocke des nombres bruts d’un seul type dans un unique bloc contigu, si bien que NumPy peut exécuter toute l’opération en C compilé et utiliser les instructions vectorielles (SIMD) de votre processeur. Vous évitez entièrement le surcoût de l’interpréteur par élément, ce qui explique pourquoi le code vectorisé est couramment 50 à 100× plus rapide sur de grands tableaux.

NoteQu’est-ce que le broadcasting dans NumPy ?

Le broadcasting est la règle de NumPy pour faire de l’arithmétique entre des tableaux de shapes différentes sans copier les données. NumPy aligne les shapes en partant de la droite et, pour chaque dimension, les accepte si elles sont égales ou si l’une d’elles vaut 1 — la dimension de taille 1 (ou absente) est « étirée » pour correspondre. C’est ainsi que array + scalar, ou matrix + row, fonctionne tout simplement. Si les dimensions de fin ne concordent pas et qu’aucune ne vaut 1, vous obtenez une ValueError de broadcasting.

NoteComment sélectionner des éléments avec une condition dans NumPy ?

Utilisez un masque booléen. Écrivez la condition sur le tableau — a > 0 — qui renvoie un tableau booléen, puis indexez avec : a[a > 0] renvoie uniquement les éléments où la condition vaut True. Combinez les conditions avec & (et) et | (ou), en entourant chacune de parenthèses : a[(a > 0) & (a < 10)]. Vous pouvez aussi affecter à travers un masque, par ex. a[a < 0] = 0 pour plafonner les négatifs.

NoteQue signifient axis=0 et axis=1 ?

axis est la dimension que vous réduisez, pas celle que vous conservez. Pour un tableau 2D, axis=0 réduit le long des lignes et renvoie une valeur par colonne (par colonne), tandis que axis=1 réduit à travers les colonnes et renvoie une valeur par ligne (par ligne). Si vous oubliez, vérifiez la shape du résultat : axis=0 sur un tableau (2, 3) donne la shape (3,), donc les colonnes ont survécu.

NoteQuelle est la différence entre un tableau NumPy et une liste Python ?

Une liste est un conteneur souple et ordonné qui peut mélanger les types et grandir, mais elle est lente pour le calcul car chaque élément est un objet Python distinct. Un tableau NumPy est une grille de taille fixe d’un seul dtype, stockée de façon compacte, ce qui rend le calcul élément par élément, le broadcasting et les agrégations rapides et concis. Utilisez une liste pour la gestion générale ; utilisez un tableau dès l’instant où vous faites du travail numérique.

Testez vos connaissances

Travaillez chaque tâche dans la cellule Essayez en direct ci-dessus — modifiez et exécutez.

ImportantÀ votre tour — travaillez ceci avant de regarder

Tâche 1. Créez le tableau temps = np.array([18, 22, 30, 15, 27, 33]) (températures en °C). Sans boucle, produisez un nouveau tableau ne contenant que les températures au-dessus de 25.

AstuceIndice

Une comparaison comme temps > 25 crée un masque booléen ; indexez le tableau avec ce masque.

AstuceSolution

import numpy as np
temps = np.array([18, 22, 30, 15, 27, 33])
print(temps[temps > 25])

[30 27 33]

temps > 25 construit un tableau booléen, et l’indexation avec celui-ci renvoie uniquement les éléments où il vaut True — sans aucune boucle.

Tâche 2. Vous avez une matrice (2, 3) m = np.array([[1, 2, 3], [4, 5, 6]]). Calculez la moyenne de chaque colonne, puis la moyenne de chaque ligne.

AstuceIndice

axis est la dimension que vous réduisez. Les moyennes de colonnes réduisent les lignes ; les moyennes de lignes réduisent les colonnes.

AstuceSolution

import numpy as np
m = np.array([[1, 2, 3], [4, 5, 6]])
print(m.mean(axis=0))   # column means → [2.5 3.5 4.5]
print(m.mean(axis=1))   # row means    → [2. 5.]

[2.5 3.5 4.5]
[2. 5.]

axis=0 réduit les lignes (une moyenne par colonne) ; axis=1 réduit les colonnes (une moyenne par ligne).

Vérification rapide. Vous avez une matrice de shape (4, 3) et vous lui ajoutez un tableau 1D de shape (3,). Est-ce que ça fonctionne, et que calcule-t-il ?

AstuceAfficher la réponse

Oui, ça fonctionne par broadcasting. NumPy aligne les shapes en partant de la droite : (4, 3) et (3,) — les dimensions de fin valent toutes deux 3, et la première dimension absente de la ligne est traitée comme 1 et étirée à 4. Le résultat est de shape (4, 3) : le même tableau de longueur 3 est ajouté à chacune des quatre lignes. (Si le tableau 1D avait eu la shape (4,) à la place, il ne se diffuserait pas — discordance de fin 3 contre 4 — et lèverait une ValueError.)

Conclusion

Les tableaux NumPy sont le socle numérique sous pandas, scikit-learn et matplotlib — et la raison pour laquelle Python est assez rapide pour le travail sur les données. L’habitude centrale est simple : stockez vos nombres dans un tableau, puis opérez sur le tableau entier d’un coup avec des calculs vectorisés, du broadcasting et des masques au lieu d’écrire des boucles. Familiarisez-vous avec dtype, shape, les trois façons d’indexer et l’argument axis, et vous aurez tout ce qu’il faut pour lire et écrire du vrai code numérique.

À lire aussi : DataFrames pandas — pandas s’appuie sur NumPy en ajoutant des étiquettes à ces tableaux · Vecteurs et types en R — R est vectorisé lui aussi, la même idée dans un autre langage.