📘 Leçon 4 — Les opérations de base : création, sélection, modification

Dans la leçon précédente (Les types NumPy et la gestion mémoire), tu as appris à choisir les bons dtypes pour booster les performances.

Aujourd’hui, on passe à la vitesse supérieure :
➡️ créer des tableaux,
➡️ sélectionner des éléments,
➡️ modifier les données,
➡️ et manipuler tout ça avec les meilleures opérations NumPy.

Tu vas voir, c’est fluide comme du beurre fondu.
Si les pandas (🐼) utilisent NumPy pour tout, ce n’est pas pour rien.

PARTIE 1 — Créer des tableaux (bases des opérations NumPy)

Avant de pouvoir manipuler quoi que ce soit, il faut créer un tableau.
Les opérations NumPy de création sont nombreuses, simples et ultra optimisées.

1. Création à partir d’une liste : np.array()

import numpy as np

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

Parfait pour débuter… mais on évite les listes Python pour les grosses données (on ne veut pas exploser la RAM).

2. Zéros, Un, Valeurs fixes

np.zeros((3,3))
np.ones((2,5))
np.full((4,4), 9)

Les opérations NumPy de création rapides = gains de performance massifs.

3. np.arange() (le range version turbo)

np.arange(0, 20, 2)

Rapide, élégant, parfait pour les séries numériques.

4. np.linspace() — Le favori du Machine Learning

np.linspace(0, 1, 10)

10 valeurs entre 0 et 1 = idéal pour normalisation, modèles et graphiques.

5. Matrices aléatoires

np.random.random((4,4))
np.random.randint(0, 100, (3,3))

Essentiel dans toutes les opérations NumPy liées aux statistiques, simulations et jeux de données.
(Et tu vas en faire BEAUCOUP dans la leçon suivante 👉 Statistiques avec NumPy)

TABLEAU RÉCAPITULATIF : Création dans NumPy

Méthode	Description	Exemple
np.array()	Créer depuis liste	np.array([1,2,3])
np.zeros()	Matrice de 0	np.zeros((3,3))
np.ones()	Matrice de 1	np.ones((2,5))
np.full()	Valeur constante	np.full((4,4),7)
np.arange()	Suite numérique	np.arange(0,20,2)
np.linspace()	Valeurs régulières	np.linspace(0,1,50)
np.random.*	Aléatoire	np.random.rand(10)

Tu viens de poser les fondations des opérations NumPy.
Accroche-toi, on passe au niveau Jedi.

PARTIE 2 — Sélectionner des données (indexing & slicing)

Voici le cœur des opérations NumPy : récupérer exactement ce dont tu as besoin, et rien d’autre

1. Indexation simple

a[2]      # 3ᵉ élément
a[-1]     # dernier élément

NumPy — comme Python — commence l’indexation à 0.

• Donc :
  • a[0] → 1ᵉ élément
  • a[1] → 2ᵉ élément
  • a[2] → 3ᵉ élément

Tu demandes donc à NumPy :
→ « Donne-moi la valeur située à la position 2 dans le tableau. »

2. Slicing (le couteau suisse des opérations NumPy)

Le slicing (découpage) permet d’extraire plusieurs éléments d’un coup :

a[1:4]

NumPy inclut l’index de début → 1

• NumPy exclut l’index de fin → 4

Donc tu obtiens : éléments 1, 2 et 3

C’est comme dire :
→ « Donne-moi tout depuis 1 jusqu’avant 4. »

a[:5]

Pas d’index avant les : → NumPy comprend :
→ « commence au tout début ».

Donc : index 0→4.

a[::2]

Ici :

• pas de start → début
• pas de stop → jusqu’à la fin
• step = 2 → un élément sur deux

Utile pour :

• compresser des données
• réduire une série temporelle
• sélectionner des indices pairs

3. Accès multidimensionnel

NumPy gère les matrices avec une syntaxe puissante :

m[ligne, colonne]

m[1, 2] — ligne 2, colonne 3

m[1, 2]     # ligne 2, colonne 3

Même logique que pour les tableaux 1D :

• ligne 1 = 2ᵉ ligne
• colonne 2 = 3ᵉ colonne

Tu récupères donc un élément précis dans la matrice.

m[:, 0] — toute la première colonne

m[:, 0]     # première colonne

📌 Interprétation

• : → toutes les lignes
• 0 → colonne 1

Tu obtiens un vecteur contenant toute la 1ère colonne.

