Non puoi selezionare più di 25 argomenti Gli argomenti devono iniziare con una lettera o un numero, possono includere trattini ('-') e possono essere lunghi fino a 35 caratteri.
Questo repository è archiviato. Puoi vedere i file e clonarli, ma non puoi effettuare richieste di pushj o aprire problemi/richieste di pull.

e2l-python-classes-01.md 8.2 KiB

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