NumPy 1 – le tableau

Le cours en une phrase

Apprendre à penser « tableau entier » plutôt qu'élément par élément,
puis à poser des questions à des données réelles.

Trois outils, dans l'ordre où ils s'empilent :

1. NumPy (S1–S2) : le tableau numérique homogène, rapide, vectorisé
2. pandas (S3–S4) : la table étiquetée, construite sur NumPy
3. matplotlib (S5–S6) : les figures, pour voir ce que les chiffres cachent

Objectif de fin d'UE : charger un jeu de données, le nettoyer, le résumer,
le tracer — et simuler un petit système physique sans une seule boucle sur les éléments.

Calendrier des 6 séances

Pas de séance le 22 septembre.

Déroulé type d'une séance (3 h)

On ne lit pas tout en séance : la fiche de chaque séance dit quoi traiter,
quoi sauter, et où je reprends la main.

Les règles du jeu

• Devoirs D1–D5 : corrigés et notés au fil de l'eau → note d'avancement.
  Un devoir rendu en retard vaut moins qu'un devoir rendu incomplet à l'heure.
• Quiz (S2 → S6) : 10 minutes, sur papier → note de contrôle continu.
  Ils portent sur la séance précédente, y compris le devoir.
• Pas d'examen final : la note = quiz + devoirs + projet de la séance 6 (fait et rendu en classe).
• IA : autorisée pour apprendre (demander une explication, un contre-exemple),
  interdite pendant les quiz. On rend du code qu'on sait expliquer ligne à ligne —
  je peux vous demander de le faire.
• Erreurs : lisez le message en entier, la dernière ligne d'abord. C'est la
  compétence n° 1 du cours.

Ressources

• Cours (notebooks) : https://numerique.info-mines.paris — les notebooks x-yy
  du plan, exécutables dans le navigateur ou à télécharger
• Exercices, TP, HOWTO : https://numerique-exos.info-mines.paris
• Le site du cours : https://pe-2026.noce.fr — le plan de chaque séance, les slides
  et les sujets des devoirs, publiés au fil des séances

Deux raccourcis à garder sous le coude :

• 4-00 cheat sheets NumPy / pandas / matplotlib — imprimez-les
• 5-01 → 5-11 rappels Python (fonctions, containers, références partagées…)
  si un point de langage vous bloque ; 9-01 pour vous auto-tester

Au programme aujourd'hui

