Não pode escolher mais do que 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. Pode ver ficheiros e cloná-lo, mas não pode fazer envios ou lançar questões ou pedidos de integração.
 
 
 
 
 
 

177 linhas
3.4 KiB

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