Les dictionnaires et les ensembles en Python

Un dictionnaire stocke des paires : une clé désigne un élément et sa valeur contient l’information recherchée. Une liste de contacts est un modèle utile : un nom mène à un numéro de téléphone. L’accès à un dictionnaire utilise une clé, même lorsque cette clé est un nombre.

Écrire les paires

ages = {"Ana": 31, "Ben": 27, "Cara": 35}
print(ages["Ben"])
print(len(ages))

Ce code affiche 27, puis 3. Les deux-points associent chaque clé à sa valeur ; les virgules séparent les paires. len compte les paires. Tant {} que dict() créent un dictionnaire vide.

Chaque clé n’apparaît qu’une fois. Dans {"a": 1, "b": 2, "a": 3}, la dernière valeur de "a" remplace la précédente et donne {'a': 3, 'b': 2}. Deux clés différentes peuvent avoir la même valeur : {"Ana": "blue", "Ben": "blue"} contient toujours deux éléments.

Construire à partir d’autres données

Choisis la forme adaptée aux données d’entrée :

colors = dict(red=1, blue=2)
coordinates = dict([("x", 10), ("y", 20)])
labels = dict(zip(["a", "b", "c"], [1, 2, 3]))

La première forme crée des clés sous forme de chaînes à partir des noms des arguments. La deuxième lit une séquence de paires à deux éléments. La troisième associe les éléments correspondants de deux listes et produit {'a': 1, 'b': 2, 'c': 3}. Dans la première forme, les chaînes sont 'red' et 'blue' : il ne s’agit pas de recherches de variables.

Choisir des clés utilisables

Les clés de dictionnaire doivent être hachables. Les chaînes de caractères et les nombres conviennent, tout comme les tuples composés uniquement d’éléments hachables. Les listes, les dictionnaires et les ensembles ordinaires ne peuvent pas servir de clés. Pour une position, utilise (2, 3), un tuple, plutôt que [2, 3], une liste :

board = {(0, 0): "start", (2, 3): "treasure"}
print(board[(2, 3)])

Ce code affiche treasure. Les parenthèses font du couple de coordonnées une seule clé. Un tuple contenant une liste ne respecte toujours pas la règle de hachabilité. Les valeurs d’un dictionnaire n’ont pas cette restriction : une valeur peut être une liste, un autre dictionnaire ou tout autre type.

Des clés numériques égales désignent la même entrée. Puisque 1, 1.0 et True sont considérés comme égaux, {1: "one", 1.0: "float one"} contient une paire, dont la valeur est 'float one'. La chaîne "1" est une clé distincte du nombre 1.

Distinguer l’ordre et l’identité

Depuis Python 3.7, les dictionnaires conservent l’ordre d’insertion. Les âges ci-dessus apparaissent dans l’ordre Ana, Ben, Cara à l’affichage ou lors d’un parcours. Ils restent associés à des clés, pas à des positions de liste : ages[0] cherche la clé 0 et lève KeyError: 0.

Les dictionnaires sont mutables. Après backup = ages, les deux noms désignent le même dictionnaire. Exécuter backup["Ana"] = 32 modifie aussi la valeur accessible par ages. Pour copier le dictionnaire externe, écris backup = ages.copy() ou backup = dict(ages). Des dictionnaires externes distincts peuvent encore partager des listes et des dictionnaires imbriqués.

Le mode d’accès doit correspondre à ce que signifie une clé manquante dans ton programme. Elle signale parfois une erreur. Parfois, elle est normale, comme pour un produit qui n’a pas encore été compté. Python propose différentes façons de traiter ces cas.

Lire une valeur existante

stock = {"apples": 12, "pears": 0, "plums": 7}
print(stock["plums"])

L’accès par crochets renvoie 7. Les clés doivent correspondre exactement : "Plums" est différent de "plums". La lecture de stock["kiwis"] lève KeyError: 'kiwis', car cette clé est absente. Elle ne fournit ni valeur vide ni effectif nul.

Utilise cet accès direct lorsqu’une clé est obligatoire. Une erreur attire alors l’attention sur des données incomplètes ou une faute de frappe à l’endroit où elle se produit.

Tester la présence d’une clé

L’expression key in stock vérifie si une clé existe. "pears" in stock vaut True, bien que sa valeur stockée soit zéro. "kiwis" not in stock vaut également True.

item = "kiwis"
if item in stock:
    print(stock[item])
else:
    print("No stock record for", item)

Ici, la clé manquante entraîne l’affichage d’un message. L’accès n’a lieu que dans la branche où la clé existe.

Le test d’appartenance sur un dictionnaire cherche dans les clés. 12 in stock vaut False ; pour savoir si un élément a pour valeur stockée 12, écris 12 in stock.values(). La collection placée après in détermine ce qui est parcouru.

Lire avec une valeur par défaut

