Cours NumPy et Matplotlib

Cours Introductif : NumPy et Matplotlib

Angelo
Juin 2025

Résumé
Ce cours introductif est conçu pour les personnes souhaitant acquérir une compréhension fonda-
mentale de NumPy et Matplotlib, deux bibliothèques essentielles pour la manipulation numérique
et la visualisation de données en Python. En environ 4 heures, nous couvrirons les bases de ces outils
puissants.

Table des matières

1 Objectifs du cours 2

2 Partie 1 : Introduction à NumPy (environ 1h45) 2

2.1 Qu’est-ce que NumPy ? (15 min) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Le ndarray : l’objet central de NumPy (30 min) . . . . . . . . . . . . . . . . . . . . . . . 2
2.3 Indexation et Slicing (25 min) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.4 Opérations sur les tableaux (45 min) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

3 Partie 2 : Introduction à Matplotlib (environ 1h45) 4

3.1 Qu’est-ce que Matplotlib ? (15 min) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2 Créer des graphiques simples (30 min) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.3 Personnalisation des graphiques (45 min) . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.4 Sauvegarder des figures (15 min) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

4 Partie 3 : Exercices Pratiques et Questions/Réponses (environ 30 min) 7

4.1 Exercices suggérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.2 Session de questions-réponses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1 Auteur : Angelo
 Cours NumPy et Matplotlib

1 Objectifs du cours
À la fin de ce cours, vous serez capable de :
— Utiliser NumPy pour créer et manipuler des tableaux (arrays) multidimensionnels.
— Effectuer des opérations mathématiques efficaces sur ces tableaux.
— Comprendre les avantages de NumPy par rapport aux listes Python pour le calcul numérique.
— Créer des graphiques de base (lignes, barres, nuages de points) avec Matplotlib.
— Personnaliser vos visualisations pour une meilleure clarté et impact.
—

2 Partie 1 : Introduction à NumPy (environ 1h45)

2.1 Qu’est-ce que NumPy ? (15 min)
— Définition : NumPy (Numerical Python) est la bibliothèque fondamentale pour le calcul scien-
tifique en Python. Elle fournit un objet tableau multidimensionnel de haute performance, le
ndarray, ainsi que des outils pour travailler avec ces tableaux.
— Pourquoi NumPy ?
— Performance : Les opérations sur les tableaux NumPy sont beaucoup plus rapides que les
boucles Python sur les listes, car elles sont implémentées en C.
— Efficacité mémoire : Les tableaux NumPy consomment moins de mémoire que les listes
Python.
— Fonctionnalités étendues : Vaste collection de fonctions mathématiques pour les opérations
sur les tableaux (algèbre linéaire, transformation de Fourier, etc.).
— Installation : pip install numpy

2.2 Le ndarray : l’objet central de NumPy (30 min)

Le ndarray est un tableau homogène d’éléments de la même taille en mémoire.
— Création de tableaux :
— À partir de listes Python : [Link]([1, 2, 3])
— Tableaux de zéros, uns, ou vides : [Link]((2, 3)), [Link]((2, 3)), [Link]((2, 3))
— Plages de valeurs : [Link](10) (similaire à range), [Link](0, 1, 5) (nombres
espacés linéairement)
— Tableaux aléatoires : [Link](2, 2) (flottants uniformes), [Link](0,
10, size=(2, 2)) (entiers aléatoires)
— Attributs des tableaux :
— shape : Dimensions du tableau (ex : (3, 4) pour 3 lignes, 4 colonnes)
— ndim : Nombre de dimensions (ou axes)
— size : Nombre total d’éléments dans le tableau
— dtype : Type de données des éléments (ex : int64, float64, bool)

1 import numpy as np
2
3 # Création d'un tableau à partir d'une liste
4 arr = [Link]([1, 2, 3, 4, 5])
5 print(f"Tableau arr: {arr}")
6 print(f"Type de arr: {type(arr)}")
7 print(f"Forme de arr: {[Link]}")
8 print(f"Dimensions de arr: {[Link]}")
9 print(f"Nombre d'éléments de arr: {[Link]}")
10 print(f"Type de données de arr: {[Link]}")
11
12 # Création d'un tableau 2D (matrice)
13 matrix = [Link]([[1, 2, 3], [4, 5, 6]])
14 print(f"\nMatrice: \n{matrix}")
15 print(f"Forme de la matrice: {[Link]}")
16
17 # Tableaux de zéros et de uns
18 zeros_matrix = [Link]((2, 3))
19 ones_matrix = [Link]((3, 2))
20 print(f"\nMatrice de zéros: \n{zeros_matrix}")