Notebooks (dans l'ordre) :

• 0-00 intro · 1-01 pourquoi NumPy · 1-02 le ndarray
• 1-03 la mémoire · 1-05 indexation & slicing
• 1-04 vectorisation — première moitié seulement (la suite en S2)

TP : 1-06 TP images (1/2) — créer, lire, découper une image couleur

Devoir : D1 « damier, escaliers & pixel art », pour le dimanche 13 septembre, 23 h 59

Pourquoi NumPy ? Le ndarray

Python n'a pas de type fait pour les tableaux numériques. NumPy le fournit
depuis 2006 ; tout l'écosystème scientifique (pandas, SciPy, scikit-learn…) repose dessus.

import numpy as np

mat = np.array([[1, 2, 3, 4, 5],
                [6, 7, 8, 9, 10]])
mat.shape   # (2, 5)   forme : un tuple (lignes, colonnes)
mat.size    # 10       nombre total d'éléments
mat.dtype   # int64    type de TOUS les éléments
mat.ndim    # 2        nombre de dimensions

Quatre attributs à connaître par cœur : ils répondent à 90 % des « mais qu'est-ce que j'ai dans mat ? ».

Un type homogène et de taille fixe

Tous les éléments partagent le même dtype, donc la même taille en octets — et NumPy ne « promeut » jamais tout seul :

a = np.array([-1, 2, 3], dtype=np.int8)   # entiers de -128 à 127
a * 100                      # array([-100, -56, 44], dtype=int8)   et non [-100, 200, 300] !
np.array([1, 2.5]).dtype     # float64  : l'entier est monté en flottant
np.array([1, "a"]).dtype     # <U21     : tout devient du texte !

200 déborde d'un int8 : la valeur boucle (overflow silencieux).
Changer de type se demande explicitement : a.astype(np.float64) → une copie.

Pourquoi : c'est cette homogénéité qui rend le calcul rapide. Le prix : c'est à vous de choisir le type.

Les fabriques

On crée rarement un tableau à la main :

np.zeros((4, 5))                  # rempli de 0. → float64 par défaut
np.ones((2, 3), dtype=np.uint8)   # le dtype se précise à la création
np.arange(0, 10, 2)               # [0 2 4 6 8]  comme range : borne haute EXCLUE
np.linspace(-1, 1, 5)             # [-1. -0.5 0. 0.5 1.]  5 points, bornes INCLUSES
np.random.randint(10, 20, size=(2, 3))

Pour une image : np.zeros((hauteur, largeur, 3), dtype=np.uint8) —
trois canaux R, V, B codés de 0 à 255.

arange compte des pas, linspace compte des points. Les deux coexistent parce qu'on ne veut pas la même chose.

Un buffer contigu, lu à travers une forme

La mémoire d'un ndarray est toujours un segment continu de cases de même taille.
La shape est une grille de lecture posée dessus.

a = np.arange(10, dtype=np.int32)
a.itemsize   # 4  octets par case
a.nbytes     # 40 octets en tout — pas un de plus

Deux conséquences :

• passer à la case voisine = un simple décalage → rapide ;
• aucune indirection, contrairement à une list Python qui range des adresses d'objets.

Pourquoi s'en soucier : tout le reste (vues, reshape, performance) découle de cette image mentale.

reshape : une autre grille, le même buffer

seg = np.arange(30)
mat = seg.reshape(5, 6)     # nouvelle VUE, rien n'est copié
mat[0, 0] = 99
seg[0]                      # 99 — la mémoire est partagée !
np.shares_memory(seg, mat)  # True

• reshape(3, -1) : NumPy calcule la dimension manquante ;
• la taille doit coller : np.arange(12).reshape(5, 3) → ValueError ;
• mat.T (transposée) est aussi une vue.

Pourquoi : copier 30 cases c'est rien, copier une image 4K à chaque reshape serait absurde.

Indexer : une coordonnée par dimension

tab = np.arange(24).reshape(2, 3, 4)   # 2 matrices de 3 lignes × 4 colonnes
tab[1, 2, 0]      # 20 : 2e matrice, 3e ligne, 1re colonne
tab[0, :, 1]      # [1 5 9] : 1re matrice, toutes les lignes, 2e colonne
tab[:, 0].shape   # (2, 4) : la 1re ligne de chaque matrice
tab[0, 1:, ::2]   # [[ 4  6]
                  #  [ 8 10]]

• on écrit tab[i, j, k], pas tab[i][j][k] (qui marche, mais crée des tableaux intermédiaires) ;
• chaque dimension prend un entier ou une tranche début:fin:pas ;
• les indices négatifs comptent depuis la fin, comme en Python.

Slicing : on obtient une vue

La différence avec les listes Python. Slicer une liste copie ; slicer un ndarray
renvoie une vue sur le même buffer :

l = [1, 2, 3]
l2 = l[:]; l2[0] = 99
l                 # [1, 2, 3]   la liste est intacte

vec = np.arange(10)
vec[::2] = 100    # on écrit À TRAVERS la vue
vec               # [100  1 100  3 100  5 100  7 100  9]  → l'original a changé

Très pratique : img[:, :, 0] = 255 met tout le canal rouge à fond, sans copie.

Besoin d'un tableau indépendant ? Demandez-le : vec[::2].copy().

Vue ou copie ? La règle

En cas de doute : np.shares_memory(a, b), ou b = a.copy() avant de modifier.

Pourquoi deux comportements : une vue est gratuite ; une copie coûte mémoire et temps. NumPy choisit le gratuit chaque fois que la mémoire le permet.

Les 3 pièges du jour

1. Le slicing modifie l'original. b = a[2:5]; b[:] = 0 → a a changé.
   Réflexe : .copy() si vous voulez une version indépendante.

2. Le dtype ne s'élargit jamais tout seul. uint8 : 200 + 100 donne 44.
   Réflexe : img.astype(float) avant de sommer ou moyenner des pixels.

3. arange exclut, linspace inclut. np.arange(0, 1, 0.1) n'atteint pas 1 ;
   np.linspace(0, 1, 11) oui, avec 11 points.

Bonus : shape est un tuple — (5,) n'est pas 5, et len(a) ne donne que la 1re dimension.

TP du jour : images (1/2)

Notebook 1-06 sur https://numerique.info-mines.paris (section NumPy).

1. créer une image couleur de toutes pièces (zeros + slicing + canaux) ;
2. lire une vraie image avec plt.imread, regarder shape et dtype ;
3. découper des morceaux, isoler les canaux R, V, B ;
4. jouer avec la transparence (4e canal).

À rendre : rien — mais gardez le notebook, la 2e partie (S2) repart de là.

Pour les rapides : 1-11 TP dés (avancé) ; les exercices NumPy « tableaux »
sur https://numerique-exos.info-mines.paris ; catalogue tp-optionnels/ du dépôt.

Devoir pour la prochaine séance

D1 — Damier, escaliers & pixel art

Pour le dimanche 13 septembre, 23 h 59 (la séance 2 est le mardi 15).

• construire des images sans boucle Python : un damier n × n, des escaliers de
  gris, puis un pixel art de votre choix ;
• le tout avec les outils du jour : zeros/ones, dtype=uint8, slicing avec pas,
  affectation à travers une vue ;
• sauvegarder le résultat en PNG (plt.imsave).

Ce qu'on rend : le notebook .ipynb exécuté de bout en bout + le PNG,
dans le dossier D1/ de votre dépôt pe-2026, commité et poussé avant la date limite.

Ce qui est noté : ça tourne, pas de boucle sur les pixels, vous savez expliquer chaque slice.