Structures de données en Python : listes, tuples, ensembles, dictionnaires et compréhensions

Jusqu'ici, vos programmes manipulaient des valeurs une variable à la fois. Les données réelles arrivent en masse : une classe d'élèves, un mois de températures, un panier de produits. Cette leçon présente les quatre collections natives de Python: listes, tuples, ensembles et dictionnaires: puis la fonctionnalité qui rend le code Python immédiatement reconnaissable : les compréhensions. Beaucoup d'apprenants décrivent cette leçon comme le moment où le langage fait tilt, car soudain les programmes que vous pouvez écrire cessent d'être des exercices pour devenir utiles.

Une promesse discrète avant de commencer : vous n'avez pas besoin de mémoriser chaque méthode de chaque collection. Vous devez savoir à quoi sert chaque structure, les quelques opérations que vous utiliserez quotidiennement et comment retrouver le reste. Le tableau de choix de la section 5 est le véritable enseignement de cette leçon ; la syntaxe s'estompe dans la mémoire, mais savoir quel conteneur convient à un problème est une compétence durable.

1. Listes : le conteneur à tout faire

Une liste est une séquence ordonnée et modifiable de valeurs, écrite entre crochets. Les éléments conservent l'ordre dans lequel vous les avez fournis, peuvent être lus par position à partir de zéro, et peuvent être ajoutés, supprimés et remplacés librement. Les listes contiennent n'importe quoi: nombres, chaînes, autres listes, un mélange: bien qu'en pratique un bon code conserve un seul type par liste. Les index négatifs comptent depuis la fin, -1 désignant le dernier élément, un idiome que vous utiliserez constamment.

marks = [78, 91, 65, 84, 70]

print(marks[0])      # 78    first
print(marks[-1])     # 70    last
print(len(marks))    # 5

marks.append(88)         # add at the end
marks.insert(0, 50)      # add at a position
marks.remove(65)         # remove first matching value
top = max(marks)
marks.sort()             # in place, ascending
print(marks)             # [50, 70, 78, 84, 88, 91]
print(f"top mark: {top}")

Le découpage lit une sous-liste avec la même convention début-inclus, fin-exclue que range : notes[1:4] donne les éléments aux positions 1, 2 et 3, notes[:3] donne les trois premiers, notes[-2:] les deux derniers, et notes[::-1] la liste entière inversée. Les tranches produisent toujours une nouvelle liste, laissant l'original intact, ce qui est aussi la manière standard de copier une liste : copie = original[:]. Cette distinction entre partage et copie est importante car les listes sont mutables, et deux noms peuvent pointer vers une même liste ; si vous ajoutez un élément via un nom, l'autre le voit aussi, le même phénomène d'alias qui rendait les valeurs par défaut mutables dangereuses dans la partie 4.

2. Tuples : des séquences qui promettent de ne pas changer

Un tuple est une séquence ordonnée comme une liste, mais immuable : une fois créé, il ne peut ni grandir, ni rétrécir, ni être modifié. Les tuples s'écrivent avec des parenthèses, ou sans rien du tout, car ce sont en réalité les virgules qui font un tuple, exactement ce que vous avez utilisé quand une fonction de la partie 4 renvoyait deux valeurs. Utilisez les tuples pour des données de forme fixe: une paire de coordonnées, un triplet de date, un enregistrement nom et score: et les listes pour des collections ouvertes de choses similaires.

point = (12.5, 7.8)
student = ("Amina", 87)        # the record shape from Part 4

name, score = student          # unpacking: one name per slot
print(f"{name} scored {score}")

x, y = point
y, x = x, y                    # the classic Python swap, no temp needed
print(x, y)                    # 7.8 12.5

Le dépaquetage est l'idiome à intérioriser ici. Toute séquence peut être dépaquetée dans des noms correspondant exactement, les boucles peuvent dépaqueter au fur et à mesure, et un nom étoilé peut absorber le milieu : premier, *reste = scores. L'immuabilité n'est pas une limitation ; c'est une information. Quand vous voyez un tuple, vous savez que rien ne le modifiera dans votre dos, ce qui explique aussi pourquoi les tuples peuvent servir de clés de dictionnaire alors que les listes ne le peuvent pas.