stock.get("kiwis") renvoie None sans lever KeyError. Fournis un deuxième argument pour choisir une autre valeur par défaut : stock.get("kiwis", 0) renvoie 0. Aucun des deux appels n’insère de nouvel élément. Après ces deux appels, le dictionnaire ne contient toujours que les pommes, les poires et les prunes.

La valeur par défaut remplace le résultat d’un accès à une clé manquante, pas une valeur stockée. stock.get("pears", 99) renvoie 0, car les poires ont déjà une valeur.

Ne pas confondre zéro et absence

if stock.get("pears"): teste la valeur de vérité du résultat renvoyé. Zéro est faux, donc cette branche est ignorée. Le même test ignore aussi une clé manquante dont l’accès renvoie None. Pour distinguer ces cas, teste directement l’appartenance de la clé.

Traiter une commande entière

prices = {"coffee": 3.5, "tea": 2.75}
order = ["tea", "coffee", "tea", "soda"]
total = 0
for item in order:
    if item in prices:
        total += prices[item]
    else:
        print("No price for", item)
print(total)

Le premier thé porte le total à 2,75, le café le porte à 6,25 et le deuxième thé le porte à 9,0. Le soda produit le message No price for soda et n’ajoute rien. Un accès direct à chaque passage échouerait pour le soda ; utiliser sans avertissement un prix par défaut de zéro masquerait le prix manquant. La branche distincte rend cette information manquante visible.

Les mises à jour d’un dictionnaire utilisent les clés pour désigner ce qui change. L’affectation d’une valeur peut ajouter une paire ou remplacer une ancienne valeur. La suppression d’une paire peut aussi renvoyer une information utile, comme la quantité retirée d’un stock.

Ajouter et remplacer

scores = {"Ana": 8}
scores["Ben"] = 6
scores["Ana"] = 9
scores["Ben"] += 2
print(scores)

Le résultat est {'Ana': 9, 'Ben': 8}. Ben est ajouté, la valeur d’Ana est mise à jour, puis le score existant de Ben augmente. La ligne avec += lit d’abord l’ancienne valeur ; elle lève donc KeyError si la clé manque. Les dictionnaires n’ont pas de méthode append.

Combiner des dictionnaires

update copie des paires dans un dictionnaire existant. Avec ces scores, scores.update({"Ben": 7, "Cara": 10}) fait passer le score de Ben à 7 et ajoute Cara avec 10.

Depuis Python 3.9, l’opérateur de fusion peut construire un nouveau dictionnaire :

left = {"x": 1, "y": 2}
right = {"y": 5, "z": 3}
merged = left | right
print(merged)

Ce code affiche {'x': 1, 'y': 5, 'z': 3}. Pour une clé commune, la valeur de droite l’emporte. left reste inchangé ; left |= right le mettrait à jour en place.

update() renvoie None. Écrire scores = scores.update(new_scores) modifie l’ancien dictionnaire, puis fait référence à None avec scores. Appelle update sur une ligne distincte. Affecte le résultat de left | right lorsque tu veux un nouveau dictionnaire fusionné.

Supprimer des paires

Pour {"a": 1, "b": 2, "c": 3}, popitem() renvoie ('c', 3). Cette méthode utilise l’ordre d’insertion, et non l’ordre alphabétique ou la plus grande valeur.

Suivre une modification de stock

inventory = {"pens": 10, "pads": 4}
inventory["pens"] -= 3
inventory["clips"] = 50
removed = inventory.pop("pads")

Après la vente, il reste 7 stylos. L’ajout de trombones crée une nouvelle clé. Le retrait des blocs-notes stocke 4 dans removed et laisse {'pens': 7, 'clips': 50}. La valeur renvoyée par pop permet au programme d’utiliser la quantité retirée après la suppression de la paire.

Insérer uniquement en cas d’absence

setdefault(key, default) renvoie la valeur existante, ou insère et renvoie la valeur par défaut lorsque la clé manque. Pour stock = {"apples": 12, "pears": 0, "plums": 7}, stock.setdefault("kiwis", 0) insère les kiwis et renvoie 0. stock.setdefault("apples", 99) renvoie 12 et ne modifie pas la valeur des pommes. Cette insertion fait la différence avec get.

La mise à jour d’une clé existante ne change pas sa place. À partir de {"a": 1, "b": 2, "c": 3}, l’instruction d["a"] = 10 conserve "a" en première place. Supprimer "a" puis l’insérer à nouveau la place après "c". Le remplacement d’une valeur et l’insertion d’une nouvelle paire ont des effets différents sur l’ordre.

Choisis une boucle qui te donne la partie de chaque paire dont tu as besoin. Un dictionnaire seul fournit les clés. Ses vues peuvent fournir les valeurs ou les paires entières, afin que tu n’aies pas à retrouver une information que la boucle pourrait te donner directement.

Parcourir les clés, les valeurs ou les paires

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
for day, temp in temps.items():
    print(day, temp)

