Listes, dictionnaires et tuples

Comprendre les trois structures

En Python, une structure de données sert à regrouper plusieurs valeurs dans un même objet. En Première NSI, trois structures reviennent très souvent : la liste, le dictionnaire et le tuple. Elles se ressemblent parfois, mais elles ne répondent pas au même besoin.

Une liste garde des éléments dans un ordre précis. On accède à chaque élément grâce à sa position, appelée indice. Les indices commencent à 0. Une liste peut être modifiée : on peut remplacer une valeur, ajouter un élément ou en supprimer un.

Un dictionnaire associe des clés à des valeurs. On n’utilise pas un indice, mais une clé. Cette clé peut être une chaîne de caractères, un entier, ou un autre objet non modifiable. Le dictionnaire sert quand on veut retrouver une information à partir d’un nom, d’un identifiant ou d’une catégorie.

Un tuple ressemble à une liste ordonnée, mais il n’est pas modifiable après sa création. On l’utilise pour regrouper des valeurs qui vont ensemble et qui ne doivent pas changer, par exemple des coordonnées.

Structure	Écriture	Accès	Modifiable	Usage courant
Liste	[12, 15, 9]	Par indice : notes[0]	Oui	Suite de valeurs dans un ordre
Dictionnaire	{"nom": "Ada", "age": 16}	Par clé : eleve["nom"]	Oui	Association clé, valeur
Tuple	(3, 4)	Par indice : point[1]	Non	Groupe fixe de valeurs

Listes : indices, parcours et modifications

Une liste se crée avec des crochets. Elle peut contenir des entiers, des flottants, des chaînes de caractères, des booléens ou même d’autres listes.

nombres = [8, 13, 21, 34]

Dans cette liste, nombres[0] vaut 8, nombres[1] vaut 13, et nombres[3] vaut 34. L’indice du dernier élément n’est donc pas égal au nombre d’éléments, mais au nombre d’éléments moins un.

Modifier une liste

Comme la liste est modifiable, on peut changer directement un élément.

nombres[2] = 20

La liste devient [8, 13, 20, 34]. On peut aussi ajouter un élément à la fin avec append.

nombres.append(55)

La liste devient [8, 13, 20, 34, 55].

Pour connaître la longueur d’une liste, on utilise len. Par exemple, len(nombres) vaut 5 après l’ajout précédent.

Parcourir une liste

Il existe deux parcours fréquents. Le premier lit directement les valeurs.

for x in nombres:

print(x)

Ce parcours convient quand on n’a pas besoin des indices. Le second utilise les indices.

for i in range(len(nombres)):

print(i, nombres[i])

Ce parcours convient quand on doit modifier certains éléments ou comparer un élément avec son voisin.

Attention à l’erreur classique : si une liste contient 5 éléments, les indices valides vont de 0 à 4. L’accès nombres[5] provoque une erreur.

Dictionnaires : associer des clés et des valeurs

Un dictionnaire se crée avec des accolades. Chaque association s’écrit avec une clé, deux-points, puis une valeur.

eleve = {"nom": "Nora", "classe": "Première", "moyenne": 14}

Pour accéder au nom, on écrit eleve["nom"]. Le résultat est "Nora". Pour accéder à la moyenne, on écrit eleve["moyenne"]. Le résultat est 14.

Modifier, ajouter, tester

Un dictionnaire est modifiable. On peut remplacer une valeur associée à une clé.

eleve["moyenne"] = 15

On peut aussi ajouter une nouvelle association.

eleve["option"] = "NSI"

Le dictionnaire contient maintenant une clé supplémentaire. Pour tester si une clé existe, on utilise in.

"classe" in eleve

Cette expression vaut True, car la clé "classe" est présente. En revanche, "age" in eleve vaut False si aucune clé "age" n’a été ajoutée.

Parcourir un dictionnaire

Le parcours simple donne les clés.

for cle in eleve:

print(cle, eleve[cle])

On peut aussi parcourir directement les couples clé, valeur avec items.

for cle, valeur in eleve.items():

print(cle, valeur)

Le dictionnaire est particulièrement adapté aux comptages. Par exemple, pour compter les occurrences des lettres dans une chaîne, on peut associer chaque lettre à son nombre d’apparitions.

