Exercice : 403 : Python Bases - Listes

Objectifs

Concepts clés abordés

  1. Listes : création, affichage, longueur (len()).

  2. Parcours : boucle for pour itérer sur les éléments.

  3. Agrégats : somme et moyenne des valeurs (approche manuelle puis fonctions natives sum()).

  4. Extrêmes : recherche du minimum et du maximum (logique algorithmique puis fonctions min()/max()).

  5. Alignement de listes : utilisation des indices pour associer notes et coefficients en vue d'une moyenne pondérée.

Les listes

Vous avez obtenu 4 notes : 12, 15, 8, 11

Pour calculer la moyenne, vous faites la somme des 4 notes divisé par 4.

Avec le tableur, la fonction moyenne de la plage qui contient les 4 notes serait cohérent. On pourrait aussi envisager de calculer pour chaque note de i à n la moyenne des i premières notes.

En programmation, l'équivalent de la recopie vers le bas d'une formule tableur se traduit par la mise en place d'une boucle qui serait ici fixée à 4 itérations.

Pour stocker l'équivalent de la colonne Note, nous allons utiliser un objet de type liste

1
# Déclaration d'une liste de notes
2
notes = [12, 15, 8, 11]
3
print(f"Notes : {notes}")

Pour obtenir le nombre d'éléments de la liste

1
# Obtenir le nombre d'éléments
2
nb = len(notes)
3
print(f"Nombre de notes : {nb}")

Parcourir la liste en affichant chaque note

1
for note in notes:
2
    print(note)
3
Pour en faire le cumul : équivalent TABLEUR de la fonction SOMME
1
# Méthode 1 : Cumul manuel avec boucle
2
somNotes = 0  # Initialisation à 0 de la variable cumul
3
for note in notes: 
4
    # Addition à chaque itération de chaque note
5
    somNotes += note  # Équivaut à : somNotes = somNotes + note
6
    print(f"Cumul après ajout de {note} : {somNotes}")
7
8
print(f"\nSomme totale : {somNotes}")
9
10
# Méthode 2 : Utilisation de la fonction sum() (plus pythonique)
11
somNotes_v2 = sum(notes)
12
print(f"Somme avec sum() : {somNotes_v2}")
Question
Calculer la moyenne en divisant la variable cumul par le nombre de notes : équivalent tableur de la fonction MOYENNE
Solution
1
# Méthode 1 : Calcul manuel
2
moyenne = somNotes / nb
3
print(f"Moyenne : {moyenne:.2f}")
4
5
# Méthode 2 : Plus pythonique
6
moyenne_v2 = sum(notes) / len(notes)
7
print(f"Moyenne (version 2) : {moyenne_v2:.2f}")
Question
Calculer la note minimum en complétant le code initial : équivalent tableur de la fonction MIN
1
min = 20 # initialisation de la valeur du minimum à 20 -> la première note sera forcément plus petite
2
for note in notes :
3
  # chaque note plus basse que le minimum temporaire (min) devient le minimum
4
print(min)
Solution
1
# Méthode 1 : Recherche manuelle du minimum
2
min_note = 20  # Initialisation à une valeur supérieure au max possible
3
for note in notes:
4
    if note < min_note:
5
        min_note = note
6
print(f"Note minimum (méthode 1) : {min_note}")
7
8
# Méthode 2 : Utilisation de la fonction min() (recommandé)
9
min_note_v2 = min(notes)
10
print(f"Note minimum (méthode 2) : {min_note_v2}")
Question
Calculer la note maximum :  équivalent tableur de la fonction MAX
Solution
1
# Méthode 1 : Recherche manuelle du maximum
2
max_note = 0  # Initialisation à une valeur inférieure au min possible
3
for note in notes:
4
    if note > max_note:
5
        max_note = note
6
print(f"Note maximum (méthode 1) : {max_note}")
7
8
# Méthode 2 : Utilisation de la fonction max() (recommandé)
9
max_note_v2 = max(notes)
10
print(f"Note maximum (méthode 2) : {max_note_v2}")
Indices des éléments ou rang ou index
Nous allons maintenant ajouter à chaque note un coefficient : les coefficients seront gérés dans une deuxième liste indépendante de la liste note. Le liant entre les 2 listes est le rang qui permet de savoir quel coefficient est affecté à chaque note
Question
Initialiser une liste nommée coef composée de 4 éléments tous égaux à 1.
Ils sont fixés 1 de façon à ce que la moyenne coefficientée que nous allons calculer soit identique à celle que nous avons calculée sans coefficients.
Solution
1
coefs = [1,1,1,1]
2
#coefs = [2,1,3,4] à utiliser lorsque le calcul de la moyenne coefficientée sera jugé juste
Question
Calculer la somme des éléments de la liste coef : Pou rappel, le traitement est exactement le même que la somme des notes, seule le nom de la liste diffère.
Le résultat affiché doit bien sûr être de 4
Solution
1
somCoefs = 0 # initialisation à 0 de la variable cumul
2
for coef in coefs: 
3
	 # addition à chaque itération de chaque note à la variable cumul 
4
   somCoefs +=coef # même chose que somCoefs = somCoefs + coef
5
   print(somCoefs) # la somme est affichée après chaque coef cumulé