Les températures sont en degrés Fahrenheit. Ce code affiche Mon 68, Tue 75 et Wed 71 sur des lignes distinctes, dans l’ordre d’insertion. Chaque élément est un tuple à deux éléments que la boucle dépaquette dans day et temp.

Avec for day in temps:, utilise temps[day] dans la boucle lorsque tu as besoin de la valeur correspondante. Si le programme a besoin des deux parties à chaque passage, .items() exprime généralement la tâche plus clairement.

Comprendre les vues

keys(), values() et items() renvoient des vues, qui reflètent les modifications ultérieures de leur dictionnaire. Ce ne sont pas des listes et elles ne permettent pas l’accès par indice. temps.keys()[0] lève TypeError. Convertis la vue en liste si tu as besoin d’un instantané avec des positions : list(temps) donne ['Mon', 'Tue', 'Wed'].

Calculer un total ou trouver une clé correspondante

sum(temps.values()) renvoie 214, et la division par len(temps) donne une moyenne d’environ 71,33. max(temps.values()) renvoie 75. Pour trouver le jour associé à cette valeur, écris max(temps, key=temps.get), qui renvoie 'Tue'.

L’argument key= fournit une fonction utilisée pour la comparaison. Ici, Python parcourt les clés des jours et appelle temps.get pour chacune afin d’obtenir sa température. Écris le nom de la fonction sans l’appeler : temps.get, pas temps.get(). En cas d’égalité entre les valeurs, max renvoie la première clé rencontrée.

Trier un rapport

sorted(temps) renvoie les clés dans l’ordre alphabétique. sorted(temps.items()) renvoie les paires triées par clé. Pour trier les clés des jours par température, utilise sorted(temps, key=temps.get), ce qui produit ['Mon', 'Wed', 'Tue']. Ajoute reverse=True pour obtenir ['Tue', 'Wed', 'Mon']. Ces appels renvoient des listes ; ils ne changent pas l’ordre de temps.

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
passing = 0
for name, grade in grades.items():
    print(f"{name}: {grade}")
    if grade >= 75:
        passing += 1

Le rapport affiche chaque nom avec sa note. Ana et Cara atteignent le seuil, donc passing vaut 2 à la fin.

Supprimer des entrées sans perturber le parcours

N’ajoute ni ne supprime de clés pendant que tu parcours directement un dictionnaire. Modifier sa taille peut lever RuntimeError: dictionary changed size during iteration. Remplacer une valeur existante est autorisé.

Pour supprimer les jours les plus frais, utilise for day in list(temps): et supprime temps[day] lorsque sa valeur est inférieure à 70. La boucle parcourt une liste de clés distincte et laisse {'Tue': 75, 'Wed': 71} dans le dictionnaire. Construire un nouveau dictionnaire filtré est une autre façon de séparer le parcours des modifications.

Un nouveau dictionnaire provient souvent d’une règle appliquée à des données existantes. Commence par une boucle que tu peux expliquer, puis utilise une compréhension lorsque la même règle s’exprime clairement en une seule expression.

Construire une paire à la fois

words = ["kiwi", "fig", "banana"]
lengths = {}
for word in words:
    lengths[word] = len(word)

À chaque passage, le programme choisit un mot comme clé et sa longueur comme valeur. Le résultat est {'kiwi': 4, 'fig': 3, 'banana': 6}. Le dictionnaire est créé avant la boucle pour que les paires précédentes restent disponibles lors des passages suivants.

Un dictionnaire en compréhension exprime le même travail :

lengths = {word: len(word) for word in words}

Lis la partie for pour voir ce qui est parcouru, puis l’expression qui la précède pour voir quelle paire est produite. Les deux-points séparent l’expression de la clé de celle de la valeur. Sans ces deux-points, {word for word in words} construit un ensemble.

Conserver certains éléments

Une clause if filtre les données d’entrée :

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
high_grades = {
    name: grade
    for name, grade in grades.items()
    if grade >= 80
}

Ana et Cara satisfont la condition, ce qui donne {'Ana': 88, 'Cara': 95}. La paire de Ben est écartée. Le dictionnaire d’entrée ne change pas ; le résultat ne contient que les paires qui satisfont la condition.

Transformer les valeurs

Une compréhension peut conserver les jours tout en convertissant les relevés Fahrenheit en Celsius :

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
celsius = {
    day: round((f - 32) * 5 / 9, 1)
    for day, f in temps.items()
}

Le résultat est {'Mon': 20.0, 'Tue': 23.9, 'Wed': 21.7}. Pour mardi, soustraire 32 donne 43 ; multiplier par 5 et diviser par 9 donne environ 23,89. round(..., 1) stocke 23,9. La clé reste la même tandis que la valeur change.

Associer les listes avec précaution