Tuples : regrouper sans modifier

Un tuple se crée avec des parenthèses, ou simplement avec des valeurs séparées par des virgules. On rencontre souvent l’écriture avec parenthèses, car elle est plus lisible.

point = (3, 5)

On accède aux éléments par indice, comme avec une liste. point[0] vaut 3 et point[1] vaut 5. En revanche, on ne peut pas écrire point[0] = 4. Le tuple n’est pas modifiable.

Cette propriété est utile quand une donnée doit rester stable. Par exemple, une position, une couleur codée par plusieurs valeurs, ou le résultat d’une fonction qui renvoie plusieurs informations.

Une fonction peut renvoyer un tuple.

def quotient_reste(a, b):

return a // b, a % b

Si on appelle quotient_reste(17, 5), le quotient entier vaut 3 et le reste vaut 2. La fonction renvoie donc le tuple (3, 2).

On peut récupérer ces deux valeurs par affectation multiple.

q, r = quotient_reste(17, 5)

Après cette ligne, q vaut 3 et r vaut 2.

Exemple pas à pas : calculer une moyenne et un bilan

On part d’un dictionnaire qui associe chaque élève à une liste de notes.

notes = {"Inès": [12, 15, 9], "Samir": [10, 14, 16], "Léa": [18, 11, 13]}

Objectif : produire un nouveau dictionnaire qui associe chaque prénom à un tuple contenant la somme des notes et la moyenne.

On veut obtenir une structure de ce type :

{"Inès": (36, 12.0), "Samir": (40, 13.333333333333334), "Léa": (42, 14.0)}

Étape 1 : prendre un élève

Pour "Inès", la liste est [12, 15, 9]. On calcule la somme :

12 + 15 + 9 = 36

La liste contient 3 notes. La moyenne vaut donc :

36 / 3 = 12.0

On associe alors "Inès" au tuple (36, 12.0).

Étape 2 : généraliser avec une boucle

On crée d’abord un dictionnaire vide.

bilan = {}

Puis on parcourt les couples prénom, liste de notes.

for prenom, liste_notes in notes.items():

total = sum(liste_notes)

moyenne = total / len(liste_notes)

bilan[prenom] = (total, moyenne)

Pour "Samir", la somme vaut 10 + 14 + 16 = 40. La moyenne vaut 40 / 3, donc environ 13.333333333333334 avec l’affichage habituel de Python.

Pour "Léa", la somme vaut 18 + 11 + 13 = 42. La moyenne vaut 42 / 3 = 14.0.

Cet exemple combine les trois structures. Le dictionnaire sert à retrouver les données par prénom. Les listes stockent les notes, car elles forment une suite modifiable. Les tuples stockent le résultat final, car la somme et la moyenne forment un couple de valeurs.

Méthode le jour de l’évaluation

Commence par identifier la structure attendue. Si l’ordre compte et que les données peuvent changer, choisis une liste. Si on doit retrouver une valeur grâce à une clé, choisis un dictionnaire. Si on regroupe quelques valeurs fixes, choisis un tuple.

• Pour une liste : vérifie les indices. Le premier est 0. Le dernier est len(liste) - 1.
• Pour un dictionnaire : distingue bien les clés et les valeurs. L’accès se fait avec dico[cle], pas avec un indice.
• Pour un tuple : n’essaie pas de modifier un élément. Crée un nouveau tuple si les valeurs doivent changer.
• Pour une boucle : choisis entre parcourir les valeurs, les indices, ou les couples clé, valeur.
• Pour une erreur : relis d’abord les accès. Beaucoup d’erreurs viennent d’un indice trop grand ou d’une clé absente.

Avant d’écrire le programme complet, teste mentalement une petite donnée. Note les valeurs prises par les variables à chaque tour de boucle. Cette trace suffit souvent à trouver l’erreur.

En exercice, écris toujours ce que contient la structure après une modification. Par exemple, après liste.append(7), indique la nouvelle liste. Après dico["x"] = 4, indique la nouvelle association. Cette habitude rend le raisonnement plus sûr et évite les confusions entre liste, dictionnaire et tuple.

Hugo Arbonnier