Commit 269b20c39d7e34936eafe8808f7540acd8335b3b

Authored by Rémi Emonet
1 parent 18e92e77e3
Exists in master

cm8

Showing 3 changed files with 586 additions and 0 deletions

cours-08.html View file @ 269b20c
  1 +<!DOCTYPE html>
  2 +<html>
  3 + <head>
  4 + <meta charset="utf-8">
  5 + <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  6 +
  7 + <title>Programmation Impérative   autre</title>
  8 + <meta name="cours-n" content="8">
  9 +
  10 + <meta name="author" content="Rémi Emonet">
  11 + <meta name="venue" content="ProgImp L2 Chimie/SPI">
  12 + <meta name="date" content="2016">
  13 + <meta name="affiliation" content="Université Jean Monnet − Laboratoire Hubert Curien">
  14 +
  15 + <style type="text/css">
  16 + .funclist {font-size: 75% !important;}
  17 + .highlight { background: #FFA; }
  18 + .opacity0 { opacity: 0; }
  19 + </style>
  20 +
  21 + <!--
  22 + <script src="deck.js/extensions/includedeck/load.js"></script>
  23 + <script src="extensions/slides-dev.js"></script>
  24 + -->
  25 + <script src="extensions/deck-packed.js"></script>
  26 + <script src="extensions/slides.js"></script>
  27 + <script>go(function() {
  28 + $('.overview:first').addClass('no-print');
  29 + $('.overview:not(.no-print):first').addClass('no-print');
  30 + })</script>
  31 + </head>
  32 +
  33 +<body>
  34 +
  35 +<div class="deck-container">
  36 +
  37 + <div class="deck-loading-splash" style="background: black; color: chartreuse;"><span class="vcenter" style="font-size: 30px; font-family: Arial; ">Please wait, while our marmots are preparing the hot chocolate…</span></div>
  38 +
  39 +<section class="smart">
  40 +
  41 +# @chunk: chunks/title.md
  42 +
  43 +# Questions ? <br/> Commentaires ? {no-print}
  44 +
  45 +# @chunk: chunks/objectives.md
  46 +
  47 +## Programmation Impérative <span>{var-cours-n}</span> : Plan {#plan overview deck-status-fake-end}
  48 +- Écriture de tests [☀](#testu) {testu}
  49 +- Conception d'algorithmes [☀](#algo) {algo}
  50 +- Autres Éléments en Python [☀](#more) {more}
  51 +- Correction TP « pi » <a href="tp3.pdf" target="_blank">…</a>
  52 +- Chargement de données et tracé de courbes [☀](#dataanalysis) {dataanalysis}
  53 +- Plus de qtido / simulations [☀](#exqtido) {exqtido}
  54 +- Snake [☀](#snake) {snake}
  55 +- Correction Exam <a href="exam.pdf" target="_blank">…</a>
  56 +- Autre ?
  57 +
  58 +# @copy:#plan
  59 +
  60 +
  61 +
  62 +
  63 +<!-- ######################################## -->
  64 +# @copy:#plan: %+class:inred: .testu
  65 +
  66 +## Mon Programme est-il Correct ? {#testu libyli}
  67 +- Comment savoir si un programme est correct ? {libyli} // selon vous ?
  68 + - le prouver formellement // très difficile
  69 + - essayer toutes les entrées possibles // par exemple avec INPUT(),, combien y-en-a-t-il selon vous ?
  70 + - s'en convaincre <span class="slide">en essayant une partie des entrées possibles</span> // comment ?      NB: faux, simple, contre exemple
  71 +- Écriture de tests
  72 + - but : essayer des entrées automatiquement // fainéantise
  73 + - écriture d'un programme qui essaie/teste notre programme
  74 +- Instruction `assert`
  75 + - `assert «cond»`
  76 + - `assert «cond», «expr»`
  77 + - Sémantique{slide}
  78 + - assertion : proposition qu'on avance et qu'on donne comme vraie
  79 + - lève une exception (génère une erreur) si la condition est fausse
  80 + - second paramètre possible : une description de l'assertion
  81 +```python
  82 +assert 12 == 2*6 # ne fait rien
  83 +assert 12 == 2*6, "produit ok" # ne fait rien
  84 +assert 12 == 3*3, "hum..." # erreur et "AssertionError: hum..."
  85 +print("Tout Ok") # jamais exécuté de part l'erreur
  86 +{slide}
  87 +```
  88 +
  89 +## Écriture de Tests avec des Assertions {libyli}
  90 +- Exemple {dense}
  91 +```python
  92 +def distanceOrigine(x, y):
  93 + return (x*x + y*y) ** 0.5
  94 +
  95 +assert distanceOrigine(0, 0) == 0
  96 +assert distanceOrigine(1, 0) == 1
  97 +assert distanceOrigine(-1,0) == 1
  98 +assert distanceOrigine(0, 1) == 1
  99 +assert distanceOrigine(1, 1) == 2**0.5
  100 +assert distanceOrigine(3, 4) == 5
  101 +{slide dense}
  102 +```
  103 +- Challenge : remplir la fonction mystère // forme de spec return a GE min(b) and a LE max(b)
  104 +```python
  105 +def mystere(a, b):
  106 + ...
  107 +assert not mystere(0, [1, 5])
  108 +assert not mystere(0, [1, 2, 5])
  109 +assert mystere(5, [5])
  110 +assert mystere(5, [2, 5])
  111 +assert mystere(5, [2, 10])
  112 +assert mystere(5, [100, 5])
  113 +assert mystere(99, [100, 5])
  114 +assert mystere(99, [1, 100, 5, 1])
  115 +assert not mystere(4, [100, 5])
  116 +assert not mystere(101, [100, 5])
  117 +assert not mystere(101, [100, 5, 42])
  118 +{slide dense}
  119 +```
  120 +
  121 +# Quizz ! {no-print}
  122 +# @chunk: chunks/q/py-assert-1.md
  123 +# @chunk: chunks/q/py-assert-2.md
  124 +# @chunk: chunks/q/py-assert-3.md
  125 +# @chunk: chunks/q/py-assert-4.md
  126 +# @chunk: chunks/q/py-assert-5.md
  127 +
  128 +
  129 +
  130 +<!-- ######################################## -->
  131 +# @copy:#plan: %+class:inred: .algo
  132 +
  133 +## Challenges {libyli #algo}
  134 +- Écrivez une fonction `plusPetit(l)` qui
  135 + - prends une liste `l` de nombres
  136 + - retourne la plus petite valeur de la liste `l`
  137 + - n'utilise pas les fonctions `min()` ou `sort()` prédéfinies
  138 +- Écrivez une fonction `indicePlusPetit(l)` qui
  139 + - prends une liste `l` de nombres
  140 + - retourne l'indice de la plus petite valeur de la liste `l` // au choix si plusieurs
  141 + - (indice = position dans la liste)
  142 +- Et les deux ? // juste une solution pour les prints
  143 +```python
  144 +def valeurEtIndicePlusPetit(l):
  145 + meilleur = 0
  146 + for i in range(len(l)):
  147 + if l[i] < l[meilleur]:
  148 + meilleur = i
  149 + return (meilleur, l[meilleur])
  150 +{slide}
  151 +```
  152 +
  153 +## Les Algorithmes sont Partout {libyli}
  154 +- Exemples d'algorithmes ? // selon vous
  155 +- Qu'est-ce qu'un algorithme ? // selon vous
  156 + - une façon systématique de procéder pour faire quelque chose
  157 + - une description d'une suite d'action à effectuer
  158 +- Exemples {libyli}
  159 + - instructions pour se rendre à une adresse donnée (ou GPS)
  160 + - méthode pour trouver les racines d'un polynôme de degré 2
  161 + - succession d'étapes pour produire un tel médicament // soit la molécule, soit le produit fini
  162 + - procédure pour s'inscrire à l'université
  163 + - procédure pour chercher un mot dans le dictionnaire // ça se fait encore ?
  164 + - algorithme d'Euclide : recherche du pgcd de deux nombres <br/> (pgcd : plus grand commun diviseur)
  165 + - n'importe quelle recette de cuisine
  166 + - comment gagner au morpion
  167 +
  168 +## Algorithme d'Écriture d'Algorithme {libyli}
  169 +- But 1 : résoudre le problème ci dessous
  170 +- But 2 : **introspection**
  171 + - réfléchissez/étudiez ce que vous faites
  172 + - quelles étapes suivez vous pour résoudre le problème ?
  173 +- Problème : <br/>Écrivez une fonction `somme(l)` qui
  174 + - retourne la somme des valeurs de la liste `l`
  175 + - n'utilise pas la fonction `sum()` prédéfinie
  176 +
  177 +## Étapes pour l'Écriture d'un Programme {libyli}
  178 +- Objectif pour vous : le programme (ou la fonction) {first}
  179 + - le programme n'est qu'une traduction de l'algorithme
  180 + - dans un langage que l'ordinateur comprend
  181 + - &rArr; sous objectif : écrire l'algorithme
  182 + - @anim: -.first | %attr:.first:height:0 +
  183 +- Conception d'un algorithme {libyli}
  184 + - décrire la tâche (sur papier)
  185 + - entrées reçues
  186 + - sortie voulue
  187 + - lister un/des exemples (sur papier)
  188 + - valeurs d'entrées, valeur de sortie attendue
  189 + - avoir des exemples variés : du plus simple au plus compliqué
  190 + - pour chaque exemple (sur papier)
  191 + - décrire les actions successives permettant d'arriver à la sortie attendue
  192 + - actions : lecture de valeurs, affectations (écriture)
  193 + - actions : opérateurs simples
  194 + - généraliser, rendre plus générique
  195 + - utiliser des variables/symboles
  196 + - faire apparaître des répétitions (boucles) et conditions
  197 + - exécuter à la main l'algorithme pour vérifier que ça fonctionne
  198 + - écrire le programme et le valider (par des tests)
  199 +
  200 +
  201 +
  202 +## Mise en Pratique {libyli}
  203 +- Notes sur la conception d'algorithmes
  204 + - on va se tromper
  205 + - nos tests et exemples vont nous le montrer
  206 + - on va étudier les cas où ça ne fonctionne pas
  207 + - on va faire plusieurs itérations jusqu'à trouver une solution
  208 +- Exo : Soustraire 42 à tous les éléments d'une liste
  209 +- Exo : Compter les occurrences d'un élément dans une liste (ex: le nombre de "poum")
  210 +- Exo : Remplacer toutes les occurrences d'un élément donné par un autre (ex: transformer les "poum" en "tchak")
  211 +- Exo : Inverser une liste, retourner une nouvelle liste avec le résultat
  212 +- Exo : Calculer la factorielle d'un nombre ($n!$)
  213 +
  214 +
  215 +
  216 +
  217 +
  218 +<!-- ######################################## -->
  219 +# @copy:#plan: %+class:inred: .more
  220 +
  221 +## Autres Éléments en Python {#more}
  222 +- Bonnes Pratiques
  223 +- Valeurs de Paramètres par Défaut
  224 +- Paramètres Nommés
  225 +- Boucle et Court-Circuit `continue`
  226 +- Compréhension de Listes
  227 +- Dictionnaires
  228 +- Tuples, n-uplets
  229 +- Gestion d'Erreur
  230 +
  231 +## Bonnes Pratiques {libyli}
  232 +- Toujours {libyli}
  233 + - bien nommer les variables
  234 + - tester vos fonctions avec différentes entrées
  235 + - tester vos programmes avec différentes entrées
  236 + - ajouter des variables intermédiaires
  237 + - éviter les expressions trop longues
  238 + - éviter de répéter des expressions récurrentes
  239 + - lire les messages d'erreur
  240 +- Dans un programme {libyli}
  241 + - mettre les `import` au départ
  242 + - ne pas abuser de `from .... import *` (l'étoile)
  243 + - mettre les définitions de fonctions ensuite
  244 + - mettre le corps du programme à la fin
  245 +- Dans une fonction {libyli}
  246 + - bien nommer la fonction
  247 + - bien nommer les paramètres
  248 + - ne pas oublier le `return` (si besoin)
  249 + - éviter d'accéder à des variables globales
  250 +
  251 +
  252 +
  253 +## Valeurs de Paramètres par Défaut {libyli}
  254 +- But
  255 + - rendre certains paramètres optionnels
  256 + - leurs donner des valeurs par défaut
  257 +- Exemples
  258 +```python
  259 +def puissance(a, b=2):
  260 + return a**b
  261 +
  262 +# utilisation de la fonction
  263 +print( puissance(10, 2) ) # 100
  264 +print( puissance(10, 3) ) # 1000
  265 +print( puissance(10) ) # 100
  266 +{slide}
  267 +```
  268 +
  269 +```python
  270 +def somme(a, b, c=0, d=0):
  271 +  return a+b+c+d
  272
  273 +# utilisation de la fonction
  274 +print( somme(10, 2) ) # 12
  275 +print( somme(10, 2, 5) ) # 17
  276 +print( somme(10, 2, 5, 100) ) # 117
  277 +{slide}
  278 +```
  279 +- Note : on ne peut omettre que le(s) dernier(s) paramètre(s)
  280 +
  281 +## Paramètres Nommés (*culture*) {libyli}
  282 +- But
  283 + - ne fournir de valeur que pour certains paramètres
  284 + - garder les autres paramètres par défaut
  285 + - ne pas être limité aux derniers paramètres par défaut
  286 +- Exemple
  287 +```python
  288 +def puissance(a=-1, b=2):
  289 + "retourne a puissance b, avec a=-1 et b=2 par défaut"
  290 + return a**b
  291 +{slide}
  292 +```
  293 +- Comment l'appeler en ne passant que `b` ?
  294 +```python
  295 +print( puissance(b=10) ) # 1
  296 +{slide}
  297 +```
  298 +- Déjà vu avec `print`
  299 +```python
  300 +print("hello", "world", sep="!!!") # hello!!!world
  301 +{slide}
  302 +```
  303 +
  304 +
  305 +
  306 +## Boucle et Court-Circuit `continue` {libyli}
  307 +- Rappel : `break`
  308 + - interrompt une boucle
  309 +- Instruction `continue`
  310 + - passe à l'itération suivante de la boucle
  311 +- Exemple : qu'affiche le programme suivant ? {anim-continue}
  312 +```python
  313 +for i in range(100):
  314 + if i % 3 == 1:
  315 + continue
  316 + if i == 8:
  317 + break
  318 + print(i)
  319 +{slide}
  320 +```
  321 +- `0`, `2`, `3`, `5`, `6`
  322 +- et avec `i == 7` à la place de `i == 8` ?
  323 +
  324 +## Compréhension de Listes (*culture*) {libyli}
  325 +- Cas d'utilisation
  326 + - on veut parcourir une liste
  327 + - calculer une valeur pour chaque élément
  328 + - et remplir une nouvelle liste
  329 +- Version « classique » {anim-continue}
  330 +```python
  331 +premiers = [2, 3, 5, 7, 11]
  332 +carres = []
  333 +for n in premiers:
  334 + carres.append(n*n)
  335 +{slide}
  336 +```
  337 +- Compréhension de liste {anim-continue}
  338 +```python
  339 +premiers = [2, 3, 5, 7, 11, 13]
  340 +carres = [n*n for n in premiers]
  341 +{slide}
  342 +```
  343 +- Compréhension de liste avec condition {anim-continue}
  344 +```python
  345 +def premier(n):
  346 + ...
  347 +carres = [n*n for n in range(15) if premier(n)]
  348 +{slide}
  349 +```
  350 +
  351 +## Dictionnaires (*culture*) {libyli}
  352 +- Dictionnaire = conteneur associatif
  353 + - associe une valeur (de type quelconque) à une clé
  354 + - exemple:
  355 + - "lundi" -> "semaine"
  356 + - "mardi" -> "semaine"
  357 + - ...
  358 + - "dimanche" -> "week-end"
  359 +- Définition de dictionnaire {anim-continue}
  360 +```python
  361 +dico = {"lundi": "semaine", "mardi": "semaine",
  362 + "dimanche": "week-end"}
  363 +{slide}
  364 +```
  365 +- Accès à un dictionnaire {anim-continue}
  366 +```python
  367 +print(dico["mardi"])
  368 +# dico["jamais"] # <- erreur, clé non existante
  369 +{slide}
  370 +```
  371 +- Ajout à un dictionnaire {anim-continue}
  372 +```python
  373 +dico["LUNDI"] = "semaine"
  374 +{slide}
  375 +```
  376 +
  377 +
  378 +## Tuples, n-uplets (*culture*) {libyli}
  379 +- Motivation : paire, triplet, quadruplet
  380 + - grouper des valeurs ensemble
  381 + - comme une liste, mais non-mutable (constant)
  382 + - utilisable aussi avec `for`, `len()`, ...
  383 +- Notation : comme un liste mais avec des parenthèses {anim-continue}
  384 +```python
  385 +tup = ("hello", 12345, "poum")
  386 +print(tup[0]) # hello
  387 +print(tup[1]) # 12345
  388 +{slide dense}
  389 +```
  390 +- Dé-construction de tuples (et de listes) {anim-continue}
  391 +```python
  392 +a,b = ("hello", 12345)
  393 +print(a) # hello
  394 +a,b = (b,a)
  395 +print(a) # 12345
  396 +{slide dense}
  397 +```
  398 +- Pour retourner plusieurs valeurs {anim-continue}
  399 +```python
  400 +def nimp(): return ("hello", 12345)
  401 +
  402 +a,b = nimp()
  403 +{slide dense}
  404 +```
  405 +
  406 +## Gestion d'Erreur (*culture*) {libyli}
  407 +- Motivation
  408 + - ne pas s'interrompre abruptement en cas d'erreur
  409 + - gérer les erreurs « d'entrées utilisateur »
  410 +- Exemple typique
  411 + - `input()` renvoie une chaîne de caractères
  412 + - la valeur doit être convertie si on veut un nombre
  413 + - (ou, autre exemple, on attend uniquement "oui" ou "non")
  414 +```python
  415 +nb_str = input("Entrez un nombre : ") # ex: '5'
  416 +msg = input("Entrez un message : ") # ex: 'Poum Tchak'
  417 +nb = int(nb_str) # erreur si nb_str ne représente pas un entier
  418 +print(nb * msg)
  419 +{slide dense}
  420 +```
  421 +- Gestion d'erreur avec `try`/`except` {anim-continue}
  422 +```python
  423 +nb_str = input("Entrez un nombre : ")
  424 +msg = input("Entrez un message : ")
  425 +try: # essayer d'exécuter le code ci-dessous
  426 + nb = int(nb_str)
  427 +except: # s'il y a eu une erreur
  428 + print("Hum... ", nb_str, " pas entier ?")
  429 + exit()
  430 +print(nb * msg)
  431 +{slide dense}
  432 +```
  433 +
  434 +
  435 +
  436 +<!-- ######################################## -->
  437 +# @copy:#plan: %+class:inred: .dataanalysis
  438 +
  439 +## Analyse de Données {#dataanalysis libyli}
  440 +- Étapes d'analyse de données
  441 + - collecte des données
  442 + - (filtrage manuel)
  443 + - chargement des données
  444 + - traitement des données (statistiques, transformations, ...)
  445 + - affichage des données
  446 +- Bibliothèques en Python
  447 + - chargement et traitement : numpy, scipy, pandas
  448 + - affichage : matplotlib
  449 +
  450 +## Tracé de courbes {libyli}
  451 +- Matplotlib
  452 + - de nombreuses fonctions pour tracer des courbes
  453 + - <a href="http://matplotlib.org/index.html" target="_blank">accueil</a>, <a href="http://matplotlib.org/gallery.html" target="_blank">galerie</a>
  454 + - très souvent utilisé avec « numpy »
  455 +- Utilisation de `pyplot` du module `matplotlib`
  456 + - très souvent importé avec
  457 +```python
  458 +import matplotlib.pyplot as plt
  459 +# as ... permet de donner un autre nom à un import
  460 +{slide dense}
  461 +```
  462 +- Exemple
  463 +```python
  464 +import matplotlib.pyplot as plt
  465 +lesx = range(101)
  466 +lesy = []
  467 +for x in lesx:
  468 + lesy.append( x**2 - 100*x )
  469 +
  470 +plt.plot(lesx, lesy)
  471 +plt.savefig('test.pdf')
  472 +plt.show()
  473 +{slide dense second}
  474 +```
  475 +- @anim: .second>span:nth-of-type(1)
  476 +- @anim: .second>span:nth-of-type(7)
  477 +- @anim: .second>span:nth-of-type(9)
  478 +- @anim: .second>span:nth-of-type(8)
  479 +
  480 +
  481 +## Des Données au Graphe {libyli}
  482 +- Utilisation en général de
  483 + - `numpy` chargement/manipulation des données (matrices)
  484 + - `matplotlib` pour l'affichage
  485 + - `scipy`, `pandas`, `sklearn` manipulation supplémentaires
  486 +- Exemple (<a href="http://swcarpentry.github.io/python-novice-inflammation/" target="_blank">autre exemple, en anglais)</a>)
  487 +```python
  488 +import matplotlib.pyplot as plt
  489 +import numpy as np
  490 +import pandas
  491 +
  492 +# chargement dans une matrice
  493 +m = np.loadtxt('cours-08-donnees.csv', delimiter=',')
  494 +
  495 +# moyenne sur les 4 premières colonnes
  496 +prems = m[:, 0:4]
  497 +prems = prems.mean(axis=1)
  498 +
  499 +# moyenne sur les autres colonnes
  500 +lasts = m[:, 4:]
  501 +lasts = lasts.mean(axis=1)
  502 +
  503 +# affichage en nuage de points
  504 +plt.scatter(prems, lasts)
  505 +plt.show()
  506 +{slide denser}
  507 +```
  508 +
  509 +<!-- ######################################## -->
  510 +# @copy:#plan: %+class:inred: .exqtido
  511 +
  512 +## Idées qtido / simulations {#exqtido}
  513 +- Tortue, "spirales"
  514 +- Animation artistique, mouvement brownien
  515 +- Le canard et le renard
  516 +- Lunar/Moon lander
  517 +- Diffusion de la chaleur
  518 +- vos idées ?
  519 +
  520 +<!-- ######################################## -->
  521 +# @copy:#plan: %+class:inred: .snake
  522 +
  523 +## Snake {#snake image-full bottom-left darkened /black-bg /no-status}
  524 +<div class="img" style="background-image: url('media/snake.jpg')" data-attribution="https://www.flickr.com/photos/d_e_s_t_a/427375806/sizes/o/" data-attribution-content="CC by [desta] (Flickr)" data-scale=""></div>
  525 +
  526 +## Serpent/Snake {libyli}
  527 +- Fonctionnalités ? // serpent, pommes, grandir, accélérer, score
  528 +- Modèle de données / technique de la simulation ? // le score + le serpent en liste
  529 + - variables pour stocker l'état ?
  530 + - état initial ?
  531 + - réactions aux événements ?
  532 +- Implémentation ? // qtido tuto etc
  533 + - aide/rappel `«e» in «l»` teste (valeur booléenne) si «e» est dans la liste «l» (attention, ceci est très différent de `for «e» in «l»`)
  534 + - `python3 serpent.py 15 10`
  535 +
  536 +
  537 +
  538 +
  539 +
  540 +
  541 +
  542 +<!-- ######################################## -->
  543 +## Points Clés {key deck-status-fake-end}
  544 +
  545 +</section>
  546 +
  547 + <!-- deck.status snippet -->
  548 + <p class="deck-status deck-progress-10"> <span class="deck-status-current"></span> / <span class="deck-status-total"></span> − <span class="var-author">will be replaced by the author</span> − <span class="var-title">will be replaced by the title</span></p>
  549 +
  550 + <a data-progress-size=": spe.top(15, 555); height: 45*designRatio; left: slide.right - 90*designRatio; width: 90*designRatio" class="ccby" href="http://en.wikipedia.org/wiki/Creative_Commons_license" title="This work is under CC-BY licence." target="_blank"></a>
  551 +
  552 + <a class="ujm" data-progress-size=": spe.top(15, 525); height: 65*designRatio; left: slide.left; width: 130*designRatio" target="_blank"></a>
  553 +
  554 +</div>
  555 +<!-- clicky Cla -->
  556 +<script type="text/javascript">
  557 +var clicky_site_ids = clicky_site_ids || [];
  558 +clicky_site_ids.push(100779706);
  559 +(function() {
  560 + var s = document.createElement('script');
  561 + s.type = 'text/javascript';
  562 + s.async = true;
  563 + s.src = '//static.getclicky.com/js';
  564 + ( document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0] ).appendChild( s );
  565 +})();
  566 +</script>
  567 +<noscript><p><img alt="Clicky" width="1" height="1" src="//in.getclicky.com/100779706ns.gif" /></p></noscript>
  568 +
  569 +
  570 +<!-- Histats.com START (aync)-->
  571 +<script type="text/javascript">var _Hasync= _Hasync|| [];
  572 +_Hasync.push(['Histats.start', '1,2767123,4,0,0,0,00010000']);
  573 +_Hasync.push(['Histats.fasi', '1']);
  574 +_Hasync.push(['Histats.track_hits', '']);
  575 +(function() {
  576 +var hs = document.createElement('script'); hs.type = 'text/javascript'; hs.async = true;
  577 +hs.src = ('http://s10.histats.com/js15_as.js');
  578 +(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(hs);
  579 +})();</script>
  580 +<noscript><a href="http://www.histats.com" target="_blank"><img src="http://sstatic1.histats.com/0.gif?2767123&101" alt="javascript hit counter" border="0"></a></noscript>
  581 +<!-- Histats.com END -->
  582 +</body>
  583 +</html>
... ... @@ -44,6 +44,8 @@
44 44 <a href="cours-07.html">Slides 7 <br/> fonctions, suite</a>
45 45 <a href="raw/fichiers-des-cours-b.zip">archive zip : fichiers des cours 6 et 7</a>
46 46 <a href="raw/fichiers-des-cours-c.zip">archive zip : fichiers TD damier + <tt>inter.py</tt></a>
  47 + <a href="cours-08.html">Slides 8 <br/> autre</a>
  48 + <a href="raw/fichiers-des-cours-d.zip">archive zip : code cours 8 <tt>inter.py</tt></a>
47 49 <!--
48 50 <a href="cours-08.html">Slides 8 <br/> tests, algos</a>
49 51 <a href="cours-09.html">Slides 9 <br/> snake</a>
... ... @@ -55,6 +57,7 @@
55 57 <a href="export-cours-05.pdf">Slides 5 <br/> (en PDF)</a>
56 58 <a href="export-cours-06.pdf">Slides 6 <br/> (en PDF)</a>
57 59 <a href="export-cours-07.pdf">Slides 7 <br/> (en PDF)</a>
  60 + <a href="export-cours-08.pdf">Slides 8 <br/> (en PDF)</a>
58 61 <!--
59 62 -->
60 63 <!--a href="../static/export_cours_1_2_3_4.pdf">Slides 1,2,3,4 <br/> en PDF</a-->
raw/fichiers-des-cours-d.zip View file @ 269b20c

No preview for this file type