dict(zip(names, scores)) associe chaque nom au score situé à la même position. zip s’arrête à la fin de la plus courte des données d’entrée. Associer ["Ana", "Ben", "Cara"] à [90, 85] donne {'Ana': 90, 'Ben': 85}. Aucune erreur ne signale le score manquant de Cara : vérifie donc les longueurs des données d’entrée lorsque chaque nom doit avoir un score.

Échanger les clés et les valeurs

favorites = {"Ana": "blue", "Ben": "red", "Cara": "blue"}
by_color = {color: name for name, color in favorites.items()}

Le résultat est {'blue': 'Cara', 'red': 'Ben'}. Ana et Cara auraient toutes deux besoin de la même nouvelle clé, donc la paire de Cara, qui vient ensuite, remplace celle d’Ana. L’inversion ne conserve toutes les paires que lorsque les anciennes valeurs sont uniques et hachables. Une valeur de type liste ne peut pas du tout devenir une clé de dictionnaire. Pour conserver plusieurs noms sous une même couleur, stocke une liste de noms sous cette couleur.

Utilise une boucle ordinaire lorsque la tâche demande plusieurs instructions, messages ou vérifications. Une compréhension est utile parce qu’elle rend une règle courte visible ; y faire entrer de force une procédure plus longue rend la règle plus difficile à suivre.

Un tableau des effectifs indique combien de fois chaque élément distinct apparaît. Ses clés désignent les éléments ; ses valeurs sont des compteurs. Le dictionnaire s’agrandit lorsqu’un nouvel élément apparaît, tandis que les apparitions suivantes augmentent un effectif existant.

Suivre un compteur

counts = {}
for letter in "banana":
    if letter in counts:
        counts[letter] += 1
    else:
        counts[letter] = 1

La première lettre crée 'b': 1. La suivante crée 'a': 1, puis la suivante crée 'n': 1. Le "a" suivant porte son effectif existant à 2. Après les deux dernières lettres, le dictionnaire est {'b': 1, 'a': 3, 'n': 2}. Son ordre indique quand chaque lettre est apparue pour la première fois, et non quelle lettre est la plus fréquente.

Utiliser zéro avant la première occurrence

Les deux branches peuvent devenir une seule affectation :

counts = {}
for letter in "banana":
    counts[letter] = counts.get(letter, 0) + 1

Le membre de droite lit l’effectif précédent, en utilisant zéro lorsque la clé manque, puis ajoute un. Le membre de gauche stocke ce nouvel effectif. get lui-même n’insère rien ; c’est l’affectation qui le fait.

Utiliser seulement counts[letter] += 1 échoue lorsqu’une lettre est nouvelle. Déplacer counts = {} dans la boucle provoque un autre problème : chaque passage efface les effectifs précédents. Initialise le dictionnaire une fois avant de traiter les éléments.

Déterminer ce qui compte comme un même mot

Pour le texte, la casse et la ponctuation influent sur les clés. Les chaînes "The" et "the" diffèrent, tout comme "dog." et "dog". Nettoie les formes avant de les utiliser comme clés :

text = "The cat saw the dog. The dog ran."
counts = {}
for word in text.lower().split():
    word = word.strip(".,!?")
    counts[word] = counts.get(word, 0) + 1

Ce code produit {'the': 3, 'cat': 1, 'saw': 1, 'dog': 2, 'ran': 1}. lower traite la casse, split sépare les mots aux caractères d’espacement et strip supprime les caractères de ponctuation indiqués aux extrémités. Cette méthode ne supprime pas la ponctuation au milieu d’un mot.

Trouver les éléments les plus fréquents

Pour ce tableau non vide, max(counts, key=counts.get) renvoie 'the'. Pour trouver les deux mots les plus fréquents, utilise sorted(counts, key=counts.get, reverse=True)[:2], ce qui donne ['the', 'dog']. Les effectifs égaux conservent leur ordre d’origine après le tri.

Ce schéma compte aussi des nombres ou des tuples. Pour les lancers [3, 6, 3, 1, 6, 3], il construit {3: 3, 6: 2, 1: 1}. Une valeur jamais observée n’a pas d’entrée. Lis-la avec une valeur par défaut de zéro lorsque c’est utile.

Reconnaître le raccourci de la bibliothèque

from collections import Counter
letter_counts = Counter("banana")
print(letter_counts.most_common(1))
print(letter_counts["z"])

Ce code affiche [('a', 3)], puis 0. L’importation rend Counter disponible depuis la bibliothèque standard de Python. Un Counter est un dictionnaire conçu pour les comptages : ses clés sont des éléments hachables et l’accès direct à un élément manquant renvoie zéro. Ses effectifs affichés pour cette entrée sont Counter({'a': 3, 'n': 2, 'b': 1}).

Un dictionnaire peut stocker un groupe entier sous chaque clé. La clé nomme la catégorie et une liste contient les éléments qui lui sont affectés. Chaque membre reste ainsi disponible pour des totaux, des moyennes ou des rapports ultérieurs.

Construire des listes distinctes pour les groupes