Somme de produits : équivalent TABLEUR de la fonction SOMMEPROD
Calculer la somme des produits des listes notes et coef : Analyse du problème
  • Dans ce cas, comme la boucle principale permet d'afficher chaque note de la liste notes avec l'itérateur note, il faut pouvoir accéder au coefficient de la note à chaque itération
  • Nous allons donc utiliser un itérateur indice dont la valeur changera à chaque itération de 0 à 3 (pour nos 4 notes ou le nombre d'éléments de notre liste)
Pour accéder à l'élément i de la liste notes il faut utiliser la notation liste[indice] --> indice peut être appelé rang ou index
1
# Accès par index (commence à 0)
2
i = 1  # Deuxième élément
3
j = 3  # Quatrième élément
4
print(f"Note à l'index {i} : {notes[i]}")
5
print(f"Note à l'index {j} : {notes[j]}")
6
print(f"notes[{i}] = {notes[i]}, notes[{j}] = {notes[j]}")
Pour créer une liste que nous allons utiliser comme itérateur de la boucle for, il faut essayer l'instruction ci-dessous
1
# range() génère une séquence de nombres
2
print(f"range(0,6) : {range(0,6)}")  # Objet range
3
print(f"Liste des indices : {list(range(0,6))}")  # [0, 1, 2, 3, 4, 5]
Pour parcourir la liste des notes, on peut donc procéder comme suit
1
# Parcours avec index explicite
2
for i in range(0, len(notes)):
3
    note = notes[i]
4
    print(f"Index {i} : note = {note}")
Il est vrai que c'est un peu plus long que le code précédent
1
for note in notes: 
2
    print(note)
Mais dans ce code plus court, nous ne connaissons que la valeur de la note, pas sa position dans la liste. Or, il nous faut pour chaque note accéder à son coefficient qui se trouve au même rang que la note dans sa propre liste (coefs)
Pour afficher à chaque itération la note et son coef nous aurons donc
1
# Méthode 1 : Avec range() et index
2
for i in range(0, len(notes)):
3
    note = notes[i]
4
    coef = coefs[i]  # CORRECTION : coefs au lieu de coef
5
    print(f"Note {i+1} : {note} (coef: {coef})")
6
7
# Méthode 2 : Avec enumerate() (plus pythonique)
8
print("\nAvec enumerate() :")
9
for i, note in enumerate(notes):
10
    coef = coefs[i]
11
    print(f"Note {i+1} : {note} (coef: {coef})")
12
13
# Méthode 3 : Avec zip() (le plus élégant)
14
print("\nAvec zip() :")
15
for note, coef in zip(notes, coefs):
16
    print(f"Note : {note} (coef: {coef})")
Question
Compléter le code ci-dessus en ajoutant une variable cumul nommée somProd initialisée à 0
A chaque itération (dans la boucle for après avoir lu les variables note et coef de chaque itération ou rang i), ajouter à somProd le produit note * coef
Afficher somProd à chaque itération pour visualiser le cumul de manière progressive (ou après chaque note lue)
Changer votre liste de coefs avec coefs=coefs = [2,1,3,4] pour vérifier que votre cumul à la fin est bien de 12*2 + 15*1 + 8*3 + 11*4 = 107
Solution
1
# Somme des produits notes × coefficients
2
somProd = 0
3
for i in range(0, len(notes)):
4
    note = notes[i]
5
    coef = coefs[i]  # CORRECTION : coefs au lieu de coef
6
    somProd += note * coef
7
    print(f"Cumul après note {note}×{coef} : {somProd}")
8
9
print(f"\nSomme pondérée totale : {somProd}")
10
11
# Alternative pythonique avec sum() et zip()
12
somProd_v2 = sum(n * c for n, c in zip(notes, coefs))
13
print(f"Somme pondérée (version 2) : {somProd_v2}")
Remarque
somProd+=note * coef est la même chose que somProd = somProd + note * coef
Question
Calculer la moyenne pondérée
Solution
1
# Méthode 1 : Calcul manuel de la moyenne pondérée
2
somProd = 0
3
somCoefs = 0
4
for i in range(0, len(notes)):
5
    note = notes[i]
6
    coef = coefs[i]  # CORRECTION : coefs au lieu de coef
7
    somProd += note * coef
8
    somCoefs += coef 
9
10
moyPond = somProd / somCoefs
11
print(f"Moyenne pondérée : {moyPond:.2f}")
12
13
# Méthode 2 : Version pythonique avec compréhensions
14
moyPond_v2 = sum(n * c for n, c in zip(notes, coefs)) / sum(coefs)
15
print(f"Moyenne pondérée (version 2) : {moyPond_v2:.2f}")
16
17
# Affichage détaillé du calcul
18
print(f"\nDétail : ({' + '.join(f'{n}×{c}' for n, c in zip(notes, coefs))}) / {sum(coefs)}")
CONCLUSION
Résumé : l'étude conjointe de la boucle avec les listes permettra de mieux comprendre comment manipuler d'autres objets très utiles comme les fichiers, les dictionnaires, ou les bases de données.
A savoir : les listes sont initialisées avec des valeurs constantes en début de programme. Les méthodes append, remove, count, index ou les fonctions len et del permettent d'interagir sur les éléments de la liste.
Pour la suite, ce qui nous intéresse principalement est de lire des données dans un fichier CSV structurant les données en (ligne-colonne) afin d'extraire les colonnes de tableur en les mémorisant dans des listes. Comme on s'approche d'une gestion de type “base de données”, il sera obligatoire que toutes les données stockées dans les colonnes soient toutes de même type.