Exploration des Dictionnaires Python : Un Guide Complet des Méthodes
Vous souhaitez maîtriser l’art de manipuler les dictionnaires en Python ? Ce tutoriel est conçu pour vous guider à travers les méthodes essentielles permettant de lire, modifier et effectuer diverses opérations sur ces structures de données fondamentales.
Nous commencerons par un rappel des bases des dictionnaires Python, puis nous créerons un exemple pratique que nous modifierons à l’aide des méthodes dédiées.
Plongeons-nous dans le sujet…
Comprendre les Dictionnaires Python
Les dictionnaires, intrinsèques à Python, sont des structures de données qui permettent de stocker des informations sous forme de paires clé-valeur. Imaginez un annuaire téléphonique où chaque nom (clé) correspond à un numéro (valeur). Ils établissent ainsi une association ou un mappage entre les clés et les valeurs.
Les clés d’un dictionnaire doivent impérativement être uniques et immuables (hachables). Elles servent de référence pour retrouver une valeur spécifique ou pour utiliser les fonctions intégrées (que nous aborderons sous peu).
Lors de la création d’un dictionnaire, vous avez la possibilité d’initialiser directement toutes les paires clé-valeur, ou de partir d’un dictionnaire vide auquel vous ajouterez ensuite les paires souhaitées.
>>> dict1 = {'langue':'Python','aime':True}
>>> type(dict1)
<class 'dict'>
# ou nous pouvons faire ceci :
>>> dict1 = {}
>>> dict1['langue']='Python'
>>> dict1['aime']=True
Méthodes Clés des Dictionnaires Python pour les Opérations Courantes
Note importante : pour reproduire les exemples de code, assurez-vous d’avoir Python 3.7 ou une version ultérieure installée.
Vous pouvez interagir directement avec un REPL Python ou utiliser l’éditeur Python en ligne de toptips.fr.
>>> personne = {'nom':'Alice',
... 'ville':'Portland',
... 'interet':'Programmation',
... 'profession':'Developpeur'
... }
Maintenant que nous avons un dictionnaire Python initialisé, explorons les différentes méthodes disponibles.
Extraire les Clés d’un Dictionnaire avec keys()
Une opération fréquente avec un dictionnaire Python est d’accéder à l’ensemble de ses clés, valeurs, ou paires clé-valeur. Pour obtenir les clés d’un dictionnaire, la méthode `keys()` est votre alliée :
>>> personne.keys() dict_keys(['nom', 'ville', 'interet', 'profession'])
Récupérer les Valeurs d’un Dictionnaire avec values()
La méthode `values()` renvoie toutes les valeurs contenues dans le dictionnaire. Elle est particulièrement utile lorsque vous souhaitez manipuler ces valeurs.
Voici comment accéder aux valeurs du dictionnaire de notre exemple :
>>> personne.values() dict_values(['Alice', 'Portland', 'Programmation', 'Developpeur'])
Obtenir les Paires Clé-Valeur avec items()
La méthode `items()` retourne une liste de tuples, chaque tuple représentant une paire clé-valeur. L’appel de cette méthode sur notre dictionnaire `personne` nous donnera :
>>> personne.items()
dict_items([('nom', 'Alice'), ('ville', 'Portland'), ('interet', 'Programmation'),
('profession', 'Developpeur')])
Créer une Copie Superficielle avec copy()
La méthode `copy()` permet de générer une copie superficielle d’un dictionnaire Python.
>>> personne_copie = personne.copy()
Dans cet exemple, `personne_copie` est une réplique superficielle du dictionnaire `personne`. Modifions cette copie en changeant le nom de ‘Alice’ à ‘Bob’.
>>> personne_copie['nom'] = 'Bob' >>> personne_copie
Nous constatons que le nom a bien été modifié à ‘Bob’ dans la copie.
{
'nom': 'Bob',
'ville': 'Portland',
'interet': 'Programmation',
'profession': 'Developpeur'
}
Cependant, le dictionnaire original `personne` n’a pas été impacté :
>>> personne
{
'nom': 'Alice',
'ville': 'Portland',
'interet': 'Programmation',
'profession': 'Developpeur'
}
Définir des Valeurs par Défaut avec setdefault()
Lors de la manipulation des dictionnaires, il est fréquent de rencontrer une exception `KeyError` si la clé recherchée n’existe pas. Par exemple, si nous tentons d’accéder à la clé ‘age’ :
>>> personne['age'] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'age'
Pour éviter de telles erreurs, on peut utiliser les méthodes `setdefault()` et `get()` au lieu d’accéder directement à la valeur comme ci-dessus.
La méthode `setdefault(clé)` renvoie `dict[clé]` si la clé est présente dans le dictionnaire.
>>> personne.setdefault('nom')
'Alice'
Si la clé est absente, elle est ajoutée au dictionnaire avec la valeur par défaut `None`.
>>> personne.setdefault('adresse')
>>> personne
La clé ‘adresse’ a été ajoutée avec la valeur par défaut `None` :
{
'nom': 'Alice',
'ville': 'Portland',
'interet': 'Programmation',
'profession': 'Developpeur',
'adresse': None
}
Nous pouvons maintenant définir la valeur de la clé ‘adresse’ :
>>> personne['adresse'] = "10, rue xyz"
>>> personne
{
'nom': 'Alice',
'ville': 'Portland',
'interet': 'Programmation',
'profession': 'Developpeur',
'adresse': '10, rue xyz'
}
On peut également spécifier la valeur lors de l’appel de la méthode :
>>> personne.setdefault('pays','USA')
'USA'
>>> personne
La clé ‘pays’, initialement absente, a été ajoutée avec la valeur ‘USA’.
{
'nom': 'Alice',
'ville': 'Portland',
'interet': 'Programmation',
'profession': 'Developpeur',
'adresse': '10, rue xyz',
'pays': 'USA'
}
Accéder à une Valeur Spécifique avec get()
La méthode `get()` renvoie la valeur associée à la clé. Elle accepte un second argument optionnel, une valeur par défaut qui est retournée si la clé est introuvable.
Si nous cherchons la valeur de la clé ‘nom’, la réponse sera ‘Alice’ car la clé existe dans le dictionnaire :
>>> personne.get('nom')
'Alice'
Le dictionnaire ne contient pas de clé ‘gpa’. Ainsi, si nous tentons d’accéder à sa valeur, nous n’obtenons rien directement dans le REPL. Cependant, si l’on imprime la valeur, on obtient `None`.
>>> personne.get('gpa')
>>> print(personne.get('gpa'))
None
Mais si nous fournissons une valeur par défaut, c’est elle qui sera retournée à la place de `None`.
>>> personne.get('gpa','non trouvé')
'non trouvé'
Il est important de noter que la méthode `get()` n’ajoute pas la clé ‘gpa’ au dictionnaire.
>>> personne
{
'nom': 'Alice',
'ville': 'Portland',
'interet': 'Programmation',
'profession': 'Developpeur',
'adresse': '10, rue xyz',
'pays': 'USA'
}
Comparaison entre setdefault() et get()
Bien que `setdefault()` et `get()` puissent être utilisées pour gérer les erreurs `KeyError`, résumons leurs différences :
- `dict.setdefault(clé, valeur)` ajoute la clé au dictionnaire avec la valeur par défaut. Si la valeur n’est pas spécifiée, la clé est ajoutée avec la valeur par défaut `None`.
- `dict.get(clé, valeur)` renvoie la valeur associée à la clé dans le dictionnaire. Si la clé est absente, elle renvoie la valeur par défaut spécifiée (ou `None` si non spécifiée), mais n’ajoute pas la clé au dictionnaire.
Pour une gestion plus poussée des `KeyErrors`, vous pouvez également considérer l’utilisation de `defaultdict`.
Mettre à Jour un Dictionnaire avec update()
La méthode `update()` permet de modifier un dictionnaire en y ajoutant des paires clé-valeur provenant d’un autre dictionnaire, ou d’un itérable Python.
Définissons un dictionnaire `plus_de_details` et mettons à jour `personne` avec son contenu :
>>> plus_de_details = {'loisir':'chanter', 'aime':'les sucreries'}
>>> personne.update(plus_de_details)
Nous observons que les clés ‘loisir’ et ‘aime’ ont été ajoutées au dictionnaire `personne`.
>>> personne
{
'nom': 'Alice',
'ville': 'Portland',
'interet': 'Programmation',
'profession': 'Developpeur',
'adresse': '10, rue xyz',
'pays': 'USA',
'loisir': 'chanter',
'aime': 'les sucreries'
}
Supprimer le Dernier Élément Ajouté avec popitem()
La méthode `popitem()` supprime et renvoie la dernière paire clé-valeur ajoutée au dictionnaire.
>>> personne.popitem()
('aime', 'les sucreries')
L’appel de `popitem()` sur le dictionnaire `personne` retourne la paire (‘aime’, ‘les sucreries’), qui était le dernier élément ajouté.
Cette méthode supprime également la paire clé-valeur du dictionnaire. On peut le vérifier en examinant son contenu :
>>> personne
{
'nom': 'Alice',
'ville': 'Portland',
'interet': 'Programmation',
'profession': 'Developpeur',
'adresse': '10, rue xyz',
'pays': 'USA',
'loisir': 'chanter'
}
Supprimer un Élément Spécifique avec pop()
Alors que `popitem()` supprime le dernier élément, la méthode `pop(clé)` permet de cibler un élément particulier. Elle retourne la valeur correspondant à la clé et supprime simultanément la paire clé-valeur du dictionnaire.
Voici un exemple :
>>> personne.pop('loisir')
'chanter'
Comme nous avons supprimé l’élément associé à la clé ‘loisir’, il n’est plus présent dans le dictionnaire.
>>> personne
{
'nom': 'Alice',
'ville': 'Portland',
'interet': 'Programmation',
'profession': 'Developpeur',
'adresse': '10, rue xyz',
'pays': 'USA'
}
Si l’on spécifie une clé inexistante, une exception `KeyError` est levée :
>>> personne.pop('age')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'age'
Contrairement à la méthode `pop()` des listes qui supprime par défaut le dernier élément, la version pour les dictionnaires nécessite une clé.
>>> personne.pop() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: pop expected at least 1 argument, got 0
Supprimer Tous les Éléments d’un Dictionnaire avec clear()
Si vous souhaitez supprimer tous les éléments d’un dictionnaire, la méthode `clear()` est la solution. Elle efface toutes les paires clé-valeur.
>>> personne.clear()
>>> personne
{}
L’appel de `clear()` sur le dictionnaire `personne` le vide complètement.
Récapitulatif des Méthodes de Dictionnaire Python
Voici une synthèse des méthodes que nous avons abordées :
| Méthode | Syntaxe | Description |
| keys() | `dict1.keys()` | Retourne les clés du dictionnaire `dict1` |
| values() | `dict1.values()` | Retourne les valeurs du dictionnaire `dict1` |
| items() | `dict1.items()` | Retourne une liste de toutes les paires clé-valeur de `dict1` |
| copy() | `dict1.copy()` | Retourne une copie superficielle de `dict1` |
| setdefault() | `dict1.setdefault(clé, valeur_par_defaut)` | Ajoute une clé avec la `valeur_par_defaut` (par défaut `None`) si elle n’existe pas; retourne `dict1[clé]` si la clé existe déjà. |
| get() | `dict1.get(clé, valeur_par_defaut)` | Retourne `dict1[clé]` si la clé existe; sinon, retourne `valeur_par_defaut` (par défaut `None`). |
| update() | `dict1.update(iterable1)` | Met à jour `dict1` avec les paires clé-valeur de `iterable1`. |
| popitem() | `dict1.popitem()` | Supprime et retourne la dernière paire clé-valeur de `dict1`. |
| pop() | `dict1.pop(clé)` | Supprime et retourne la valeur correspondant à `dict1[clé]`. Lève une `KeyError` si la clé n’existe pas. |
| clear() | `dict1.clear()` | Supprime tous les éléments de `dict1`. |
Conclusion
Ce tutoriel vous a permis de découvrir les méthodes clés pour manipuler les dictionnaires Python, vous donnant les outils nécessaires pour lire, mettre à jour, et supprimer des éléments. Vous avez également appris à gérer les `KeyErrors` grâce aux méthodes `get()` et `setdefault()`. N’oubliez pas qu’il est possible de trier un dictionnaire Python en fonction de ses clés ou de ses valeurs.
Pour approfondir vos connaissances, vous pouvez explorer la liste des méthodes de liste Python. Bonne programmation !