words = ["apple", "bean", "avocado", "beet", "corn"]
groups = {}
for word in words:
    first = word[0]
    if first not in groups:
        groups[first] = []
    groups[first].append(word)

Pour "apple", le programme crée une liste vide sous "a" et y ajoute le mot. "bean" crée une liste distincte sous "b". "avocado" rejoint la liste existante sous "a". Le résultat est {'a': ['apple', 'avocado'], 'b': ['bean', 'beet'], 'c': ['corn']}.

La liste vide n’est créée que pour un nouveau nom de groupe. La créer à chaque passage supprimerait les membres précédents de ce groupe.

Raccourcir l’initialisation

groups.setdefault(word[0], []).append(word) effectue la même étape de regroupement. setdefault renvoie la liste existante s’il y en a une. Sinon, il stocke la liste vide fournie et la renvoie. L’appel suivant à append modifie cette liste renvoyée.

Une autre solution crée automatiquement les listes :

from collections import defaultdict
groups = defaultdict(list)
for word in words:
    groups[word[0]].append(word)

Passe list, la fonction qui crée une nouvelle liste, sans parenthèses. Lors de l’accès à une clé manquante, ce defaultdict crée et stocke une nouvelle liste vide. Même une lecture comme groups["z"] insère cette clé manquante. Utilise "z" in groups lorsque tu veux seulement vérifier si un groupe existe.

Garder les listes indépendantes

groups = dict.fromkeys(["a", "b"], []) place la même liste sous les deux clés. Ajouter 1 par groups["a"] donne alors {'a': [1], 'b': [1]}. Les listes sont partagées et non copiées.

Pour commencer avec des listes distinctes, utilise {key: [] for key in keys}, setdefault avec un nouveau [] ou defaultdict(list). Chaque nouvelle catégorie doit recevoir son propre objet liste.

Additionner les montants par catégorie

Le comptage ajoute un à chaque occurrence. Un total par catégorie ajoute le montant de chaque élément :

expenses = [("food", 12.5), ("travel", 30),
            ("food", 7.25), ("books", 18)]
totals = {}
for category, amount in expenses:
    totals[category] = totals.get(category, 0) + amount

Le total de l’alimentation commence à 12,5, puis augmente de 7,25 pour atteindre 19,75. Le transport totalise 30 et les livres 18. Stocker amount seul remplacerait le total précédent au lieu de l’augmenter.

Calculer la moyenne d’un groupe ou supprimer ses doublons

Pour scores = {"A": [80, 90], "B": [70]}, parcours scores.items() et calcule sum(values) / len(values). La moyenne du groupe A est de 85,0 ; celle du groupe B est de 70,0. Teste if values: avant de diviser afin de traiter séparément un groupe vide.

Lorsque les répétitions doivent disparaître à l’intérieur de chaque groupe, utilise des ensembles comme valeurs. tags.setdefault(post, set()).add(tag) crée un ensemble pour une nouvelle publication et y ajoute son mot-clé. Un mot-clé répété reste un seul élément ; une liste conserverait chaque occurrence.

Un enregistrement rassemble des champs liés, comme l’âge, la filière et les notes d’un étudiant. Un dictionnaire imbriqué stocke un autre dictionnaire comme valeur. Les clés externes peuvent désigner les enregistrements, tandis que les clés internes désignent les champs.

Lire un niveau à la fois

students = {
    "ana": {"age": 19, "major": "math", "grades": [88, 92]},
    "ben": {"age": 22, "major": "history", "grades": [75, 81, 79]},
}

students["ana"] donne le dictionnaire d’enregistrement d’Ana. Ajouter ["major"] lit sa filière, donc students["ana"]["major"] renvoie 'math'. Pour obtenir la dernière note de Ben, students["ben"]["grades"][-1] accède à l’enregistrement, puis à sa liste, puis au dernier élément de la liste, 79.

Chaque accès agit sur l’objet renvoyé par l’accès précédent. La même syntaxe à crochets peut désigner une clé de dictionnaire à un niveau et une position de liste à un autre.

Modifier un champ ou ajouter un enregistrement

students["ana"]["age"] = 20
students["ben"]["email"] = "ben@example.com"
students["cara"] = {"age": 21, "major": "art", "grades": []}
students["cara"]["grades"].append(90)

Les deux premières lignes modifient ou ajoutent des champs dans des enregistrements existants. La troisième ajoute un enregistrement entier sous un nouvel identifiant. La quatrième accède à la liste des notes de Cara et y ajoute une note.

L’affectation students["dev"]["age"] = 30 échoue, car l’accès externe à "dev" a lieu en premier et lève KeyError: 'dev'. Crée l’enregistrement avant d’affecter ses champs.

Pour une lecture facultative, students.get("dev", {}).get("age") renvoie None. La première valeur par défaut est un dictionnaire vide, donc le deuxième get dispose d’un dictionnaire à lire même si l’enregistrement est absent. Pour ces enregistrements, chaque valeur externe est elle-même un dictionnaire.

