Représentations graphiques

15 minutes de Python

Représentation graphique de séries statistiques : utiliser la fonction plt.hist

Thème : Représentations graphiques

Niveau : ECG2

Année : Maths appliquées, Maths approfondies

Objectif : Savoir représenter à l’aide d’un histogramme une série statistique et savoir lire un histogramme.

Représenter une série statistique avec plt.hist

Le module matplotlib.pyplot permet également de représenter graphiquement un grand nombre de données à l’aide d’un histogramme. En probabilités, cela permet de visualiser la répartition des valeurs prises par une variable aléatoire simulée, et d’obtenir une approximation de sa loi ou de sa densité.

import matplotlib.pyplot as plt

La commande de base est :

plt.hist(X)

où X est une liste ou un tableau numpy contenant des réalisations d’une variable aléatoire. La figure affichée est un histogramme représentant les effectifs (ou fréquences) des valeurs observées.

On affiche ensuite la figure avec :

plt.show()

On peut préciser plusieurs options importantes :

bins = n : nombre de classes de l’histogramme,
density = True : normalise l’histogramme pour que l’aire totale vaille 1,
plt.grid() : affiche une grille.

Variables aléatoires discrètes

Pour une variable aléatoire discrète, l’histogramme permet de visualiser les fréquences empiriques des différentes valeurs possibles.

On simule d’abord un grand nombre de réalisations à l’aide de numpy.random, puis on trace l’histogramme de l’échantillon obtenu.

import numpy as np
import matplotlib.pyplot as plt
import numpy.random as rd

X = rd.binomial(20,0.4,10000)

plt.hist(X)
plt.grid()
plt.show()

Le graphique obtenu représente la répartition des valeurs prises par la variable simulée. Lorsque le nombre de simulations est grand, l’histogramme se rapproche de la loi théorique.

Variables aléatoires à densité

Pour une variable aléatoire à densité, on utilise généralement l’option density=True, afin que l’aire totale de l’histogramme soit égale à 1. L’histogramme fournit alors une approximation graphique de la densité de probabilité.

import numpy as np
import matplotlib.pyplot as plt
import numpy.random as rd

X = rd.exponential(1,10000)

plt.hist(X, bins=50, density=True)
plt.grid()
plt.show()

Lorsque le nombre de simulations augmente et que le nombre de classes est suffisamment grand, la forme de l’histogramme se rapproche de la courbe de la densité de la variable aléatoire.

Exemple

import numpy as np
import numpy.random as rd
import matplotlib.pyplot as plt

X = rd.exponential(1,10000)
plt.hist(X,bins=50,density=True)

x = np.linspace(0,8,400)
y = np.exp(-x)
plt.plot(x,y)

plt.grid()
plt.show()

Explication

La variable X est un tableau contenant 10000 réalisations indépendantes d’une variable aléatoire suivant une loi exponentielle de paramètre 1.

X = rd.exponential(1,10000)

La commande

plt.hist(X,bins=50,density=True)

trace l’histogramme des valeurs simulées avec 50 classes, et l’option density=True normalise l’histogramme : l’aire totale vaut 1. L’histogramme fournit ainsi une approximation de la densité de la loi simulée.

On construit ensuite un tableau x de valeurs entre 0 et 8, puis on calcule

y = np.exp(-x)

qui correspond à la densité théorique de la loi exponentielle de paramètre 1, à savoir \(f(t)=e^{-t}\) pour \(t\ge 0\).

La commande plt.plot(x,y) superpose alors la courbe de cette densité théorique à l’histogramme. On obtient ainsi, sur une même figure, une comparaison entre l’histogramme empirique et la densité théorique.

Chaque rectangle de l’histogramme correspond à un intervalle \([a,b]\). Sa base est la largeur de l’intervalle, et sa hauteur est choisie de sorte que l’aire du rectangle soit égale à la fréquence des valeurs de X appartenant à \([a,b]\). Autrement dit, si beaucoup de réalisations de la variable aléatoire tombent dans l’intervalle \([a,b]\), alors le rectangle correspondant est haut.

Lorsque le nombre de simulations est grand, la fréquence des valeurs de X dans un petit intervalle \([a,b]\) est proche de la probabilité \(\mathbb{P}(a \le X \le b)\). Or, pour une variable à densité \(f\), on a \(\mathbb{P}(a \le X \le b) \approx f(x)\,(b-a)\) si l’intervalle est petit. Il est donc normal que la hauteur du rectangle, qui est approximativement \(\dfrac{\mathbb{P}(a \le X \le b)}{b-a}\), soit proche de \(f(x)\).

Ainsi, lorsque les classes sont suffisamment fines et le nombre de simulations suffisamment grand, l’histogramme normalisé se rapproche de la courbe de la densité.

Enfin, plt.grid() affiche une grille et plt.show() affiche la figure.

Un exercice pour vérifier ta maîtrise

On souhaite illustrer graphiquement une loi exponentielle à l’aide d’un histogramme, et comparer l’histogramme obtenu avec la densité théorique.

On considère une variable aléatoire \(X\) suivant une loi exponentielle de paramètre 1.

Compléter le script suivant afin de :

simuler 10000 réalisations de \(X\),
tracer l’histogramme normalisé,
superposer la courbe de la densité théorique \(f(x)=e^{-x}\) pour \(x\ge 0\).

import numpy as np
import numpy.random as rd
import matplotlib.pyplot as plt

X = rd.exponential(1,      )
plt.hist(X, bins=      , density=      )

x = np.linspace(0,      , 400)
y =      

plt.plot(x,y)
plt.grid()
plt.show()

import numpy as np
import numpy.random as rd
import matplotlib.pyplot as plt

X = rd.exponential(1,10000)
plt.hist(X, bins=50, density=True)

x = np.linspace(0,8,400)
y = np.exp(-x)

plt.plot(x,y)
plt.grid()
plt.show()

Explication

La commande rd.exponential(1,10000) simule 10000 réalisations indépendantes d’une variable aléatoire suivant une loi exponentielle de paramètre 1.

L’instruction plt.hist(X, bins=50, density=True) trace l’histogramme des valeurs simulées, avec 50 classes, et le normalise de sorte que l’aire totale soit égale à 1. L’histogramme fournit ainsi une approximation de la densité de la variable aléatoire.

On construit ensuite un tableau x de valeurs entre 0 et 8, et on calcule y = np.exp(-x), qui correspond à la densité théorique \(f(x)=e^{-x}\).

La commande plt.plot(x,y) superpose la courbe de la densité théorique à l’histogramme, ce qui permet de comparer visuellement la loi simulée et la loi théorique.

Et pour quelques minutes de plus…

Prendre en main la programmation, pas à pas.

Ces exercices sont conçus pour t’aider à maîtriser progressivement la programmation en Python, en partant de la lecture et de la compréhension du code, jusqu’à l’écriture autonome de scripts complets.

L’objectif n’est pas d’aller vite, mais de construire des automatismes solides, en comprenant ce que fait chaque instruction, puis en apprenant à les utiliser par toi-même.

L’ordre des exercices est volontaire : on lit, on comprend, on complète, puis on écrit seul. Prends le temps de chaque étape : c’est la clé pour progresser durablement.

Niveau 1 Analyser un code

Comprendre avant d’écrire.
Dans cette première série, tu observes et analyses des scripts Python déjà écrits. L’objectif est de comprendre la logique du programme, le rôle des variables, des boucles et des conditions, et d’être capable de prévoir ce que le code affiche ou calcule.

Niveau 1 Exercice 1 ★☆☆☆☆