Comment trouver la moyenne, la médiane et le mode en Python ?

La moyenne, la médiane et le mode sont des concepts essentiels en statistiques. Ils peuvent être facilement calculés en Python, avec ou sans l'utilisation de bibliothèques externes.

Ces trois mesures sont les principales pour déterminer la tendance centrale, qui permet de comprendre les valeurs "typiques" ou "moyennes" d'un ensemble de données. Si vous débutez dans le domaine de la science des données, ce tutoriel est conçu pour vous.

À l'issue de ce guide, vous serez capable de :

Comprendre les notions de moyenne, médiane et mode
Créer vos propres fonctions pour calculer la moyenne, la médiane et le mode en Python
Utiliser le module de statistiques de Python pour appliquer rapidement ces mesures

Si vous désirez une version téléchargeable des exemples suivants, consultez le référentiel GitHub.

Examinons maintenant les différentes méthodes pour calculer la moyenne, la médiane et le mode.

Calcul de la moyenne avec Python

La moyenne, ou moyenne arithmétique, est la mesure de tendance centrale la plus couramment utilisée.

Il est important de se rappeler que la tendance centrale représente une valeur caractéristique d'un ensemble de données.

Un ensemble de données est une collection d'éléments, et en Python, il peut s'agir de l'une des structures de données intégrées suivantes :

Listes, tuples et ensembles : des collections d'objets
Chaînes de caractères : une collection de caractères
Dictionnaires : une collection de paires clé-valeur

Note: Bien qu'il existe d'autres structures de données en Python, comme les files d'attente ou les piles, nous nous concentrerons sur celles qui sont directement disponibles.

La moyenne se calcule en additionnant toutes les valeurs d'un ensemble de données, puis en divisant le résultat par le nombre total de valeurs. Par exemple, pour la liste de nombres suivante :

[1, 2, 3, 4, 5, 6]

La moyenne serait de 3,5. En effet, la somme des nombres est 21, et la liste contient 6 éléments. 21 divisé par 6 donne 3,5. Le calcul est le suivant :

(1 + 2 + 3 + 4 + 5 + 6) / 6 = 3.5

Dans ce tutoriel, nous utiliserons les joueurs d'une équipe de basketball comme exemples de données.

Création d'une fonction personnalisée pour la moyenne

Commençons par calculer l'âge moyen des joueurs de l'équipe de basket-ball, que nous appellerons "Pythonic Machines".

pythonic_machine_ages = [19, 22, 34, 26, 32, 30, 24, 24]

def mean(dataset):
    return sum(dataset) / len(dataset)

print(mean(pythonic_machine_ages))

Décortiquons ce code :

`pythonic_machine_ages` est une liste qui contient l'âge des joueurs de basketball.
Nous définissons une fonction `mean()` qui renvoie la somme des éléments de l'ensemble de données divisée par sa longueur.
- La fonction `sum()` calcule la somme de tous les éléments d'un itérable, ici, une liste. Si vous passez `pythonic_machine_ages` en argument, elle retournera 211.
- La fonction `len()` renvoie la longueur d'un itérable. Si vous passez l'ensemble de données, elle retournera 8.
Nous passons l'âge des joueurs à la fonction `mean()` et nous affichons le résultat.

Le résultat obtenu est :

26.375
# Car 211 / 8 = 26.375

Ce résultat représente l'âge moyen des joueurs de l'équipe de basket-ball. Il est à noter que cette valeur n'apparaît pas dans l'ensemble de données original, mais elle décrit la valeur "typique" de l'âge des joueurs.

Utilisation de la fonction `mean()` du module `statistics`

Calculer les mesures de tendance centrale est une tâche courante pour les développeurs. C'est pourquoi le module `statistics` de Python fournit diverses fonctions pour effectuer ces calculs, ainsi que d'autres opérations statistiques de base.

Comme ce module fait partie de la bibliothèque standard de Python, il n'est pas nécessaire d'installer un package externe avec PIP.

Voici comment utiliser ce module :

from statistics import mean

pythonic_machine_ages = [19, 22, 34, 26, 32, 30, 24, 24]

print(mean(pythonic_machine_ages))

Dans ce code, nous importons la fonction `mean()` du module `statistics` et nous lui passons l'ensemble de données en argument. Elle retournera le même résultat que notre fonction personnalisée :

26.375

Maintenant que vous maîtrisez la notion de moyenne, passons à la médiane.

Calcul de la médiane en Python

La médiane est la valeur centrale d'un ensemble de données trié. Elle est également utilisée pour indiquer une valeur "typique" d'une population.

En programmation, la médiane est la valeur qui divise un ensemble de données en deux parties égales : une moitié inférieure et une moitié supérieure.

