Plusieurs langages de programmation, dont Python, permettent de travailler avec une structure de données bien particulière, un dictionnaire.
Dans certains langages de programmation, on utilisera plutôt le terme tableau associatif.
Un dictionnaire, c'est un peu comme un tableau à deux dimensions. Chaque élément ajouté au dictionnaire comprend deux informations : une clé et une valeur. Plutôt que de travailler avec des indices comme on le ferait avec un tableau, on travaillera avec les clés du dictionnaire.
Le dictionnaire n'est ni meilleur, ni pire que le tableau à deux dimensions. Il sert simplement des buts différents. Le dictionnaire offre une foule de facilités pour manipuler des données dans ce contexte.
Voici un exemple de dictionnaire. Il y a trois clés : 'fr', 'en' et 'sp' avec la valeur correspondant à chacun : 'français', 'anglais' et 'espagnol'.
langues = {
'fr': 'français',
'en': 'anglais',
'sp': 'espagnol'
}
Alors que les listes (tableaux à longueur variable) utilisent des crochets carrés et que les tuples (tableaux immuables) utilisent des parenthèses, les dictionnaires utilisent des accolades.
L'initialisation d'un dictionnaire vide est toute simple :
langues = {}
Il est possible d'ajouter un élément dans le dictionnaire dès son initialisation :
Ex :
langues = {'fr': 'français'}
ou même plusieurs :
langues = {
'fr': 'français',
'en': 'anglais',
'sp': 'espagnol'
}
Dans un dictionnaire, chaque clé doit avoir une valeur unique.
L'ajout d'un élément consiste à donner une valeur à une clé qui n'existe pas.
Ex :
langues['ru'] = 'russe'
Un dictionnaire est spécifiquement conçu pour retrouver une valeur à partir d'une clé avec cette syntaxe :
valeur = dictionnaire[cle]
Ex :
nom_langue = langues['fr'] # nom_langue sera initialisé à 'français'
Python n'offre pas de fonction pour retrouver une clé à partir d'une valeur. Qu'à celà ne tienne, je vous fournis ici une petite fonction bien pratique qui permet d'y arriver.
def retrouver_cle(dictionnaire, valeur):
"""Retrouver une clé dans un dictionnaire à partir d'une valeur (inverse de valeur = dictionnaire[cle])."""
cles = list(dictionnaire.keys())
valeurs = list(dictionnaire.values())
return cles[valeurs.index(valeur)]
Voici la syntaxe pour utiliser cette fonction :
cle = retrouver_cle(dictionnaire, valeur)
Ex :
code_langue = retrouver_cle(langues, 'français') # code_langue sera initialisé à 'fr'
La commande del sera utilisée pour retirer un élément à partir de sa clé.
Ex :
del langues['ru']
Le nombre d'éléments présents dans le dictionnaire sera obtenu à l'aide de la fonction len().
Ex :
taille = len(langues)
Le dictionnaire est parfait pour effectuer une boucle. Le traitement sera plus efficace si on prend soin à chaque itération de convertir l'élément courant en tuple à l'aide de la fonction items().
Chaque itération pourra travailler avec la clé et la valeur de l'élément courant.
Ex :
for cle, valeur in langues.items():
...
La fonction keys() permet d'extraire les clés d'un dictionnaire. Cette fonction retourne un type spécial de données que l'on nomme view.
Ex :
cles = langues.keys()
Si on fait afficher à l'écran la valeur de la variable cles, on obtiendra quelque chose du genre :
dict_keys(['fr', 'en', 'sp'])
Il n'est pas utile d'en savoir plus sur ce type de données pour l'instant. Les clés du dictionnaire extraites avec keys() seront directement utilisables dans plusieurs contextes, notamment dans une boucle for.
Ex :
for cle in langues.keys():
...
Dans d'autres contextes, il faudra convertir l'objet de type view en tableau. On utilisera pour cela la fonction list() (en Python, une liste est un tableau modifiable de taille variable, contrairement à un tuple qui est un tableau immuable de taille fixe).
Ex :
tableau_cles = list(langues.keys())
Cette fois, si on fait afficher tableau_cles à la console, on obtiendra quelque chose du genre :
['fr', 'en', 'sp']
La fonction values() a un comportement très semblable à keys(), sauf qu'elle travaille avec les valeurs plutôt qu'avec les clés.
Ex :
tableau_valeurs = list(langues.values())
Cette fois, si on fait afficher tableau_valeurs à la console, on obtiendra quelque chose du genre :
['français', 'anglais', 'espagnol']
L'opérateur in permet de vérifier si une clé fait partie du dictionnaire.
Ex :
if 'fr' in langues:
...
Si c'est une valeur qui est recherchée, il faudra extraire les valeurs du dictionnaire à l'aide de values() puis appliquer l'opérateur in aux valeurs ainsi obtenues.
Ex :
if 'français' in langues.values():
...
▼Publicité