2 Auteur : Angelo
 Cours NumPy et Matplotlib

21 print(f"Matrice de uns: \n{ones_matrix}")

22
23 # Plage de valeurs
24 range_arr = [Link](0, 10, 2) # Start, stop (exclusif), step
25 print(f"\nPlage de valeurs: {range_arr}")
26
27 # Nombres aléatoires
28 random_arr = [Link](2, 2) # Nombres flottants entre 0 et 1 (distribution uniforme)
29 print(f"\nTableau aléatoire (rand): \n{random_arr}")
30
31 random_int_arr = [Link](0, 10, size=(2, 3)) # Entiers entre 0 (inclus) et 10 (exclusif)
32 print(f"\nTableau aléatoire (randint): \n{random_int_arr}")

2.3 Indexation et Slicing (25 min)

L’accès aux éléments et l’extraction de sous-tableaux sont des opérations clés en NumPy.
— Accès aux éléments : Similaire aux listes Python, mais avec des spécificités pour les dimensions
multiples (accès par array[ligne, colonne]).
— Slicing : Extraction de sous-tableaux en utilisant la syntaxe [début:fin:pas]. L’index fin est
toujours exclus.
— Indexation booléenne : Sélection d’éléments basée sur des conditions logiques.

1 import numpy as np
2
3 arr = [Link]([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
4 matrix = [Link]([[10, 11, 12], [13, 14, 15], [16, 17, 18]])
5
6 # Accès aux éléments
7 print(f"Premier élément de arr: {arr[0]}")
8 print(f"Dernier élément de arr: {arr[-1]}")
9 print(f"Élément (0, 0) de la matrice: {matrix[0, 0]}") # Ligne 0, Colonne 0
10 print(f"Élément (1, 2) de la matrice: {matrix[1, 2]}") # Ligne 1, Colonne 2
11
12 # Slicing 1D
13 print(f"\nSlicing arr[2:7]: {arr[2:7]}") # Éléments de l'index 2 à 6
14 print(f"Slicing arr[:5]: {arr[:5]}") # Du début à l'index 4
15 print(f"Slicing arr[5:]: {arr[5:]}") # De l'index 5 à la fin
16 print(f"Slicing arr[::2]: {arr[::2]}") # Tous les deux éléments
17
18 # Slicing 2D
19 print(f"\nMatrice originale:\n{matrix}")
20 print(f"Première ligne de la matrice: {matrix[0, :]}") # Toutes les colonnes de la ligne 0
21 print(f"Deuxième colonne de la matrice: {matrix[:, 1]}") # Toutes les lignes de la colonne 1
22 print(f"Sous-matrice matrix[0:2, 1:3]:\n{matrix[0:2, 1:3]}") # Lignes 0-1, Colonnes 1-2
23
24 # Indexation booléenne
25 greater_than_5 = arr[arr > 5]
26 print(f"\nÉléments de arr > 5: {greater_than_5}")
27
28 even_elements = arr[arr % 2 == 0]
29 print(f"Éléments pairs de arr: {even_elements}")

2.4 Opérations sur les tableaux (45 min)

NumPy excelle dans l’exécution rapide d’opérations sur des tableaux entiers.
— Opérations arithmétiques : Ajout, soustraction, multiplication (élément par élément), division,
exponentiation. Ces opérations sont effectuées élément par élément.
— Fonctions universelles (ufuncs) : Des fonctions mathématiques qui opèrent élément par élé-
ment sur un tableau ([Link](), [Link](), [Link](), [Link](), [Link](), etc.). Elles sont
optimisées pour la performance.
— Opérations d’agrégation : Calculent des statistiques sur tout ou partie du tableau (sum(),
mean(), min(), max(), std() (écart-type), var() (variance)).

3 Auteur : Angelo
 Cours NumPy et Matplotlib

— Opérations sur les axes : Possibilité d’appliquer des opérations d’agrégation le long d’un axe
spécifique (axis=0 pour les colonnes, axis=1 pour les lignes dans un tableau 2D).
— Broadcasting : Mécanisme puissant permettant à NumPy d’effectuer des opérations sur des ta-
bleaux de formes différentes. NumPy étire implicitement les tableaux pour les rendre compatibles,
si possible.

1 import numpy as np
2
3 arr1 = [Link]([1, 2, 3])
4 arr2 = [Link]([4, 5, 6])
5
6 # Opérations arithmétiques élément par élément
7 print(f"Arr1 + Arr2: {arr1 + arr2}")
8 print(f"Arr1 - Arr2: {arr1 - arr2}")
9 print(f"Arr1 * Arr2: {arr1 * arr2}") # Multiplication élément par élément
10 print(f"Arr1 / 2: {arr1 / 2}")
11 print(f"Arr1 ** 2: {arr1 ** 2}") # Élément au carré
12
13 # Fonctions universelles (ufuncs)
14 print(f"\nSinus de Arr1: {[Link](arr1)}")
15 print(f"Exponentielle de Arr1: {[Link](arr1)}")
16 print(f"Racine carrée de Arr2: {[Link](arr2)}")
17
18 matrix = [Link]([[1, 2, 3], [4, 5, 6]])
19
20 # Opérations d'agrégation
21 print(f"\nSomme de tous les éléments de la matrice: {[Link]()}")
22 print(f"Moyenne de tous les éléments de la matrice: {[Link]()}")
23 print(f"Minimum de tous les éléments de la matrice: {[Link]()}")
24 print(f"Maximum de tous les éléments de la matrice: {[Link]()}")
25
26 # Opérations sur les axes
27 print(f"\nSomme par colonne (axis=0): {[Link](axis=0)}") # Somme des éléments le long de l'axe 0
,→ (colonnes)
28 print(f"Somme par ligne (axis=1): {[Link](axis=1)}") # Somme des éléments le long de l'axe 1
,→ (lignes)
29 print(f"Moyenne par colonne (axis=0): {[Link](axis=0)}")
30
31 # Broadcasting
32 arr_scalar = [Link]([10])
33 print(f"\nArr1 + Scalaire (Broadcasting): {arr1 + arr_scalar}") # Le scalaire est "étiré" pour
,→ correspondre à la forme de arr1
34
35 matrix_col = [Link]([[10], [20]]) # Une matrice colonne (2 lignes, 1 colonne)
36 print(f"\nMatrice: \n{matrix}")
37 print(f"Matrice colonne: \n{matrix_col}")
38 # Opération entre une (2,3) et une (2,1) -> le (2,1) est broadcasté sur l'axe des colonnes
39 print(f"Matrice + Matrice colonne (Broadcasting):\n{matrix + matrix_col}")

3 Partie 2 : Introduction à Matplotlib (environ 1h45)

3.1 Qu’est-ce que Matplotlib ? (15 min)
— Définition : Matplotlib est une bibliothèque de traçage complète pour la création de visualisa-
tions statiques, animées et interactives en Python.
— Pourquoi Matplotlib ?
— Contrôle fin : Permet un contrôle très précis sur tous les aspects d’un graphique (couleurs,
polices, tailles, etc.).
— Polyvalence : Supporte une large gamme de types de graphiques (lignes, barres, nuages de
points, histogrammes, boîtes à moustaches, etc.).
— Intégration : Fonctionne naturellement avec NumPy et d’autres bibliothèques scientifiques
comme Pandas.
— Installation : pip install matplotlib

4 Auteur : Angelo
 Cours NumPy et Matplotlib

— La convention d’importation : Il est courant d’importer le module pyplot de Matplotlib sous

l’alias plt : import [Link] as plt.

3.2 Créer des graphiques simples (30 min)

Matplotlib utilise une approche orientée objet, mais la plupart des utilisateurs débutants interagissent
avec l’interface pyplot pour simplifier le processus.
— Graphique en ligne ([Link]()) :
— Utilisé pour représenter l’évolution d’une variable continue ou la relation entre deux variables
continues.
— Syntaxe de base : [Link](x, y)
— Graphique à barres ([Link]()) :
— Utilisé pour comparer des catégories discrètes ou montrer la distribution de données catégo-
rielles.
— Syntaxe de base : [Link](categories, values)
— Nuage de points ([Link]()) :
— Utilisé pour montrer la relation entre deux variables continues, identifier des clusters ou des
tendances.
— Syntaxe de base : [Link](x, y)
Chaque graphique nécessite [Link]() pour être affiché.

1 import [Link] as plt

2 import numpy as np
3
4 # --- Graphique en ligne ---
5 x = [Link](0, 10, 100) # 100 points entre 0 et 10
6 y = [Link](x)
7
8 [Link](figsize=(8, 4)) # Définit la taille de la figure (largeur, hauteur en pouces)
9 [Link](x, y)
10 [Link]("Graphique de Sin(x)") # Titre du graphique
11 [Link]("X") # Étiquette de l'axe X
12 [Link]("Sin(X)") # Étiquette de l'axe Y
13 [Link](True) # Ajoute une grille
14 [Link]() # Affiche le graphique
15
16 # --- Graphique à barres ---
17 categories = ['A', 'B', 'C', 'D']
18 values = [23, 45, 56, 12]
19
20 [Link](figsize=(6, 5))
21 [Link](categories, values, color='skyblue') # Définition de la couleur des barres
22 [Link]("Comparaison de Catégories")
23 [Link]("Catégorie")
24 [Link]("Valeur")
25 [Link]()
26
27 # --- Nuage de points ---
28 [Link](42) # Pour la reproductibilité des résultats aléatoires
29 x_scatter = [Link](50) * 10
30 y_scatter = 2 * x_scatter + [Link](50) * 2 # Relation linéaire avec du bruit aléatoire
31
32 [Link](figsize=(7, 6))
33 [Link](x_scatter, y_scatter, color='red', alpha=0.7) # alpha pour la transparence des points
34 [Link]("Nuage de Points")
35 [Link]("Variable X")
36 [Link]("Variable Y")
37 [Link]()

3.3 Personnalisation des graphiques (45 min)

La personnalisation est cruciale pour rendre les graphiques clairs et informatifs.
— Titres et étiquettes : [Link](), [Link](), [Link]()
— Légendes : [Link]() (nécessite l’attribut label dans les fonctions de traçage comme
[Link]()).

5 Auteur : Angelo
 Cours NumPy et Matplotlib

— Couleurs et styles de ligne/marqueur : Paramètres comme color, linestyle (’-’, ’–’, ’:’,
′
’-.’), marker (’o’, ’x’, ’ ), linewidth, [Link] des axes :[Link](), [Link]()pourdf inirles
— Grilles : [Link](True) pour activer la grille, avec des options pour son style.
—
— Plusieurs tracés sur une même figure : Simplement appeler les fonctions de traçage ([Link](),
[Link]()) plusieurs fois avant [Link]().
— Sous-graphiques ([Link]() ou fig, ax = [Link]()) : Créer plusieurs graphiques
distincts au sein d’une même figure.

1 import [Link] as plt

2 import numpy as np
3
4 # --- Personnalisation avancée d'un graphique en ligne ---
5 x = [Link](0, 2 * [Link], 100) # x de 0 à 2*pi
6 y1 = [Link](x)
7 y2 = [Link](x)
8
9 [Link](figsize=(10, 6))
10
11 [Link](x, y1, label='Sin(x)', color='blue', linestyle='--', marker='o', markersize=4, markevery=10)
12 [Link](x, y2, label='Cos(x)', color='red', linestyle='-', linewidth=2)
13
14 [Link]("Fonctions Sinus et Cosinus", fontsize=16, fontweight='bold')
15 [Link]("Angle (radians)", fontsize=12)
16 [Link]("Valeur", fontsize=12)
17
18 [Link](loc='upper right', shadow=True, fancybox=True) # Position et style de la légende
19 [Link](True, linestyle=':', alpha=0.6, color='gray') # Personnalisation de la grille
20
21 [Link](0, 2 * [Link]) # Limites de l'axe X
22 [Link](-1.1, 1.1) # Limites de l'axe Y
23
24 [Link]()
25
26 # --- Création de sous-graphiques ---
27 # [Link]() retourne une figure (fig) et un tableau d'axes (axes)
28 fig, axes = [Link](1, 2, figsize=(12, 5)) # 1 ligne, 2 colonnes de sous-graphiques
29
30 # Premier sous-graphique (graphique en ligne) - accès via axes[0]
31 axes[0].plot(x, y1, color='purple')
32 axes[0].set_title("Graphique Sin(x)")
33 axes[0].set_xlabel("X")
34 axes[0].set_ylabel("Y")
35 axes[0].grid(True)
36
37 # Deuxième sous-graphique (histogramme) - accès via axes[1]
38 data = [Link](1000) # Données pour l'histogramme (distribution normale)
39 axes[1].hist(data, bins=30, color='green', alpha=0.7, edgecolor='black') # bins: nombre de barres
40 axes[1].set_title("Histogramme de Données Normales")
41 axes[1].set_xlabel("Valeur")
42 axes[1].set_ylabel("Fréquence")
43
44 plt.tight_layout() # Ajuste automatiquement les paramètres des sous-graphiques pour qu'ils s'adaptent à
,→ la figure
45 [Link]()

3.4 Sauvegarder des figures (15 min)

Une fois que votre graphique est parfait, vous pouvez le sauvegarder dans divers formats.
— [Link](’nom_du_fichier.png’) ou .pdf, .svg, .jpg, etc.
— Paramètres pour la sauvegarde :
— dpi : Résolution en points par pouce (dots per inch). Une valeur plus élevée donne une meilleure
qualité pour l’impression (ex : dpi=300).
— bbox_inches=’tight’ : Ajuste automatiquement le cadre de l’image pour qu’il n’y ait pas de
marges blanches excessives.

6 Auteur : Angelo
 Cours NumPy et Matplotlib

1 import [Link] as plt

2 import numpy as np
3
4 x = [Link](0, 10, 100)
5 y = x**2
6
7 [Link](figsize=(8, 5))
8 [Link](x, y, color='darkorange', linewidth=2)
9 [Link]("Fonction Carrée")
10 [Link]("X")
11 [Link]("Y")
12 [Link](True, linestyle='--', alpha=0.7)
13
14 # Sauvegarde du graphique
15 # La fonction savefig doit être appelée AVANT [Link]() si vous ne voulez pas que
16 # le graphique s'affiche en plus d'être sauvegardé, ou après si vous voulez les deux.
17 [Link]('fonction_carree.png', dpi=300, bbox_inches='tight')
18 print("Graphique sauvegardé sous fonction_carree.png")
19
20 # [Link]() # Décommenter si vous voulez aussi afficher le graphique à l'écran

4 Partie 3 : Exercices Pratiques et Questions/Réponses (environ

30 min)
C’est le moment de mettre en pratique vos connaissances et de poser vos questions !

4.1 Exercices suggérés

1. NumPy avancé : Créez un tableau NumPy 3D de forme (3, 4, 2) avec des nombres aléatoires
entre 0 et 100. Extrayez une "tranche" spécifique, par exemple, tous les éléments de la deuxième
"page" (le long du premier axe) et de la troisième colonne.
2. Statistiques avec NumPy : Générez 1000 nombres aléatoires suivant une distribution nor-
male (avec [Link]()). Calculez leur moyenne, leur écart-type, leur minimum et leur
maximum.
3. Tracé de fonction : Tracez un graphique en ligne de la fonction y = e−x cos(2πx) pour x allant
de 0 à 5, avec 200 points. Ajoutez un titre, des étiquettes d’axes, une grille et une couleur de ligne
distinctive.
4. Graphique à barres avancé : Créez un graphique à barres comparant les "ventes" de 5 "pro-
duits" différents sur un mois. Les noms des produits et les ventes doivent être générés aléatoire-
ment. Ajoutez des étiquettes de données sur chaque barre.
5. Sous-graphiques complexes : Créez une figure avec deux sous-graphiques côte à côte. Le
premier sera un nuage de points montrant la relation entre deux séries de données aléatoires.
Le second sera un histogramme de l’une de ces séries de données. Assurez-vous que les deux
sous-graphiques ont des titres et des étiquettes d’axes appropriés.

4.2 Session de questions-réponses

N’hésitez pas à poser toutes vos questions concernant NumPy et Matplotlib, ou les concepts abordés
dans ce cours.

7 Auteur : Angelo