Pour calculer la médiane, il est nécessaire de commencer par trier l'ensemble de données, soit en utilisant des algorithmes de tri, soit avec la fonction intégrée `sorted()`. Ensuite, il faut déterminer si la longueur de l'ensemble de données est paire ou impaire. La méthode de calcul de la médiane dépend de ce résultat :

Impair : la médiane est la valeur centrale de l'ensemble de données.
Pair : la médiane est la moyenne des deux valeurs centrales.

Reprenons notre exemple de l'équipe de basketball et calculons la taille médiane des joueurs en centimètres :

[181, 187, 196, 196, 198,  203, 207, 211, 215]
# L'ensemble de données étant de longueur impaire, nous choisissons la valeur centrale
median = 198

Dans ce cas, la médiane est la valeur centrale car la longueur de l'ensemble de données est impaire. Cependant, si un joueur prenait sa retraite ?

Dans ce cas, il faudrait calculer la médiane en faisant la moyenne des deux valeurs centrales de l'ensemble de données :

[181, 187, 196, 198, 203, 207, 211, 215]
# Nous choisissons les deux valeurs centrales et nous les divisons par 2
median = (198 + 203) / 2
median = 200.5

Création d'une fonction `median()` personnalisée

Mettons en pratique le concept précédent dans une fonction Python.

Pour obtenir la médiane d'un ensemble de données, il est important de se souvenir des trois étapes à suivre :

Trier l'ensemble de données : cela peut être réalisé avec la fonction `sorted()`.
Déterminer si l'ensemble est de taille impaire ou paire : cela se fait en calculant la longueur de l'ensemble de données et en utilisant l'opérateur modulo (%).
Retourner la médiane en fonction du résultat :
- Si l'ensemble est de taille impaire : retourner la valeur centrale.
- Si l'ensemble est de taille paire : retourner la moyenne des deux valeurs centrales.

Cela donne la fonction suivante :

pythonic_machines_heights = [181, 187, 196, 196, 198, 203, 207, 211, 215]
after_retirement = [181, 187, 196, 198, 203, 207, 211, 215]

def median(dataset):
    data = sorted(dataset)
    index = len(data) // 2
    
    # Si l'ensemble de données est de taille impaire
    if len(dataset) % 2 != 0:
        return data[index]
    
    # Si l'ensemble de données est de taille paire
    return (data[index - 1] + data[index]) / 2

Affichons le résultat pour nos ensembles de données :

print(median(pythonic_machines_heights))
print(median(after_retirement))

Résultat :

198
200.5

Remarquez que nous créons une variable `data` qui pointe vers l'ensemble de données trié au début de la fonction. Bien que les listes ci-dessus soient déjà triées, l'objectif est de créer une fonction réutilisable qui trie l'ensemble de données à chaque appel.

La variable `index` stocke la valeur médiane (ou la valeur médiane supérieure) de l'ensemble de données, grâce à l'opérateur de division entière. Par exemple, pour la liste `pythonic_machine_heights`, la valeur de `index` sera 4.

Il est important de se rappeler que dans Python, l'index d'une séquence commence à zéro. C'est pourquoi nous pouvons utiliser la division entière pour obtenir l'index du milieu d'une liste.

Ensuite, nous vérifions si la longueur de l'ensemble de données est impaire en comparant le résultat de l'opération modulo avec une valeur différente de zéro. Si cette condition est vérifiée, nous retournons l'élément du milieu. Par exemple, pour la liste `pythonic_machine_heights` :

>>> pythonic_machine_heights[4]
# 198

Si l'ensemble de données est de taille paire, nous retournons la somme des valeurs centrales divisée par deux. Il est à noter que `data[index - 1]` donne la valeur centrale inférieure, tandis que `data[index]` donne la valeur centrale supérieure.

Utilisation de `median()` du module `statistics`

Cette méthode est plus simple car elle utilise une fonction existante du module `statistics`.

