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.
for et while, puis résous des défis avec et sans liste dans la page Exercices boucles.notes = [4, 5.5, 3, 6]
noms = ["Alice", "Bob", "Claire"]
vide = []
| Élément recherché | Écriture | Avec L = [10, 20, 30, 40, 50] |
|---|---|---|
| Premier | L[0] | 10 |
| Deuxième | L[1] | 20 |
| Dernier | L[-1] | 50 |
| Avant-dernier | L[-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
L[1] ou L[-2], vérifie que la liste contient au moins deux éléments : if len(L) >= 2:.L = [10, 20, 30, 40, 50]
print(len(L))Les indices positifs valides vont de 0 à len(L) - 1. Ici, le dernier indice positif est donc 4.
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.
L = [10, 20, 30, 40, 50]
for i in range(len(L)):
print("indice", i, "valeur", L[i])
Cette forme est utile lorsque la position i doit aussi être connue ou modifiée.
L = [10, 20, 30, 40, 50]
debut = 1
fin = 4
for i in range(debut, fin):
print(L[i])
range(debut, fin) inclut la borne debut, mais exclut la borne fin. Les indices parcourus sont donc 1, 2 et 3.L = [10, 20, 30, 40, 50]
for i in range(1, len(L)):
print(L[i])
On commence à l’indice 1. La valeur len(L) est exclue, donc le dernier indice utilisé est bien len(L) - 1.
L = [10, 20, 30, 40, 50]
for i in range(0, len(L), 2):
print(L[i])
Le troisième argument de range est le pas. Ici, l’indice avance de 2 en 2.
L = [10, 20, 30, 40, 50]
for i in range(len(L) - 1, -1, -1):
print(L[i])
Le parcours commence au dernier indice, s’arrête avant -1 et recule avec un pas de -1.
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
Comme avec range, L[debut:fin] inclut debut et exclut fin.
L = [10, 20, 30]
L[1] = 25 # remplace le deuxième élément
L.append(40) # ajoute un élément à la fin
print(L)
L = [10, 25, 30, 40]
L.remove(25) # supprime la valeur 25
L.pop() # supprime le dernier élément
print(L)
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)
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)
Le premier élément sert de valeur provisoire. Chaque élément suivant est comparé, puis remplace la valeur provisoire si nécessaire.
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)
notes = [4, 5.5, 3, 6]
compteur = 0
for note in notes:
if note < 4:
compteur = compteur + 1
print(compteur)
notes = []
if len(notes) == 0:
print("Aucune note")
else:
total = 0
for note in notes:
total = total + note
print(total / len(notes))
L[0] ou de diviser par len(L).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))
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)
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)
| Instruction | Ce qu’elle fait |
|---|---|
nombre | La valeur que l’on cherche, par exemple 6. |
compteur = 0 | Repart de zéro pour chaque nouvelle valeur. |
for x in liste | Regarde toutes les valeurs de la liste. |
if x == nombre | Vérifie si la valeur observée est celle recherchée. |
compteur += 1 | Ajoute une occurrence ; équivaut à compteur = compteur + 1. |
deja_vu.append(nombre) | Évite de recompter et de réafficher cette 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)
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.
| Tour | nombre | Action | Dictionnaire après le tour |
|---|---|---|---|
| Départ | aucun | Créer le dictionnaire vide | {} |
| 1 | 6 | occurrences[6] = 1 : créer la clé | {6: 1} |
| 2 | 6 | occurrences[6] += 1 | {6: 2} |
| 3 | 6 | occurrences[6] += 1 | {6: 3} |
| 4 | 5 | occurrences[5] = 1 : créer une autre clé | {6: 3, 5: 1} |
| Fin | 7 | Chaque 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])
deja_vu et deux boucles. Le dictionnaire permet ensuite de compter en un seul parcours de la liste.