Exercice Corrigé: Les dictionnaires en Python – Partie 1

# Créez un dictionnaire « d » avec deux paires clé-valeur.
d = {0: 10, 1: 20}

# Afficher le dictionnaire original 'd'.
print(d)

# Actualiser le dictionnaire 'd' en ajoutant une nouvelle paire clé-valeur {2:30}
d.update({2: 30})

# Afficher le dictionnaire 'd' après la mise à jour, qui comprend désormais la nouvelle paire clé-valeur.
print(d) 

# Créez trois dictionnaires 'dic1', 'dic2' et 'dic3' avec des paires clé-valeur.
dic1 = {1: 10, 2: 20}
dic2 = {3: 30, 4: 40}
dic3 = {5: 50, 6: 60}

# Créer un dictionnaire vide 'dic4' qui stockera les paires clé-valeur concatinées de 'dic1', 'dic2' et 'dic3'.
dic4 = {}

# Parcourez chaque dictionnaire ('dic1', 'dic2' et 'dic3') à l'aide d'une boucle.
for d in (dic1, dic2, dic3):
    # Mise à jour de 'dic4' en ajoutant les paires clé-valeur du dictionnaire actuel 'd'.
    dic4.update(d)

# Afficher le dictionnaire concatiné 'dic4' contenant toutes les paires clé-valeur de 'dic1', 'dic2' et 'dic3'.
print(dic4) 

d = {0:10, 1:20, 2:30}
key = 1

# Vérifier si 'key' est une clé du dictionnaire 'd'.
if key in d:
    # Si 'key' est présent dans 'd', un message indiquant que la clé est présente est affiché.
    print("La clé est présente dans le dictionnaire")
else:
    # Si 'key' n'est pas présent dans 'd', un message indiquant que la clé n'est pas présente est affiché.
    print("La clé n'est pas présente dans le dictionnaire")

d = {'a': 10, 'b': 20, 'c': 30} 

# Parcourir les paires clé-valeur du dictionnaire à l'aide d'une boucle for.
# 'key' représente la clé, et 'val' représente la valeur de chaque paire.
for key, val in d.items():
    # Afficher la clé suivi de '->' et la valeur correspondante.
    print(key, '->', val)

n = 5

# Créez un dictionnaire vide pour stocker le carré des nombres.
d = dict()

# Parcourir les nombres de 1 à 'n' (inclus).
for x in range(1, n + 1):
    # Calculer le carré de chaque nombre et le stocker dans le dictionnaire 'd' avec le nombre comme clé.
    d[x] = x * x

# Afficher le dictionnaire 'd' contenant les carrés des nombres de 1 à 'n'.
print(d) 

# Créez un dictionnaire vide pour stocker les carrés des nombres.
d = dict()

# Parcourir les nombres de 1 à 5 (inclus).
for x in range(1, 6):
    # Calculer le carré de chaque nombre et le stocker dans le dictionnaire 'd' avec le nombre comme clé.
    d[x] = x ** 2

# Afficher le dictionnaire 'd' contenant les carrés des nombres de 1 à 5.
print(d)

# Créer le 1er dictionnaire avec des paires clé-valeur.
d1 = {'a': 10, 'b': 20}

# Créer le 2éme dictionnaire avec des paires clé-valeur.
d2 = {'x': 30, 'y': 40}

# Créer un nouveau dictionnaire et l'initialiser comme une copie de 'd1'.
d = d1.copy()

# Mettre à jour le dictionnaire 'd' en y ajoutant les paires clé-valeur de 'd2'.
d.update(d2)

# Afficher le dictionnaire 'd' après avoir fusionné les paires clé-valeur de 'd1' et 'd2'.
print(d) 

# Créer un dictionnaire 'd' avec des paires clé-valeur.
d = {'val1': 10, 'val2': 20, 'val3': 10}

# Utilisez la fonction 'sum' pour calculer la somme de toutes les valeurs du dictionnaire 'd'.
# La fonction 'd.values()' extrait les valeurs du dictionnaire et la fonction 'sum' calcule leur somme.
result = sum(d.values())