Choisir une structure adaptée à l’accès

Une liste de dictionnaires conserve les lignes dans l’ordre :

rows = [{"name": "Ana", "city": "Austin"},
        {"name": "Ben", "city": "Denver"}]
print(rows[1]["city"])

Ce code affiche Denver : l’indice de liste d’abord, puis la clé du champ. Un dictionnaire de listes, comme {"A": [80, 90], "B": [70]}, stocke plusieurs valeurs par nom de groupe. Ces structures peuvent être combinées lorsqu’un enregistrement a besoin à la fois de champs nommés et d’une liste ordonnée.

Lorsque les noms désignent les lignes de façon unique, construis by_name = {row["name"]: row for row in rows}. Ensuite, by_name["Ben"] trouve directement la ligne de Ben. Les valeurs sont les dictionnaires de lignes existants : les modifications faites par cet index touchent donc aussi ces lignes. Si des noms se répètent, une ligne ultérieure remplace une ligne précédente sous cette clé.

Copier les données imbriquées en connaissance de cause

backup = students partage le dictionnaire entier. backup = students.copy() crée un dictionnaire externe distinct, mais conserve les mêmes enregistrements internes. Après cette copie superficielle, backup["ana"]["age"] = 99 modifie aussi l’âge d’Ana dans students.

import copy
independent = copy.deepcopy(students)
independent["ana"]["age"] = 25

Pour ces dictionnaires et listes imbriqués, la copie profonde crée aussi des objets internes distincts. Modifier l’âge copié ne change pas l’âge d’origine. Utilise des noms de champs cohérents dans tous les enregistrements pour que le même code d’accès fonctionne pour chacun.

Traiter des données imbriquées signifie suivre le niveau atteint par la boucle. Une boucle externe choisit un enregistrement. Un accès à un champ atteint une valeur dans cet enregistrement, puis une boucle interne peut parcourir les éléments d’une liste stockée.

Résumer un enregistrement par passage

students = {
    "ana": {"major": "math", "grades": [88, 92]},
    "ben": {"major": "history", "grades": [75, 81, 79]},
    "cara": {"major": "art", "grades": []},
}
for name, info in students.items():
    grades = info["grades"]
    major = info["major"]
    if grades:
        average = sum(grades) / len(grades)
        print(f"{name}: {major}, average {average:.1f}")
    else:
        print(f"{name}: {major}, no grades")

Les notes d’Ana totalisent 180, donc sa moyenne est de 90,0. Le total de Ben est de 235 pour trois notes, ce qui donne environ 78,33 ; le format :.1f affiche 78.3. La liste de Cara est vide, donc le programme affiche cara: art, no grades sans diviser par zéro.

Les affectations à grades et major dans la boucle donnent à chaque nom les valeurs de l’enregistrement courant. La moyenne doit aussi être calculée dans la boucle : elle doit l’être séparément pour chaque étudiant.

Lire les champs facultatifs

info.get("email", "no email") fournit du texte pour un champ de courriel facultatif. Un accès direct avec info["email"] lèverait KeyError pour un enregistrement qui ne le contient pas. La valeur par défaut doit se trouver au niveau où le champ peut manquer. Le get du dictionnaire externe chercherait des identifiants d’étudiants, pas des champs de courriel.

Sélectionner des enregistrements

math_students = []
for name, info in students.items():
    if info["major"] == "math":
        math_students.append(name)

Ce code produit ['ana']. La condition lit un champ de l’enregistrement courant ; la valeur ajoutée est la clé externe. Si le rapport avait besoin des enregistrements entiers, il pourrait ajouter info à la place. Détermine le type de résultat dont la suite du programme a besoin.

Parcourir chaque note stockée

count = 0
for info in students.values():
    for grade in info["grades"]:
        if grade > 80:
            count += 1

La boucle interne parcourt les notes 88 et 92 d’Ana, puis les notes 75, 81 et 79 de Ben. La liste vide de Cara n’ajoute aucun passage. Trois notes dépassent 80 : 88, 92 et 81. Le compteur est initialisé à l’extérieur des deux boucles, car il décrit tous les étudiants ensemble. Le réinitialiser dans la boucle externe ne conserverait que l’effectif du dernier enregistrement.

Compter les enregistrements selon un champ

majors = {}
for info in students.values():
    major = info["major"]
    majors[major] = majors.get(major, 0) + 1

Chaque enregistrement ajoute un à l’effectif de sa filière. Pour Ana et Ben seuls, le résultat est {'math': 1, 'history': 1} ; inclure Cara ajoute 'art': 1. Pour totaliser ou regrouper un autre champ, conserve la boucle externe sur les enregistrements et change la valeur apportée par chaque enregistrement.

