Comment travailler avec les dictionnaires

2022-10-10 15:44:34 lundi 14743 mots

Travailler avec les dictionnaires

Un dictionnaire Python fonctionne selon le même principe que votre Larousse ou votre Robert préféré. Vous créez une clé qui est associée à une valeur (pour un dictionnaire du monde réel, vous remplacez juste clé par mot, et valeur par définition). Comme les listes, les dictionnaires sont mutables, ce qui signifie que vous pouvez les modifier selon vos besoins. Le principal intérêt des dictionnaires est d’accélérer les recherches. Une clé est toujours unique et courte, ce qui fait que ^因此 l’ordinateur passe beaucoup moins de temps à rechercher les données dont vous avez besoin.

Les sections qui suivent montrent comment créer et utiliser des dictionnaires. Grâce à eux, il est possible de pallier les déficiences du langage Python. Ainsi, la plupart des langages de programmation possèdent une instruction switch qui sert essentiellement à proposer un menu dans lequel l’utilisateur fait son choix. Or, cette instruction manque à Python, ce qui fait que vous devez faire appel à des instructions if…elif pour effectuer ce genre de tâche (certes, cela fonctionne, mais cette méthode manque de clarté 译：是的，它有效，但这种方法缺乏清晰性).

Créer et utiliser un dictionnaire

Le principe^原理 ressemble beaucoup à celui des listes, si ce n’est que vous devez maintenant définir des paires clé/valeur. Il faut pour cela respecter certaines règles :

La clé doit être unique. Si vous entrez une clé qui existe déjà, elle vient simplement remplacer la définition antérieure.
La clé doit être immutable. Cela signifie que la clé peut être une chaîne, un nombre ou encore un tuple. Mais elle ne peut pas être une liste.

Il n’y a aucune restriction sur les valeurs associées aux clés. Il peut s’agir d’un objet Python quelconque, ce qui vous permet par exemple de vous servir d’un dictionnaire pour accéder aux informations sur les membres du personnel de votre entreprise, ou toute autre donnée complexe. Les étapes qui suivent vous aideront à mieux comprendre le fonctionnement de ces dictionnaires.

Ouvrez une fenêtre de Python en mode Shell.
Vous voyez l’indicatif habituel.
Tapez Colors = {'Paul' : 'Bleu', 'Annie' : 'Rouge', 'Sarah' : 'Jaune'} et appuyez sur Entrée.
Python vient de créer un dictionnaire comprenant trois entrées : des prénoms de personnes, et la couleur favorite de chacune. Remarquez la manière dont les entrées du dictionnaire sont fabriquées ^制作. La clé vient en premier, suivie d’un deux-points, puis de la valeur. Les entrées sont séparées l’une de l’autre par une virgule.
Tapez Colors et appuyez sur Entrée.
Python affiche les paires clé/valeur, comme l’illustre la Figure. Remarquez que les clés sont triées selon un certain ordre dont Python a le secret. ► Un dictionnaire organise automatiquement les clés pour rendre leur accès plus rapide, ce qui signifie que les temps de réponse seront très courts, même dans le cas d’un volume de données important. La contrepartie ^{译：对应的是}, c’est que la création d’un dictionnaire est plus lente que celle d’une liste, puisque l’ordinateur doit effectuer ce travail de classement.
Tapez Colors['Annie'] et appuyez sur Entrée.
Vous voyez la couleur associée à Annie, le Rouge (voir la Figure). Utiliser une chaîne comme clé, plutôt qu’un index numérique, facilite la lecture du code ainsi que sa maintenance. En procédant ainsi, les dictionnaires vous permettront de gagner énormément de temps sur le long terme (c’est d’ailleurs pourquoi ils sont si populaires). Cependant, vous devez aussi prendre en compte ^考虑 le coût du temps nécessité par leur création, ainsi que la mobilisation supplémentaire de ressources que cela implique (以及由此带来的额外资源调动).
Figure : Un dictionnaire place ses entrées dans un certain ordre.