# Afficher le résultat, qui est la somme des valeurs.
print(result) 

# Créer un dictionnaire 'd' avec des paires clé-valeur.
d = {'val1': 10, 'val2': 20, 'val3': 10}

# Initialiser 'result' à 1. Cette variable stockera le produit de toutes les valeurs du dictionnaire.
result = 1

# Parcourez les clés du 'd' à l'aide d'une boucle for.
for key in d:
    # Multiplier le résultat actuel par la valeur associée à la clé actuelle dans 'd'.
    result = result * d[key]

# Afficher le résultat final, qui est le produit de toutes les valeurs du dictionnaire.
print(result) 

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Afficher le dictionnaire original 'd'.
print(d)

# Vérifier si la clé 'a' existe dans le dictionnaire 'd'.
if 'a' in d:
    # Si 'a' se trouve dans le dictionnaire, supprimer la paire clé-valeur avec la clé 'a'.
    del d['a']

# Afficher le dictionnaire 'd' mis à jour après la suppression de la clé 'a' (si elle existait).
print(d)

# Créer une liste 'keys' 
keys = ['a', 'b', 'c']

# Créer une liste 'values' 
values = [1, 2, 3]

# Utilisez la fonction 'zip' pour associer chaque clé à son valeur correspondant et créer une liste de tuples.
# Ensuite, utilisez le constructeur 'dict' pour convertir cette liste de tuples en un dictionnaire 'd'.
d = dict(zip(keys, values))

# Afficher le 'd' résultant contenant les clés et les valeurs.
print(d)

dict = {'c': 3, 'b': 2, 'a': 1}

# Parcourir les clés du dictionnaire 'dict' après les avoir triées dans l'ordre lexicographique.
for key in sorted(dict):
    # Afficher chaque paire clé-valeur où '%s' est un espace réservé pour la clé et la valeur qui lui est associé.
    print("%s: %s" % (key, dict[key]))

dict = {'a': 1, 'b': 5, 'c': 9}

# Trouver la clé avec la valeur maximale dans 'dict' en utilisant la fonction 'max' et une fonction lambda.
# L'argument 'key' spécifie comment la valeur maximale est déterminée.
key_max = max(dict.keys(), key=(lambda k: dict[k]))

# Trouver la clé avec la valeur minimale dans 'dict' en utilisant la fonction 'min' et une fonction lambda.
# L'argument 'key' spécifie comment la valeur minimale est déterminée.
key_min = min(dict.keys(), key=(lambda k: dict[k]))

# Afficher la valeur maximale en utilisant 'key_max' pour accéder à la valeur correspondante dans 'dict'.
print('max:', dict[key_max])

# Afficher la valeur minimale en utilisant 'key_min' pour accéder à la valeur correspondante dans 'dict'.
print('min:', dict[key_min])

dict = {'a': 1, 'a': 2, 'b': 3}

# Créez un dictionnaire vide 'result' pour stocker les clés uniques.
result = {}

# Parcourez les paires clé-valeur du dictionnaire 'dict' à l'aide d'une boucle 'for'.
for key, value in dict.items():
    # Vérifier si la valeur actuelle ne se trouve pas déjà dans le dictionnaire 'result'.
    if value not in result.values():
        # Si la valeur ne se trouve pas déjà dans 'result', elle est ajoutée à 'result' avec la clé correspondante.
        result[key] = value

# Afficher le dictionnaire 'result' contenant des clés uniques.
print(result) 

# Créer un dictionnaire vide 'dict'.
dict = {}

# Vérifier si le dictionnaire est vide en évaluant sa valeur booléenne.
# La fonction 'bool()' renvoie False pour un dictionnaire vide, donc s'il n'est pas vide, la condition est True.
if not bool(dict):
    # Afficher un message indiquant que le dictionnaire est vide.
    print("Le dictionnaire est vide")