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.

tuples.md 3.4 KiB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208
  1. % notions: tuples, immuables & mutables, passage par référence,
  2. % copie, retour multiples
  3. #
  4. \center Les tuples
  5. # Création de tuples
  6. ```python
  7. mon_tuple = tuple() # un tuple vide
  8. mon_tuple = () # aussi un tuple vide
  9. mon_tuple = (1, 2) # un tuple à deux éléments
  10. ```
  11. # Note
  12. C'est la virgule qui fait le tuple, pas les parenthèses
  13. (on n'utilise les parenthèse que pour l'esthétique)
  14. \vfill
  15. ```python
  16. (1)
  17. # pas un tuple, juste le nombre 1 (entre parenthèses)
  18. (1,)
  19. # un tuple à un élément
  20. 1,
  21. # le *même* tuple
  22. ```
  23. # Indexation, test d'appartenance
  24. ```python
  25. >>> couple = ('Starsky', 'Hutch')
  26. >>> couple[0]
  27. 'Starsky'
  28. >>> couple[1]
  29. 'Hutch'
  30. >>> couple[3]
  31. IndexError
  32. >>> 'Starsky' in couple
  33. True
  34. >>> 'Batman' in couple
  35. False
  36. ```
  37. Rien de nouveau en principe :p
  38. # Déstructuration
  39. Créer plusieurs variables en une seule ligne
  40. ```python
  41. >>> couple = ("Batman", "Robin")
  42. >>> héro, side_kick = couple
  43. >>> héro
  44. 'Batman'
  45. >>> side_kick
  46. 'Robin'
  47. ```
  48. On dit aussi: unpacking
  49. # Quelques erreurs
  50. ```python
  51. >>> héro, side_kick, ennemi = couple
  52. ValueError (3 != 2)
  53. >>> (héro,) = couple
  54. ValueError (1 != 2)
  55. # Gare à la virgule:
  56. >>> héro, = couple
  57. ValueError (1 != 2)
  58. ```
  59. # Pièges
  60. ```python
  61. f(a, b, c) # appelle f() avec trois arguments
  62. f((a, b, c)) # appelle f() avec un seul argument
  63. # (qui est lui-même un tuple à 3 valeurs)
  64. ```
  65. # On peut aussi déstructurer des listes
  66. ```python
  67. >>> fruits = ["pomme", "banane", "orange"]
  68. >>> premier, deuxième, troisième = fruits
  69. ```
  70. # Retour multiple
  71. Retourner plusieurs valeurs:
  72. ```python
  73. def tire_carte(():
  74. valeur = "10"
  75. couleur = "trèfle"
  76. return (valeur, couleur)
  77. (v, c) = tire_carte()
  78. print("{} de {}", v, c)
  79. # 10 de trèfle
  80. ```
  81. \vfill
  82. En fait c'est juste une manipulation de tuples :)
  83. # Les tuples sont immuables
  84. ```python
  85. >>> couple = ('Starsky', 'Hutch')
  86. >>> couple[0] = 'Batman'
  87. TypeError
  88. ```
  89. Les méthodes `count()` et `index()` existent
  90. parce qu'elles ne modifient pas le tuple.
  91. # Les tuples sont immuables (2)
  92. Les méthodes qui modifieraient le tuple n'existent pas:
  93. ```python
  94. >>> couple = ('Starsky', 'Hutch')
  95. >>> couple.clear()
  96. AttributeError
  97. ```
  98. #
  99. \center Mutables, immuables, et références
  100. # Mutables et immuables
  101. * Mutables: listes, ensembles, dictionnaires
  102. * Immuables: entiers, flottants, booléens, strings
  103. # Passage par référence
  104. En Python, on ne manipule jamais les objets directement, on
  105. ne manipule que des *références* sur ces objets.
  106. ```python
  107. x = 3 # x est une référence vers l'objet 'entier 3'
  108. x = "hello" # x référence une string
  109. ```
  110. # Exemple 1
  111. ```python
  112. def ajoute_trois(x):
  113. x = x + 3 # crée une nouvelle référence
  114. mon_entier = 42
  115. ajoute_trois(mon_entier)
  116. # 'mon_entier' vaut toujours 42
  117. ```
  118. # Exemple 2
  119. ```python
  120. def ajoute_trois(l):
  121. l.append(3)
  122. # Ne crée pas de nouvelle référence
  123. # Appelle une méthode qui modifie 'l' sur place
  124. ma_liste = [1, 2]
  125. ajoute_trois(ma_liste)
  126. # 'ma_liste' vaut maintenant [1, 2, 3]
  127. ```
  128. # Exemple 3
  129. ```python
  130. def get_max(liste):
  131. autre_liste = liste.copy()
  132. autre_liste.sort()
  133. return autre_liste[-1]
  134. ma_liste = [1, 3, 2]
  135. x = get_max(ma_liste)
  136. # x = 3
  137. # `ma_liste` n'a pas changé
  138. ```
  139. # Notes
  140. * on peut aussi utiliser la fonction native "max()"
  141. * on peut aussi utiliser une slice: `autre_liste = liste[:]`
  142. # Conclusion
  143. Une fonction ne peut modifier la valeur de ses arguments qui s'ils sont
  144. mutables.
  145. Toutes les copies doivent être explicites