Python en Mathématiques - Niveau 2

Caractéristiques d'une série statistique

Plus tard ! Le contenu de cette page peut être travaillé en seconde lecture.

Série statistique aléatoire

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
  • Un rappel
  • Une solution
  • Une autre solution

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 :


			
			

Moyenne

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
  • Une solution
  • Une autre solution
  • Encore une solution

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.

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 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
  • Une solution
  • Une autre solution
  • ... et une autre Plus tard !

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.

On peut aussi éviter la fonction 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)
	

Des effectifs aux fréquences

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

  • Une solution
  • Une autre solution

			
			

La même solution, mais avec une liste en compréhension (au programme de 1ère):


			
			

Des effectifs aux effectifs cumulés

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

  • Une solution

			
			

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

  • 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 Q1 :

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

  • 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, 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 !)
  • 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).


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)