You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
This repo is archived. You can view files and clone it, but cannot push or open issues/pull-requests.

пре 5 година
пре 5 година
пре 5 година
пре 5 година
пре 5 година
пре 5 година
пре 5 година
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366
  1. % Programmation avec Python (chapitre 7)
  2. % Dimitri Merejkowsky
  3. #
  4. \center \huge Un nouveau mot-clé
  5. # Les mots-clés
  6. Des mots qui ne peut être utilisé pour des noms de variales.
  7. On a déjà vu: `def`, `class`, `import`, etc ...
  8. # Assertions
  9. * Arrêter immédiatement le programme avec un message
  10. * Ressemble à `sys.exit()`
  11. * Mais usage un peu différent
  12. # Les assertions sont là pour les dévelopeurs
  13. * Le message n'aura en général *aucun* sens si c'est un simple utilisateur
  14. qui le lit.
  15. * Il indique en général un problème *interne*, dans le code lui-même,
  16. par opposition aux erreurs *externes*
  17. Mais on en reparlera :)
  18. #
  19. \center \huge Rappels sur les classes
  20. # Définition d'une classe
  21. Construire la classe`Counter` avec un attribut `count`:
  22. ```python
  23. class Counter:
  24. def __init__(self):
  25. self.count = 0
  26. ```
  27. # Instantiation
  28. Construire une nouvelle *instance* de `Counter`
  29. ```python
  30. >>> counter = Counter()
  31. >>> counter.count
  32. 0
  33. ```
  34. # Méthode
  35. Ajouter une méthode pour incrémenter le compteur:
  36. ```python
  37. class Counter:
  38. def __init__(self):
  39. self.count = 0
  40. def increment(self):
  41. self.count += 1
  42. ```
  43. # Apeller une méthode
  44. ```python
  45. >>> counter = Counter()
  46. >>> counter.count
  47. 0
  48. >>> counter.increment()
  49. >>> counter.count
  50. 1
  51. ```
  52. #
  53. \center \huge Compléments sur les classes
  54. # Attributs d'instances
  55. En vrai les attributs qu'on a vu maintenant sont des
  56. attributs d'instance. Ils sont liés à l'instance courante.
  57. Mais on dit souvent "attribut" tout court.
  58. Il existe un autre type d'attribut.
  59. # Attributs de classe
  60. Dans le bloc de la classe, mais à l'extérieur des
  61. blocs de méthodes:
  62. ```python
  63. class Car:
  64. total_number_of_cars = 0
  65. def __init__(self, color="black"):
  66. # attribut d'instance: avec self
  67. self.color = color
  68. # attribut de classe: avec le nom de la classe
  69. Car.total_number_of_cars += 1
  70. ```
  71. # Attributs de classe - 2
  72. Les attributs de classe sont partagés entre toutes
  73. les instances:
  74. ```python
  75. >>> ford = Car()
  76. >>> ferrari = Car(color="red")
  77. >>> Car.total_number_of_cars
  78. 2
  79. ```
  80. # Méthodes de classes
  81. De même, techniquement les méthodes qu'on a vu sont des méthodes
  82. d'instance, et il existe des méthodes de classe
  83. # Méthodes de classes
  84. Avec un joli `@classmethod` au-dessus
  85. ```python
  86. class Car:
  87. total_number_of_cars = 0
  88. @classmethod
  89. def print_number_of_cars(cls):
  90. print(cls.total_number_of_cars, "have been made")
  91. def print_color(self):
  92. print("This car is", self.color)
  93. ```
  94. Notez le `cls`
  95. # Méthodes de classes
  96. Pour appeler:
  97. ```python
  98. >>> ferrari = Car(color="red")
  99. >>> ford = Car()
  100. >>> Car.print_number_of_cars()
  101. 2 cars have been made
  102. ```
  103. # On retrouve le même mécanisme
  104. * ce qu'on écrit
  105. ```
  106. car.print_color()
  107. ```
  108. \vfill
  109. * ce qui est appelé:
  110. ```
  111. # self = car
  112. def print_color(self):
  113. print(self.color)
  114. ```
  115. # On retrouve le même mécanisme
  116. * ce qu'on écrit
  117. ```
  118. Car.print_number_of_cars()
  119. ```
  120. \vfill
  121. * ce qui est appelé:
  122. ```
  123. # cls = Car
  124. @classmethod
  125. def print_number_of_cars(cls):
  126. print(cls.total_number_of_cars)
  127. ```
  128. #
  129. \center \huge Les API Web
  130. # Concepts
  131. # HTTP
  132. Une façon pour des machines différentes de parler entre elles.
  133. On fait toujours un aller-retour du *client* vers le *serveur*.
  134. ![](img/client-serveur.png)
  135. # Requêtes
  136. Une requête part du client vers le serveur et consite en:
  137. * Une URL
  138. * Un verbe (souvent GET)
  139. * Des paramètres
  140. * Et d'autres trucs
  141. # Réponses
  142. Une réponse revient du serveur vers le client et contient
  143. * Un code de retour
  144. * Du contenu (très souvent, du texte)
  145. * Et d'autres trucs
  146. # API Web et navigateurs
  147. Quand vous tapez une url dans votre navigateur ou que vous suivez
  148. un lien, c'est votre navigateur qui fait la requête.
  149. Le serveur lui renvoie un contenu particulier (du HTML)
  150. C'est ce que vous voyez quand vous faites "show source"
  151. Vous voyez parfois le code de retour (le plus connu étant 404)
  152. *C'est très simplifié*
  153. # Utiliser une API Web
  154. * Lire les conditions d'utilisation (important!)
  155. * Regarder les URLs possibles et les paramètres attendus
  156. * Faire quelque chose avec la réponse
  157. Notez qu'on a *absolument* aucune connaissance du code qui tourne sur le serveur!
  158. # JSON
  159. * Un format *texte*. (Comme HTML)
  160. * *Très* utilisé justement pour échanger des données entre des machines différentes.
  161. * Implémenté dans plein de langages.
  162. # JSON
  163. Examples:
  164. * Une liste:
  165. ```json
  166. ["one", "two"]
  167. ```
  168. * Un "objet":
  169. ```json
  170. {
  171. "color": "blue",
  172. "size": 3
  173. }
  174. ```
  175. # JSON
  176. On peut imbriquer les objets les uns dans les autres:
  177. ```json
  178. {
  179. "a": 42,
  180. "b": true,
  181. "c": ["one", "two"],
  182. }
  183. ```
  184. On dit que JSON est un format *texte* par ce qu'on peut le mettre dans une string.
  185. # JSON / Python
  186. Python | JSON
  187. -------|-----
  188. dictionnary | object
  189. True | true
  190. False | false
  191. None | null
  192. # Parser du JSON en Python
  193. ```python
  194. >>> import json
  195. >>> data = json.loads("...")
  196. >>> data["a"]
  197. 42
  198. ```
  199. # Émettre du JSON à partir d'un objet Python
  200. ```python
  201. >>> import json
  202. >>> my_object = { "key1" : ["one", "two"] }
  203. >>> json.dumps(my_object, indent=2)
  204. """
  205. {
  206. "key1": ["one", "two"]
  207. }
  208. """
  209. ```
  210. #
  211. \center \huge Atelier
  212. # Objectif
  213. * Partir d'un bout de code (moche) qui utilise l'API marvel
  214. * Le nettoyer en introduisant des classes
  215. * Le rendre plus flexible
  216. * Etc ...
  217. # Requests
  218. *La* librarie pour faire des requêtes HTTP en Python.
  219. Malheureusement pas dans la librarie standard.
  220. ```python
  221. import requests
  222. >>> response = request.get(url)
  223. >>> response.status_code
  224. 200 # si tout va bien
  225. >>> response.text
  226. "<!DOCTYPE html ..."> # le texte de la réponse
  227. ```
  228. # Requests + JSON
  229. ```python
  230. >>> response = requests.get(url)
  231. >>> text = response.text
  232. >>> data = json.loads(text)
  233. ```
  234. Ou directement
  235. ```python
  236. >>> response = requests.get(url)
  237. >>> data = response.json()
  238. ```