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.
 
 
 
 
 
 

704 líneas
12 KiB

  1. \documentclass{beamer}
  2. \usepackage[utf8]{inputenc}
  3. \usepackage{hyperref}
  4. \usepackage{listings}
  5. \lstset{language=Python, showstringspaces=false}
  6. \usetheme{Madrid}
  7. \hypersetup{colorlinks=true}
  8. \title{Introduction à la programmation avec Python \\ (chapitre 2)}
  9. \author{Dimitri Merejkowsky}
  10. \institute{E2L}
  11. \begin{document}
  12. \frame{\titlepage}
  13. \begin{frame}
  14. Note: \\~\\
  15. Les sources sont sur GitHub:
  16. \url{https://github.com/E2L/cours-python/tree/master/sources}. \\~\\
  17. Mais il vaut mieux recopier le code vous-mêmes.
  18. \end{frame}
  19. \begin{frame}
  20. \frametitle{Plan}
  21. \begin{itemize}
  22. \item Retours sur le chapitre 1
  23. \item Fonctions
  24. \item Structures de données
  25. \end{itemize}
  26. \end{frame}
  27. \begin{frame}[fragile]
  28. \centering
  29. \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
  30. Retours sur le chapitre 1
  31. \end{beamercolorbox}
  32. \end{frame}
  33. \begin{frame}[fragile]
  34. \frametitle{Combiner assignation et opérations}
  35. \begin{lstlisting}
  36. >>> a = 3
  37. >>> a = a + 1
  38. 3
  39. \end{lstlisting}
  40. Même résultat que:
  41. \begin{lstlisting}
  42. >>> a = 3
  43. >>> a += 1
  44. \end{lstlisting}
  45. \vfill
  46. Marche aussi avec \texttt{-=}, \texttt{*=} etc.
  47. \end{frame}
  48. \begin{frame}[fragile]
  49. \frametitle{Retour sur les strings}
  50. \begin{lstlisting}
  51. >>> text = "Je suis un message\nSur deux lignes")
  52. >>> print(text)
  53. Je suis un message
  54. Sur deux lignes
  55. \end{lstlisting}
  56. \end{frame}
  57. \begin{frame}[fragile]
  58. \frametitle{Concaténation implicite}
  59. \begin{lstlisting}
  60. >>> text = "Je suis une " "longue" " string"
  61. >>> text
  62. 'Je suis une longue string'
  63. \end{lstlisting}
  64. \end{frame}
  65. \begin{frame}[fragile]
  66. \frametitle{Concaténer des strings (2)}
  67. \begin{lstlisting}
  68. message = (
  69. "ligne 1\n"
  70. "ligne 2\n"
  71. )
  72. \end{lstlisting}
  73. Les parenthèse permettent d'aller à la ligne dans le code :)
  74. \end{frame}
  75. \begin{frame}[fragile]
  76. \frametitle{Répéter une string}
  77. \begin{lstlisting}
  78. >>> "argh " * 3
  79. argh argh argh
  80. \end{lstlisting}
  81. \end{frame}
  82. \begin{frame}[fragile]
  83. \frametitle{Faire une longue string sur plusieurs lignes}
  84. \begin{lstlisting}
  85. poeme = """
  86. Ceci est un poeme
  87. Qui contient "des quotes"
  88. Et parle d'autre choses ...
  89. """
  90. \end{lstlisting}
  91. \begin{block}{Note}
  92. Marche aussi avec des "triples-simple-quotes", mais c'est moins lisible :P
  93. \end{block}
  94. \end{frame}
  95. \begin{frame}[fragile]
  96. \frametitle{Opérations sur les strings (1)}
  97. \begin{lstlisting}
  98. >>> text = " bonjour! \n "
  99. >>> text.strip()
  100. "bonjour!"
  101. \end{lstlisting}
  102. Nouvelle syntaxe: notez le '.' entre la variable et la "fonction".
  103. \end{frame}
  104. \begin{frame}[fragile]
  105. \frametitle{Opérations sur les strings (2)}
  106. Modification de la casse:
  107. \begin{lstlisting}
  108. >>> text = "Hello"
  109. >>> text.upper()
  110. "HELLO"
  111. >>> text = "Au Revoir"
  112. >>> text.lower()
  113. "au revoir"
  114. >>> text = "ceci est un titre"
  115. >>> text.title()
  116. "Ceci est un titre"
  117. \end{lstlisting}
  118. \end{frame}
  119. \begin{frame}[fragile]
  120. \frametitle{Retour sur input()}
  121. On peut afficher un message avant de lire l'entrée utilisateur.
  122. \begin{lstlisting}
  123. # A adapter
  124. import random
  125. secret = random.randint()
  126. print("Devine le nombre auquel je pense")
  127. while True:
  128. reponse = input("Ta reponse: ")
  129. response = int(response)
  130. ...
  131. \end{lstlisting}
  132. \end{frame}
  133. \begin{frame}[fragile]
  134. \frametitle{Retour sur print()}
  135. On peut spécifier le caractère de fin. \textbackslash n par défaut.
  136. \begin{lstlisting}
  137. # Dans hello.py
  138. print("Bonjour", end=" ")
  139. print("monde", end="!\n")
  140. \end{lstlisting}
  141. \begin{lstlisting}
  142. $ python hello.py
  143. Bonjour monde!
  144. \end{lstlisting}
  145. \end{frame}
  146. \begin{frame}[fragile]
  147. \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
  148. Fonctions
  149. \end{beamercolorbox}
  150. \end{frame}
  151. \begin{frame}[fragile]
  152. \frametitle{Sans arguments}
  153. \begin{lstlisting}
  154. def say_hello():
  155. print("Hello")
  156. say_hello()
  157. \end{lstlisting}
  158. \vfill
  159. Notez l'utilisation des parenthèses pour \emph{appeler} la fonction
  160. \end{frame}
  161. \begin{frame}[fragile]
  162. \frametitle{Définition simple}
  163. \begin{lstlisting}
  164. def add(a, b):
  165. return a + b
  166. a = 1
  167. b = 2
  168. c = add(a, b)
  169. print(c)
  170. \end{lstlisting}
  171. \end{frame}
  172. \begin{frame}[fragile]
  173. \frametitle{Paramètres nommés}
  174. \begin{lstlisting}
  175. def greet(name, shout=False):
  176. result = "Hello, "
  177. result += name
  178. if shout:
  179. result += "!"
  180. return result
  181. >>> greet("John")
  182. 'Hello, John'
  183. >>> greet("Jane", shout=True)
  184. 'Hello, Jane!'
  185. \end{lstlisting}
  186. \end{frame}
  187. \begin{frame}[fragile]
  188. \frametitle{Note}
  189. \texttt{print()} est une fonction :)
  190. \end{frame}
  191. \begin{frame}[fragile]
  192. \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
  193. Structures de données
  194. \end{beamercolorbox}
  195. \end{frame}
  196. \begin{frame}[fragile]
  197. \frametitle{Créer une liste}
  198. \begin{lstlisting}
  199. >>> ma_liste = list() # liste vide
  200. >>> ma_liste = [] # aussi une liste vide
  201. >>> ma_liste = [1, 2, 3] # trois entiers
  202. \end{lstlisting}
  203. \vfill
  204. \begin{alertblock}{Note}
  205. \texttt{list()} est \textbf{aussi} une fonction :)
  206. \end{alertblock}
  207. \end{frame}
  208. \begin{frame}[fragile]
  209. \frametitle{Listes hétérogènes}
  210. On peut mettre des types différents dans une même liste:
  211. \begin{lstlisting}
  212. >>> pommes_et_carottes = [True, 2, "three"]
  213. \end{lstlisting}
  214. \vfill
  215. Et même des listes dans des listes:
  216. \begin{lstlisting}
  217. >>> liste_de_liste = [[1, 2], ["one", "two"]]
  218. \end{lstlisting}
  219. \end{frame}
  220. \begin{frame}[fragile]
  221. \frametitle{Connaître la taille d'une liste}
  222. Avec la fonction \texttt{len()}:
  223. \vfill
  224. \begin{lstlisting}
  225. >>> liste_vide = []
  226. >>> len(liste_vide)
  227. 0
  228. >>> autre_liste = [1, 2, 3]
  229. >>> len(autre_liste)
  230. 3
  231. \end{lstlisting}
  232. \end{frame}
  233. \begin{frame}[fragile]
  234. \frametitle{Indexer une liste}
  235. \begin{lstlisting}
  236. >>> liste = [1, 2, 3]
  237. >>> liste[0] # ca commence a zero
  238. 1
  239. >>> liste[4]
  240. IndexError
  241. \end{lstlisting}
  242. \vfill
  243. Astuce: l'index maximal est \texttt{len(list) -1} ;)
  244. \end{frame}
  245. \begin{frame}[fragile]
  246. \frametitle{Modifer une liste}
  247. \begin{lstlisting}
  248. >>> liste = [1, 2, 3]
  249. >>> liste[1] = 4
  250. >>> liste
  251. [1, 4, 3]
  252. \end{lstlisting}
  253. \end{frame}
  254. \begin{frame}[fragile]
  255. \frametitle{Itérer sur les éléments d'une liste}
  256. \begin{lstlisting}
  257. names = ["Alice", "Bob", "Charlie"]
  258. for name in names:
  259. print("Bonjour", name)
  260. Bonjour Alice
  261. Bonjour Bob
  262. Bonjour Charlie
  263. \end{lstlisting}
  264. \end{frame}
  265. \begin{frame}[fragile]
  266. \frametitle{Test de présence}
  267. Avec le mot-clé \texttt{in}:
  268. \vfill
  269. \begin{lstlisting}
  270. >>> fruits = ["pomme", "banane"]
  271. >>> "pomme" in fruits
  272. True
  273. >>> "orange" in fruits
  274. False
  275. \end{lstlisting}
  276. \end{frame}
  277. \begin{frame}[fragile]
  278. \frametitle{Ajout d'un élément}
  279. Avec \texttt{append()}
  280. \begin{lstlisting}
  281. >>> fruits.append("poire")
  282. >>> fruits
  283. ['pomme', 'banane', 'poire']
  284. \end{lstlisting}
  285. \vfill
  286. Notez le point entre `fruits` et `append`
  287. \end{frame}
  288. \begin{frame}[fragile]
  289. \frametitle{Autres opérations}
  290. \begin{lstlisting}
  291. >>> fruits = ["pomme", "poire"]
  292. >>> fruits.insert(1, "abricot")
  293. # ['pomme', 'abricot', 'poire']
  294. >>> fruits.remove("pomme")
  295. # ['abricot', 'poire']
  296. >>> fruits.remove("pas un fruit")
  297. Erreur!
  298. \end{lstlisting}
  299. \end{frame}
  300. \begin{frame}[fragile]
  301. \frametitle{Découper une string en liste}
  302. \begin{lstlisting}
  303. >>> message = "un deux trois"
  304. >>> message.split() # espaces
  305. ["un", "deux", "trois"]
  306. \end{lstlisting}
  307. \end{frame}
  308. \begin{frame}[fragile]
  309. \frametitle{Dictionnaires}
  310. Des clés et des valeurs:
  311. \begin{lstlisting}
  312. >>> mon_dico = dict() # dictionaire vide
  313. >>> mon_dico = {} # aussi un dictionnaire vide
  314. # deux cles et deux valeurs:
  315. >>> scores = {"john": 24, "jane": 23}
  316. >>> scores.keys()
  317. ["john", "jane"
  318. >>> mon_dico.values()
  319. [24, 23]
  320. \end{lstlisting}
  321. \end{frame}
  322. \begin{frame}[fragile]
  323. \frametitle{Insertion}
  324. \begin{lstlisting}
  325. >>> scores = {"john": 10 }
  326. >>> scores["john"] = 12 # John marque deux points
  327. >>> scores["bob"] = 3 # Bob entre dans la partie
  328. >>> scores["personne"]
  329. KeyError
  330. \end{lstlisting}
  331. \end{frame}
  332. \begin{frame}[fragile]
  333. \frametitle{Fusion de dictionnaires}
  334. \begin{lstlisting}
  335. >>> s1 = {"john": 12, "bob": 2}
  336. >>> s2 = {"bob": 3, "charlie": 4}
  337. >>> s1.update(s2)
  338. >>> s1
  339. {"john": 12, "bob": 3, "charlie": 4}
  340. \end{lstlisting}
  341. \end{frame}
  342. \begin{frame}[fragile]
  343. \frametitle{Destruction}
  344. \begin{lstlisting}
  345. >>> scores = {"john": 12, "bob": 23}
  346. >>> scores.pop("john")
  347. # {"bob': 23}
  348. >>> scores.pop("personne")
  349. KeyError
  350. \end{lstlisting}
  351. \end{frame}
  352. \begin{frame}[fragile]
  353. \frametitle{Ensembles}
  354. Des objets sans ordre ni doublons.
  355. Création avec la fonction \texttt{set()}:
  356. \begin{lstlisting}
  357. >>> sac = set()
  358. >>> sac = {} # oups, c'est un dictionnaire vide!
  359. >>> sac = {"one", "two"} # un set avec deux strings
  360. >>> len(sac) # len() fonctionne aussi avec les ensembles
  361. >>> 2
  362. \end{lstlisting}
  363. \end{frame}
  364. \begin{frame}[fragile]
  365. \frametitle{Ajout d'un élement dans un ensemble}
  366. \begin{lstlisting}
  367. >>> sac = {"one", "two"}
  368. >>> sac.add("three"}
  369. # {"one", "two", "three"}
  370. >>> sac.add("one")
  371. # {"one", "two", "three"} # pas de changement
  372. \end{lstlisting}
  373. \end{frame}
  374. \begin{frame}[fragile]
  375. \frametitle{Autres opérations}
  376. \begin{lstlisting}
  377. >>> s1 = {"one", "two"}
  378. >>> s2 = {"one", "three"}
  379. # {"two"}
  380. \end{lstlisting}
  381. Aussi:
  382. \begin{itemize}
  383. \item \texttt{update()}
  384. \item \texttt{union()}
  385. \item \texttt{intersection()}
  386. \end{itemize}
  387. \end{frame}
  388. \begin{frame}[fragile]
  389. \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
  390. Jeu du pendu
  391. \end{beamercolorbox}
  392. \end{frame}
  393. \begin{frame}[fragile]
  394. \frametitle{Squelette}
  395. \begin{itemize}
  396. \item Lire les mots possibles depuis un fichier texte
  397. \item Choisir un mot au hasard
  398. \item Afficher un "hint"
  399. \item Démarrer une boucle
  400. \begin{itemize}
  401. \item Demander une lettre
  402. \item Afficher le "hint" mis à jour
  403. \item Vérfier si le jeu est fini
  404. \item Repartir au début de la boucle
  405. \end{itemize}
  406. \end{itemize}
  407. \end{frame}
  408. \begin{frame}[fragile]
  409. \frametitle{Une fonction par tâche}
  410. \begin{itemize}
  411. \item \texttt{read\_words()}
  412. \item \texttt{choose\_word()}
  413. \item \texttt{display\_hint()}
  414. \item \texttt{has\_won()}
  415. \end{itemize}
  416. \end{frame}
  417. \begin{frame}[fragile]
  418. \frametitle{Structure de données}
  419. \begin{itemize}
  420. \item Une liste pour les mots dans le fichier
  421. \item Un ensemble pour les bonnes lettre devinées
  422. \end{itemize}
  423. \end{frame}
  424. \begin{frame}[fragile]
  425. \frametitle{Implémentation: lire un fichier}
  426. \begin{itemize}
  427. \item \texttt{open()} renvoie un "objet fichier"
  428. \item \texttt{read()} lit le fichier \textbf{en entier} et retourne une string
  429. \end{itemize}
  430. \begin{lstlisting}
  431. def read_words():
  432. stream = open("noms.txt")
  433. contents = stream.read()
  434. stream.close()
  435. words = splitlines()
  436. return words
  437. \end{lstlisting}
  438. \end{frame}
  439. \begin{frame}[fragile]
  440. \frametitle{Choisir un mot au hasard dans la liste}
  441. \begin{lstlisting}
  442. import random # remember me?
  443. def choose_word(words):
  444. n = len(words)
  445. index = random.randint(0, n-1)
  446. return words[index]
  447. \end{lstlisting}
  448. \end{frame}
  449. \begin{frame}[fragile]
  450. \frametitle{Afficher les lettres devinées}
  451. \begin{lstlisting}
  452. def display_hint(word, letters):
  453. for letter in word:
  454. if letter in letters:
  455. print(letter, end="")
  456. else:
  457. print("_", end="")
  458. print("")
  459. \end{lstlisting}
  460. \begin{lstlisting}
  461. >>> display_hint("vache", {"a"})
  462. _a___
  463. >>> display_hint("vache", {"a", "c"})
  464. _ac__
  465. \end{lstlisting}
  466. \end{frame}
  467. \begin{frame}[fragile]
  468. \frametitle{L'utilisateur a-t-il gagné?}
  469. L'utilisateur a gagné si toutes les lettres ont
  470. été devinées:
  471. \begin{lstlisting}
  472. def has_won(word, letters):
  473. for letter in word:
  474. if letter not in letters:
  475. return False
  476. return True
  477. \end{lstlisting}
  478. \end{frame}
  479. \begin{frame}[fragile]
  480. \frametitle{Boucle principale}
  481. \begin{lstlisting}
  482. words = read_words()
  483. word = choose_word(words)
  484. letters = set()
  485. display_hint(word, letters)
  486. while True:
  487. new_letter = input()
  488. letters.add(new_letter)
  489. display_hint(word, letters)
  490. if has_won(word, letters):
  491. print("OK")
  492. return
  493. \end{lstlisting}
  494. \end{frame}
  495. \begin{frame}[fragile]
  496. \frametitle{Une tradition}
  497. Traditionnelement, on appelle ce genre de fonction \texttt{main()}:
  498. \begin{lstlisting}
  499. def main():
  500. words = read_words()
  501. word = choose_word(words)
  502. ...
  503. main() # ne pas oublier de l'appeler!
  504. \end{lstlisting}
  505. \end{frame}
  506. \end{document}