Boucles et générateurs de dictionnaires

6.1 Utilisation de enumerate()

On a déjà vu comment travailler avec les boucles pour keys, values et items dans les dictionnaires. Maintenant, penchons-nous sur la fonction enumerate().

La fonction enumerate() est utile pour itérer sur les éléments d'un dictionnaire, en fournissant un accès à la fois aux indices, clés et valeurs.

Voici quelques exemples d'utilisation de enumerate() avec les dictionnaires :

Itération sur les clés et valeurs d'un dictionnaire avec indices

Tu peux utiliser enumerate() pour parcourir les clés et les valeurs d'un dictionnaire en obtenant les indices.

# Dictionnaire avec des données sur une personne
person = {"name": "Alice", "age": 25, "city": "New York"}

# Itération sur les clés et valeurs du dictionnaire avec indices
for index, (key, value) in enumerate(person.items()):
    print(f"Index : {index}, Clé : {key}, Valeur : {value}")
    # Affiche l'indice, la clé et la valeur de chaque élément du dictionnaire

Sortie :

Index : 0, Clé : name, Valeur : Alice
Index : 1, Clé : age, Valeur : 25
Index : 2, Clé : city, Valeur : New York

Transformation des valeurs d'un dictionnaire avec les indices

Tu peux utiliser enumerate() pour modifier les valeurs d'un dictionnaire en fonction de leur indice.

# Dictionnaire initial
person = {"name": "Alice", "age": 25, "city": "New York"}

# Nouveau dictionnaire avec des indices dans les valeurs
indexed_person = {}
for index, (key, value) in enumerate(person.items()):
    indexed_person[key] = f"{value}_{index}"
    # Associe à la valeur du dictionnaire un indice sous forme de chaîne

print(indexed_person) 
# Affiche le dictionnaire avec des indices ajoutés aux valeurs

Sortie :

{'name': 'Alice_0', 'age': '25_1', 'city': 'New York_2'}

Utilisation de enumerate() pour créer un nouveau dictionnaire

Tu peux utiliser enumerate() pour créer un nouveau dictionnaire où les indices seront les clés.

# Dictionnaire initial
person = {"name": "Alice", "age": 25, "city": "New York"}

# Nouveau dictionnaire où les indices sont utilisés comme clés
indexed_person = {index: (key, value) for index, (key, value) in enumerate(person.items())}
print(indexed_person)
# Affiche le nouveau dictionnaire avec les indices comme clés

Sortie :

{0: ('name', 'Alice'), 1: ('age', 25), 2: ('city', 'New York')}

6.2 Générateurs de dictionnaires

On a déjà utilisé les List Comprehensions pour générer des listes et les Set Comprehensions pour générer des ensembles. De même, tu peux utiliser la syntaxe des générateurs pour créer des dictionnaires. Les Dictionary Comprehensions (générateurs de dictionnaires) te permettent d'écrire un code plus concis et lisible pour créer des dictionnaires.

La syntaxe de base des dictionary comprehensions est la suivante :

{expression1: expression2 for variable in sequence if condition}

où

• variable — la variable qui prend la valeur de chaque élément de l'objet itérable.
• sequence — l'objet itérable (par exemple, liste, tuple, chaîne) qui est parcouru par la variable.
• expression1 — l'expression pour générer les clés du dictionnaire. Elle dépend généralement de la variable.
• expression2 — l'expression pour générer les valeurs du dictionnaire.
• condition — (optionnel) la condition qui doit être remplie pour inclure l'élément dans le dictionnaire.

Exemple 1 :

Créer un dictionnaire avec les carrés des nombres

# Création d'un dictionnaire où les clés sont les nombres de 1 à 5 et les valeurs leurs carrés
squares = {x: x ** 2 for x in range(1, 6)}
print(squares)  # Affiche : {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Exemple 2 :

Créer un dictionnaire à partir d'une liste de tuples

# Liste de tuples contenant des paires clé-valeur
pairs = [("name", "Alice"), ("age", 25), ("city", "New York")]

# Génération d'un dictionnaire à partir d'une liste de tuples
person = {key: value for key, value in pairs}
print(person)  # Affiche : {'name': 'Alice', 'age': 25, 'city': 'New York'}

Exemple 3 :

Filtrage des éléments lors de la création d'un dictionnaire

# Création d'un dictionnaire où les clés sont les nombres de 1 à 10 et les valeurs leurs carrés
# Uniquement pour les nombres pairs
even_squares = {x: x ** 2 for x in range(1, 11) if x % 2 == 0}
print(even_squares)  # Affiche : {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

Exemple 4 :

Transformation des éléments lors de la création d'un dictionnaire

# Liste de chaînes
words = ["apple", "banana", "cherry"]

# Génération d'un dictionnaire où les clés sont des chaînes et les valeurs leur longueur
word_lengths = {word: len(word) for word in words}
print(word_lengths)  # Affiche : {'apple': 5, 'banana': 6, 'cherry': 6}

Dictionary comprehensions imbriqués

# Liste de listes avec des paires clé-valeur
nested_pairs = [[("a", 1), ("b", 2)], [("c", 3), ("d", 4)]]

# Génération d'un dictionnaire à partir d'une liste imbriquée
nested_dict = {key: value for sublist in nested_pairs for key, value in sublist}
print(nested_dict)  # Affiche : {'a': 1, 'b': 2, 'c': 3, 'd': 4}

Méthodes combinées

Tu peux combiner différentes méthodes de création de dictionnaires pour des cas plus complexes.

# Fusion de plusieurs dictionnaires en un
dict1 = {"name": "John", "age": 30}
dict2 = {"city": "New York", "country": "USA"}
combined_dict = {**dict1, **dict2}
print(combined_dict)  # Affiche : {'name': 'John', 'age': 30, 'city': 'New York', 'country': 'USA'}

L'utilisation de l'opérateur ** avant le nom du dictionnaire permet de décomposer ses éléments comme s'ils étaient énumérés individuellement. Ainsi, l'expression {**dict1, **dict2} combine en fait les éléments des deux dictionnaires.