Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
Tento repozitář je archivovaný. Můžete prohlížet soubory, klonovat, ale nemůžete nahrávat a vytvářet nové úkoly a požadavky na natažení.
 
 
 
 
 
 

309 řádky
8.4 KiB

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