Utile pour :

• extraire une variable spécifique
• isoler un canal (ex : canal R d’une image RGB)
• travailler par colonnes en data science

m[1, :] — toute la 2ᵉ ligne

m[1, :]     # deuxième ligne

📌 Interprétation

• 1 → ligne 2
• : → toutes les colonnes

Tu obtiens un tableau contenant toute la ligne sélectionnée.

🔥 4. Indexation booléenne — Le super-pouvoir des opérations NumPy

C’est LA fonctionnalité la plus puissante.

a[a > 50] — filtrer les valeurs supérieures à 50

a[a > 50]

Ce code fait 2 choses en une étape :

Étape 1 — créer un masque booléen

Si a = [10, 55, 3, 80],
a > 50 donne :

[False, True, False, True]

Étape 2 — appliquer ce masque pour filtrer

a[a > 50] garde uniquement les éléments où le masque vaut True :

[55, 80]

Pourquoi les data scientists adorent ?

Parce que cette syntaxe remplace :

❌ une boucle
❌ une condition
❌ une liste temporaire

Par…

✅ une seule ligne
✅ ultra lisible
✅ 50x plus rapide
✅ vectorisée

On utilise cette technique partout :

• filtrage d’images
• extraction de valeurs aberrantes
• analyse climat (pixels > 0.4)
• nettoyage de données ML
• seuils statistiques

Résumé rapide

Code	Signification
a[2]	3ᵉ élément
a[-1]	dernier élément
a[1:4]	éléments 1→3
a[:5]	0→4
a[::2]	un élément sur deux
m[1,2]	ligne 2, colonne 3
m[:,0]	1ère colonne
m[1,:]	2ᵉ ligne
a[a>50]	filtrage booléen

PARTIE 3 — Modifier les valeurs (opérations NumPy indispensables)

Tu sais sélectionner un élément ?
Parfait. Maintenant… on change les valeurs.
Et tu vas voir : NumPy modifie les données comme un chef cuisinier qui découpe au laser.

Modifier une valeur

a[0] = 999

• a[0] sélectionne la première valeur du tableau.
• Tu lui assignes 999.

Rien de plus simple :
➡️ Tu prends une cellule > tu lui donnes une nouvelle valeur.

À noter :
NumPy modifie en place → pas de copie → c’est rapide et ça économise la RAM.

Modifier un slice

a[1:4] = [10, 20, 30]

❗ Ce que cela signifie

• a[1:4] = éléments avec index 1, 2, 3
• Tu remplaces ces 3 valeurs par [10, 20, 30]

Comment ça marche ?

NumPy vérifie que :

• la forme du slice
• correspond à la forme des nouvelles valeurs

Ici :
Mon slice = 3 éléments → ma liste = 3 éléments → tout va bien ✔

Bonus

Tu peux aussi mettre une valeur unique : a[1:4] = 0
➡️ Broadcasting : NumPy remplit automatiquement toute la zone avec 0.

Modifier selon une condition

a[a < 0] = 0

Étape 1 — créer un masque
a < 0 → tableau booléen qui vaut True là où la valeur est négative.

Étape 2 — remplacement
Tu dis :
➡️ « Toutes les valeurs négatives deviennent 0. »

Ce que cette ligne remplace

❌ une boucle
❌ une condition
❌ une variable temporaire

Par…
✔ une seule ligne
✔ ultra rapide
✔ vectorisée

NumPy, c’est du pouvoir pur..

PARTIE 4 — Opérations mathématiques de base

On arrive aux opérations NumPy que tu vas faire 100 fois par jour si tu travailles en data science.

Addition, Multiplication…

a + b
a * 10
a / 3
a ** 2

🧠 Pourquoi c’est magique ?

Parce que NumPy applique ces opérations :

• à tout le tableau
• sans boucle
• sans effort
• 100% vectorisé
• 50x plus rapide qu’en Python natif

Ce que Python ferait : Des boucles for partout. 💀

Ce que NumPy fait : Un seul calcul optimisé en C sous le capot. ⚡

Référence : https://numpy.org/doc/stable/reference/routines.math.html

Fonctions mathématiques universelles (ufunc)

np.sqrt(a)
np.sin(a)
np.exp(a)
np.log(a)

Tu remplaces des dizaines de lignes Python en 4 caractères : np.*.

PARTIE 5 — Reshape, Transpose & Co : transformer les données

