Les listes en Python : application aux probabilités et statistiques

On considère un dé à six faces parfaitement équilibrées et numérotées de 1 à 6. On s’intéresse à l’expérience aléatoire consistant à lancer ce dé un certain nombre de fois n.

Pour obtenir plus facilement les résultats de cette expérience, on la simule à l’aide d’un programme en Python.
Pour cela, on réfléchit d’abord à l’algorithme à mettre en place. Il peut s’écrire sous la forme suivante.

Pour obtenir les résultats de cette expérience aléatoire, on a donc besoin de deux fonctions en Python :

• la première pour simuler le lancer du dé ;
• la seconde pour construire la liste des résultats, c’est-à-dire la liste de toutes les faces obtenues à l’issue des n lancers du dé.

Pour simuler le lancer d’un dé à six faces, on rédige le programme suivant :

Une fois la fonction exécutée, on obtient, par exemple, les résultats suivants :

L1 de()   # On appelle la fonction de() qui simule le lancer d’un dé à six faces.
L2 3   # On obtient le résultat 3.
L3 de()   # On appelle la fonction de() qui simule le lancer d’un dé à six faces.
L4 1   # On obtient le résultat 1.

Pour construire la liste des résultats, c’est-à-dire la liste de toutes les faces obtenues à l’issue des n lancers du dé, on rédige le programme suivant :

Les deux fonctions précédentes ayant été exécutées, on obtient par exemple les résultats suivants :

L1 tirages(10) # On appelle la fonction tirages(10) qui simule 10 fois le lancer d’un dé à six faces.
L2 [4, 3, 4, 5, 2, 1, 6, 4, 6, 3] # On obtient une liste de 10 résultats.
L3 tirages(20) # On appelle la fonction tirages(10) qui simule 20 fois le lancer d’un dé à six faces.
L4 [1, 3, 3, 2, 2, 4, 2, 5, 1, 1, 5, 5, 1, 1, 1, 5, 3, 2, 1, 5] # On obtient une liste de 20 résultats.

Le programme final est donc :

Dans une ville, on relève chaque jour la température pendant une période de 30 jours. Ces données sont indiquées sous la forme d’une liste de 30 valeurs, exprimées en degrés Celsius.

Pour analyser ces données, on veut déterminer la température maximale, la température minimale et la température moyenne sur 30 jours.
On a donc besoin de 3 fonctions :

• une fonction max_val qui retourne la valeur maximale de la liste ;
• une fonction min_val qui retourne la valeur minimale ;
• une fonction moyenne_val qui retourne la valeur moyenne.

Il existe déjà une fonction implémentée en Python qui retourne la valeur maximale d’une liste. Elle se nomme tout simplement max.

def max_val(liste):  # fonction qui retourne la valeur maximale d’une liste
   return max(liste)

Si les températures relevées sont contenues dans une liste temp et que la fonction max_val a été exécutée, on obtient :

La fonction min implémentée en Python retourne la valeur minimale d’une liste.

def min_val(liste):  # fonction qui retourne la valeur minimale d’une liste
   return min(liste)

Si les températures relevées sont contenues dans une liste temp et que la fonction min_val a été exécutée, on obtient :

Pour calculer la moyenne d’une liste, il suffit de calculer la somme de toutes les valeurs puis de la diviser par l’effectif total.

• La fonction sum() permet de calculer la somme des éléments d’une liste ne comportant que des valeurs numériques.
• L’effectif total est déterminé par le nombre total de valeurs de la liste, ce qui correspond à la longueur de la liste.

On a donc :

On obtient :

On considère un dé parfaitement équilibré à six faces, numérotées de 1 à 6.
On note X le résultat obtenu après un lancer de dé.

X est alors une variable aléatoire discrète : X ne peut prendre qu’un nombre fini de valeurs appartenant à {1, 2, 3, 4, 5, 6} mais on ne peut déterminer exactement quelle sera cette valeur.

À chaque valeur x_i ∈ {1,2,3,4,5,6}, on peut associer la probabilité p_i = p(X = x_i).
Comme on est ici en situation d’équiprobabilité, toutes les probabilités sont égales à .

On appelle espérance de la variable aléatoire X, le nombre défini par : .

L’espérance d’une variable aléatoire dépend des valeurs possibles de X et des probabilités associées, c’est-à-dire de la loi de probabilité de X.

On peut utiliser une liste de listes en Python pour décrire la loi de probabilité d’une variable aléatoire.
Si l’on revient à notre exemple du dé et si l’on note loi_X la loi de probabilité associée à X, on a :
loi_X=[[1,1/6],[2,1/6],[3,1/6],[4,1/6],[5,1/6],[6,1/6]]

Cette liste contient 6 éléments entre crochets.
Chacun des éléments entre crochets est une liste à 2 éléments correspondant aux valeurs possibles de X et à leur probabilité.
Le premier élément de la liste [1, 1/6] signifie que X peut prendre la valeur 1 avec une probabilité de .

On peut alors accéder aux différents éléments de la liste à l’aide des indices :

• accès au premier élément de la liste loi_X
  >>> loi_X[0]
  [1, 0.16666666666666666]
• accès au premier élément du premier élément de la liste
  >>>loi_X[0][0]
  1
• accès au second élément du premier élément de la liste
  >>>loi_X[0][1]
  0.16666666666666666

L’algorithme permettant de calculer l’espérance d’une variable aléatoire X est :

On a donc le programme suivant en Python :

Après exécution, on obtient :

Si on veut vérifier pour la variable X, on a bien :

Il existe un lien entre la notion d’espérance en probabilité et la notion de moyenne en statistiques.
Pour le mettre en évidence, nous allons étudier la distance entre l’espérance d’une loi de probabilité et la valeur moyenne d’un échantillon de taille n.
Pour cela, nous allons reprendre l’exemple du lancer de dé et les fonctions définies précédemment.
Nous allons avoir besoin :

• de la fonction simulant un échantillon de n lancers (voir la partie 1 de la fiche, Simulation d’une expérience aléatoire) ;
• de la fonction calculant la moyenne d’une série statistique (voir la partie 2 de la fiche, Analyse de données statistiques) ;
• de la fonction déterminant l’espérance d’une variable aléatoire connaissant sa loi de probabilité (voir la partie 3 de la fiche, Calcul de l’espérance d’une variable aléatoire) ;
• d’une nouvelle fonction ecart_moyenne_esperance qui calculera la distance entre la moyenne et l’espérance.

Il suffit donc de reprendre certaines fonctions définies précédemment :

Puis, on ajoute la fonction ecart_moyenne_esperance au programme précédent :

On obtient ainsi le programme complet permettant d’étudier la distance entre l’espérance d’une loi de probabilité et la valeur moyenne d’un échantillon de taille n.

Après avoir exécuté le programme, on peut effectuer quelques comparaisons :

On observe que pour une petite valeur de n (n = 10), la distance entre la moyenne et l’espérance vaut 0,5, ce qui n’est pas négligeable sur un échantillon de 10 valeurs.

Pour une valeur plus importante de n (n = 100), cette distance n’est plus que d’environ 0,06, ce qui est assez peu sur un échantillon de 100.

De la même manière, on peut calculer des distances pour des valeurs de n plus importantes :

On vérifie empiriquement que plus la valeur de n est grande, plus la distance entre la moyenne de l’échantillon et l’espérance se rapproche de 0.
Autrement dit, lorsque la taille n de l’échantillon est importante, la valeur de la moyenne de l’échantillon se rapproche de la valeur de l’espérance.