Dictionnaires : paires clé-valeur

Qu'est-ce qu'un dictionnaire en Python ? Définition et caractéristiques

En Python, un dictionnaire est une structure de données qui permet de stocker des paires clé-valeur. Chaque élément d'un dictionnaire est constitué d'une clé unique et d'une valeur associée. Les dictionnaires sont parfois appelés "tableaux associatifs", "maps", ou "hash tables" dans d'autres langages de programmation.

Les principales caractéristiques des dictionnaires sont :

• Non ordonnés (avant Python 3.7) / Ordonnés (depuis Python 3.7) : Jusqu'à Python 3.6, l'ordre des éléments dans un dictionnaire n'était pas garanti. Depuis Python 3.7, les dictionnaires conservent l'ordre d'insertion des éléments.
• Modifiables (mutables) : Vous pouvez modifier le contenu d'un dictionnaire après sa création (ajouter, supprimer, modifier des paires clé-valeur).
• Indexés par clés : Vous accédez aux valeurs d'un dictionnaire par leurs clés, et non par leur position (comme dans les listes ou les tuples).
• Clés uniques : Chaque clé d'un dictionnaire doit être unique. Si vous essayez d'ajouter une paire clé-valeur avec une clé déjà existante, la valeur associée à cette clé sera écrasée.
• Clés immuables : Les clés d'un dictionnaire doivent être des objets immuables (comme des nombres, des chaînes de caractères, ou des tuples). Les listes ne peuvent pas être utilisées comme clés. Les valeurs, en revanche, peuvent être de n'importe quel type.
• Hétérogènes : Les clés et les valeurs d'un dictionnaire peuvent être de types différents.

Les dictionnaires sont très utilisés en Python pour représenter des données structurées de manière flexible et efficace.

Créer un dictionnaire : différentes méthodes

Il existe plusieurs façons de créer un dictionnaire en Python :

• Utiliser des accolades `{}` : C'est la méthode la plus courante. Vous pouvez créer un dictionnaire vide ou un dictionnaire contenant des paires clé-valeur initiales. Séparez les clés et les valeurs par deux-points `:` et les paires par des virgules `,`.
• Utiliser la fonction `dict()` : Vous pouvez créer un dictionnaire à partir d'une liste de tuples (clé, valeur), ou en utilisant des arguments nommés.
• Utiliser une compréhension de dictionnaire : Similaire aux compréhensions de listes, mais pour créer des dictionnaires.

Exemples :

# Dictionnaire vide
dictionnaire_vide = {}

# Dictionnaire avec des paires clé-valeur initiales
personne = {
    "nom": "Dupont",
    "prenom": "Alice",
    "age": 30
}

# Dictionnaire à partir d'une liste de tuples
couleurs = dict([("rouge", "#FF0000"), ("vert", "#00FF00"), ("bleu", "#0000FF")])

# Dictionnaire avec des arguments nommés
coordonnees = dict(x=10, y=20, z=30)

# Dictionnaire créé avec une compréhension de dictionnaire
carres = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Accéder aux valeurs d'un dictionnaire : par clé, avec get()

Vous accédez aux valeurs d'un dictionnaire par leurs clés, en utilisant des crochets `[]` :

personne = {
    "nom": "Dupont",
    "prenom": "Alice",
    "age": 30
}

print(personne["nom"])     # Affiche Dupont
print(personne["age"])    # Affiche 30

Si vous essayez d'accéder à une clé qui n'existe pas, Python lèvera une erreur `KeyError`. Pour éviter cette erreur, vous pouvez utiliser la méthode `get()` :

# print(personne["ville"])  # Lèverait une KeyError

print(personne.get("ville"))  # Affiche None (valeur par défaut si la clé est absente)
print(personne.get("ville", "Inconnue"))  # Affiche Inconnue (valeur par défaut spécifiée)

La méthode `get()` permet d'accéder à une valeur par sa clé, mais retourne une valeur par défaut (par défaut `None`) si la clé est absente, plutôt que de lever une erreur.

Modifier un dictionnaire : ajouter, modifier, supprimer des paires clé-valeur

Vous pouvez ajouter une nouvelle paire clé-valeur à un dictionnaire en utilisant l'opérateur d'affectation `=` et une nouvelle clé entre crochets :

personne = {
    "nom": "Dupont",
    "prenom": "Alice",
    "age": 30
}

personne["ville"] = "Paris"  # Ajoute une nouvelle paire clé-valeur
print(personne) # Affiche {'nom': 'Dupont', 'prenom': 'Alice', 'age': 30, 'ville': 'Paris'}

Vous pouvez modifier la valeur associée à une clé existante de la même manière :

personne["age"] = 31  # Modifie la valeur associée à la clé "age"
print(personne) # Affiche {'nom': 'Dupont', 'prenom': 'Alice', 'age': 31, 'ville': 'Paris'}

Pour supprimer une paire clé-valeur, vous pouvez utiliser l'instruction `del` :

del personne["ville"]
print(personne) # Affiche {'nom': 'Dupont', 'prenom': 'Alice', 'age': 31}

