No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
Este repositorio está archivado. Puede ver los archivos y clonarlo, pero no puede subir cambios o reportar incidencias ni pedir Pull Requests.

python-S02-E02.md 9.4 KiB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638
  1. % Programmation avec Python (chapitre 2)
  2. % Dimitri Merejkowsky
  3. #
  4. \center \huge Rappels
  5. # Variables
  6. ```python
  7. score = 2 # un entier
  8. taille = 1.85 # un flottant
  9. message = "bonjour!" # une string
  10. ```
  11. # Opérations mathématiques
  12. * `+`, `*`, `-`, `/`
  13. ```python
  14. x = 3
  15. y = 5
  16. x + y # 8
  17. ```
  18. * `//` et `%`
  19. ```python
  20. 14 // 3 # 4
  21. 14 % 3 # 2
  22. ```
  23. # Opérations avec les strings
  24. * Concaténation:
  25. ```python
  26. nom = "Bob"
  27. message = "Bonjour " + nom
  28. "Bonjour Bob"
  29. ```
  30. * Conversions:
  31. ```python
  32. score = 42
  33. message = "votre score est: " + str(score)
  34. ```
  35. ```python
  36. print("Entrez votre age")
  37. réponse = input()
  38. age = int(réponse)
  39. ```
  40. # Booléens et tests
  41. ```python
  42. a = 3
  43. b = 4
  44. a > b # False
  45. c = 3
  46. a == b # True
  47. ```
  48. # Tester une condtion avec if
  49. ```python
  50. a = 3
  51. b = 4
  52. if a == b:
  53. print("a et b sont égaux")
  54. print("on continue")
  55. ```
  56. # Tester une condition avec if et else
  57. ```python
  58. a = 3
  59. b = 4
  60. if a == b:
  61. print("a et b sont égaux")
  62. else:
  63. print("a et b sont différents")
  64. print("on continue")
  65. ```
  66. # Tester des conditions avec if, else et elif
  67. ```python
  68. if age < 10:
  69. print("inférieur à dix")
  70. elif 10 <= age < 20:
  71. print("âge entre 10 et 20")
  72. elif 20 <= age < 40:
  73. print("âge entre 20 et 40")
  74. else:
  75. print("âge supérieur à 40")
  76. ```
  77. # Boucler sur une condition avec while
  78. ```python
  79. i = 0
  80. while i < 3:
  81. print(i)
  82. i = i + 1
  83. ```
  84. ```
  85. 0
  86. 1
  87. 2
  88. ```
  89. # Sortir d'une boucle avec if et break
  90. ```python
  91. i = 0
  92. while True:
  93. i = i + 1
  94. print(i)
  95. if i > 3:
  96. break
  97. ```
  98. #
  99. \center \huge Compléments
  100. # Combiner assignation et opérations
  101. `a += b` est équivalent à `a = a +b`
  102. ```python
  103. >>> a = 3
  104. >>> a = a + 1
  105. >>> a
  106. 4
  107. >>> a = 3
  108. >>> a += 1
  109. >>> a
  110. 4
  111. ```
  112. # Gérer les retours à la ligne
  113. `\n` sert à échapper les retours à la ligne:
  114. ```python
  115. >>> texte = "Je suis un message\nsur deux lignes"
  116. >>> print(texte)
  117. Je suis un message
  118. sur deux lignes
  119. >>>
  120. ```
  121. # Concaténation de littéraux
  122. Pas besoin de `+` pour concaténer des "littéraux".
  123. ```python
  124. >>> text = "Je suis une " "longue" " string"
  125. >>> text
  126. 'Je suis une longue string'
  127. ```
  128. # Répétition
  129. ```python
  130. >>> "argh " * 3
  131. 'argh argh argh'
  132. ```
  133. # Une longue string sur plusieurs lignes
  134. ```python
  135. poème = """
  136. Ceci est un poème
  137. Qui contient "des quotes"
  138. Et parle d'autre choses ...
  139. """
  140. ```
  141. #
  142. \center \huge Fonctions
  143. # Fonction sans argument
  144. Définition:
  145. ```python
  146. def dire_bonjour():
  147. print("Bonjour")
  148. ```
  149. * avec `def`
  150. * avec un `:` à la fin et un _bloc indenté_ (appelé le "corps")
  151. \vfill
  152. Appel:
  153. ```
  154. >>> dire_bonjour()
  155. Bonjour
  156. ```
  157. * avec le nom de la fonction et des parenthèses
  158. # Le pouvoir des fonctions
  159. Ici on vient de créer une nouvelle fonctionnalité
  160. à Python. Avant qu'on définisse la fonction
  161. `dire_bonjour()`, il ne savait pas dire bonjour,
  162. il savait uniquement afficher des messages à
  163. l'écran.
  164. On dit qu'on a _créé une abstraction_. Et
  165. c'est une technique extrêmement utile en
  166. programmation.
  167. # Fonction avec un argument
  168. Définition: avec l'argument à l'intérieur des parenthèses
  169. ```python
  170. def dire_bonjour(prénom):
  171. print("Bonjour " + prénom)
  172. ```
  173. \vfill
  174. Appel: en passant une variable ou une valeur dans les parenthèses
  175. ```python
  176. >>> dire_bonjour("Germaine")
  177. Bonjour Germaine
  178. >>> prénom_de_charlotte = "Charlotte"
  179. >>> dire_bonjour(prénom_de_charlotte)
  180. Bonjour Charlotte
  181. ```
  182. # Exécution d'une fonction
  183. C'est exatement comme si on assignait les arguments de la fonction avant d'éxécuter le code
  184. dans le corps
  185. ```python
  186. # Ceci:
  187. dire_bonjour("Dimitri")
  188. # Est équivalent à cela:
  189. prénom_de_dimitri = "Dimitri"
  190. print("Bonjour " + prénom_de_dimitri)
  191. # Lui-même équivalent à:
  192. print("Bonjour " + "Dimitri")
  193. ```
  194. # Portée des variables - 1
  195. Les arguments d'une fonction n'existent que dans le corps de celle-ci
  196. ```python
  197. def dire_bonjour(prénom):
  198. print("Bonjour " + prénom)
  199. dire_bonjour("Dimitri") # Ok
  200. print(prénom) # Erreur
  201. ```
  202. # Portée des variables - 2
  203. Les variables en dehors des fonctions sont disponibles partout:
  204. ```python
  205. salutation = "Bonjour "
  206. def dire_bonjour(prénom):
  207. print(salutation + prénom)
  208. dire_bonjour("Dimitri")
  209. ```
  210. # Portée des variables - 3
  211. Une variable peut avoir en "cacher" une autre si elle a une portée différente
  212. ```python
  213. def dire_bonjour(prénom):
  214. print("Bonjour " + prénom) # portée: uniquement dans
  215. # le corps dire_bonjour
  216. prénom = "Dimitri" # portée: dans tout le programme
  217. dire_bonjour(prénom) # Ok
  218. ```
  219. # Fonction avec plusieurs arguments
  220. On peut mettre autant d'arguments qu'on veut, séparés
  221. par des virgules:
  222. ```python
  223. def afficher_addition(x, y):
  224. résultat = x + y
  225. print(résultat)
  226. ```
  227. \vfill
  228. ```python
  229. >>> a = 4
  230. >>> b = 5
  231. >>> afficher_addition(a, b)
  232. 9
  233. ```
  234. # Arguments nommés
  235. En Python, on peut aussi utiliser le *nom* des arguments au lieu de
  236. leur position:
  237. ```python
  238. def dire_bonjour(prénom):
  239. print("Bonjour " + prénom)
  240. ```
  241. ```python
  242. >>> dire_bonjour(prénom="Gertrude")
  243. Bonjour Gertrude
  244. >>> afficher_addition(y=3, x=4)
  245. 7
  246. ```
  247. # Arguments par défaut
  248. On peut aussi mettre des valeurs par défaut:
  249. Définition:
  250. ```python
  251. def dire_bonjour(prénom, enthousiaste=False):
  252. message = "Bonjour " + prénom
  253. if enthousiaste:
  254. message += "!"
  255. print(message)
  256. ```
  257. \vfill
  258. Appel:
  259. ```python
  260. >>> dire_bonjour("Thomas", enthousiaste=True)
  261. Bonjour Thomas!
  262. >>> dire_bonjour("Thomas", enthousiaste=False)
  263. Bonjour Thomas
  264. >>> dire_bonjour("Thomas")
  265. Bonjour Thomas
  266. ```
  267. # Fonctions natives
  268. Fonctions qui sont toujours présentes dans l'interpréteur. On en a déjà vu quelques unes:
  269. * `print`, `input`: écrire et lire sur la ligne de commande
  270. * `str`, `int`: convertir des entiers en strings et vice-versa
  271. Il y en a tout un tas!
  272. La liste ici: https://docs.python.org/fr/3/library/functions.html#built-in-funcs
  273. # Retour sur print
  274. On peut passer autant d'arguments qu'on veut à `print` et:
  275. * Il les sépare par des espaces
  276. * Ajoute un retour à la ligne à la fin:
  277. ```python
  278. >>> prénom = "Charlotte"
  279. print("Bonjour", pŕenom)
  280. Bonjour Charlotte
  281. ```
  282. # Retour sur print
  283. On peut demander à `print` de changer son séparateur:
  284. ```python
  285. >>> a = "chauve"
  286. >>> b = "souris"
  287. >>> print(a, b, sep="-")
  288. chauve-souris
  289. ```
  290. Ou de changer le caractère de fin:
  291. ```python
  292. >>> print("Ceci tient", end="")
  293. >>> print("sur une seule ligne")
  294. Ceci tient sur une seule ligne
  295. ```
  296. # Retourner des valeurs
  297. Définition avec le mot `return`
  298. ```python
  299. def additionner(x, y):
  300. return x + y
  301. ```
  302. \vfill
  303. Récupérer la valeur de retour
  304. ```python
  305. >>> a = 3
  306. >>> b = 4
  307. >>> c = additionner(a, b) # encore une assignation
  308. >>> c
  309. 7
  310. ```
  311. # Sortir d'une fonction avec return
  312. `return` interrompt également l'éxécution du
  313. corps de la fonction:
  314. ```python
  315. def dire_bonjour(prénom, première_fois=False):
  316. print("Bonjour", prénom)
  317. if not première_fois:
  318. return
  319. print("Heureux de faire votre connaissance")
  320. ```
  321. \vfill
  322. ```python
  323. >>> dire_bonjour("Dimitri", première_fois=True)
  324. Bonjour Dimitri
  325. Heureux de faire votre connaissance
  326. >>> dire_bonjour("Dimitri", première_fois=False)
  327. Bonjour Dimitri
  328. ```
  329. #
  330. \center \huge Listes
  331. # Définition
  332. Une liste est une _suite ordonée_ d'éléments.
  333. # Créer une liste
  334. Avec `[]`, et les élements séparés par des virgules:
  335. ```python
  336. liste_vide = []
  337. trois_entiers = [1, 2, 3]
  338. ```
  339. # Listes hétérogènes
  340. On peut mettre des types différents dans la même liste
  341. ```python
  342. ma_liste = [True, 2, "trois"]
  343. ```
  344. \vfill
  345. On peut aussi mettre des listes dans des listes:
  346. ```python
  347. liste_de_listes = [[1, 2], ["Germaine", "Gertrude"]]
  348. ```
  349. # Connaître la taille d'une liste
  350. Avec `len()` - encore une fonction native
  351. ```python
  352. >>> liste_vide = []
  353. >>> len(liste_vide)
  354. 0
  355. >>> trois_entiers = [1, 2, 3]
  356. >>> len(trois_entiers)
  357. 3
  358. ```
  359. # Concaténation de listes
  360. Avec `+`
  361. ```python
  362. >>> prénoms = ["Alice", "Bob"]
  363. >>> prénoms += ["Charlie", "Eve"]
  364. >>> prénoms
  365. ['Alice', 'Bob', "Charlie", 'Eve']
  366. ```
  367. \vfill
  368. On ne peut concaténer des listes que avec d'autres listes:
  369. ```python
  370. >>> scores = [1, 2, 3]
  371. >>> scores += 4 # TypeError
  372. >>> scores += [4] # OK
  373. ```
  374. # Test d'appartenance
  375. Avec `in`:
  376. ```python
  377. >>> prénoms = ["Alice", "Bob"]
  378. >>> "Alice" in prénoms
  379. True
  380. ```
  381. \vfill
  382. ```python
  383. >>> prénoms = ["Alice", "Bob"]
  384. >>> "Charlie" in prénoms
  385. False
  386. ```
  387. # Itérer sur les élements d'une liste
  388. Avec `for ... in`
  389. ```python
  390. prénoms = ["Alice", "Bob", "Charlie"]
  391. for prénom in prénoms:
  392. # La variable 'prénom" est assignée à chaque
  393. # élément de la liste
  394. print("Bonjour", prénom)
  395. Bonjour Alice
  396. Bonjour Bob
  397. Bonjour Charlie
  398. ```
  399. # Indéxer une liste
  400. * Avec `[]` et un entier
  401. * Les index valides vont de 0 à `n-1` où `n` est la
  402. taille de la liste.
  403. ```python
  404. >>> fruits = ["pomme", "orange", "poire"]
  405. >>> fruits[0]
  406. "pomme"
  407. >>> fruits[1]
  408. "orange"
  409. >>> list[2]
  410. "poire"
  411. >>> fruits[3] # IndexError
  412. ```
  413. # Modifier une liste
  414. Encore une assignation:
  415. ```python
  416. >>> fruits = ["pomme", "orange", "poire"]
  417. >>> fruits[0] = "abricot"
  418. >>> fruits
  419. ["abricot", "orange", "poire"]
  420. ```
  421. # Les strings sont aussi des listes (presque) - 1
  422. On peut itérer sur les caractères d'une string:
  423. ```python
  424. for c in "vache":
  425. print(c)
  426. v
  427. a
  428. c
  429. h
  430. e
  431. ```
  432. # Les strings sont aussi des listes (presque) - 2
  433. On peut tester si un caractère est présent:
  434. ```python
  435. >>> "e" in "vache"
  436. True
  437. >>> "x" in "vache"
  438. False
  439. ```
  440. # Les strings sont aussi des listes (presque) - 3
  441. Mais on neut peut pas modifier une string
  442. ```python
  443. >>> prénom = "Charlotte"
  444. >>> prénom[0]
  445. "C"
  446. >>> prénom[3]
  447. "r"
  448. >>> prénom[0] = "X" # TypeError
  449. ```
  450. #
  451. \huge \center Atelier
  452. # Jeu du pendu
  453. Squellete:
  454. ```python
  455. def choisir_mot_au_hasard():
  456. ....
  457. def main():
  458. mot = choisir_mot_au_hasard()
  459. ...
  460. main()
  461. ```