3. Dictionnaires : chercher des choses par nom

Un dictionnaire associe des clés à des valeurs, comme un annuaire téléphonique associe des noms à des numéros. C'est la structure de données la plus utilisée en Python réel, car la plupart des données réelles sont naturellement étiquetées : un utilisateur a un nom, un email, un âge ; un produit a un prix et un stock. Les accolades avec des paires clé deux-points valeur en créent un, les crochets lisent et écrivent par clé, et l'opérateur in vérifie si une clé existe. Lire une clé absente avec des crochets lève KeyError ; la méthode get renvoie None, ou une valeur par défaut de votre choix, à la place, et choisir délibérément entre ces deux comportements est la marque d'un code réfléchi.

student = {"name": "Amina", "score": 87, "city": "Colombo"}

print(student["name"])              # Amina
student["score"] = 91               # update
student["grade"] = "A"              # insert new key
print(student.get("email"))         # None, no crash
print(student.get("email", "n/a"))  # n/a, your default

for key, value in student.items():  # unpacking in the loop header
    print(f"{key}: {value}")

Compter des choses est le motif de dictionnaire que vous utiliserez le plus, un accumulateur de la partie 3 où l'accumulateur est un dict. Parcourez les données ; pour chaque élément, ajoutez un à son entrée, en créant l'entrée à la première occurrence avec get. Cette forme en cinq lignes alimente les fréquences de mots, les décomptes de votes, les inventaires, et le travail sur les données à venir dans la partie 11 ; le bac à sable à la fin de cette leçon vous fait le construire vous-même.

4. Ensembles : appartenance et unicité

Un ensemble (set) est une collection non ordonnée de valeurs uniques. Ajoutez deux fois le même élément et il n’est stocké qu’une seule fois ; demandez si un élément est présent et la réponse arrive quasiment instantanément, quelle que soit la taille de l’ensemble, ce qui est radicalement plus rapide que de parcourir une longue liste. Les deux usages quotidiens sont la déduplication: set(items) élimine les doublons en un seul appel: et le test d’appartenance rapide pour les recherches effectuées dans une boucle. Les ensembles supportent aussi l’algèbre tout droit sortie des cours de maths : union, intersection et différence, qui transforment des questions comme « qui a assisté aux deux sessions » en un simple opérateur.

monday = {"amina", "zane", "ruwan", "kai"}
tuesday = {"zane", "kai", "neha"}

print(monday & tuesday)    # {'zane', 'kai'}        both days
print(monday | tuesday)    # everyone at least once
print(monday - tuesday)    # {'amina', 'ruwan'}     Monday only

emails = ["a@x.com", "b@x.com", "a@x.com", "c@x.com", "b@x.com"]
unique = set(emails)
print(f"{len(emails)} signups, {len(unique)} unique")   # 5 signups, 3 unique

5. Choisir la bonne structure

Quand deux structures semblent toutes deux plausibles, demandez-vous ce que le code environnant va faire. Si vous allez parcourir dans l’ordre, list. Si vous allez demander sans cesse « est-ce que X existe », set ou dict. Si la forme est fixe et que la signification vient de la position, tuple. Bien choisir n’est pas du pédantisme ; la structure que vous choisissez détermine la lisibilité de chaque ligne ultérieure, et souvent sa vitesse d’exécution.

6. Les compréhensions : construire des collections en une ligne

Voici le geste signature de Python. Le motif qui consiste à créer une liste vide, à boucler et à ajouter des éléments transformés est si courant que le langage lui offre une syntaxe dédiée. Une compréhension de liste place l’expression en premier, puis la boucle, puis un filtre optionnel, le tout entre crochets, et cela se lit presque comme une notation ensembliste de l’école : les carrés de n pour chaque n dans l’intervalle, en ne gardant que les pairs. Remplacez les crochets par des accolades et vous obtenez une compréhension d’ensemble ; ajoutez une clé deux-points valeur et vous obtenez une compréhension de dictionnaire.

