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.

01-classes.md 7.3 KiB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319
  1. +++
  2. title = "Classes"
  3. weight = 1
  4. +++
  5. # Classes
  6. Ce qu’on a vu jusqu’ici:
  7. * Des types simples (entiers, booléens, ...)
  8. * Des structures de données (listes, dictionnaires, ...)
  9. * Des fonctions qui manipulent ces types ou ces types
  10. * Des fonctions qui s’appellent les unes les autres
  11. On appelle cet ensemble de concepts, cette façon d'écrire du code, un *paradigme* -
  12. et c'est un paradigme *procédural*.
  13. On va passer à un autre paradigme: l'*orienté objet*.
  14. ## Orienté objet - une première définition
  15. Un "objet" informatique *représente* un véritable "objet" physique
  16. dans le vrai monde véritable.
  17. Ce n'est pas une très bonne définition:
  18. 1. Ce n'est pas nécessaire
  19. 2. Ce n'est même pas forcément souhaitable!
  20. Je le mentionne juste parce que c'est une idée reçue très répandue.
  21. ## Orienté objet - 2ème définition
  22. Une meilleure définition, c'est de dire que la programmation
  23. orientée objet permet de mettre au même endroit:
  24. * des données
  25. * des fonctions qui opèrent sur ces données
  26. L'important c'est que les deux aillent ensemble!
  27. *Note: ce n'est pas **la** meilleure définition de l'orienté objet, mais on s'en contentera
  28. pour le moment ...*
  29. ## Les classes
  30. On va parler *d'une* façon de faire de l'orienté objet: avec des classes.
  31. Mais notez bien qu'on peut faire de l'orienté objet *sans* classes!
  32. ## Le plan de construction
  33. On dit souvent qu'en Python, "tout est objet".
  34. Pour bien comprendre cela, il faut d'abord parler des *classes* et des *instances de classes*.
  35. Une classe est un *plan de construction*, et est définie ainsi:
  36. ```python
  37. class MaClasse:
  38. # du code ici
  39. ```
  40. Comme les fonctions, les classes contienent un *corps*, qui est le bloc *identé* en dessous
  41. du mot-clé `class`, de nom de la classe et du `:` en fin de ligne.
  42. Les classes sont utilisées pour construire des *instances*.
  43. ## Créons des instances
  44. On peut faire un plan de construction vide avec le mot clé pass:
  45. ```python
  46. class MaClasse:
  47. pass
  48. ```
  49. Dans ce cas, on crée une instance en mettant le nom de la classe suivi d'une paire de parenthèses -
  50. un peu comme pour appeler une fonction:
  51. ```python
  52. >>> mon_instance = MaClasse()
  53. ```
  54. Ici, `mon_instance` est une *instance* de la classe `MaClasse`.
  55. ## Attributs
  56. Les attributs sont des éléments **nommés** à *l'intérieur* d'une instance.
  57. On peut y accéder avec la syntaxe `<instance>.<attribut>`:
  58. ```python
  59. y = a.x
  60. ```
  61. Ici, `y` est l'attribut `x` de l'instance `a`.
  62. Les attributs peuvent être des fonctions:
  63. ```python
  64. func = a.x
  65. func(10)
  66. ```
  67. Ici, on crée une variable `func` qui prend la valeur de l'attribut `x` dans l'instance `a`, puis
  68. on l'appelle avec l'argument `10` à la ligne suivante.
  69. Le code suivant fait exactement la même chose, mais avec une ligne de moins:
  70. ```python
  71. a.x(10)
  72. ```
  73. On peut *créer* des attributs dans *n'importe quel instance*, en utilisant l'*assignation*:
  74. ```python
  75. >>> mon_instance = MaClasse()
  76. # Création de l'attribut `x` dans `mon_instance`
  77. >>> mon_instance.x = 42
  78. # Accés à l'attribut `x` dans `mon_instance`
  79. >>> mon_instance.mon_attribut
  80. 42
  81. ```
  82. ## Méthodes - définition
  83. On peut aussi mettre des *méthodes* dans des classes.
  84. On utilise `def`, comme pour les fonctions, mais les méthodes *doivent* avoir au
  85. moins un argument appelé `self`, et être à l'intérieur du bloc de la classe:
  86. ```python
  87. class MaClasse:
  88. def ma_méthode(self):
  89. return 42
  90. ```
  91. ## Méthodes - appel
  92. Une méthode ne peut être appelée que depuis une *instance* de
  93. la classe:
  94. ```python
  95. class MaClasse:
  96. def ma_méthode(self):
  97. return 42
  98. >>> ma_méthode()
  99. Erreur
  100. >>> mon_instance = MaClasse()
  101. >>> mon_instance.ma_méthode()
  102. 42
  103. ```
  104. Notez qu'on ne passe *pas* d'argument quand on apelle `ma_méthode` depuis l'instance.
  105. ## Méthodes et attributs
  106. `self` *prend la valeur de l'instance courante* quand la méthode est appelée.
  107. On peut le voir en utilisant des attributs:
  108. ```python
  109. class MaClasse:
  110. def affiche_attribut_x(self):
  111. # Accès à l'attribut `x` dans `self`
  112. print(self.x)
  113. >>> mon_instance = MaClasse()
  114. >>> mon_instance.x = 42
  115. >>> mon_instance.affiche_attribut_x()
  116. 42
  117. ```
  118. On peut aussi *créer* des attributs dans une méthode:
  119. ```python
  120. class MaClasse:
  121. def crée_attribut_x(self):
  122. self.x = 42
  123. def affiche_attribut_x(self):
  124. print(self.x)
  125. >>> mon_instance = MaClasse()
  126. >>> mon_instance.affiche_attribut_x()
  127. # Erreur: `mon_instance` n'a pas d'attribut `x`
  128. >>> mon_instance.crée_attribut_x()
  129. >>> mon_instance.affiche_attribut_x()
  130. 42
  131. ```
  132. Les méthodes peuveunt aussi prendre plusieurs arguments, en plus de `self` - mais `self` doit
  133. toujours être le premier argument.
  134. Par example, pour créer un attribut avec une certaine valeur:
  135. ```python
  136. class MaClasse
  137. def crée_attribut_x(self, valeur_de_x):
  138. self.x = valeur_de_x
  139. def affiche_attribut_x(self);
  140. print(self.x)
  141. >>> mon_instance = MaClasse()
  142. >>> mon_instance.crée_attribut_x(42)
  143. >>> mon_instance.affiche_attribut_x()
  144. 42
  145. ```
  146. ## Méthodes appelant d'autres méthodes
  147. Comme les méthodes sont *aussi* des attributs, les méthodes d'une instance peuvent s'appeler
  148. les unes les autres:
  149. ```python
  150. class MaClasse:
  151. def méthode_1(self):
  152. print("démarrage de la méthode 1")
  153. print("la méthode 1 affiche bonjour")
  154. print("bonjour")
  155. print("fin de la méthode 1")
  156. def méthode_2(self):
  157. print("la méthode 2 appelle la méthode 1")
  158. self.méthode_1()
  159. print("fin de la méthode 2")
  160. ```
  161. ```python
  162. >>> mon_instance = MaClasse()
  163. >>> mon_instance.méthode_2()
  164. ```
  165. ```text
  166. la méthode 2 appelle la méthode 1
  167. démarrage de la méthode 1
  168. la méthode 1 affiche bonjour
  169. bonjour
  170. fin de la méthode 1
  171. fin de la méthode 2
  172. ```
  173. ## Une méthode spéciale
  174. Si vous définissez une méthode `__init__`, celle-ci est appelée *automatiquement*
  175. quand l'instance est construite.
  176. On dit que c'est une méthode "magique" parce qu'elle fait quelque chose _sans_ qu'on
  177. l'appelle explicitement.
  178. On utilise souvent `__init__` pour créer des attributs
  179. ```python
  180. class MaClasse:
  181. def __init__(self):
  182. self.x = 1
  183. self.y = 2
  184. >>> mon_instance = MaClasse()
  185. # __init__ est appelée automatiquement!
  186. >>> mon_instance.x
  187. 1
  188. >>> mon_instance.y
  189. 2
  190. ```
  191. On prend souvent les *valeurs* des attributs à créer en arguments de la méthode `__init__ `.
  192. ```python
  193. class MaClasse:
  194. def __init__(self, x, y):
  195. self.x = x
  196. self.y = y
  197. ```
  198. Dans ce cas, les arguments de la méthode `__init__` apparaissent à l'intérieur des parenthèses après le
  199. nom de la classe:
  200. ```
  201. >>> mon_instance = MaClasse(3, 4)
  202. >>> mon_instance.x
  203. 3
  204. >>> mon_instance.y
  205. 4
  206. ```
  207. *Pour cette raison, `__init__` est souvent appelé le _constructeur_ de la classe.*
  208. ## Récapitulatif
  209. * Classe: plan de construction
  210. * Instance: valeur issue d'une classe
  211. * Attribut: variable dans une instance
  212. * Méthode: fonction dans une instance (qui prend `self` en premier argument)
  213. * `__init__`: méthode magique appelée automatiquement pendant l'instanciation
  214. ## Classes et programmation orienté objet
  215. Ainsi, on peut ranger au même endroit des données et des fonctions opérant sur ces données.
  216. Les données sont les attributs, et les fonctions opérant sur ces attributs sont les méthodes.
  217. On peut ainsi séparer les *responsabilités* à l'intérieur d'un code en les répartissant
  218. entres plusieurs classes.