Vous pouvez aussi utiliser la méthode `pop()` pour supprimer une paire clé-valeur et récupérer la valeur associée :

age = personne.pop("age")
print(age)       # Affiche 31
print(personne)  # Affiche {'nom': 'Dupont', 'prenom': 'Alice'}

La méthode `pop()` lève une `KeyError` si la clé est absente. Vous pouvez spécifier une valeur par défaut à retourner si la clé est absente : `personne.pop("ville", None)`.

Pour supprimer tous les éléments, vous pouvez utiliser la méthode `clear()` :

personne.clear()
print(personne) # {}

Itérer sur un dictionnaire : clés, valeurs, paires clé-valeur

Il existe plusieurs façons d'itérer sur les éléments d'un dictionnaire :

• Itérer sur les clés (par défaut) :

personne = {
    "nom": "Dupont",
    "prenom": "Alice",
    "age": 30
}

for cle in personne:
    print(cle)  # Affiche nom, prenom, age (dans l'ordre d'insertion depuis Python 3.7)

• Itérer sur les valeurs :

for valeur in personne.values():
    print(valeur)  # Affiche Dupont, Alice, 30

• Itérer sur les paires clé-valeur :

for cle, valeur in personne.items():
    print(cle, ":", valeur)  # Affiche nom : Dupont, prenom : Alice, age : 30

Les méthodes `keys()`, `values()`, et `items()` retournent des "vues" (view objects) qui sont des objets dynamiques reflétant les changements apportés au dictionnaire.

Méthodes courantes des dictionnaires

Voici un résumé des méthodes courantes des dictionnaires (en plus de celles déjà vues) :

• `keys()` : Retourne une vue sur les clés du dictionnaire.
• `values()` : Retourne une vue sur les valeurs du dictionnaire.
• `items()` : Retourne une vue sur les paires clé-valeur (sous forme de tuples) du dictionnaire.
• `copy()` : Retourne une copie superficielle du dictionnaire.
• `update(autre_dictionnaire)` : Fusionne le dictionnaire avec un autre dictionnaire (ou un itérable de paires clé-valeur). Les clés existantes sont écrasées.
• `setdefault(cle, valeur_par_defaut)` : Si la clé est présente, retourne sa valeur. Sinon, insère la clé avec la valeur par défaut et retourne cette valeur par défaut.
• `fromkeys(iterable, valeur)`: Crée un nouveau dictionnaire avec les clés de l'itérable et la valeur spécifiée (par défaut `None`).

Exemples :

personne = {"nom": "Dupont", "prenom": "Alice", "age": 30}

cles = personne.keys()
print(cles)   # dict_keys(['nom', 'prenom', 'age'])

valeurs = personne.values()
print(valeurs) # dict_values(['Dupont', 'Alice', 30])

paires = personne.items()
print(paires)  # dict_items([('nom', 'Dupont'), ('prenom', 'Alice'), ('age', 30)])

personne2 = personne.copy()

personne.update({"age": 31, "ville": "Paris"})
print(personne)  # {'nom': 'Dupont', 'prenom': 'Alice', 'age': 31, 'ville': 'Paris'}

# Utile pour initialiser un dictionnaire avec des valeurs par défaut:
cles = ["a", "b", "c"]
valeur = 0
dictionnaire = dict.fromkeys(cles, valeur) # {'a': 0, 'b': 0, 'c': 0}

Compréhensions de dictionnaires : création concise

Comme pour les listes, il existe une syntaxe concise pour créer des dictionnaires, appelée "compréhension de dictionnaire".

La syntaxe est la suivante :

{cle: valeur for item in iterable if condition}

• `cle` : Une expression qui est évaluée pour chaque `item` de l'`iterable` et qui devient la clé.
• `valeur` : Une expression qui est évaluée pour chaque `item` de l'`iterable` et qui devient la valeur associée à la clé.
• `item` : Une variable qui prend successivement la valeur de chaque élément de l'`iterable`.
• `iterable` : Une séquence (liste, tuple, chaîne de caractères, etc.) ou un itérable.
• `condition` (optionnelle) : Une condition qui filtre les éléments de l'`iterable`.

Exemple : Créer un dictionnaire qui associe à chaque nombre de 0 à 4 son carré :

carres = {x: x**2 for x in range(5)}
print(carres) # Affiche {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Exemple : Créer un dictionnaire qui associe à chaque lettre d'un mot sa position :

mot = "Bonjour"
positions = {lettre: index for index, lettre in enumerate(mot)}
print(positions) # Affiche {'B': 0, 'o': 4, 'n': 2, 'j': 3, 'u': 5, 'r': 6}

Exemple avec une condition:

nombres = [1, 2, 3, 4, 5, 6]
pairs = {x: x*2 for x in nombres if x % 2 == 0} # {2: 4, 4: 8, 6: 12}

Les compréhensions de dictionnaires sont un moyen élégant et efficace de créer des dictionnaires en Python, mais il faut veiller à ne pas les rendre trop complexes pour préserver la lisibilité.