Personnellement, s'il existe une fonction pré-définie, je l'utiliserais par principe DRY (Don't Repeat Yourself) : éviter de répéter le code existant.

Le code suivant permet de calculer la médiane des ensembles de données précédents :

from statistics import median

pythonic_machines_heights = [181, 187, 196, 196, 198, 203, 207, 211, 215]
after_retirement = [181, 187, 196, 198, 203, 207, 211, 215]

print(median(pythonic_machines_heights))
print(median(after_retirement))

Résultat :

198
200.5

Calcul du mode en Python

Le mode est la valeur la plus fréquente d'un ensemble de données. On peut le comparer au groupe le plus "populaire" d'une école, qui représente une norme pour les autres élèves.

Un exemple de mode pourrait être le nombre de ventes quotidiennes d'un magasin de produits technologiques. Le mode serait le produit le plus vendu pendant un jour donné.

['laptop', 'desktop', 'smartphone', 'laptop', 'laptop', 'headphones']

Dans cet ensemble de données, le mode est "laptop", car c'est la valeur la plus fréquente.

Il est intéressant de noter que le mode peut être calculé sur des ensembles de données non numériques, comme les chaînes de caractères.

Analysons un autre ensemble de données de ventes :

['mouse', 'camera', 'headphones', 'usb', 'headphones', 'mouse']

Cet ensemble de données a deux modes : "mouse" et "headphones", car ils apparaissent tous les deux deux fois. C'est un ensemble de données multimodal.

Que se passe-t-il s'il n'y a pas de mode dans un ensemble de données, comme le suivant ?

['usb', 'camera', 'smartphone', 'laptop', 'TV']

On appelle cela une distribution uniforme, ce qui signifie qu'il n'y a pas de mode dans cet ensemble de données.

Maintenant que vous connaissez le concept du mode, calculons-le avec Python.

Création d'une fonction `mode()` personnalisée

Il est possible de considérer la fréquence d'une valeur comme une paire clé-valeur, c'est-à-dire un dictionnaire Python.

En reprenant l'analogie du basketball, nous pouvons utiliser deux ensembles de données : les points marqués par match et les marques de chaussures de basketball portées par les joueurs.

Pour trouver le mode, il faut d'abord créer un dictionnaire de fréquences pour chaque valeur de l'ensemble de données. Ensuite, nous identifions la fréquence maximale et nous retournons tous les éléments qui ont cette fréquence.

Traduisons cela en code :

points_per_game = [3, 15, 23, 42, 30, 10, 10, 12]
sponsorship = ['nike', 'adidas', 'nike', 'jordan',
               'jordan', 'rebook', 'under-armour', 'adidas']

def mode(dataset):
    frequency = {}

    for value in dataset:
        frequency[value] = frequency.get(value, 0) + 1

    most_frequent = max(frequency.values())

    modes = [key for key, value in frequency.items()
                      if value == most_frequent]

    return modes

Vérifions le résultat en passant les deux listes en argument :

print(mode(points_per_game))
print(mode(sponsorship))

Résultat :

[10]
['nike', 'adidas', 'jordan']

Comme nous pouvons le voir, le premier `print` a donné un seul mode, tandis que le second en a donné plusieurs.

Analysons plus en détail ce code :

Nous déclarons un dictionnaire `frequency`.
Nous parcourons l'ensemble de données pour créer un histogramme, terme statistique pour un ensemble de compteurs (ou fréquences).
- Si la clé est déjà dans le dictionnaire, on incrémente sa valeur.
- Si la clé n'est pas trouvée, nous créons une nouvelle paire clé-valeur avec la valeur 1.
La variable `most_frequent` stocke la fréquence la plus élevée (la valeur, pas la clé) dans le dictionnaire `frequency`.
Nous retournons la variable `modes` qui contient toutes les clés du dictionnaire de fréquences qui ont la fréquence la plus élevée.

Il est à noter l'importance du nom des variables pour écrire du code lisible.

Utilisation de `mode()` et `multimode()` du module `statistics`

Encore une fois, le module `statistics` nous offre un moyen rapide de réaliser des opérations statistiques de base.

Nous pouvons utiliser deux fonctions : `mode()` et `multimode()`.

from statistics import mode, multimode

points_per_game = [3, 15, 23, 42, 30, 10, 10, 12]
sponsorship = ['nike', 'adidas', 'nike', 'jordan',
               'jordan', 'rebook', 'under-armour', 'adidas']

Le code ci-dessus importe les deux fonctions et définit les ensembles de données que nous avons utilisés précédemment.

La différence entre les deux fonctions est que `mode()` retourne le premier mode qu'elle rencontre, tandis que `multimode()` retourne une liste avec toutes les valeurs qui ont la fréquence la plus élevée dans l'ensemble de données.

Par conséquent, nous pouvons dire que la fonction personnalisée que nous avons créée est en fait une fonction `multimode()`.

print(mode(points_per_game))
print(mode(sponsorship))

Résultat :

10
nike

Note : Dans Python 3.8 ou supérieur, la fonction `mode()` retourne le premier mode trouvé. Si vous utilisez une version plus ancienne, une erreur `StatisticsError` sera levée.

Utilisation de la fonction `multimode()` :

print(multimode(points_per_game))
print(multimode(sponsorship))

Résultat :

[10]
['nike', 'adidas', 'jordan']

Conclusion

Félicitations ! Si vous avez suivi ce guide jusqu'ici, vous avez appris à calculer la moyenne, la médiane et le mode, qui sont les principales mesures de tendance centrale.

Bien que vous puissiez créer vos propres fonctions pour calculer la moyenne, la médiane et le mode, il est recommandé d'utiliser le module `statistics` car il fait partie de la bibliothèque standard et ne nécessite pas d'installation supplémentaire.

Pour aller plus loin, vous pouvez consulter cette introduction à l'analyse de données avec Python.