Figure : Les dictionnaires rendent les valeurs facilement accessibles et bien documentées.
Tapez Colors.keys() et appuyez sur Entrée.
Python affiche la liste des clés présentes dans le dictionnaire Colors (voir la Figure). Vous pouvez vous servir de ces clés pour automatiser l’accès au dictionnaire.
Tapez le code suivant en appuyant sur Entrée après chaque ligne, et une seconde fois sur Entrée après la dernière ligne :

Cet exemple affiche tous les noms des utilisateurs ainsi que leur couleur préférée ^首选颜色. Utiliser des dictionnaires peut nettement faciliter l’affichage d’informations. De plus, un emploi judicieux des clés permet d’utiliser celles-ci dans les sorties.
Figure : La liste des clés du dictionnaire Colors.
```
>>> Couleur = {'阿当' : '中华美女', '勇少' : '波斯美色'}
>>> Couleur.keys()
dict_keys(['阿当', '勇少'])
```

Tapez Colors['Sarah'] = 'Pourpre' et appuyez sur Entrée.
Le contenu du dictionnaire est mis à jour pour refléter la nouvelle couleur préférée de Sarah.

>>> Couleur = {'阿当' : '中华美女', '勇少' : '波斯美色'}
>>> Couleur.keys()
dict_keys(['阿当', '勇少'])
>>> Colors['阿当'] = 'Pourpre'
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    Colors['阿当'] = 'Pourpre'
NameError: name 'Colors' is not defined
>>> Couleur['阿当'] = 'Pourpre'
>>> Couleur.keys()
dict_keys(['阿当', '勇少'])
>>> Couleur
{'阿当': 'Pourpre', '勇少': '波斯美色'}

Tapez Colors.update({'Pierre' : 'Orange'}) et appuyez sur Entrée.
Une nouvelle entrée est ajoutée au dictionnaire.

>>> Couleur = {'阿当' : '中华美女', '勇少' : '波斯美色'}
>>> Couleur.keys()
dict_keys(['阿当', '勇少'])
>>> Colors['阿当'] = 'Pourpre'
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    Colors['阿当'] = 'Pourpre'
NameError: name 'Colors' is not defined
>>> Couleur['阿当'] = 'Pourpre'
>>> Couleur.keys()
dict_keys(['阿当', '勇少'])
>>> Couleur
{'阿当': 'Pourpre', '勇少': '波斯美色'}
>>> Couleur.update({'ren' : '玛索'})
>>> Couleur.keys()
dict_keys(['阿当', '勇少', 'ren'])
>>> Couleur
{'阿当': 'Pourpre', '勇少': '波斯美色', 'ren': '玛索'}

Placez votre curseur à la fin de la troisième ligne de code saisie lors de l’Étape 6 et appuyez sur Entrée.
L’éditeur crée automatiquement une copie de ce code. Cette technique permet de gagner pas mal de temps lorsque vous faites des expériences dans le mode Shell de Python, puisque vous pouvez ainsi réutiliser du code sans avoir à le ressaisir.
Appuyez deux fois sur Entrée.
Vous voyez la sortie actualisée illustrée sur la Figure. Remarquez que Pierre est ajouté à l’index du dictionnaire (qui n’est manifestement pas un simple ordre alphabétique). De plus, la nouvelle couleur préférée de Sarah est bien présente.
Figure : Créez des clés parlantes de manière à pouvoir les utiliser facilement dans les sorties.
Tapez del Colors['Paul'] et appuyez sur Entrée.
Python supprime l’entrée Paul du dictionnaire.
```
>>> del Couleur['阿当']
>>> Couleur
{'勇少': '波斯美色', 'ren': '玛索'}
```
Répétez les Étapes 9 et 10.
Vous vérifiez que Paul a bien disparu.
Tapez len(Colors) et appuyez sur Entrée.
La valeur affichée, 3, vérifie que le dictionnaire contient trois entrées, et non plus quatre.
```
>>> len(Couleur)
2
```
Tapez Colors.clear() et appuyez sur Entrée.
Tapez len(Colors) et appuyez sur Entrée.
La réponse est maintenant 0, puisque vous venez de vider le dictionnaire.
```
>>> Couleur.clear()
>>> Couleur
{}
```
Vous pouvez refermer la fenêtre de Python.
Figure : Les dictionnaires sont faciles à modifier.

