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-S02-E03.md 10 KiB

vor 5 Jahren
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646
  1. % Programmation avec Python (chapitre 3)
  2. % Dimitri Merejkowsky
  3. #
  4. \center \huge Rappels chapitre 2
  5. # Retour sur les listes - 1
  6. ```python
  7. vide = []
  8. deux_éléments = ["pomme", 42]
  9. for fruit in ["pomme", "banane", "poire"]:
  10. print(fruit)
  11. ```
  12. # Retour sur les listes - 2
  13. Index valides: de 0 à (taille - 1)
  14. ```python
  15. >>> fruits = ["pomme", "banane", "poire"]:
  16. >>> fruits[1]
  17. "banane"
  18. >>> fruits[2] = "orange"
  19. >>> fruits
  20. ["pomme", "banane", "orange"]
  21. ```
  22. # Retour sur les listes - 3
  23. ```python
  24. >>> fruits = ["pomme", "banane", "poire"]:
  25. >>> len(fruits)
  26. 3
  27. >>> "mandarine" in fruits
  28. False
  29. ```
  30. # Fonctions sans argument
  31. *Définition*:
  32. ```python
  33. def dire_bonjour():
  34. print("Bonjour")
  35. ```
  36. \vfill
  37. *Appel*:
  38. ```python
  39. >>> dire_bonjour()
  40. Bonjour
  41. ```
  42. # Fonctions avec un argument
  43. ```python
  44. def dire_bonjour(prénom):
  45. print("Bonjour", prénom)
  46. ```
  47. \vfill
  48. ```python
  49. >>> dire_bonjour("Bob")
  50. Bonjour Bob
  51. ```
  52. # Arguments par défaut
  53. ```python
  54. def dire_bonjour(prénom, enthousiaste=False):
  55. message = "Bonjour " + prénom
  56. if enthousiaste:
  57. message += "!"
  58. print(message)
  59. ```
  60. \vfill
  61. # Appeler une fonction avec des arguments par défaut
  62. ```python
  63. >>> dire_bonjour("John", enthousiaste=True)
  64. Bonjour John!
  65. >>> dire_bonjour("John", enthousiaste=False)
  66. Bonjour John
  67. >>> dire_bonjour("John")
  68. Bonjour John
  69. ```
  70. # Retourner une valeur
  71. ```python
  72. def additionner(x, y):
  73. return x + y
  74. ```
  75. ```python
  76. >>> a = 3
  77. >>> b = 4
  78. >>> c = additionner(a, b)
  79. >>> c
  80. 7
  81. ```
  82. # Portée des variables - 1
  83. ```python
  84. def dire_bonjour(prénom):
  85. # prénom est une variable locale
  86. print("Bonjour " + prénom)
  87. dire_bonjour("Dimitri")
  88. print(prénom)
  89. ```
  90. # Portée des variables - 2
  91. ```python
  92. # salutation est une variable globale
  93. salutation = "Bonjour "
  94. def dire_bonjour(prénom):
  95. print(salutation + prénom)
  96. dire_bonjour("Dimitri")
  97. ```
  98. # Portée des variables - 3
  99. ```python
  100. def dire_bonjour(prénom):
  101. print("Bonjour " + prénom)
  102. prénom = "Dimitri"
  103. dire_bonjour(prénom)
  104. ```
  105. #
  106. \center \huge None
  107. # Définition
  108. `None` est un "objet magique" natif en Python. Il est toujours présent, et il est unique.
  109. Un peu comme `True` et `False` qui sont deux objets qui servent à représenter tous les booléens.
  110. # Représenter l'absence
  111. L'interpréteur intéractif n'affiche rien quand la valeur est None
  112. ```python
  113. >>> a = 42
  114. >>> a
  115. 42
  116. >>> b = None
  117. >>> b
  118. ```
  119. # Retourner None
  120. En réalité, *toutes* les fonctions pythons retournent *quelque chose*, même quand
  121. elle ne contiennent pas le mot-clé `return`.
  122. ```python
  123. def ne_renvoie_rien():
  124. print("je ne fais qu'afficher quelque chose")
  125. ```
  126. ```python
  127. >>> resultat = ne_renvoie_rien()
  128. "je ne fais qu'afficher quelque chose"
  129. >>> resultat
  130. ```
  131. # Opérations avec None
  132. La plupart des fonctions que nous avons vues échouent si on leur passe None
  133. en argument:
  134. ```python
  135. >>> len(None)
  136. TypeError: object of type 'NoneType' has no len()
  137. >>> None < 3
  138. TypeError: '<' not supported between instances of
  139. 'NoneType' and 'int'
  140. >>> int(None)
  141. TypeError: int() argument must be a string,
  142. a bytes-like object or a number,
  143. not 'NoneType'
  144. >>> str(None)
  145. 'None'
  146. ```
  147. # Example d'utilisation:
  148. ```python
  149. def trouve_dans_liste(valeur, liste):
  150. for element in liste:
  151. if element == valeur:
  152. return element
  153. return None
  154. ```
  155. ```python
  156. >>> trouve_dans_liste(2, [1, 2, 3])
  157. 2
  158. >>> trouve_dans_liste(False, [True, False])
  159. False
  160. >>> trouve_dans_liste(1, [3, 4])
  161. ```
  162. # Example d'utilisation - 2
  163. ```python
  164. def trouve_dans_liste(liste, valeur):
  165. for element in liste:
  166. if element == valeur:
  167. return element
  168. ```
  169. None est Falsy, et on peut vérifier si une variable vaut None avec `is None`
  170. ```python
  171. # hypothèse: `ma_valeur` n'est pas None
  172. mon_element = trouve_dans_liste(ma_valeur, ma_liste)
  173. if mon_element is None:
  174. print("élément absent de la liste")
  175. if not mon_element:
  176. # Peut-être que l'élément n'était pas dans la liste,
  177. # ou peut-être y était-il, mais avec une valeur falsy
  178. ...
  179. ```
  180. #
  181. \center \huge Les dictionnaires
  182. # Définition
  183. Un dictionaire est une _association_ entre des clés et des valeurs.
  184. * Les clés sont uniques
  185. * Les valeurs sont arbitraires
  186. # Création de dictionnaires
  187. ```python
  188. # dictionaire vide
  189. >>> {}
  190. # une clé, une valeur
  191. >>> {"a": 42}
  192. # deux clés, deux valeurs
  193. >>> {"a": 42, "b": 53}
  194. # les clés sont uniques:
  195. >>> {"a": 42, "a": 53}
  196. {"a": 53}
  197. ```
  198. Note: tous les dictionnaires sont truthy, sauf les dictionnaires vides.
  199. # Accès aux valeurs
  200. Avec `[]`, comme pour les listes, mais avec une *clé* à la place d'un *index*.
  201. ```python
  202. >>> scores = {"john": 10, "bob": 42}
  203. >>> scores["john"]
  204. 10
  205. >>> scores["bob"]
  206. 42
  207. >>> scores["charlie"]
  208. KeyError
  209. ```
  210. # Test d'appartenance
  211. Avec `in`, comme le listes:
  212. ```python
  213. >>> scores = {"john": 10, "bob": 42}
  214. >>> "charlie" in scores
  215. False
  216. ```
  217. # Modifier la valeur d'une clé
  218. Comme pour les listes: on assigne la nouvelle variable:
  219. ```python
  220. >>> scores = {"john": 10, "bob": 42}
  221. >>> scores["john"] = 20
  222. >>> scores
  223. {"john": 20, "bob": 42}
  224. ```
  225. # Créer une nouvelle clé
  226. Même méchanisme que pour la modification des clés existantes
  227. ```python
  228. >>> scores = {"john": 10, "bob": 42}
  229. >>> scores["charlie"] = 30
  230. >>> scores
  231. {"john": 20, "bob": 42, "charlie": 30}
  232. ```
  233. *rappel*: ceci ne fonctionne pas avec les listes!
  234. ```python
  235. >>> ma_liste = ["a", "b"]
  236. >>> ma_liste[1] = "c" # ok
  237. ["a", "c"]
  238. >>> ma_liste[3] = "d"
  239. IndexError
  240. ```
  241. # Itérer sur les clés
  242. Avec `for ... in ...`, comme pour les listes
  243. ```python
  244. scores = {"john": 10, "bob": 42}
  245. for nom in scores:
  246. # `nom` est assigné à "john" puis "bob"
  247. score_associé_au_nom = scores[nom]
  248. print(nom, score_associé_au_nom)
  249. ```
  250. # Détruire une clé
  251. Avec `del` - un nouveau mot-clé:
  252. ```python
  253. >>> scores = {"john": 10, "bob": 42}
  254. >>> del scores["bob"]
  255. >>> scores
  256. {"john": 10}
  257. ```
  258. # Détruire un élément d'une liste
  259. ```python
  260. >>> fruits = ["pomme", "banane", "poire"]
  261. >>> del fruits[1]
  262. >>> fruits
  263. ["pomme", "poire"]
  264. ```
  265. # Détruire une variable
  266. ```python
  267. >>> mon_entier = 42
  268. >>> mon_entier += 3
  269. >>> mon_entier
  270. 45
  271. >>> del mon_entier
  272. >>> mon_entier == 45
  273. NameError: name 'mon_entier' is not defined
  274. ```
  275. # Détruire une fonction
  276. On peu aussi supprimer des fonctions:
  277. ```python
  278. def ma_fonction():
  279. print("bonjour")
  280. del ma_fonction
  281. >>> ma_fonction()
  282. NameError: name 'ma_fonction' is not defined
  283. ```
  284. # Des dictionnaires partout
  285. Les variables globales d'un programme Python sont dans un dictionnaire,
  286. accessible avec la fonction native `globals()`:
  287. ```python
  288. $ python3
  289. >>> globals()
  290. {
  291. ...
  292. '__doc__': None,
  293. '__name__': '__main__',
  294. ...
  295. }
  296. ```
  297. On reparlera de `__doc__` et `__name__` un autre jour ...
  298. # Des dictionnaires partout - 2
  299. ```python
  300. $ python3
  301. >>> a = 42
  302. >>> globals()
  303. {
  304. ...
  305. '__doc__': None,
  306. '__name__': '__main__',
  307. ...
  308. 'a': 42
  309. }
  310. ```
  311. # Des dictionnaires partout - 3
  312. ```python
  313. $ python3
  314. >>> a = 42
  315. >>> del globals()["a"]
  316. >>> a
  317. NameError: name 'a' is not defined
  318. ```
  319. # Des dictionnaires partout - 4
  320. On peut accéder aux variables locales d'une fonction avec `locals()`
  321. ```python
  322. def ma_fonction():
  323. a = 42
  324. b = 3
  325. c = a + b
  326. print(locals())
  327. >>> ma_fonction()
  328. {'a': 42, 'b': 3, 'c': 45}
  329. ```
  330. En revanche, il n'est pas conseillé de modifier le dictionaire renvoyé par `locals()` ...
  331. #
  332. \center \huge Les tuples
  333. # Définition
  334. Un tuple est un ensemble *ordonné* et *immuable* d'éléments. Le nombre, l'ordre et la valeur des objets sont fixes.
  335. # Création de tuples
  336. ```python
  337. # Un tuple vide
  338. ()
  339. # Un tuple à un élément
  340. (1,) # notez la virgule
  341. # Un tuple à deux éléments, aussi appelé couple
  342. (1, 2)
  343. ```
  344. Sauf pour le tuple vide, c'est la *virgule* qui fait le tuple
  345. Note: tous les tuples sont truthy, sauf les tuples vides.
  346. # Tuples hétérogènes
  347. Comme les listes, les tuples peuvent contenir des éléments de types différents:
  348. ```python
  349. # Un entier et une string
  350. mon_tuple = (42, "bonjour")
  351. # Un entier et un autre tuple
  352. mon_tuple = (21, (True, "au revoir"))
  353. ```
  354. # Accès
  355. Avec `[]` et l'index de l'élément dans le tuple:
  356. ```python
  357. mon_tuple = (42, "bonjour")
  358. mon_tuple[0]
  359. 42
  360. mon_tuple[1]
  361. "bonjour"
  362. ```
  363. # Modification
  364. Interdit!
  365. ```python
  366. mon_tuple = (42, "bonjour")
  367. mon_tuple[0] = 44
  368. TypeError: 'tuple' object does not support item assignment
  369. ```
  370. # Test d'appartenance
  371. Avec `in`
  372. ```python
  373. >>> mon_tuple = (42, 14)
  374. >>> 42 in mon_tuple
  375. True
  376. >>> 14 in mon_tuple
  377. True
  378. >>> 13 in mon_tuple
  379. False
  380. ```
  381. # Déstructuration
  382. Créer plusieurs variables en une seule ligne:
  383. ```python
  384. >>> couple = ("Batman", "Robin")
  385. >>> héro, side_kick = couple
  386. >>> héro
  387. 'Batman'
  388. >>> side_kick
  389. 'Robin'
  390. ```
  391. # Quelques erreurs classiques
  392. ```python
  393. >>> héro, side_kick, ennemi = couple
  394. ValueError (3 != 2)
  395. >>> (héro,) = couple
  396. ValueError (1 != 2)
  397. # Gare à la virgule:
  398. >>> héro, = couple
  399. ValueError (1 != 2)
  400. ```
  401. # Pièges
  402. ```python
  403. f(a, b, c) # appelle f() avec trois arguments
  404. f((a, b, c)) # appelle f() avec un seul argument
  405. # (qui est lui-même un tuple à 3 valeurs)
  406. f(()) # appelle f() avec un tuple vide
  407. (a) # juste la valeur de a entre parenthèses
  408. (a,) # un tuple à un élément, qui vaut la valeur de a
  409. ```
  410. # On peut aussi déstructurer des listes
  411. ```python
  412. >>> fruits = ["pomme", "banane", "orange"]
  413. >>> premier, deuxième, troisième = fruits
  414. >>> premier
  415. "pomme"
  416. >>> deuxième
  417. "banane"
  418. >>> troisième
  419. "orange"
  420. ```
  421. On dit aussi: unpacking
  422. # Utilisations des tuples - 1
  423. Pour simplifier des conditions:
  424. ```python
  425. # Avant
  426. if (
  427. ma_valeur == "nord" or
  428. ma_valeur == "sud" or
  429. ma_valeur == "ouest" or
  430. ma_valeur == "est"):
  431. print("direction", ma_valeur)
  432. ```
  433. \vfill
  434. ```python
  435. # Après
  436. if ma_valeur in ("nord", "sud", "est", "ouest"):
  437. print("direction", ma_valeur)
  438. ```
  439. # Pour retourner plusieurs valeurs
  440. ```python
  441. def tire_carte():
  442. valeur = "10"
  443. couleur = "trèfle"
  444. return (valeur, couleur)
  445. v, c = tire_carte()
  446. print(v, "de", c)
  447. # 10 de trèfle
  448. ```
  449. Ce n'est pas une nouvelle syntaxe, juste de la manipulation de tuples!
  450. #
  451. \center \huge Atelier
  452. #
  453. Retour au pendu, mais cette fois nous voulons implémenter la gestion des high scores!
  454. #
  455. \center \huge Consignes pour travailler chez vous
  456. # Préparation
  457. * Récupérer l'archive `pendu-1.zip` dans la section Cours/Ateliers/Labos du site de l'ECL
  458. * L'extraire dans un répertoire quelconque
  459. * Se rendre dans ce répertoire et taper `python3.py pendu.py`
  460. * Si tout va bien, le message 'bonjour' s'affiche
  461. # Consignes
  462. * Remplacer le code dans `main()` en appelant correctement les autres fonctions définies dans le ficher.
  463. * Vérifier que le code fonctionne en jouant avec plusieurs noms différents.
  464. * Envoyez votre code ou questions par mail à dimitri@e2li.org