Exercice Corrigé: Les dictionnaires en Python – Partie 2

# Importez le module 'itertools', qui fournit des outils pour travailler avec des itérateurs et des objets itérables.
import itertools

# Créez un dictionnaire avec des clés '1' et '2', et des listes de caractères associées comme valeurs.
d = {'1': ['a', 'b'], '2': ['c', 'd']}

# Interroger les combinaisons de valeurs du dictionnaire 'd' en utilisant 'itertools.product'.
# Les valeurs sont triées en fonction de leurs clés afin de garantir un ordre spécifique.
for comb in itertools.product(*[d[k] for k in sorted(d.keys())]):
    # Affichez les combinaisons sous forme de chaînes de caractères en joignant les caractères de chaque combinaison.
    print(''.join(comb))

# Importer la fonction 'nlargest' du module 'heapq'.
from heapq import nlargest

# Créer un dictionnaire 'd' avec des paires clé-valeur.
d = {'a': 5, 'b': 1, 'c': 3, 'd': 8, 'e': 9, 'f': 7}

# Utiliser la fonction 'nlargest' pour trouver les trois plus grandes clés du dictionnaire 'd' en fonction de leurs valeurs.
# L'argument 'key' spécifie que les valeurs doivent être utilisées pour la comparaison.
res = nlargest(3, d, key=d.get)

# Afficher les trois plus grandes clés trouvées dans le dictionnaire 'd'.
print(res)

# Importez les classes 'defaultdict' et 'Counter' du module 'collections'.
from collections import defaultdict, Counter

# Créer une chaîne de caractères 'str'.
str = 'waytolearnx'

# Créez un dictionnaire vide 'd' pour stocker le nombre de caractères.
d = {}

# Parcourez les caractères de 'str' à l'aide d'une boucle for.
for letter in str:
    # Mettre à jour le 'd' en incrémentant le compteur du caractère courant.
    # Utiliser la méthode 'get' avec une valeur par défaut de 0 pour initialiser les compteurs des nouveaux caractères.
    d[letter] = d.get(letter, 0) + 1

# Afficher le dictionnaire 'd', qui contient le nombre de caractères.
print(d) 

# Créez un dictionnaire 'd' dont les clés sont 'C1', 'C2' et 'C3', et les valeurs correspondantes.
d = {'C1': [1, 2, 3], 'C2': [4, 5, 6], 'C3': [7, 8, 9]}

# Utiliser une liste de compréhension pour créer une liste de tuples où chaque tuple contient une clé et sa liste de valeurs correspondante.
# Trier les éléments (paires clé-valeur) dans le dictionnaire 'd' en fonction de leurs clés.
# La fonction 'zip' est utilisée pour transposer les lignes et les colonnes.
for row in zip(*([key] + (value) for key, value in sorted(d.items()))):
    # Affiche chaque ligne de données transposées sous forme de valeurs séparées par des espaces.
    print(*row)

# Créer une liste 'liste' contenant des nombres.
liste = [1, 2, 3, 4]

# Créez un dictionnaire vide 'd' et initialisez 'current' pour qu'il fasse référence au même dictionnaire.
d = current = {}

# Parcourez les nombres de la 'liste' à l'aide d'une boucle 'for'.
for i in liste:
    # Créer un dictionnaire vide imbriqué sous le dictionnaire 'current' avec le 'i' actuel comme clé.
    current[i] = {}
    
    # Mettre à jour la référence 'current' pour qu'elle pointe vers le dictionnaire imbriqué nouvellement créé.
    current = current[i]

# Afficher le dictionnaire 'd', qui est une structure imbriquée avec des dictionnaires vides.
print(d)

# Créez un dictionnaire 'd' avec les clés 'n1', 'n2' et 'n3', et des listes de nombres associées comme valeurs.
d = {'n1': [2, 3, 1], 'n2': [5, 1, 2], 'n3': [3, 2, 4]}

# Utiliser un dictionnaire pour créer un nouveau dictionnaire 'd'.
# Itère à travers les paires clé-valeur dans 'd' et trie les listes de nombres 'y' pour chaque clé 'x'.
d = {x: sorted(y) for x, y in d.items()}

# Affichez le dictionnaire 'd', qui contient les mêmes clés avec des listes triées de nombres comme valeurs.
print(d)

d = {'a  lex': 1, 'b o b': 2, 'em i ly': 3}

print("Dictionnaire original: ", d)

# Utiliser un dictionnaire de compréhension pour créer un nouveau dictionnaire 'res'.
# Interroger les paires clé-valeur dans 'd'.
# Supprimer les espaces supplémentaires des clés en utilisant la méthode 'translate' avec une table de traduction.
res = {x.translate({32: None}): y for x, y in d.items()}

print("Résultat:", res) 

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

# Afficher un en-tête pour la table de sortie.
print("key  value  count")

# Parcourir les paires clé-valeur dans 'd' à l'aide de la fonction 'enumerate'.
# La fonction 'enumerate' attribue un compteur à partir de 1 à chaque paire et les décompose en (count, (key, value)).
for count, (key, value) in enumerate(d.items(), 1):
    # Afficher la clé, la valeur et le nombre dans une table formatée.
    print(key, '   ', value, '    ', count) 

cars = {'Mercedes': {'model': 'C190', 'id': 2}, 'Audi': {'model': 'A9', 'id': 3}}

# Parcourez les noms des voitures (clés) dans le dictionnaire à l'aide d'une boucle for.
for a in cars:
    # Afficher le nom de la voiture.
    print(a)
    
    # Parcourir les clés du dictionnaire imbriqué associé à la voiture actuelle à l'aide d'une boucle for imbriquée.
    for b in cars[a]:
        # Afficher la clé, les deux points et la valeur correspondante du dictionnaire imbriqué.
        print(b, ':', cars[a][b])

myCar = {'name': 'Mercedes', 'model': 'C190', 'id': 2}

# Vérifier si l'ensemble des clés de 'myCar' contient les clés 'name' et 'model'.
print(myCar.keys() >= {'name', 'model'})

print(myCar.keys() >= {'name', 'Mercedes'})

print(myCar.keys() >= {'id', 'name'})