Python NumPy en pratique : le code et les commandes qui comptent vraiment

Pas de théorie interminable ici : on ouvre le terminal et on pratique. Voici l'essentiel de Python NumPy, extrait directement d'un cours complet de 35 leçons — avec du vrai code que tu peux copier-coller maintenant.

Créer des arrays

Objectifs pédagogiques

Pourquoi pas toujours np.array() ?

On pourrait toujours écrire np.array([0,0,0,0,0,0,0,0,0,0]). Mais imaginez maintenant qu’il vous faut un array de 1 000 000 zéros : impossible à taper à la main.

Heureusement, NumPy propose des fabriques spécialisées pour ces cas récurrents. Elles sont plus rapides, plus lisibles et plus sûres qu’une boucle Python.

np.zeros : un tableau de zéros

L’outil n°1 pour initialiser un array. On passe en argument la shape souhaitée :

import numpy as np

# Vecteur de 5 zéros
a = np.zeros(5)
print(a)
# [0. 0. 0. 0. 0.]

# Matrice 3 x 4 de zéros
b = np.zeros((3, 4))
print(b)
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Cube 2 x 3 x 4 (un tenseur 3D !)
c = np.zeros((2, 3, 4))
print(c.shape)
# (2, 3, 4)

np.ones : un tableau de uns

Identique à zeros, mais rempli de 1. Très utile comme masque, ou comme point de départ pour des matrices de poids.

import numpy as np

# Vecteur de poids initialisés à 1
poids = np.ones(10)
print(poids)
# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

# Matrice carrée 3 x 3 de uns
M = np.ones((3, 3), dtype=int)
print(M)
# [[1 1 1]
#  [1 1 1]
#  [1 1 1]]

Notez le paramètre dtype=int : par défaut, zeros et ones produisent des float64. Si vous voulez des entiers, demandez-le explicitement.

np.full : remplir avec n’importe quelle valeur

Quand vous voulez remplir avec une valeur autre que 0 ou 1, utilisez np.full(shape, valeur) :

import numpy as np

# Matrice 2x3 remplie de 7
sept = np.full((2, 3), 7)
print(sept)
# [[7 7 7]
#  [7 7 7]]

# Tableau de NaN (valeur manquante)
nan_arr = np.full(5, np.nan)
print(nan_arr)
# [nan nan nan nan nan]

Cas pratique fréquent : initialiser un tableau de résultats à NaN, puis remplir cellule par cellule au fil d’un calcul.

np.arange : la version « range » de NumPy

np.arange(start, stop, step) est l’équivalent NumPy de la fonction range de Python, mais elle retourne un ndarray :

import numpy as np

# 0, 1, 2, ..., 9 (stop est exclu)
a = np.arange(10)
print(a)
# [0 1 2 3 4 5 6 7 8 9]

# De 5 à 20 (exclu), par pas de 2
b = np.arange(5, 20, 2)
print(b)
# [ 5  7  9 11 13 15 17 19]

# Avec un pas flottant : possible mais à éviter
c = np.arange(0, 1, 0.1)
print(c)
# [0.  0.1 0.2 ... 0.9] (mais méfiance, voir warning)

np.linspace : N points régulièrement espacés

np.linspace(start, stop, num) retourne num points régulièrement espacés entre start et stop, en incluant les deux bornes :

import numpy as np

# 11 points de 0 à 1 inclus
a = np.linspace(0, 1, 11)
print(a)
# [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]

# 5 points entre -pi et +pi (idéal pour tracer sin/cos)
x = np.linspace(-np.pi, np.pi, 5)
print(x)
# [-3.14 -1.57  0.    1.57  3.14]

# 1000 points pour un tracé lisse
t = np.linspace(0, 10, 1000)

linspace est indispensable pour tracer des courbes mathématiques avec Matplotlib. C’est l’outil n°1 pour créer des axes continus.

Indexation de base

Objectifs pédagogiques

Indexation 1D : comme une liste Python

Pour un array 1D, l’indexation est identique à une liste Python. Le premier élément a l’indice 0.

import numpy as np

notes = np.array([12, 15, 17, 9, 18, 14])

print(notes[0])     # 12 (première note)
print(notes[2])     # 17 (troisième note)
print(notes[5])     # 14 (dernière note)

Le type renvoyé est un scalaire NumPy, pas un array. Vous pouvez l’utiliser comme un nombre Python normal.

Indices négatifs : depuis la fin

Comme en Python, -1 désigne le dernier élément, -2 l’avant-dernier, etc.

import numpy as np

notes = np.array([12, 15, 17, 9, 18, 14])

print(notes[-1])    # 14  (dernière)
print(notes[-2])    # 18  (avant-dernière)
print(notes[-6])    # 12  (la première, depuis la fin)

Indexation 2D : ligne et colonne

Pour une matrice, il faut deux indices : arr[i, j]. C’est la convention NumPy, beaucoup plus claire que arr[i][j] de Python.

import numpy as np

bulletin = np.array([
    [14, 15, 12],   # élève 0
    [18, 11, 17],   # élève 1
    [9, 10, 8],     # élève 2
    [16, 19, 14],   # élève 3
])