Remplacer l’instruction switch par un dictionnaire

La plupart les langages de programmation disposent d’une instruction switch qui permet d’effectuer des sélections dans des menus. L’utilisateur dispose de plusieurs options et il doit en choisir une. Le programme effectue ensuite l’action correspondante. Voici à quoi pourrait ressembler une telle instruction dans un autre langage (bien entendu, cela ne signifie rien pour Python) :

L’application présente normalement une interface de type menu, récupère une valeur correspondant à la sélection effectuée par l’utilisateur, puis effectue la ou les tâches définies à partir de l’instruction switch. Cette méthode est plus claire et plus simple que l’emploi d’une série d’instructions if…elif pour obtenir le même résultat.

Mais si Python ne propose pas de type d’instruction, vous pouvez tout de même la simuler en utilisant un dictionnaire. C’est ce que vous montrent les étapes suivantes. Vous pouvez également les retrouver dans le fichier téléchargeable PythonSwitch.py.

Ouvrez une fenêtre de fichier Python.
Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne :
```
def PrintBlue():
   print("Vous avez choisi bleu !\r\n")
   
def PrintRed():
   print("Vous avez choisi rouge !\r\n")

def PrintOrange():
   print("Vous avez choisi orange !\r\n")

def PrintYellow():
   print("Vous avez choisi jaune  !\r\n")
```
Avant que le code puisse faire quoi que ce soit, vous devez définir les tâches à accomplir. Chacune de ces fonctions définit donc une tâche associée au choix d’une couleur. Un seul de ces éléments peut être appelé à un moment donné. (在代码可以执行任何操作之前，您需要定义要完成的任务。因此，这些函数中的每一个都定义了与颜色选择相关联的任务。在任何给定时间只能调用这些元素中的一个。)
Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne :
```
ColorSelect = {
   0: PrintBlue,
   1: PrintRed,
   2: PrintOrange,
   3: PrintYellow
}
```
Ce code définit le dictionnaire. Chaque clé correspond à une partie d’une instruction de type switch. Les valeurs spécifient ce qu’il faut faire en fonction de la valeur de la clé. Les fonctions que vous avez créées plus haut sont les actions associées à la clause switch virtuelle, celle qui se trouvent normalement entre l’instruction case et la clause break.
Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne :
```
Selection = 0

while (Selection != 4):
   print("0. Bleu")
   print("1. Rouge")
   print("2. Orange")
   print("3. Jaune")
   print("4. Quitter")

   Selection = int(input("Sélectionnez une option de couleur : "))

   if (Selection >= 0) and (Selection < 4):
      ColorSelect[Selection]()
```
Vous voyez ici la partie de l’exemple qui affiche l’interface utilisateur. Le code commence par créer une variable de saisie, Selection. Il rentre ensuite dans une boucle jusqu’à ce que l’utilisateur saisisse la valeur 4, qui termine l’opération.
Lors de chaque boucle, l’application affiche une liste d’options, puis attend que l’utilisateur tape un chiffre. Quand c’est fait, elle vérifie la saisie. Une valeur entre 0 et 3 affiche une des fonctions définies auparavant dans le dictionnaire.
Figure : L’application commence par afficher un menu.
Choisissez la commande Run Module dans le menu Run.
Une fenêtre Python en mode Shell va s’ouvrir. L’application affiche un menu semblable à celui de la Figure.
Tapez 0 et appuyez sur Entrée.
L’application vous dit que vous avez sélectionné la couleur bleue, puis elle affiche de nouveau le menu (voir la Figure).
Figure : L’application affiche la réponse, puis présente à nouveau le menu.
Tapez 4 et appuyez sur Entrée.
L’application se termine.