Pour obtenir des rapports lisibles, affiche une ligne formatée par enregistrement au lieu du dictionnaire imbriqué entier. Dans une f-string, stocke d’abord un champ dans une variable, comme ci-dessus, ou utilise l’autre type de guillemets à l’intérieur des accolades, comme dans f"{name}: {info['major']}".

Un ensemble indique quelles valeurs distinctes sont présentes. Il ne conserve chaque élément qu’une fois et son ordre n’est pas garanti. Les ensembles conviennent aux tests d’appartenance et à la suppression des doublons lorsque le nombre d’occurrences n’a pas d’importance.

Créer un ensemble

colors = {"red", "green"}
numbers = set([3, 1, 3, 2, 1])
print(len(numbers))
print(sorted(numbers))

Ce code affiche 3, puis [1, 2, 3]. Les valeurs répétées en entrée deviennent un seul élément. Un ensemble vide s’écrit set() ; {} crée un dictionnaire vide.

set("banana") parcourt les caractères de la chaîne et ne conserve que les lettres distinctes "a", "b" et "n". {"banana"} fournit la chaîne entière comme un seul élément. Comme pour les clés de dictionnaire, les valeurs numériques égales ne comptent qu’une fois : {1, 1.0, True} contient un élément.

Les éléments doivent être hachables. Les nombres, les chaînes de caractères et les tuples de valeurs hachables conviennent ; les listes, les dictionnaires et les ensembles ordinaires ne conviennent pas. Utilise (1, 2) pour représenter un élément de coordonnées plutôt que [1, 2]. Un frozenset est un ensemble immuable qui peut lui-même être un élément d’ensemble ou une clé de dictionnaire.

Travailler sans positions

colors[0] lève TypeError car un ensemble n’a pas de positions. Son ordre d’affichage n’est pas garanti et les éléments de type chaîne peuvent s’afficher dans un ordre différent lors d’une autre exécution. sorted(colors) produit une nouvelle liste triée lorsque les éléments peuvent être comparés. Cela ne donne pas d’ordre à l’ensemble.

Modifier les éléments

add("blue") ajoute une chaîne. update(["blue", "gold"]) ajoute deux chaînes. En revanche, update("blue") ajoute les caractères séparément, car une chaîne est itérable. Les ensembles n’ont pas de méthode append.

Conserver les premières apparitions si nécessaire

list(set(items)) supprime les doublons, mais perd leur ordre d’origine. Si les premières apparitions comptent, utilise l’ordre d’insertion d’un dictionnaire :

items = [3, 1, 3, 2, 1]
unique = list(dict.fromkeys(items))
print(unique)

Ce code affiche [3, 1, 2]. Les valeurs deviennent des clés de dictionnaire : chacune apparaît donc une fois, dans l’ordre de sa première apparition.

Tu peux aussi expliciter les rôles :

seen = set()
unique = []
for item in items:
    if item not in seen:
        seen.add(item)
        unique.append(item)

L’ensemble indique si un élément est déjà apparu ; la liste conserve les premières apparitions dans l’ordre. Les deux formes exigent des éléments d’entrée hachables.

Compter les éléments distincts ou tester l’appartenance

Pour les huit mots de "the cat saw the dog the dog ran".split(), len(set(words)) vaut 5 : the, cat, saw, dog et ran. Ce calcul compte les mots différents, pas leurs fréquences.

Un ensemble d’expéditeurs bloqués permet à sender in blocked d’indiquer si une adresse est présente. Pour les grandes collections, le test d’appartenance dans un ensemble ou un dictionnaire est généralement beaucoup plus rapide que la recherche dans une liste élément par élément.

Les opérations ensemblistes expriment des questions d’appartenance à deux collections. Utilise l’opération adaptée à la question : les membres de l’une ou l’autre collection, les seuls membres communs ou les membres restants après des exclusions.

Lire les quatre opérations

Supposons que les inscriptions aux cours soient les suivantes :

python = {"Ana", "Ben", "Cara", "Dev"}
sql = {"Ben", "Dev", "Eli"}

L’union comprend les cinq étudiants une seule fois. L’intersection ne conserve que les deux étudiants communs. La différence part de l’ensemble de gauche et exclut tout ce qui est dans celui de droite. Inverser la différence change la question : sql - python ne contient qu’Eli. La différence symétrique conserve les deux parties qui ne se recoupent pas ; elle est égale à l’union moins l’intersection.

Les formes nommées sont python.union(sql), python.intersection(sql), python.difference(sql) et python.symmetric_difference(sql).

Tester une relation

a <= b vérifie si chaque membre de a appartient à b. C’est le test de sous-ensemble. a < b exige en plus que b ait au moins un membre supplémentaire : a est alors un sous-ensemble strict. a >= b et a > b testent les relations correspondantes de sur-ensemble.

print({"Ben"} <= sql)
print(sql <= sql)
print(sql < sql)
print(python.isdisjoint(sql))

