Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
Dieses Repo ist archiviert. Du kannst Dateien sehen und es klonen, kannst aber nicht pushen oder Issues/Pull-Requests öffnen.

python-04.md 7.5 KiB

vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
vor 5 Jahren
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449
  1. % Programmation avec Python (chapitre 4)
  2. % Dimitri Merejkowsky
  3. #
  4. \center \huge Les tuples
  5. # Création de tuples
  6. ```python
  7. mon_tuple = tuple() # un tuple vide
  8. mon_tuple = () # aussi un tuple vide
  9. mon_tuple = (1, 2) # un tuple à deux éléments
  10. ```
  11. # Note
  12. C'est la virgule qui fait le tuple, pas les parenthèses
  13. (on n'utilise les parenthèses que pour l'esthétique)
  14. \vfill
  15. ```python
  16. (1)
  17. # pas un tuple, juste le nombre 1 (entre parenthèses)
  18. (1,)
  19. # un tuple à un élément
  20. 1,
  21. # le *même* tuple
  22. ```
  23. # Indexation, test d'appartenance
  24. ```python
  25. >>> couple = ('Starsky', 'Hutch')
  26. >>> couple[0]
  27. 'Starsky'
  28. >>> couple[1]
  29. 'Hutch'
  30. >>> couple[3]
  31. IndexError
  32. >>> 'Starsky' in couple
  33. True
  34. >>> 'Batman' in couple
  35. False
  36. ```
  37. Rien de nouveau en principe :p
  38. # Déstructuration
  39. Créer plusieurs variables en une seule ligne
  40. ```python
  41. >>> couple = ("Batman", "Robin")
  42. >>> héro, side_kick = couple
  43. >>> héro
  44. 'Batman'
  45. >>> side_kick
  46. 'Robin'
  47. ```
  48. On dit aussi: unpacking
  49. # Quelques erreurs
  50. ```python
  51. >>> héro, side_kick, ennemi = couple
  52. ValueError (3 != 2)
  53. >>> (héro,) = couple
  54. ValueError (1 != 2)
  55. # Gare à la virgule:
  56. >>> héro, = couple
  57. ValueError (1 != 2)
  58. ```
  59. # Pièges
  60. ```python
  61. f(a, b, c) # appelle f() avec trois arguments
  62. f((a, b, c)) # appelle f() avec un seul argument
  63. # (qui est lui-même un tuple à 3 valeurs)
  64. ```
  65. # On peut aussi déstructurer des listes
  66. ```python
  67. >>> fruits = ["pomme", "banane", "orange"]
  68. >>> premier, deuxième, troisième = fruits
  69. ```
  70. # Retour multiple
  71. Retourner plusieurs valeurs:
  72. ```python
  73. def tire_carte():
  74. valeur = "10"
  75. couleur = "trèfle"
  76. return (valeur, couleur)
  77. (v, c) = tire_carte()
  78. print(v, "de", c)
  79. # 10 de trèfle
  80. ```
  81. \vfill
  82. En fait c'est juste une manipulation de tuples :)
  83. # Les tuples sont immuables
  84. ```python
  85. >>> couple = ('Starsky', 'Hutch')
  86. >>> couple[0] = 'Batman'
  87. TypeError
  88. ```
  89. Les méthodes `count()` et `index()` existent
  90. parce qu'elles ne modifient pas le tuple.
  91. # Les tuples sont immuables (2)
  92. Les méthodes qui modifieraient le tuple n'existent pas:
  93. ```python
  94. >>> couple = ('Starsky', 'Hutch')
  95. >>> couple.clear()
  96. AttributeError
  97. ```
  98. #
  99. \center Mutables, immuables, et références
  100. # Mutables et immuables
  101. * Mutables: listes, ensembles, dictionnaires
  102. * Immuables: entiers, flottants, booléens, strings
  103. # Passage par référence
  104. En Python, on ne manipule jamais les objets directement, on
  105. ne manipule que des *références* sur ces objets.
  106. ```python
  107. x = 3 # x est une référence vers l'objet 'entier 3'
  108. x = "hello" # x référence une string
  109. ```
  110. # Exemple 1
  111. ```python
  112. def ajoute_trois(x):
  113. x = x + 3 # crée une nouvelle référence
  114. mon_entier = 42
  115. ajoute_trois(mon_entier)
  116. # 'mon_entier' vaut toujours 42
  117. ```
  118. # Exemple 2
  119. ```python
  120. def ajoute_trois(liste):
  121. liste.append(3)
  122. # Ne crée pas de nouvelle référence
  123. # Appelle une méthode qui modifie 'liste' sur place
  124. ma_liste = [1, 2]
  125. ajoute_trois(ma_liste)
  126. # 'ma_liste' vaut maintenant [1, 2, 3]
  127. ```
  128. # Exemple 3
  129. ```python
  130. def get_max(liste):
  131. autre_liste = liste.copy()
  132. autre_liste.sort()
  133. return autre_liste[-1]
  134. ma_liste = [1, 3, 2]
  135. x = get_max(ma_liste)
  136. # x = 3
  137. # `ma_liste` n'a pas changé
  138. ```
  139. # Notes
  140. * on peut aussi utiliser la fonction native "max()"
  141. * on peut aussi utiliser une slice: `autre_liste = liste[:]`
  142. # Valeur par défaut
  143. ```python
  144. def exemple_bizarre(liste=[1, 2, 3]):
  145. liste.append(4)
  146. return liste
  147. >>> exemple_bizarre()
  148. [1, 2, 3, 4]
  149. >>> exemple_bizarre()
  150. [1, 2, 3, 4, 4]
  151. ```
  152. * Les arguments par défaut ne sont évalué qu'une seule fois
  153. # Valeur par défaut (2)
  154. Parfois, ce comportement *peut* être voulu
  155. \vfill
  156. ```python
  157. def grosse_fonction(x, cache=dict()):
  158. if x in cache:
  159. return cache[x]
  160. else:
  161. resultat = ... # plein de calculs
  162. cache[x] = resultat
  163. return resultat
  164. ```
  165. # Valeur par défaut (3)
  166. Sinon, remplacez l'argument mutable par un argument immutable
  167. ```python
  168. def exemple_bizarre(liste=None):
  169. if not liste:
  170. liste = [1, 2, 3]
  171. liste.append(4)
  172. return l
  173. >>> exemple_bizarre()
  174. [1, 2, 3, 4]
  175. >>> exemple_bizarre()
  176. [1, 2, 3, 4]
  177. ```
  178. # Conclusions
  179. * Une fonction ne peut modifier la valeur de ses arguments qui s'ils sont
  180. mutables.
  181. * Toutes les copies doivent être explicites
  182. #
  183. \center \huge Itérer sur les dictionnaires
  184. # Itérer sur les clés
  185. ```python
  186. scores = { "alice": 3, "bob": 4 }
  187. for prénom in scores:
  188. score = scores[prénom]
  189. print(prénom, score)
  190. ```
  191. \vfill
  192. Même chose avec la méthode `.keys()`
  193. ```python
  194. for prénom in scores.keys():
  195. ...
  196. ```
  197. # Itérer sur les valeurs
  198. ```python
  199. scores = { "alice": 3, "bob": 4 }
  200. for score in scores.values():
  201. print(score)
  202. ```
  203. # Itérer sur les clés *et* les valeurs
  204. ```python
  205. for (prénom, score) in scores.items()
  206. print(prénom, score)
  207. ```
  208. \vfill
  209. Notes:
  210. * on a gagné une ligne par rapport au premier exemple.
  211. * `items()` renvoie une liste de tuples
  212. # Presque des listes
  213. Les méthodes `.keys()`, `.values()` et `.items()` ne retournent pas des listes,
  214. mais des "vues".
  215. ```python
  216. >>> prénoms = scores.keys()
  217. >>> prénoms[1]
  218. TypeError: 'dict_keys' object does not support indexing
  219. ```
  220. \vfill
  221. On détaillera cette question plus tard.
  222. # Forcer des listes
  223. En attendant, vous pouvez convertir les vues en listes:
  224. ```python
  225. >>> prénoms = scores.keys()
  226. >>> premier_prénom = list(prénoms)[0]
  227. ```
  228. #
  229. \center \huge La programmation n'est pas un art solitaire
  230. # Le mythe
  231. > Un développeur dans son garage a une idée géniale,
  232. > l'implémente tout seul et gagne un tas de pognon.
  233. \vfill
  234. Ça n'existe pas (ou plus)
  235. * Sauf dans les fictions
  236. * Quasiment mon seul reproche à propos de la série *Silicon Valley*
  237. # La code review
  238. Ce qu'on a fait avec l'exercice de la dernière fois :)
  239. # Par mail - envoi
  240. ```text
  241. Bonjour Alice, voici une nouvelle fonction:
  242. def ma_fonction():
  243. ma_liste = ...
  244. if len(ma_liste) == 0:
  245. # la liste est vide
  246. signé: Bob
  247. ```
  248. # Par mail - réponse
  249. ```text
  250. Bonjour Bob, et merci pour ta contribution!
  251. def ma_fonction():
  252. ma_liste = ...
  253. if len(ma_liste) == 0:
  254. # la liste est vide
  255. >> Ici tu pourrais mettre `if not ma_liste`
  256. signé Alice
  257. ```
  258. # Par mail - envoi 2
  259. ```text
  260. Bonjour Alice, voici le code corrigé:
  261. def ma_fonction():
  262. ma_liste = ...
  263. if not ma_liste:
  264. ...
  265. ```
  266. # Code review
  267. Croyez-le ou nom, plein de projets fonctionnent comme ça.
  268. Pas d'outil spécifiques, on peut tout faire avec des e-mail
  269. et du texte brut.
  270. Et c'est souvent comme ça qu'on contribue à du code open-source.
  271. # D'autres outils
  272. Des outils essayent de "simplifier" le processus. En vrac: `gerrit`, `github`, `gitlab`, `bitbucket`, `phabricator` ...
  273. \vfill
  274. Mais dans son essence le concept n'a pas changé
  275. #
  276. \center \huge Un atelier
  277. # Mob programming
  278. Ou programmation en foule
  279. # Les règles
  280. * Un pilote: le seul autorisé à modifier le code
  281. * Un copilote: indique au pilote quoi faire
  282. * On tourne toutes les 15 minutes
  283. # Le challenge
  284. On va prendre deux discours politique et faire de l'analyse automatique de texte dessus.
  285. Notamment, repérer les mots qui reviennent le plus
  286. # Jean Véronis - aparté
  287. Un universitaire malheureusement décédé s'en était fait une spécialité.
  288. Vous pouvez lire *Les Mots du Président* si ça vous dit.
  289. Il utilisait d'autres outils, bien sûr, mais ce qu'on va faire n'est pas si loin
  290. #
  291. \center \huge Let's go!
  292. #
  293. # À vous maintenant
  294. Résultat de l'atelier:
  295. https://github.com/E2L/cours-python/blob/master/sources/06-top-words.py
  296. À vous de corriger les bugs et de m'envoyer vos solutions par mail
  297. (d.merej@gmail.com)