Le contenu de cette page peut être travaillé en seconde lecture.
Caractéristiques d'une série statistique
Le contenu de cette page peut être travaillé en seconde lecture.
Une série statistique peut être représentée par une liste. Par exemple, une liste de notes :
L = [2, 20, 15, 18, 3, 9.5, 12, 7.5]
Écrire une fonction en Python
nommée liste_alea()
et qui respecte la spécification suivante :
Paramètres | trois entiers n, borne_min et borne_max strictement positifs tels que borne_min < borne_max |
---|---|
Valeur renvoyée | Une liste de n valeurs, chaque valeur étant obtenue aléatoirement et comprise entre borne_min et borne_max |
La fonction randint()
du module random
permet de générer
un entier aléatoire compris entre les deux valeurs données en argument.
Liste générée par ajouts successifs :
Liste générée en compréhension :
Une série statistique est ici représentée par une liste.
Par exemple, une liste de notes, obtenue grâce à la fonction liste_alea()
programmée dans l'exercice précédent :
>>> L = liste_alea(8, 0, 20) >>> L [2, 20, 15, 18, 3, 9, 12, 7]
Écrire une fonction en Python
nommée moyenne()
, qui respecte la spécification suivante :
Paramètres | une liste L contenant les valeurs d'une série statistique |
---|---|
Valeur renvoyée | la moyenne de la série |
On additionne les valeurs puis divise par le nombre d'éléments.
On utilise la fonction sum()
qui renvoie la somme
des éléments d'une séquence :
Certains modules proposent déjà une telle fonction :
##----- Importation des modules -----##
from random import randint
from statistics import mean
##----- Définition des fonctions -----##
def liste_alea(n, borne_min, borne_max):
liste = [] # On part d'une liste vide
for i in range(n):
valeur_alea = randint(borne_min, borne_max)
liste.append(valeur_alea)
return liste
##----- Programme principal et interaction -----##
L = liste_alea(8, 0, 20)
print(L)
print( mean(L) )
Des compléments sont disponibles sur la
page de documentation
du module statistics
.
On dispose d'une liste de notes et d'une seconde liste donnant les effectifs correspondants :
notes = [2, 6, 8, 10, 12, 14, 15, 18, 20]
effectifs = [1, 0, 2, 3, 4, 2, 4, 2, 3]
Lecture de ces données :
effectifs[2] = 2
et notes[2] = 8
:
deux élèves ont eu la note 8.effectifs[5] = 2
et notes[5] = 14
:
deux élèves ont eu la note 14.
Écrire une fonction en langage Python
nommée moyenne_ponderee()
et qui respecte la spécification
suivante :
Paramètres | une liste L contenant les valeurs d'une série statistique et une seconde liste contenant les effectifs correspondants |
---|---|
Valeur renvoyée | la moyenne de la série |
def moyenne_ponderee(valeurs, effectifs) :
somme_des_notes = 0
somme_des_effectifs = 0
for i in range(len(valeurs)) :
somme_des_notes = somme_des_notes + valeurs[i] * effectifs[i]
somme_des_effectifs = somme_des_effectifs + effectifs[i]
return somme_des_notes/somme_des_effectifs
>>> notes = [2, 6, 8, 10, 12, 14, 15, 18, 20] >>> effectifs = [1, 0, 2, 3, 4, 2, 4, 2, 3] >>> moyenne_ponderee(notes, effectifs) 13.333333333333334
Dans cette solution, nous utilisons la fonction pré-programmée sum()
qui renvoie la somme des valeurs de la liste passée en argument :
def moyenne_ponderee(valeurs, effectifs) :
# création d'une liste qui contiendra
# les produits valeur * effectif :
liste = []
for i in range(len(valeurs)) :
liste.append(valeurs[i] * effectifs[i])
return sum(liste)/sum(effectifs)
>>> notes = [2, 6, 8, 10, 12, 14, 15, 18, 20] >>> effectifs = [1, 0, 2, 3, 4, 2, 4, 2, 3] >>> moyenne_ponderee(notes, effectifs) 13.333333333333334
Essentiellement la même solution que la précédente, mais on crée la liste des produits valeur * effectif différemment :
def moyenne_ponderee(valeurs, effectifs) :
# création d'une liste qui contiendra
# les produits valeur * effectif :
liste = [effectif * valeur for effectif, valeur in zip(effectifs, valeurs)]
return sum(liste)/sum(effectifs)
notes = [2, 6, 8, 10, 12, 14, 15, 18, 20]
effectifs = [1, 0, 2, 3, 4, 2, 4, 2, 3]
print(moyenne_ponderee(notes, effectifs))
Pour bien saisir le fonctionnement de cette solution, vous pouvez chercher
sur le web "python liste en compréhension" puis "python zip".
La notion de liste en compréhension est au programme
des classes de 1ère et de Tale.
zip
:
def moyenne_ponderee(valeurs, effectifs) :
lg = len(effectifs)
# création d'une liste qui contiendra
# les produits valeur * effectif :
liste = [effectifs[i] * valeurs[i] for i in range(lg)]
return sum(liste)/sum(effectifs)
Écrire une fonction en Python,
nommée calcule_frequences()
, qui respecte la spécification
suivante :
Paramètres | une liste L contenant les effectifs d'une série statistique |
---|---|
Valeur renvoyée | une liste frequences contenant les fréquences correspondantes |
Pour les tests, utilisez des listes générées aléatoirement avec la fonction
liste_alea()
programmée dans l'exercice n°1.
La même solution, mais avec une liste en compréhension (au programme de 1ère):
Écrire une fonction en langage Python,
nommée effectifs_cumul_croissant()
, qui respecte la spécification suivante :
Paramètres | une liste contenant les effectifs d'une série statistique (dans l'ordre croissant des valeurs de la série statistique) |
---|---|
Valeur renvoyée | une liste contenant les effectifs cumulés (croissants) correspondants |
Pour les tests, utilisez des listes générées aléatoirement avec la fonction
liste_alea()
programmée dans l'exercice n°1.
On dispose d'une liste de notes dont on aimerait déterminer la valeur médiane :
notes = [2, 17, 18, 15, 6, 8, 2, 3, 10, 12, 14, 15, 18, 20, 19, 13]
Écrire une fonction en langage Python,
nommée mediane()
, qui respecte la spécification suivante :
Paramètres | une liste L contenant les valeurs d'une série statistique |
---|---|
Valeur renvoyée | la médiane de la série |
On pourra se servir du fait que si L
est une liste, alors
l'instruction L.sort()
trie la liste par ordre croissant.
def mediane(liste):
liste.sort() # On trie la liste
lg = len(liste)
n = lg//2
if lg%2 == 1 : # cas effectif impair
return liste[n]
else :
return (liste[n-1]+liste[n])/2
L = [1,2,3,3]
print(mediane(L))
M = [1,3,7]
print(mediane(M))
Écrire une fonction en Python qui respecte la spécification suivante :
Paramètres | une liste de valeurs d'une série statistique (dans l'ordre croissant des valeurs) et une liste contenant les effectifs correspondants d'une série statistique |
---|---|
Valeur renvoyée | le premier quartile de la série |
On rappelle la définition du premier quartile Q1 :
« Plus petite valeur de la série telle qu'au moins 25% des valeurs soient inférieures ou égales à Q1 »
def effectifs_cumul_croissant(liste_effectifs):
L = []
somme_partielle = 0
for x in liste_effectifs :
somme_partielle += x
L.append(somme_partielle)
return L
def frequences_cumul_croissant(liste_effectifs):
effectifs_cumul = effectifs_cumul_croissant(liste_effectifs)
total = effectifs_cumul[-1]
return [ x/total for x in effectifs_cumul]
def Q1(liste_valeurs, liste_effectifs):
FCC = frequences_cumul_croissant(liste_effectifs)
for i in range(len(liste_valeurs)):
if FCC[i] >= 0.25 :
return liste_valeurs[i]
valeurs = [1,2,4,7,10,12,30]
effectifs = [2,12,60, 150,204,218,222]
print(effectifs_cumul_croissant(effectifs))
print(frequences_cumul_croissant(effectifs))
print(Q1(valeurs, effectifs))
On dispose d'une liste de notes dont on aimerait déterminer le mode :
notes = [2, 17, 18, 15, 6, 8, 2, 3, 10, 12, 14, 15, 18, 20, 19, 13]
Écrire une fonction en Python qui respecte la spécification suivante :
Paramètres | une liste L contenant les valeurs d'une série statistique |
---|---|
Valeur renvoyée | le mode de la série |
Si L est une liste, L.count(5)
compte le nombre de valeurs
égale à 5 dans la liste.
On peut aussi utiliser la fonction max()
renvoyant la valeur
maximum contenue dans la liste qu'on lui donnera en argument.
def mode(liste):
# liste des valeurs sans répétition :
liste_valeurs = []
for x in liste :
if not(x in liste_valeurs) :
liste_valeurs.append(x)
# liste contenant le nombre de répétitions de chaque valeur :
liste_effectifs = []
for x in liste_valeurs :
liste_effectifs.append(liste.count(x))
# valeur max dans liste_effectifs
effectif_maxi = max(liste_effectifs)
# liste qui contiendra les valeurs
# d'effectif = effectif_maxi
liste_mode = []
for x in liste_valeurs :
if liste.count(x) == effectif_maxi :
liste_mode.append(x)
return liste_mode
L = [1,2,3,3, 5, 1, 2, 6]
print(mode(L))
Dans un des exercices précédents, nous avons vu la méthode .sort()
qui permet de trier une liste d'éléments par valeurs croissantes.
Cet exercice propose de programmer une fonction qui permet d'obtenir
le même résultat.
Écrire une fonction en Python,
nommée triCroissant()
, qui respecte la spécification
suivante :
Paramètres | une liste L contenant les valeurs d'une série statistique et une liste des effectifs correspondants |
---|---|
Valeur renvoyée | La liste L ordonnée (en n'oubliant pas d'ordonner aussi la liste des effectifs !) |
Il existe de nombreuses façons de trier une liste et donc de nombreux algorithmes permettant d'obtenir le résultat attendu. On a choisi de présenter ci-dessous la technique du tri par sélection.
Vous pouvez observer ci-dessous le tri par sélection en action.
Cliquez sur le bouton "Manuel" pour dérouler les étapes à votre rythme et comprendre ces étapes d'exécution.
Le bouton "Automate" enchaîne les étapes avec un intervalle de temps d'environ 3 secondes entre deux étapes (vous pouvez réduire ce temps en cliquant sur la petite flèche du formulaire contenant le nombre 3000).
def indice_du_min(liste, depart):
"""
Renvoie l'indice d'un élément de valeur minimale
parmi liste[depart], liste[depart+1], ..., liste[len(liste)-1]
"""
valeur_min = liste[depart]
indice = depart
for k in range(depart+1, len(liste)):
if liste[k] < valeur_min:
valeur_min, indice = liste[k], k
return indice
def triCroissant(liste_valeurs, liste_effectifs):
""" Tri suivant ordre croissant des valeurs de la série. """
for k in range(len(liste_valeurs)): # Parcours de tous les indices de la liste
j = indice_du_min(liste_valeurs, k) # Recherche de l'indice du minimum entre
# l'indice k et le dernier indice de la liste
# Puis échange des éléments correspondants
liste_valeurs[k], liste_valeurs[j] = liste_valeurs[j], liste_valeurs[k]
liste_effectifs[k], liste_effectifs[j] = liste_effectifs[j], liste_effectifs[k]
valeurs = [3, 18, 2, 45, 8, 3, 36]
effectifs = [2,12,60, 150,204,218,222]
print("Avant le tri : ")
for i in range(len(valeurs)) :
print("Valeur : {}, effectif : {}.".format(valeurs[i], effectifs[i]))
triCroissant(valeurs, effectifs)
print("\nAprès le tri : ")
for i in range(len(valeurs)) :
print("Valeur : {}, effectif : {}.".format(valeurs[i], effectifs[i]))
On dispose d'une liste de notes. Par exemple : notes = [2, 3, 8, 1, 20, 18, 2, 14, 14, 3, 15, 15, 15, 16, 20, 14, 14, 14, 1, 1, 1].
On veut réaliser une représentation en bâtons horizontaux comme suit :
**** 1 ** 2 ** 3 * 8 ***** 14 *** 15 * 16 * 18 ** 20
Programmer !
def ligne_etoilee(n, x):
print("*" * n, end = ' {}\n'.format(x))
def batons( liste_notes ) :
liste_notes.sort() # trie la liste
notes_diff = [] # pour stocker les notes sans répétition
for x in liste_notes :
if( x not in notes_diff ) :
ligne_etoilee(liste_notes.count(x), x)
notes_diff.append(x)
notes = [2, 3, 8, 1, 20, 18, 2, 14, 14, 3, 15, 15, 15, 16, 20, 14, 14, 14, 1, 1, 1]
batons(notes)