Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
Este repositório está arquivado. Você pode visualizar os arquivos e realizar clone, mas não poderá realizar push nem abrir issues e pull requests.

01-dictionnaires.md 3.1 KiB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205
  1. +++
  2. title = "Dictionnaires"
  3. weight = 1
  4. +++
  5. # Dictionnaires
  6. ## Définition
  7. Un dictionaire est une _association_ entre des clés et des valeurs.
  8. * Les clés sont uniques
  9. * Les valeurs sont arbitraires
  10. ## Création de dictionnaires
  11. ```python
  12. # dictionaire vide
  13. >>> {}
  14. # une clé, une valeur
  15. >>> {"a": 42}
  16. # deux clés, deux valeurs
  17. >>> {"a": 42, "b": 53}
  18. # les clés sont uniques:
  19. >>> {"a": 42, "a": 53}
  20. {"a": 53}
  21. ```
  22. Note: tous les dictionnaires sont truthy, sauf les dictionnaires vides.
  23. ## Accès aux valeurs
  24. Avec `[]`, comme pour les listes, mais avec une *clé* à la place d'un *index*.
  25. ```python
  26. >>> scores = {"john": 10, "bob": 42}
  27. >>> scores["john"]
  28. 10
  29. >>> scores["bob"]
  30. 42
  31. >>> scores["charlie"]
  32. KeyError
  33. ```
  34. ## Test d'appartenance
  35. Avec `in`, comme le listes:
  36. ```python
  37. >>> scores = {"john": 10, "bob": 42}
  38. >>> "charlie" in scores
  39. False
  40. ```
  41. ## Modifier la valeur d'une clé
  42. Comme pour les listes: on assigne la nouvelle variable:
  43. ```python
  44. >>> scores = {"john": 10, "bob": 42}
  45. >>> scores["john"] = 20
  46. >>> scores
  47. {"john": 20, "bob": 42}
  48. ```
  49. ## Créer une nouvelle clé
  50. Même méchanisme que pour la modification des clés existantes
  51. ```python
  52. >>> scores = {"john": 10, "bob": 42}
  53. >>> scores["charlie"] = 30
  54. >>> scores
  55. {"john": 20, "bob": 42, "charlie": 30}
  56. ```
  57. *rappel*: ceci ne fonctionne pas avec les listes!
  58. ```python
  59. >>> ma_liste = ["a", "b"]
  60. >>> ma_liste[1] = "c" # ok
  61. ["a", "c"]
  62. >>> ma_liste[3] = "d"
  63. IndexError
  64. ```
  65. ## Itérer sur les clés
  66. Avec `for ... in ...`, comme pour les listes
  67. ```python
  68. scores = {"john": 10, "bob": 42}
  69. for nom in scores:
  70. # `nom` est assigné à "john" puis "bob"
  71. score_associé_au_nom = scores[nom]
  72. print(nom, score_associé_au_nom)
  73. ```
  74. ## Détruire une clé
  75. Avec `del` - un nouveau mot-clé:
  76. ```python
  77. >>> scores = {"john": 10, "bob": 42}
  78. >>> del scores["bob"]
  79. >>> scores
  80. {"john": 10}
  81. ```
  82. ## Détruire un élément d'une liste
  83. ```python
  84. >>> fruits = ["pomme", "banane", "poire"]
  85. >>> del fruits[1]
  86. >>> fruits
  87. ["pomme", "poire"]
  88. ```
  89. ## Détruire une variable
  90. ```python
  91. >>> mon_entier = 42
  92. >>> mon_entier += 3
  93. >>> mon_entier
  94. 45
  95. >>> del mon_entier
  96. >>> mon_entier == 45
  97. NameError: name 'mon_entier' is not defined
  98. ```
  99. ## Détruire une fonction
  100. On peu aussi supprimer des fonctions:
  101. ```python
  102. def ma_fonction():
  103. print("bonjour")
  104. del ma_fonction
  105. >>> ma_fonction()
  106. NameError: name 'ma_fonction' is not defined
  107. ```
  108. ## Des dictionnaires partout
  109. Les variables globales d'un programme Python sont dans un dictionnaire,
  110. accessible avec la fonction native `globals()`:
  111. ```python
  112. $ python3
  113. >>> globals()
  114. {
  115. ...
  116. '__doc__': None,
  117. '__name__': '__main__',
  118. ...
  119. }
  120. ```
  121. On reparlera de `__doc__` et `__name__` un autre jour ...
  122. ```python
  123. $ python3
  124. >>> a = 42
  125. >>> globals()
  126. {
  127. ...
  128. '__doc__': None,
  129. '__name__': '__main__',
  130. ...
  131. 'a': 42
  132. }
  133. ```
  134. ```python
  135. $ python3
  136. >>> a = 42
  137. >>> del globals()["a"]
  138. >>> a
  139. NameError: name 'a' is not defined
  140. ```
  141. On peut accéder aux variables locales d'une fonction avec `locals()`
  142. ```python
  143. def ma_fonction():
  144. a = 42
  145. b = 3
  146. c = a + b
  147. print(locals())
  148. >>> ma_fonction()
  149. {'a': 42, 'b': 3, 'c': 45}
  150. ```
  151. En revanche, il n'est pas conseillé de modifier le dictionaire renvoyé par `locals()` ...