À la fin de cette leçon, tu seras capable de :

• Construire un nouveau dictionnaire en choisissant une clé et une valeur pour chaque élément d'entrée.
• Filtrer des entrées et transformer des clés ou des valeurs au sein d'une compréhension de dictionnaire.
• Construire une compréhension d'ensemble pour produire des valeurs uniques transformées.
• Reconnaître que les clés d'un dictionnaire sont uniques et que la dernière valeur l'emporte lorsque des clés générées entrent en collision.

Dans la leçon précédente, une compréhension de liste créait une liste à partir d'un itérable. Les compréhensions de dictionnaires utilisent des accolades avec une paire key: value :

new_dict = {key_expression: value_expression for item in source}

Utilise .items() pour traiter ensemble les clés et les valeurs du dictionnaire ; ajoute un if final pour exclure des entrées. Un dictionnaire conserve une seule valeur par clé. Si plusieurs entrées fournissent la même clé, le résultat le plus récent remplace la valeur précédente. La collection source n'est pas modifiée.

Une compréhension d'ensemble utilise également des accolades, mais sans deux-points :

new_set = {expression for item in source}

Les ensembles conservent des valeurs uniques, mais leur ordre d'itération n'est pas garanti. Lorsque la sortie nécessite un ordre prévisible, trie l'ensemble résultant avant de l'afficher ou de le renvoyer sous forme de liste. Comme pour les compréhensions de listes, choisis une boucle classique si la transformation comporte plusieurs étapes ou des effets de bord.

1. Transformer des valeurs existantes en table de correspondance

Choisis une clé et une valeur dérivée pour chaque élément :

packages = ["api", "worker", "mailer"]
name_lengths = {package: len(package) for package in packages}
print(name_lengths)

Sortie :

{'api': 3, 'worker': 6, 'mailer': 6}

Chaque paquet devient une clé ; sa longueur devient la valeur.

2. Filtrer et ajuster un dictionnaire

Utilise .items() pour accéder aux deux parties de chaque entrée :

balances = {"ops": 55, "research": 20, "support": 80}
raised = {team: amount + 10 for team, amount in balances.items() if amount >= 50}
print(raised)

Sortie :

{'ops': 65, 'support': 90}

L'entrée research est exclue, et le dictionnaire d'origine contient toujours ses valeurs initiales.

3. Normaliser et dédupliquer des valeurs

Une compréhension d'ensemble ne garde chaque étiquette nettoyée distincte qu'une seule fois :

raw_labels = [" Backend ", "backend", "DATA", "data "]
labels = {value.strip().lower() for value in raw_labels}
print(sorted(labels))

Sortie :

['backend', 'data']

Nous utilisons sorted() pour un affichage prévisible — pas parce que l'ensemble lui-même possède un ordre de tri.

4. Comprendre les clés générées en double

Lorsque différentes valeurs génèrent la même clé, la dernière affectation l'emporte :

entries = ["DEV", "dev", "Test"]
last_seen = {name.lower(): name for name in entries}
print(last_seen)

Sortie :

{'dev': 'dev', 'test': 'Test'}

Les deux premières entrées génèrent dev ; la valeur d'origine la plus tardive écrase la précédente.

• Une compréhension d'ensemble ne conserve pas les doublons et ne garantit pas l'ordre d'itération.
• Les filtres if viennent après la partie for, pas avant.
• Une entrée vide ou aucun élément correspondant produit {} pour un dictionnaire ou set() pour un ensemble.
• Normaliser différentes clés de dictionnaire vers le même texte peut écraser des valeurs antérieures.