NumPy excelle dans les transformations de forme (shape).
Manipuler la dimension des tableaux = obligatoire en data science, ML, imagerie, SIG

reshape()

a.reshape(5,2)

Tu changes la forme du tableau sans changer les données.

Exemple :
Un tableau de 10 éléments → une matrice 5×2.

flatten() & ravel()

a.flatten()   # copie
a.ravel()     # vue

• flatten() → crée une copie → la mémoire change
• ravel() → crée une vue → très rapide, mais lié au tableau original

Si tu modifies la vue, tu modifies le tableau original.

transpose()

a.T

Inverse lignes ↔ colonnes
Indispensable pour :

• algèbre linéaire
• réseaux de neurones
• images
• matrices covariance/corrélation

PARTIE 6 — Fusionner des tableaux

Fusionner, c’est assembler plusieurs tableaux pour n’en faire qu’un.

concatenate()

np.concatenate([a, b])

Fusion horizontale simple : Tu mets les tableaux les uns à la suite des autres.

vstack & hstack

np.vstack([a, b])
np.hstack([a, b])

Empile verticalement = une ligne sous une autre. Parfait pour créer une base de données à partir de plusieurs blocs.

PARTIE 7 — Bonnes pratiques (commandements NumPy)

✔ Utilise les bons dtypes (voir la leçon 3)
✔ Privilégie les ufuncs (np.exp, np.log…)
✔ Toujours utiliser axis= dans les opérations
✔ Évite les listes Python (trop lentes)
✔ Vérifie les shapes avant une fusion
✔ Privilégie ravel() si tu veux de la vitesse
✔ Utilise la vectorisation → pas de for

Tu veux être un(e) pro NumPy ?
➡️ Suis ces règles et tu vas plus vite que 95% des débutants.

PARTIE 8 — Exercices pratiques (avec solutions)

Exercice 1 — Création & filtrage

Créer un tableau de 100 valeurs entre -5 et 5.
➡️ Sélectionne les valeurs positives
➡️ Remplace-les par 1
➡️ Les valeurs négatives deviennent -1

Solution

a = np.linspace(-5, 5, 100)
a[a > 0] = 1
a[a < 0] = -1

Exercice 2 — Indexation 2D

Créer une matrice 6×6 avec les valeurs 1 à 36.
➡️ Extraire la diagonale
➡️ Extraire les bords
➡️ Remplacer la ligne 2 par 0

Solution

m = np.arange(1,37).reshape(6,6)
diag = np.diag(m)
bords = np.concatenate([m[0], m[-1], m[:,0], m[:,-1]])
m[1,:] = 0

Exercice 3 — Conditions avancées

Créer une matrice aléatoire 300×300.
➡️ Valeurs < 0.2 → 0
➡️ 0.2 ≤ x ≤ 0.7 → 1
➡️ x > 0.7 → 2

Solution

x = np.random.rand(300,300)
x[x < 0.2] = 0
x[(x >= 0.2) & (x <= 0.7)] = 1
x[x > 0.7] = 2

QCM

1. Quelle méthode crée un tableau de 100 zéros ?

A. zeros(100)
B. np.zeros(100)
C. np.nulls(100)
👉 Réponse : B

2. Quelle opération NumPy sélectionne la colonne 2 ?

A. m[2,:]
B. m[:,2]
C. m[2]
👉 Réponse : B

3. Quelle fonction transforme un tableau en 1D ?

A. flat()
B. flatten()
C. reshape(1)
👉 Réponse : B

4. Quelle opération NumPy utilise la vectorisation ?

A. for i in range()
B. a * 10
C. map(a)
👉 Réponse : B

5. Quelle fonction fusionne verticalement ?

A. vstack
B. hstack
C. merge
👉 Réponse : A

6. Quelle opération remplace toutes les valeurs négatives ?

A. a[a<0]=0
B. replace(a<0,0)
C. np.negative(a)
👉 Réponse : A

Conclusion

Félicitations 🎉 !
Tu maîtrises désormais toutes les opérations NumPy essentielles : création, sélection, modification, filtrage, reshape, fusion…

Tu es prêt pour la suite :
➡️ Leçon 5 — Statistiques avancées & opérations vectorisées
👉 https://www.coindudev.com/statistiques-avec-numpy-guide/

Grâce à ces opérations NumPy, tu peux manipuler n’importe quel tableau avec précision et vitesse.
C’est la base de la data science moderne.