numbers = [3, 8, 12, 5, 20, 7]

# The loop way
doubled = []
for n in numbers:
    doubled.append(n * 2)

# The comprehension way: same result, one honest line
doubled = [n * 2 for n in numbers]
evens   = [n for n in numbers if n % 2 == 0]
squares = {n: n ** 2 for n in numbers}        # dict comprehension
lengths = {len(w) for w in ["hi", "hey", "yo"]}  # set: {2, 3}

print(doubled)   # [6, 16, 24, 10, 40, 14]
print(evens)     # [8, 12, 20]
print(squares[5])  # 25

Les compréhensions ne visent pas à économiser des frappes ; elles visent à dire quoi plutôt que comment. Le lecteur voit l’expression de sortie en premier et connaît la destination avant le voyage. La discipline qui les garde lisibles : une boucle, au plus un if, et aucun effet de bord. Dès qu’une compréhension nécessite deux conditions et une boucle imbriquée, écrivez plutôt la boucle for classique ; les développeurs expérimentés le font, sans gêne.

7. enumerate et zip : boucler comme un habitué

Deux fonctions natives complètent la boîte à outils. enumerate associe chaque élément à son indice, tuant le motif maladroit range(len(items)), et zip parcourt deux séquences ou plus en parallèle, associant premier avec premier, deuxième avec deuxième, et s’arrêtant à la plus courte. Toutes deux produisent des paires qui se décompactent directement dans l’en-tête de la boucle, la compétence sur les tuples de la section 2 portant déjà ses fruits.

names  = ["Amina", "Zane", "Ruwan"]
scores = [87, 91, 78]

for i, name in enumerate(names, start=1):
    print(f"{i}. {name}")

for name, score in zip(names, scores):
    print(f"{name}: {score}")

ranking = dict(zip(names, scores))      # {'Amina': 87, 'Zane': 91, ...}

8. Pratique : un compteur de fréquence de mots

Le bac à sable ci-dessous construit le classique compteur de fréquence de mots : découpez un texte en mots, comptez chacun avec un dictionnaire, puis affichez les premiers résultats triés avec une clé lambda de la Partie 4. Chaque technique des trois dernières leçons apparaît en quinze lignes, ce qui est le but : les leçons cessent d’être séparées dès l’instant où vous construisez quelque chose. Les exercices l’étendent avec un ensemble, une compréhension et un décompactage de tuple.

Si votre boucle de comptage vous semble verbeuse, bon instinct : la Partie 8 présente collections.Counter, qui le fait en une ligne, et vous l’apprécierez précisément parce que vous avez construit la version manuelle. C’est un motif que ce cours répète délibérément : d’abord le principe à la main, puis le raccourci de la bibliothèque standard, pour que le raccourci ne soit jamais magique.

9. Récapitulatif et suite du parcours

Vous maîtrisez désormais les quatre conteneurs sur lesquels repose tout programme Python : les listes pour les données ordonnées et modifiables, les tuples pour les enregistrements fixes, les dicts pour les recherches par étiquette, les sets pour l'unicité et les tests d'appartenance, sans oublier les compréhensions, enumerate, zip, le slicing et le déballage. Avec les fonctions de la partie 4 qui viennent les envelopper, vous pouvez déjà écrire des programmes réellement utiles, et la suite du cours considère ces outils comme acquis, au même titre que l'arithmétique.

Ensuite, le cours passe de l'organisation des données à l'organisation des programmes : La partie 6, Python orienté objet présente les classes, le motif qui se cache derrière presque toutes les bibliothèques que vous importerez. Exercez-vous d'abord avec les exercices interactifs ci-dessus, puis enchaînez avec les leçons Structures de données et Compréhensions de l'application Learn Python ci-dessous ; le parcours complet se trouve toujours sur le hub de la série.

Entraînez-vous en mobilité

Learn Python, l'application Android gratuite

Chaque sujet de cette série est aussi dans l'application : des leçons concises, des exemples exécutables, des quiz, des mini-projets et un environnement Python hors ligne qui tourne sur votre téléphone.

Disponible sur Google Play Voir la page de l'application