選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。
このリポジトリはアーカイブされています。 ファイルの閲覧とクローンは可能ですが、プッシュや、課題・プルリクエストのオープンはできません。

python-07.md 6.0 KiB

5年前
5年前
5年前
5年前
5年前
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394
  1. % Programmation avec Python (chapitre 7)
  2. % Dimitri Merejkowsky
  3. \center \huge Rappels sur les classes
  4. # Définition d'une classe
  5. Construire une classe`Counter` vide:
  6. ```python
  7. class MyClass:
  8. ...
  9. ```
  10. # Instantiation
  11. Construire une nouvelle *instance* de `MyClass`
  12. ```python
  13. >>> my_instance = MyClass()
  14. ```
  15. # Méthodes
  16. Ajouter une méthode:
  17. ```python
  18. class MyClass:
  19. def my_method(self):
  20. ...
  21. ```
  22. `self` représente l'objet courant.
  23. # Méthodes
  24. Appeler une méthode:
  25. ```python
  26. >>> my_instance = MyClass()
  27. >>> my_instance.my_method()
  28. ```
  29. # Ajouter un attribut
  30. ```python
  31. >>> my_instance = MyClass()
  32. >>> my_instance.my_attribute = 0
  33. ```
  34. # Accéder à un attribut dans la classe
  35. ```python
  36. class MyClass():
  37. def my_method(self):
  38. print(self.my_attribute)
  39. ```
  40. # Méthode spéciale: __init__
  41. Initialiser les attributs:
  42. ```python
  43. class MyClass:
  44. def __init__(self):
  45. self.my_attribute = 0
  46. >>> my_instance = MyClass()
  47. >>> my_instance.my_attribute
  48. 0
  49. ```
  50. #
  51. \center \huge Compléments sur les classes
  52. # Attributs d'instances
  53. En vrai les attributs qu'on a vu maintenant sont des
  54. attributs d'instance. Ils sont liés à l'instance courante.
  55. Mais on dit souvent "attribut" tout court.
  56. Il existe un autre type d'attribut.
  57. # Attributs de classe
  58. Dans le bloc de la classe, mais à l'extérieur des
  59. blocs de méthodes:
  60. ```python
  61. class Car:
  62. total_number_of_cars = 0
  63. def __init__(self, color="black"):
  64. # attribut d'instance: avec self
  65. self.color = color
  66. # attribut de classe: avec le nom de la classe
  67. Car.total_number_of_cars += 1
  68. ```
  69. # Attributs de classe - 2
  70. Les attributs de classe sont partagés entre toutes
  71. les instances:
  72. ```python
  73. >>> ford = Car()
  74. >>> ferrari = Car(color="red")
  75. >>> Car.total_number_of_cars
  76. 2
  77. ```
  78. # Méthodes de classes
  79. De même, techniquement les méthodes qu'on a vu sont des méthodes
  80. d'instance, et il existe des méthodes de classe
  81. # Méthodes de classes
  82. Avec un joli `@classmethod` au-dessus
  83. ```python
  84. class Car:
  85. total_number_of_cars = 0
  86. @classmethod
  87. def print_number_of_cars(cls):
  88. print(cls.total_number_of_cars, "have been made")
  89. ```
  90. Notez le `cls`.
  91. # Méthodes de classes
  92. Pour appeler:
  93. ```python
  94. >>> ferrari = Car(color="red")
  95. >>> ford = Car()
  96. >>> Car.print_number_of_cars()
  97. 2 cars have been made
  98. ```
  99. # Note
  100. Au lieu de dire "de classe" on utilise parfois "statique".
  101. Mais "statique" veut dire plein d'autres chose...
  102. # On retrouve le même mécanisme
  103. * ce qu'on écrit
  104. ```
  105. car.print_color()
  106. ```
  107. \vfill
  108. * ce qui est appelé:
  109. ```
  110. # self = car
  111. def print_color(self):
  112. print(self.color)
  113. ```
  114. # On retrouve le même mécanisme
  115. * ce qu'on écrit
  116. ```
  117. Car.print_number_of_cars()
  118. ```
  119. \vfill
  120. * ce qui est appelé:
  121. ```
  122. # cls = Car
  123. @classmethod
  124. def print_number_of_cars(cls):
  125. print(cls.total_number_of_cars)
  126. ```
  127. #
  128. \center \huge Les API Web
  129. # HTTP
  130. Un *protocole*: une façon pour des machines différentes d'échanger des informations.
  131. On fait souvent un aller-retour du *client* vers le *serveur*.
  132. ![](img/client-serveur.png)
  133. # Requêtes
  134. Une requête part du client vers le serveur et consite en:
  135. * Une URL
  136. * Un verbe (souvent GET)
  137. * Des paramètres (sous la forme: `?a=42&b=true`)
  138. * Et d'autres trucs
  139. # Réponses
  140. Une réponse revient du serveur vers le client et contient
  141. * Un code de retour
  142. * Du contenu (très souvent, du texte)
  143. * Et d'autres trucs
  144. # API Web et navigateurs
  145. Quand vous tapez une url dans votre navigateur ou que vous suivez
  146. un lien, c'est votre navigateur qui fait la requête.
  147. Le serveur lui renvoie un contenu particulier (du HTML)
  148. C'est ce que vous voyez quand vous faites "show source"
  149. Vous voyez parfois le code de retour (le plus connu étant 404)
  150. *C'est très simplifié*
  151. # Le format HTML
  152. Des règles pour interpréter du texte:
  153. ```html
  154. <body>
  155. <h1>Ceci est un titre</h1>
  156. <p>
  157. Ceci est un paragraphe
  158. </p>
  159. </body>
  160. ```
  161. # Faire des requêtes en Python
  162. Avec `requests`, *la* librarie pour faire des requêtes HTTP en Python.
  163. Malheureusement pas dans la librarie standard.
  164. ```python
  165. import requests
  166. >>> response = request.get(url)
  167. >>> response.status_code
  168. 200 # si tout va bien
  169. >>> response.text
  170. "<!DOCTYPE html ..."> # le texte de la réponse
  171. ```
  172. # Une API Web
  173. Faire tourner de code sur le client, en utilisant du code sur un
  174. serveur *via* le protocole HTTP.
  175. ![](img/client-serveur.png)
  176. # Utiliser une API Web
  177. * Lire les conditions d'utilisation (important!)
  178. * Regarder les URLs possibles et les paramètres attendus
  179. * Ensuite seulement, écrire du code.
  180. Notez qu'on a *absolument* aucune connaissance du code qui tourne sur le serveur!
  181. # JSON
  182. * Un format *texte*. (Comme HTML)
  183. * *Très* utilisé justement pour échanger des données entre des machines différentes.
  184. * Implémenté dans plein de langages.
  185. # JSON
  186. Examples:
  187. * Une liste:
  188. ```json
  189. ["one", "two"]
  190. ```
  191. * Un "objet":
  192. ```json
  193. {
  194. "color": "blue",
  195. "size": 3
  196. "pretty": true,
  197. }
  198. ```
  199. **Attention**: les clés json sont *toujours* des strings.
  200. # JSON
  201. On peut imbriquer les objets les uns dans les autres:
  202. ```json
  203. {
  204. "a": 42,
  205. "b": true,
  206. "c": ["one", "two"],
  207. }
  208. ```
  209. # JSON / Python
  210. Python | JSON
  211. -------|-----
  212. dictionnary | object
  213. True | true
  214. False | false
  215. None | null
  216. # Parser du JSON en Python
  217. ```python
  218. >>> import json
  219. >>> data = json.loads("...")
  220. >>> data["a"]
  221. 42
  222. ```
  223. # Émettre du JSON à partir d'un objet Python
  224. ```python
  225. >>> import json
  226. >>> my_object = { "key1" : ["one", "two"] }
  227. >>> json.dumps(my_object, indent=2)
  228. """
  229. {
  230. "key1": ["one", "two"]
  231. }
  232. """
  233. ```
  234. #
  235. \center \huge Atelier
  236. # Objectif
  237. * Partir d'un bout de code (moche) qui utilise l'API marvel
  238. * Le nettoyer en introduisant des classes
  239. * Le rendre plus flexible
  240. * Etc ...
  241. # Requests + JSON
  242. ```python
  243. >>> response = requests.get(url)
  244. >>> text = response.text
  245. >>> data = json.loads(text)
  246. ```
  247. Ou directement
  248. ```python
  249. >>> response = requests.get(url)
  250. >>> data = response.json()
  251. ```
  252. # Conclusion
  253. Les sources de départ et d'arrivée sont sur GitHub:
  254. https://github.com/E2L/cours-python/tree/master/sources/marvel
  255. On repartira du code d'arrivée la prochaine fois