🐍 Python débutant : ESIG S1 à S10
Python débutant ESIG : version expliquée

Listes : indices et parcours

Une liste contient plusieurs valeurs dans un ordre précis. Chaque position possède un indice positif depuis le début et un indice négatif depuis la fin.

Dans cette documentation, les valeurs extrêmes sont recherchées avec une boucle et des comparaisons, conformément aux règles du cours.
Exercices regroupés : compare les parcours avec for et while, puis résous des défis avec et sans liste dans la page Exercices boucles.
Compter les répétitions : va directement à 17. Occurrences dans une liste, puis à 18. Clés et valeurs d’un dictionnaire.

1. Créer une liste

notes = [4, 5.5, 3, 6]
noms = ["Alice", "Bob", "Claire"]
vide = []

2. Comprendre les indices

indices positifsdepuis le début →
010-5
120-4
230-3
340-2
450-1
indices négatifs← depuis la fin
Élément recherchéÉcritureAvec L = [10, 20, 30, 40, 50]
PremierL[0]10
DeuxièmeL[1]20
DernierL[-1]50
Avant-dernierL[-2]40
L = [10, 20, 30, 40, 50]
print(L[0])   # premier
print(L[1])   # deuxième
print(L[-1])  # dernier
print(L[-2])  # avant-dernier
10
20
50
40
Avant de demander L[1] ou L[-2], vérifie que la liste contient au moins deux éléments : if len(L) >= 2:.

3. len() : nombre d’éléments

L = [10, 20, 30, 40, 50]
print(len(L))
5

Les indices positifs valides vont de 0 à len(L) - 1. Ici, le dernier indice positif est donc 4.

4. Parcourir directement les valeurs

L = [10, 20, 30, 40, 50]

for valeur in L:
    print(valeur)

Choisis cette forme lorsque tu as besoin des valeurs, mais pas de leur position.

5. Parcourir tous les indices

L = [10, 20, 30, 40, 50]

for i in range(len(L)):
    print("indice", i, "valeur", L[i])
indice 0 valeur 10
indice 1 valeur 20
indice 2 valeur 30
indice 3 valeur 40
indice 4 valeur 50

Cette forme est utile lorsque la position i doit aussi être connue ou modifiée.

6. Parcourir entre deux bornes

L = [10, 20, 30, 40, 50]
debut = 1
fin = 4

for i in range(debut, fin):
    print(L[i])
20
30
40
range(debut, fin) inclut la borne debut, mais exclut la borne fin. Les indices parcourus sont donc 1, 2 et 3.

7. Parcourir du deuxième au dernier

L = [10, 20, 30, 40, 50]

for i in range(1, len(L)):
    print(L[i])
20
30
40
50

On commence à l’indice 1. La valeur len(L) est exclue, donc le dernier indice utilisé est bien len(L) - 1.

8. Parcourir un élément sur deux

L = [10, 20, 30, 40, 50]

for i in range(0, len(L), 2):
    print(L[i])
10
30
50

Le troisième argument de range est le pas. Ici, l’indice avance de 2 en 2.

9. Parcourir en sens inverse

L = [10, 20, 30, 40, 50]

for i in range(len(L) - 1, -1, -1):
    print(L[i])
50
40
30
20
10

Le parcours commence au dernier indice, s’arrête avant -1 et recule avec un pas de -1.

10. Extraire une partie avec une tranche

L = [10, 20, 30, 40, 50]

print(L[1:4])  # indices 1 à 3
print(L[:3])   # du début à l’indice 2
print(L[2:])   # de l’indice 2 jusqu’à la fin
[20, 30, 40]
[10, 20, 30]
[30, 40, 50]

Comme avec range, L[debut:fin] inclut debut et exclut fin.

11. Modifier et ajouter

L = [10, 20, 30]
L[1] = 25       # remplace le deuxième élément
L.append(40)    # ajoute un élément à la fin
print(L)
[10, 25, 30, 40]

Supprimer un élément

L = [10, 25, 30, 40]
L.remove(25)    # supprime la valeur 25
L.pop()         # supprime le dernier élément
print(L)
[10, 30]

12. Calculer une somme et une moyenne avec une boucle

notes = [4, 5.5, 3, 6]
total = 0

for note in notes:
    total = total + note

if len(notes) > 0:
    moyenne = total / len(notes)
    print(moyenne)
4.625

13. Trouver les deux valeurs extrêmes manuellement

notes = [4, 5.5, 3, 6]
plus_petite = notes[0]
plus_grande = notes[0]

for note in notes:
    if note < plus_petite:
        plus_petite = note
    if note > plus_grande:
        plus_grande = note

print("Plus petite :", plus_petite)
print("Plus grande :", plus_grande)
Plus petite : 3
Plus grande : 6

Le premier élément sert de valeur provisoire. Chaque élément suivant est comparé, puis remplace la valeur provisoire si nécessaire.

14. Trouver la plus grande valeur et son indice

notes = [4, 5.5, 3, 6]
plus_grande = notes[0]
indice_plus_grande = 0

for i in range(1, len(notes)):
    if notes[i] > plus_grande:
        plus_grande = notes[i]
        indice_plus_grande = i