# Note de l’élève 1 en matière 2 (anglais)
print(bulletin[1, 2])    # 17

# L’élève 3 en math (colonne 0)
print(bulletin[3, 0])    # 16

Extraire une ligne entière

Avec un seul indice, on récupère toute la ligne :

import numpy as np

bulletin = np.array([
    [14, 15, 12],
    [18, 11, 17],
    [9, 10, 8],
    [16, 19, 14],
])

eleve1 = bulletin[1]
print(eleve1)              # [18 11 17]
print(eleve1.shape)        # (3,)

# Équivalent explicite avec slice :
print(bulletin[1, :])      # [18 11 17]

Les deux syntaxes bulletin[1] et bulletin[1, :] sont équivalentes. La forme avec : est plus explicite : « ligne 1, toutes les colonnes ».

Extraire une colonne entière

Pour la colonne, il faut OBLIGATOIREMENT la syntaxe à deux dimensions :

import numpy as np

bulletin = np.array([
    [14, 15, 12],
    [18, 11, 17],
    [9, 10, 8],
    [16, 19, 14],
])

# Toutes les notes de math (colonne 0)
math = bulletin[:, 0]
print(math)               # [14 18  9 16]

# Moyenne par matière
print("Moyenne math :", bulletin[:, 0].mean())
print("Moyenne franc :", bulletin[:, 1].mean())
print("Moyenne anglais :", bulletin[:, 2].mean())

Modifier une valeur par affectation

L’indexation marche aussi en écriture. Vous pouvez modifier un élément, une ligne entière ou une colonne :

import numpy as np

bulletin = np.array([
    [14, 15, 12],
    [18, 11, 17],
    [9, 10, 8],
])

# Modifier une seule cellule
bulletin[0, 1] = 16
print(bulletin[0])
# [14 16 12]

# Remplacer toute la ligne 2
bulletin[2] = [11, 12, 13]
print(bulletin)
# [[14 16 12]
#  [18 11 17]
#  [11 12 13]]

# Mettre une colonne entière à zéro
bulletin[:, 2] = 0
print(bulletin)
# [[14 16  0]
#  [18 11  0]
#  [11 12  0]]

Installer NumPy et l’environnement

Objectifs pédagogiques

Vérifier Python sur votre machine

NumPy nécessite Python 3.9 ou plus récent. Pour vérifier votre version, ouvrez un terminal et tapez :

# Windows (PowerShell ou cmd)
python --version

# macOS / Linux
python3 --version

# Sortie attendue (exemple) :
# Python 3.12.4

Si Python n’est pas installé, téléchargez-le sur le site officiel python.org/downloads. Sur Windows, cochez bien la case « Add Python to PATH » lors de l’installation.

Pourquoi un environnement virtuel ?

Un environnement virtuel est un dossier isolé qui contient sa propre copie de Python et ses propres bibliothèques. Il permet d’avoir un projet avec NumPy 1.26 et un autre avec NumPy 2.0 sans qu’ils se marchent dessus.

Sans environnement virtuel

Avec environnement virtuel

Méthode 1 : pip + venv (standard Python)

C’est la méthode officielle, légère et intégrée à Python. Créez un dossier de projet, puis ouvrez un terminal dedans :

# 1. Créer un environnement virtuel nommé "venv"
python -m venv venv

# 2. Activer l’environnement
# Windows PowerShell :
venv\Scripts\Activate.ps1

# macOS / Linux :
source venv/bin/activate

# 3. Installer NumPy
pip install numpy

# 4. (Optionnel) Installer aussi Jupyter et matplotlib
pip install jupyter matplotlib pillow

Une fois activé, votre prompt affiche (venv) devant. C’est le signe que vous travaillez dans votre bulle isolée.

Méthode 2 : Anaconda / Miniconda

Anaconda est une distribution scientifique de Python qui livre déjà installées les bibliothèques data science principales : NumPy, Pandas, scikit-learn, Jupyter, etc. C’est ultra-pratique pour les débutants.

# 1. Télécharger Anaconda sur anaconda.com/download
# 2. Lancer l’installateur graphique
# 3. Une fois installé, ouvrir l’Anaconda Prompt

# Vérifier la version de NumPy livrée
conda list numpy

# Créer un environnement dédié au cours
conda create -n cours-numpy python=3.12 numpy jupyter matplotlib pillow

# L’activer
conda activate cours-numpy

Si vous voulez seulement le strict nécessaire, optez pour Miniconda qui est une version allégée (~50 Mo) au lieu d’Anaconda (~3 Go).

pip vs conda : que choisir ?

Vérifier que NumPy fonctionne

Une fois installé, ouvrez un interpréteur Python (en tapant python dans le terminal) et tapez :

import numpy as np

# Vérifier la version
print(np.__version__)
# Sortie attendue (par exemple) : 2.1.0

# Créer un premier array
a = np.array([1, 2, 3, 4, 5])
print(a)
print("Type :", type(a))
print("Forme :", a.shape)
print("Type des éléments :", a.dtype)

FAQ

📬 Tu veux recevoir ce type de guide chaque semaine ? Abonne-toi gratuitement — code réel, zéro blabla.