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.
Deze repo is gearchiveerd. U kunt bestanden bekijken en het klonen, maar niet pushen of problemen/pull-requests openen.

python-S02-E01.md 9.2 KiB

5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
5 jaren geleden
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613
  1. % Programmation avec Python (chapitre 1)
  2. % Dimitri Merejkowsky
  3. # Plan
  4. * La ligne de commande
  5. * Présentation et historique du langage
  6. * L'interpréteur interactif
  7. * Un jeu simple
  8. #
  9. \center \huge La ligne de commande
  10. # Pourquoi la ligne de commande?
  11. * Très puissant
  12. * Ancien, mais toujours d'actualité
  13. * Indispensable dans de nombreux cas
  14. * Écrire des programmes qui marche dans la ligne de commande est (relativement) simple
  15. * Possibilités infines, même si on ne fait que manipuler du texte
  16. # Les bases
  17. On tape un commande, on appuie sur entrée, l'ordinateur interprète ce qui a été tapé et affiche un message:
  18. * `cd chemin/vers/fichier`
  19. * `ls` (ou `dir` sous Windows)
  20. * `pwd`
  21. * Le premier mot est une 'commande', les autres mots sont des 'arguments'
  22. #
  23. \center \huge Python
  24. # Petit détour: version d'un programme
  25. * Comme les versions d'un document
  26. * Si le nombre est plus grand, c'est plus récent
  27. * Souvent en plusieurs morceaux: `1.3, 1.4, 3.2.5`. etc
  28. * Plus l'écart est grand, plus le programme a changé.
  29. * `3.2.5 -> 3.2.6`: pas grand-chose
  30. * `1.5.1 -> 4.3`: beaucoup de changements
  31. * On omet souvent le reste des numéros quand c'est pas nécessaire
  32. # Historique
  33. * Créé par Guido van Rossum. Conçu à la base pour l'enseignement.
  34. * Le nom vient des Monty Python (si, si)
  35. * Python 1: Sortie en 1991
  36. * Python 2: en 2000
  37. * Python 3: en 2008
  38. # Le grand schisme
  39. La plupart des langages continuent à être compatibles d'une version à l'autre.
  40. *Ce n'est pas le cas pour Python3*, et ça a causé beaucoup de confusion et de débats.
  41. Heureusement, 10 ans plus tard, la situation s'est arrangée, et Python2 cessera d'être maintenu le premier janvier 2020.
  42. # Python3
  43. Ce cours fonctionne donc uniquement avec Python3.
  44. N'utilisez *pas* Python2, sinon certaines choses expliquées ici ne marcheront pas :/
  45. # Utilisation de Python
  46. * Aussi appelé "langage de script", `glue language`
  47. * Bon partout, excellent nulle part
  48. * Exemples d'utilisation:
  49. * Sciences (physique, chimie, linguistique ...)
  50. * Animation (Pixar, Disney ...)
  51. * Sites web (journaux, youtube, ...)
  52. * Ligne de commande
  53. * ...
  54. # Installation
  55. # L'interpréteur interactif
  56. Il se lance depuis l'invite de commande du système d'exploitation:
  57. ```
  58. $ python3
  59. Python 3.7.1 (default, Oct 22 2018, 10:41:28)
  60. [GCC 8.2.1 20180831] on linux
  61. Type "help", "credits" or "license" for more information.
  62. >>>
  63. ```
  64. # Deux invites de commandes
  65. Notez les trois chevrons: `>>>`. Cela vous permet de différencier l'invite
  66. de commandes du système d'exploitation de celle de Python.
  67. * Système d'exploitation -> Python: taper `python3` (sans arguments)
  68. * Python -> Système d'exploitation: taper `quit()`
  69. # Note
  70. À partir de maintenant, recopiez les entrées sur les slides dans votre propre
  71. interpréteur.
  72. Vous devez taper la même chose après l'invite de commande ('>>>') et vous devez voir les mêmes réponses.
  73. Si ce n'est pas le cas, prévenez moi!
  74. # Entiers et maths simples
  75. ```
  76. >>> 1
  77. 1
  78. >>> 2
  79. 2
  80. >>> 1 + 2
  81. 3
  82. >>> 2 * 3
  83. 6
  84. ```
  85. # Flottants
  86. C'est le `.` qui fait le flottant
  87. ```
  88. >>> 0.5
  89. 0.5
  90. >>> 0.5 + 0.2
  91. 0.7
  92. >>> 10 / 3
  93. 3.3333333333333335
  94. ```
  95. *Note: les flottants sont imprécis*
  96. # Division entières et modulo
  97. ```
  98. >>> 14 // 3
  99. 4
  100. >>> 14 % 3
  101. 2
  102. ```
  103. *Le `%` n'a rien à voir avec un pourcentage!*
  104. # Priorité des opérations
  105. ```
  106. >>> 1 + 2 * 3
  107. 7
  108. >>> (1 + 2) * 3
  109. 9
  110. ```
  111. *Les parenthèses permettent de grouper les expressions*
  112. # Variables
  113. ```
  114. >>> a = 2
  115. >>> a
  116. 2
  117. >>> b = 3
  118. >>> a + b
  119. 5
  120. ```
  121. * On peut nommer des valeurs
  122. * On peut afficher la valeur d'une variable entrant son nom dans le REPL
  123. # Variables (2)
  124. ```
  125. >>> a = 2
  126. >>> a
  127. 2
  128. >>> a = 3
  129. >>> a
  130. 3
  131. ```
  132. * On peut changer la valeur d'une variable (d'où son nom)
  133. # Nom des variables
  134. Préférez des noms longs et descriptifs
  135. Toujours en minuscules
  136. Séparez les "mots" par des tirets bas (underscore)
  137. ```
  138. >>> score = 42
  139. >>> age_moyen = 22
  140. ```
  141. # Les chaînes de caractères
  142. Aussi appelées "string".
  143. Avec des simple quotes (`'`)
  144. ```
  145. >>> 'Bonjour monde!'
  146. 'Bonjour monde!'
  147. ```
  148. Marche aussi avec des double quotes (`"`)
  149. ```
  150. >>> "Bonjour, monde!"
  151. 'Bonjour monde'
  152. ```
  153. # Double et simple quotes
  154. On peut mettre des simples quotes dans des double quotes et vice-versa.
  155. ```
  156. >>> "Il a dit: 'bonjour' ce matin."
  157. "Il a dit: 'bonjour' ce matin."
  158. >>> 'Il a dit: "bonjour" ce matin'
  159. 'Il a dit: "bonjour" ce matin!'
  160. ```
  161. # Échappement
  162. Avec la barre oblique inversée "backslash"
  163. ```
  164. >>> 'Il a dit: "bonjour". C\'est sympa!'
  165. 'Il a dit: "bonjour". C\'est sympa!'
  166. ```
  167. # Concaténation
  168. ```
  169. >>> name = "John"
  170. >>> message = "Bonjour " + name + " !"
  171. >>> message
  172. "Bonjour John !"
  173. ```
  174. # Types
  175. ```
  176. >>> a = 42
  177. >>> message = "La réponse est: " + a
  178. TypeError: can only concatenate str (not "int") to str
  179. ```
  180. *Notre premier message d'erreur !*
  181. On ne mélange pas les torchons et les serviettes!
  182. #
  183. \center \huge Conversions
  184. # Entier vers string
  185. ```
  186. >>> a = 42
  187. >>> message = "La réponse est: " + str(a)
  188. >>> message
  189. 'La réponse est 42'
  190. ```
  191. # String vers entier
  192. ```
  193. >>> answer = int("42")
  194. >>> answer
  195. 42
  196. ```
  197. Notez les parenthèses autour des valeurs.
  198. # Booléens
  199. True et False
  200. En Python, elle sont en majuscules!
  201. # Assignation
  202. On peut assigner des variables aux valeurs True et False
  203. ```
  204. >>> la_terre_est_plate = False
  205. ...
  206. >>> python_c_est_genial = True
  207. ```
  208. # Comparaisons
  209. ```
  210. >>> a = 2
  211. >>> b = 3
  212. >>> a > b
  213. False
  214. ```
  215. ```
  216. >>> 2 + 2 == 4
  217. True
  218. ```
  219. Note: `==` pour la comparaison, `=` pour l'assignation
  220. # Comparaisons (2)
  221. ```
  222. >>> a = 2
  223. >>> b = 3
  224. >>> a != b
  225. True
  226. >>> 2 + 2 >= 4
  227. True
  228. ```
  229. # Comparaisons (3)
  230. ```
  231. >>> a = 2
  232. >>> a < 2
  233. False
  234. >>> 1 < a < 3
  235. True
  236. ```
  237. # Non persistance
  238. ```
  239. $ python3
  240. >>> a = 2
  241. >>> quit()
  242. ```
  243. ```
  244. $ python3
  245. >>> a
  246. Traceback (most recent call last):
  247. File "<stdin>", line 1, in <module>
  248. NameError: name 'a' is not defined
  249. ```
  250. # Du code dans un fichier
  251. Aussi appelé: "code source", ou "source".
  252. L'essence du logiciel libre :)
  253. # Installation d'un éditeur de texte simple
  254. * Linux; `gedit`, `kate`, ...
  255. * macOS: `CotEditor`
  256. * Windows: `Notepad++`
  257. J'insiste sur **simple**. Inutile d'installer un IDE pour le moment.
  258. # Configuration
  259. * Police de caractères à chasse fixe
  260. * Indentation de *4 espaces*
  261. * Remplacer tabulation par des espaces
  262. * Activer la coloration syntaxique
  263. # Notre premier fichier source
  264. Insérez le code suivant dans votre éditeur de texte
  265. ```python
  266. # Affiche un message
  267. print("Bonjour, monde")
  268. ```
  269. Sauvegardez dans un fichier `bonjour.py` dans `Documents/e2l/python` par exemple
  270. # Démonstration avec `kate`
  271. C'est l'éditeur que nous utiliserons pour nos ateliers.
  272. * Pour l'environement KDE, mais ça marche bien sous Gnome aussi
  273. * Coloration syntaxique
  274. * Auto-complétion
  275. # Lancer du code en ligne de commande
  276. ```
  277. $ cd Documents/e2l/python/
  278. $ python3 bonjour.py
  279. Bonjour, monde
  280. ```
  281. * Les lignes commençant par dièse (`#`) ont été ignorées - ce sont des *commentaires*.
  282. * `print()` affiche la valeur, comme dans le REPL.
  283. # Note importante (1)
  284. Vous avez juste besoin:
  285. * d'un éditeur de texte
  286. * de Python3 installé
  287. * d'une ligne de commande
  288. Pas la peine d'installer quoique ce soit de plus pour le moment
  289. # Note importante (2)
  290. À partir de maintenant, s'il y a marqué `# à recopier` en haut d'un exemple
  291. 1. *Recopiez* le code affiché dans votre éditeur, à la suite du code
  292. déjà écrit
  293. 2. Lancez le code depuis la ligne de commande
  294. 3. Réparez les erreurs éventuelles
  295. 4. Recommencez
  296. # Note importante (3)
  297. C'est le meilleur moyen d'apprendre. Si vous restez passifs vous retiendrez beaucoup moins de choses et ne pourrez pas coder par vous-même.
  298. Profitez qu'on soit là pour vous aider si vous avez des erreurs que vous ne comprenez pas!
  299. # Flot de contrôle
  300. L'essence de la programmation!
  301. # if
  302. ```python
  303. a = 3
  304. b = 4
  305. if a == b:
  306. print("a et b sont égaux")
  307. print("on continue")
  308. ```
  309. Notes:
  310. * deux points à la fin de la ligne
  311. * indentation après les deux points
  312. * si la condition n'est pas vraie, rien ne se passe
  313. # if (2)
  314. Notez qu'on peut mettre uniquement une variable ou une valeur
  315. après le if. Ceci ne fonctionne pas:
  316. ```python
  317. if a = 3:
  318. print("a égale 3")
  319. ```
  320. et fait une erreur de syntaxe
  321. # if / else
  322. ```python
  323. a = 3
  324. b = 4
  325. if a == b:
  326. print("a et b sont égaux")
  327. else:
  328. print("a et b sont différent")
  329. ```
  330. # if / elif
  331. ```python
  332. if age < 10:
  333. print("inférieur à dix")
  334. elif 10 <= age < 20:
  335. print("âge entre 10 et 20")
  336. elif 20 <= age < 40:
  337. print("âge entre 20 et 40")
  338. else:
  339. print("âge supérieur à 40")
  340. ```
  341. On peut mettre autont de `elif` qu'on veut!
  342. Le derier `else` s'éxécute en dernier
  343. # while
  344. Répéter tant qu'une condition est vraie
  345. ```python
  346. i = 0
  347. while i < 3:
  348. print(i)
  349. i = i + 1
  350. ```
  351. ```
  352. 0
  353. 1
  354. 2
  355. ```
  356. # Notre première boucle infinie
  357. ```python
  358. while True:
  359. print("spam!")
  360. ```
  361. CTRL-C pour interrompre
  362. # Combiner while et if
  363. On peut "sortir" de la boucle `while` avec `break`
  364. ```python
  365. i = 0
  366. while True:
  367. i = i + 1
  368. print(i)
  369. if i > 3:
  370. break
  371. ```
  372. ```
  373. 1
  374. 2
  375. 3
  376. 4
  377. ```
  378. # Lire une entrée utilisateur
  379. * `input()` (encore des parenthèses ...)
  380. * interrompt le script
  381. * lit ce que l'utilisateur tape jusqu'à ce qu'il tape "entrée".
  382. * renvoie une string
  383. # Le jeu
  384. On fait deviner un nombre à l'utilisateur, en affichant 'trop grand', 'trop petit'
  385. jusqu'à ce qu'il trouve la valeur exacte.