print(plus_grande, indice_plus_grande)
6 3

15. Compter selon une condition

notes = [4, 5.5, 3, 6]
compteur = 0

for note in notes:
    if note < 4:
        compteur = compteur + 1

print(compteur)
1

16. Traiter le cas d’une liste vide

notes = []

if len(notes) == 0:
    print("Aucune note")
else:
    total = 0
    for note in notes:
        total = total + note
    print(total / len(notes))
Vérifie la longueur avant d’utiliser L[0] ou de diviser par len(L).

17. Compter les occurrences dans une liste

Une occurrence est une apparition d’une valeur. Ici, 6 apparaît trois fois, 5 deux fois, 4 deux fois et 7 six fois. Dans d’autres cours, on appelle parfois une liste Python un « tableau ».

liste = [6, 6, 6, 5, 5, 4, 4, 7, 7, 7, 7, 7, 7]

for nombre in liste:
    print(nombre, ":", liste.count(nombre))
6 : 3
6 : 3
6 : 3
5 : 2
5 : 2
4 : 2
4 : 2
7 : 6
7 : 6
7 : 6
7 : 6
7 : 6
7 : 6

liste.count(nombre) compte la valeur demandée dans toute la liste. Comme la boucle passe sur chaque élément, elle affiche plusieurs fois les mêmes nombres. Pour les afficher une seule fois, on mémorise les valeurs déjà traitées :

liste = [6, 6, 6, 5, 5, 4, 4, 7, 7, 7, 7, 7, 7]
deja_vu = []

for nombre in liste:
    if nombre not in deja_vu:
        print(nombre, ":", liste.count(nombre))
        deja_vu.append(nombre)
6 : 3
5 : 2
4 : 2
7 : 6

Sans count() et sans dictionnaire : la boucle extérieure choisit un nombre inédit ; la boucle intérieure parcourt toute la liste et ajoute 1 chaque fois qu’elle retrouve ce nombre.

liste = [6, 6, 6, 5, 5, 4, 4, 7, 7, 7, 7, 7, 7]
deja_vu = []

for nombre in liste:
    if nombre not in deja_vu:
        compteur = 0
        for x in liste:
            if x == nombre:
                compteur += 1
        print(nombre, ":", compteur)
        deja_vu.append(nombre)
6 : 3
5 : 2
4 : 2
7 : 6
InstructionCe qu’elle fait
nombreLa valeur que l’on cherche, par exemple 6.
compteur = 0Repart de zéro pour chaque nouvelle valeur.
for x in listeRegarde toutes les valeurs de la liste.
if x == nombreVérifie si la valeur observée est celle recherchée.
compteur += 1Ajoute une occurrence ; équivaut à compteur = compteur + 1.
deja_vu.append(nombre)Évite de recompter et de réafficher cette valeur.

18. Compter avec un dictionnaire : clé et valeur

occurrences = {} crée un dictionnaire vide. Un dictionnaire associe une clé à une valeur. Ici, la clé est le nombre trouvé dans la liste ; la valeur est son compteur. Les accolades {} créent le dictionnaire ; les crochets [clé] choisissent une clé.

liste = [6, 6, 6, 5, 5, 4, 4, 7, 7, 7, 7, 7, 7]
occurrences = {}

for nombre in liste:
    if nombre in occurrences:
        occurrences[nombre] += 1
    else:
        occurrences[nombre] = 1

print(occurrences)
{6: 3, 5: 2, 4: 2, 7: 6}

La clé est donnée dans le else. Au premier tour, nombre vaut 6, donc occurrences[nombre] = 1 signifie occurrences[6] = 1 : cela crée la clé 6 et lui associe la valeur 1. Quand 6 revient, if nombre in occurrences est vrai, car cette clé existe. Alors occurrences[6] += 1 remplace son compteur par 2, puis par 3.

TournombreActionDictionnaire après le tour
DépartaucunCréer le dictionnaire vide{}
16occurrences[6] = 1 : créer la clé{6: 1}
26occurrences[6] += 1{6: 2}
36occurrences[6] += 1{6: 3}
45occurrences[5] = 1 : créer une autre clé{6: 3, 5: 1}
Fin7Chaque valeur a été traitée{6: 3, 5: 2, 4: 2, 7: 6}

La règle à retenir est dictionnaire[clé] = valeur. Une affectation crée la clé si elle n’existe pas ; sinon elle remplace sa valeur. if nombre in occurrences teste la présence d’une clé, pas la présence du nombre parmi les compteurs.

Pour obtenir la même présentation que les méthodes précédentes, parcours les clés du dictionnaire. Voici un exemple autonome avec le dictionnaire déjà rempli :

occurrences = {6: 3, 5: 2, 4: 2, 7: 6}

for nombre in occurrences:
    print(nombre, ":", occurrences[nombre])
6 : 3
5 : 2
4 : 2
7 : 6
Si le cours n’a pas encore abordé les dictionnaires, utilise d’abord la méthode avec deja_vu et deux boucles. Le dictionnaire permet ensuite de compter en un seul parcours de la liste.