Ces instructions affichent True, True, False et False. Un ensemble est un sous-ensemble de lui-même, mais pas un sous-ensemble strict de lui-même. Des ensembles disjoints n’ont aucun membre commun ; Python et SQL ont Ben et Dev en commun. Les méthodes issubset et issuperset renvoient aussi des résultats booléens.

Garder les résultats séparés ou modifier un ensemble

result = a | b crée un nouvel ensemble et laisse les deux ensembles d’entrée inchangés. Les formes en place a |= b, a &= b, a -= b et a ^= b remplacent le contenu de a par l’union, l’intersection, la différence ou la différence symétrique. Tout autre nom désignant ce même ensemble voit la modification.

Les méthodes d’ensemble nommées acceptent des itérables comme les listes. python.union(["Fay"]) fonctionne. Les opérateurs ensemblistes ordinaires exigent des ensembles comme opérandes : {"a"} | ["b"] lève TypeError.

Utilise | pour combiner des ensembles, pas +. Distingue aussi & de and : {1, 2} and {3} renvoie {3} car l’ensemble de gauche est considéré comme vrai. Cette expression ne calcule pas les membres communs.

Trouver les exigences non satisfaites

required = {"python", "sql", "git"}
skills = {"python", "excel", "git"}
missing = required - skills
extra = skills - required
qualified = required <= skills

L’ensemble des compétences manquantes contient "sql" ; celui des compétences supplémentaires contient "excel". L’intersection contient "git" et "python". qualified vaut False, car au moins une compétence exigée est absente. Un candidat peut avoir de nombreuses compétences et échouer au test de sous-ensemble : tous les éléments exigés doivent être présents.

Choisis une collection selon ce que le programme doit en faire. L’ordre, les répétitions, l’accès par nom et la possibilité de modification sont des besoins distincts. Un programme peut utiliser plusieurs types de collections parce que les différentes parties de ses données servent à des tâches différentes.

Comparer les collections natives

Une liste convient à une suite d’événements : l’ordre compte et le même événement peut se produire plusieurs fois. Un tuple convient à un groupe fixe de valeurs liées, comme des coordonnées. Un tuple peut contenir un objet mutable : ses emplacements fixes ne rendent donc pas tous les objets contenus immuables. Seul un tuple d’éléments hachables peut être une clé de dictionnaire ou un élément d’ensemble.

Un dictionnaire convient à des informations nommées : un identifiant mène à un enregistrement ou un nom de produit mène à une quantité. Ses valeurs peuvent se répéter et être des collections entières. Un ensemble convient à une question d’appartenance : le programme doit savoir si un identifiant est présent, sans avoir besoin d’une valeur distincte pour celui-ci.

Préserver les informations nécessaires à la tâche

Convertir [1, 2, 1] en ensemble fait perdre à la fois l’occurrence répétée et l’ordre de la suite. C’est utile pour une liste d’éléments distincts, mais incorrect pour un journal complet d’événements. Un dictionnaire comme {"reader": True, "editor": True} peut souvent devenir {"reader", "editor"} lorsque les valeurs ne portent aucune information supplémentaire. Si chaque rôle doit avoir un niveau d’autorisation, conserve le dictionnaire.

L’égalité suit le sens de chaque collection. [1, 2] == [2, 1] vaut False, car l’ordre de la séquence diffère. {1, 2} == {2, 1} vaut True. Des dictionnaires contenant des paires clé-valeur égales sont considérés comme égaux même si leurs clés ont été insérées dans des ordres différents. Leur ordre d’insertion influe sur le parcours, pas sur ce test d’égalité.

Comparer les clés de dictionnaires comme des ensembles

store_a = {"pens": 10, "pads": 4, "ink": 2}
store_b = {"pads": 7, "clips": 30, "ink": 5}
common = store_a.keys() & store_b.keys()
only_a = store_a.keys() - store_b.keys()

Les clés communes sont "ink" et "pads" ; only_a contient "pens". Ce sont les produits vendus, quelles que soient leurs quantités. Les deux magasins ont des quantités d’encre différentes, mais l’encre reste une clé commune.

Les vues de clés de dictionnaires acceptent les opérations ensemblistes car les clés sont uniques et hachables. Les vues de valeurs n’acceptent pas ces opérateurs : store_a.values() & {1} lève TypeError. Il est possible de convertir les valeurs en ensemble lorsqu’elles sont hachables, mais cela élimine les valeurs répétées et répond à une autre question que la comparaison des clés de produits.

Combiner des structures dans un programme

Une bibliothèque peut utiliser un dictionnaire associant les identifiants de livres à des dictionnaires d’enregistrements, un ensemble des identifiants actuellement empruntés et une liste des emprunts du jour dans l’ordre chronologique. Un tuple comme ("Dune", 1965) associe un titre et une année. Le dictionnaire permet de trouver les détails d’un livre ; l’ensemble vérifie son statut d’emprunt ; la liste conserve l’historique du jour.