Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
Ce dépôt est archivé. Vous pouvez voir les fichiers et le cloner, mais vous ne pouvez pas pousser ni ouvrir de ticket/demande d'ajout.

python-06.md 4.9 KiB

il y a 5 ans
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
  1. % Programmation avec Python (chapitre 6)
  2. % Dimitri Merejkowsky
  3. #
  4. \center \huge Les classes
  5. # Paradigmes
  6. Une façon d'envisager le code.
  7. Pour l'instant on n'a vu que le paradigme *procédural* (ou (impératif).
  8. Il y en a plein d'autres! (*fonctionnel* notamment, dont on parlera un jour)
  9. # Détails du procédural
  10. * des types simples (entiers, booléens)
  11. * des structures de données (dictionnaires, listes ...)
  12. * des fonctions qui manipulent des types simples ou des structures
  13. * les fonctions sont appelées les unes après les autres
  14. Aujourd'hui on va parler de *l'orienté objet*.
  15. # Un petit détour
  16. Un nouveau built-in: `id()`
  17. L'adresse de l'objet pointé par la variable:
  18. ```
  19. >>> a = 42532
  20. >>> id(a)
  21. 94295009035968
  22. >>> b = a
  23. >>> id(b) # même objet
  24. 94295009035968
  25. >>> c = 42532 # objet différent, même valeur
  26. >>> id(c)
  27. ```
  28. # Orienté objet - 1ère définition
  29. Mettre au même endroit:
  30. * des données
  31. * des fonctions qui opèrent sur ces données
  32. L'important c'est que les deux aillent ensemble
  33. OOP en Anglais (ou juste OO)
  34. # Orienté objet - 2ème définition
  35. Des "cellules" qui s'envoient des "messages".
  36. Notamment, les cellules ne "voient" que leur état interne.
  37. On peut envoyer un message d'une cellule à une autre *sans* connaître
  38. beaucoup de détails à propos du destinataire du message
  39. # Les classes
  40. On va parler *d'une* façon de faire de l'orienté objet: avec des classes.
  41. Mais notez bien qu'on peut faire de l'orienté objet *sans* classes!
  42. # Le plan de construction
  43. La seule chose dont on a besoin, c'est le mot-clé `class` et un nom.
  44. ```python
  45. class MyObject:
  46. pas
  47. ```
  48. La classe est le plan de construction de notre objet.
  49. # Créons des objets
  50. ```python
  51. >>> object_1 = MyObject()
  52. >>> object_2 = MyObject()
  53. ```
  54. Python ne sait rien de l'objet à part son adresse on mémoire et son nom:
  55. ```python
  56. print(object_1)
  57. <__main__.MyObject at 0x7f52c831e2b0>
  58. ```
  59. On appelle `object_1` et `object_2` des *instances* de la classe `MyObject`.
  60. # Méthodes
  61. Une fonction dans une classe
  62. ```
  63. class MyObject:
  64. def my_method(the_object):
  65. print("hello", the_object)
  66. ```
  67. C'est tout!
  68. # Méthodes - 2
  69. La méthode n'existe pas en dehors de la classe (souvenez vous des cellules !)
  70. ```
  71. >>> my_method()
  72. NameError
  73. >>> object = MyObject()
  74. >>> object.my_method()
  75. Hello, <MyObject at 0x7f52c9f6d6d8>
  76. ```
  77. Notez que `my_method` a pris en premier argument ce qu'il y avait *à gauche* du point:
  78. D'ailleurs, ce code fonctionne aussi et retourne *la même chose*:
  79. ```
  80. >>> MyObject.my_method(object)
  81. Hello, <MyObject at 0x7f52c9f6d6d8>
  82. ```
  83. # Méthodes - 3
  84. Il *faut* passer l'objet en cours en paramètre:
  85. ```python
  86. class MyObject:
  87. def broken():
  88. print("You cannot call me!")
  89. ```
  90. ```python
  91. >>> o = MyObject()
  92. >>> o.broken()
  93. TypeError: broken() takes 0 positional arguments but 1 was given
  94. ```
  95. # Conventions
  96. * Les classes sont en CamelCase
  97. * Tout le reste (méthodes, etc...) en snake_case
  98. * L'objet en cours s'appelle **toujours** `self`
  99. ```python
  100. class MyObject:
  101. def my_method(self):
  102. print("hello", self)
  103. ```
  104. # Attributs
  105. * Des variables dans un objet.
  106. * On peut ajouter un attribut quand on veut à qui on veut, et toujours avec le
  107. point au milieu:
  108. ```python
  109. >>> object = MyObject()
  110. >>> object.attribute # ici l'attribut n'existe pas
  111. AttributError
  112. >>> object.attribute = 42 # maintenant oui
  113. >>> object.attribute
  114. 42
  115. ```
  116. # Attributs dans les méthodes
  117. Avec `self`, bien sûr:
  118. ```python
  119. class MyObject:
  120. def print_attribute(self):
  121. print(self.attribute)
  122. def change_attribute(self, new_value)
  123. self.attribute = new_value
  124. ```
  125. # Accéder aux attributs
  126. ```python
  127. >>> object = MyObject()
  128. >>> object.print_attribute() # ici l'attribut n'existe pas
  129. AttributError
  130. >>> object.attribute = 42
  131. >>> object.print_attribute() # ça marche
  132. 42
  133. >>> object.change_attribute(43)
  134. >>> object.attribute
  135. 43
  136. ```
  137. # Initialisation des attributs
  138. Avec `__init__`:
  139. * méthode "spéciale"
  140. * appelée automatiquement
  141. * notez les deux underscores avant et après ('dunder' en Anglais)
  142. ```python
  143. class MyObject:
  144. def __init__(self):
  145. self.attribute = 42
  146. ```
  147. ```python
  148. >>> object = MyObject()
  149. >>> object.attribute
  150. 42
  151. ```
  152. # Construire des objets différents
  153. `__init__()` et `MyObject()` sont des appels de fonctions comme les autres
  154. ```python
  155. class Car:
  156. def __init__(self, color_to_use="black"):
  157. self.color = color_to_use
  158. >>> ford = Car()
  159. >>> ford.color
  160. "black"
  161. >>> ferrari = Car(color_to_use="red")
  162. >>> ferrari.color
  163. "red"
  164. ```
  165. # Notes
  166. En vrai, on nomme souvent les paramètres du constructeur et les attributes de la même façon.
  167. ```python
  168. class Car:
  169. def __init__(self, color="black"):
  170. self.color = color
  171. ```
  172. # Récapitulatif
  173. * Classe: plan de construction
  174. * Object: ce qu'on crée avec le plan
  175. * Instance: objet issue d'une classe
  176. * Méthode: fonction dans une classe (qui prend `self` en premier argument)
  177. * Attribut: variable dans un objet