Moyenne

Une série statistique est ici 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 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

Une solution
Une autre solution
Encore une solution

On additionne les valeurs puis divise par le nombre d'éléments.

def moyenne(liste) :
    s = 0
    for n in liste :
        s += n
    return s/len(liste)
	
 
L =  [2, 20, 15, 18, 3, 9.5, 12, 7.5]
print( moyenne(L) )

La fonction sum() renvoie la somme des éléments d'une séquence :

def moyenne(liste) :
    return sum(liste)/len(liste)
	
 
L =  [2, 20, 15, 18, 3, 9.5, 12, 7.5]
print( moyenne(L) )

Certains modules proposent déjà une telle fonction :


from statistics import mean
	
L =  [2, 20, 15, 18, 3, 9.5, 12, 7.5]
print( mean(L) )

Des compléments sont disponibles sur la page de documentation du module statistics.

Moyenne pondérée

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 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

Une solution
Une autre solution
... et une autre


def moyenne_ponderee(valeurs, effectifs) :
    somme_des_notes = 0
    somme_des_effectifs = 0
    for i, valeur in enumerate(valeurs) :
        somme_des_notes += valeur * effectifs[i]
        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]

print(moyenne_ponderee(notes, effectifs))


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]

print(moyenne_ponderee(notes, effectifs))

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".

Des effectifs aux fréquences

Écrire une fonction en Python 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

Une solution
Une autre solution


def calcule_frequences(liste_effectifs) :
    # calcul de l'effectif total
    s = 0
    for x in liste_effectifs :
        s += x
    # liste des fréquences
    L = []
    for x in liste_effectifs:
        L.append(x/s)
    return L



notes =  [2, 6, 8, 10, 12, 14, 15, 18, 20]
effectifs = [1, 0, 2, 3, 4, 2, 4, 2, 3]

frequences =  calcule_frequences(effectifs)
print(frequences)

# pour vérif : 
print(sum(frequences))

La même solution, mais avec une liste en compréhension :


def calcule_frequences(liste_effectifs) :
    # calcul de l'effectif total :
    s = 0
    for x in liste_effectifs :
        s += x
    # liste des fréquences :
    return [x/s for x in liste_effectifs] 



notes =  [2, 6, 8, 10, 12, 14, 15, 18, 20]
effectifs = [1, 0, 2, 3, 4, 2, 4, 2, 3]

frequences =  calcule_frequences(effectifs)
print(frequences)

# pour vérif : 
print(sum(frequences))

Des effectifs aux fréquences cumulées

Écrire une fonction en langage Python 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 fréquences cumulées (croissantes) correspondantes

Une solution


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]
	

notes =  [2, 6, 8, 10, 12, 14, 15, 18, 20]
effectifs = [1, 0, 2, 3, 4, 2, 4, 2, 3]

frequences_cumulees =  frequences_cumul_croissant(effectifs)
print(frequences_cumulees)

Médiane

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 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.

Une solution


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))

Des effectifs au premier quartile

É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 Q₁ :

« Plus petite valeur de la série telle qu'au moins 25% des valeurs soient inférieures ou égales à Q₁ »

Une solution



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))

Mode

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.

Une solution



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))

Ordonner

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 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 !)

Une solution

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.

Illustration

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).

Pour accélérer l'automate, régler ici le temps (en ms) qui sépare deux étapes :

Le programme



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]))

Diagramme en bâtons

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 !

Une solution



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)