Commit 6b0314b1cd7478a8559a477f957c985b17804b0f

Authored by Rémi Emonet
1 parent b28165df1c
Exists in master

cm 7

Showing 2 changed files with 650 additions and 2 deletions

cours-07.html View file @ 6b0314b
  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   Fonctions, etc</title>
  8 + <meta name="cours-n" content="7">
  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}
  48 +- Infos {infos}
  49 +- Fonctions en Python {fonctions}
  50 +- Fonctions et Programmes {progvsfunc}
  51 +- Fonctions Comme Outils d'Abstraction {abstract}
  52 +- Technique de la Fonction Principale {principale}
  53 +- Technique de la Simulation {simulation}
  54 +- Fonctions Récursives et Pile d'Appels {pile}
  55 +
  56 +# @copy:#plan
  57 +
  58 +
  59 +<!-- ######################################## -->
  60 +# @copy:#plan: %+class:inred: .infos
  61 +
  62 +## Semaine Prochaine et TP {libyli}
  63 +- TP de rattrapage
  64 + - lundi 8h, H104
  65 + - pour ceux qui n'ont pas atteint 10 (**obligatoire**) {.highlight}
  66 + - un TP « classique » // deux enseignants
  67 +- Séance de TP suivante
  68 + - mercredi
  69 + - continuer le TP5 (chomp)
  70 + - rendu final avant le TP6
  71 +- NB: les TP suivants seront de moins en moins guidés
  72 +
  73 +## Retours sur les examens
  74 +- Notes par email
  75 +- Statistiques
  76 + - moyenne : 10.85
  77 + - écart type : 2.93
  78 + - médiane : 10.37
  79 +
  80 +
  81 +
  82 +<!-- ######################################## -->
  83 +# @copy:#plan: %+class:inred: .fonctions
  84 +
  85 +## Fonctions en Python {libyli}
  86 +- Les bibliothèques fournissent des fonctions
  87 +- Il est possible d'écrire ses propres fonctions
  88 + - éviter de se répéter, éviter le copier/coller
  89 +- Qu'est ce qu'une fonction
  90 + - un nom et une liste de noms de paramètres
  91 + - un corps (suite d'instructions)
  92 + - possiblement une valeur retournée (avec `return`)
  93 +- Définie suivant le modèle
  94 +```python
  95 +def «nom» ( «liste-param» ):
  96 + "documentation de la fonction, optionnelle"
  97 + «instr» # dans le corps de la fonction
  98 + «instr» # dans le corps de la fonction
  99 + … # dans le corps de la fonction
  100 +{slide dense}
  101 +```
  102 +- `def`, `(`, `)`, `:` et l'indentation sont **obligatoires**
  103 +- Dans «liste-param», les noms de variables séparés par des `,`
  104 +
  105 +
  106 +## Définir une fonction <span class="later">ne l'exécute pas</span> {libyli}
  107 +```python
  108 +def meteo(temperature):
  109 + if temperature > 0:
  110 + print("Il fait bon")
  111 + else:
  112 + print("Il fait froid")
  113 +```
  114 +- Qu'affiche le **programme** suivant ? <span class="later">&rArr; RIEN</span>
  115 +- @anim: .later
  116 +- Le corps de la fonction n'est exécuté que lorsqu'on l'appelle
  117 +```python
  118 +def meteo(temperature):
  119 + if temperature > 0:
  120 + print("Il fait bon")
  121 + else:
  122 + print("Il fait froid")
  123 +
  124 +meteo(4)
  125 +meteo(-10)
  126 +{slide}
  127 +```
  128 +
  129 +## Définition et appel de fonction
  130 +
  131 +<div class="c6 floatleft">
  132 +```python
  133 +def norme(x, y):
  134 + d = x**2 + y**2
  135 + return d ** 0.5
  136 +
  137 +# Appel 1
  138 +print(norme(3, 4))
  139 +
  140 +
  141 +
  142 +
  143 +
  144 +
  145 +# Appel 2
  146 +print(norme(40, 30))
  147 +
  148 +
  149 +
  150
  151 +{a}
  152 +```
  153 +</div>
  154 +
  155 +<div class="c6 floatright">
  156 +```python
  157 +# Juste se rappeler
  158 +# ... que norme existe
  159 +
  160 +
  161 +a1_x = 3
  162 +a1_y = 4
  163 +a1_d = a1_x**2 + a1_y**2
  164 +a1 = a1_d ** 0.5
  165 +
  166 +print(a1)
  167 +
  168 +
  169 +a2_x = 40
  170 +a2_y = 30
  171 +a2_d = a2_x**2 + a2_y**2
  172 +a2 = a2_d ** 0.5
  173 +
  174 +print(a2)
  175 +{b}
  176 +```
  177 +</div>
  178 +
  179 +- @anim: .a>span:nth-of-type(1), .a>span:nth-of-type(2), .a>span:nth-of-type(3)
  180 +- @anim: .b>span:nth-of-type(1), .b>span:nth-of-type(2)
  181 +- @anim: .b>span:nth-of-type(5), .b>span:nth-of-type(6) | .b>span:nth-of-type(7) | .b>span:nth-of-type(8)
  182 +- @anim: .b>span:nth-of-type(10)
  183 +- @anim: .b>span:nth-of-type(13), .b>span:nth-of-type(14), .b>span:nth-of-type(15), .b>span:nth-of-type(16)
  184 +- @anim: .b>span:nth-of-type(18)
  185 +- NB {slide}
  186 + - chaque appel de fonction a ses propres variables x et y
  187 + - chaque appel de fonction a sa propre variable d
  188 + - `return` donne la valeur par laquelle sera remplacée l’appel
  189 +
  190 +
  191 +<!-- ######################################## -->
  192 +# @copy:#plan: %+class:inred: .progvsfunc
  193 +
  194 +## Différence Entre Programme et Fonction {libyli}
  195 +- Programme {libyli}
  196 + - un fichier `.py` entier
  197 + - exécuté depuis bash, avec `python lefichier.py p1 p2 p3 …`
  198 + - des paramètres dont la valeur est tapée dans le terminal
  199 + - des paramètres accessibles avec la liste `sys.argv`
  200 + - des paramètres forcément chaînes de caractères
  201 + - interrompu par `exit()`
  202 +- Fonction {libyli}
  203 + - définie dans une partie d'un fichier `.py`
  204 + - appelée n'importe où en python, avec `la_fonction(p1,p2,p3)`
  205 + - des paramètres dont la valeur est calculée à l'appel de la fonction
  206 + - des paramètres qui sont des valeurs/objets python
  207 + - des paramètres accessibles avec leurs noms
  208 + - des paramètres de n'importe quel type
  209 + - interrompue par `return`
  210 + - une valeur de retour (ou `None`)
  211 +
  212 +
  213 +<!-- ######################################## -->
  214 +# @copy:#plan: %+class:inred: .abstract
  215 +
  216 +# Quand Définir des Fonctions ? {no-print}
  217 +
  218 +## Programme Sans Fonctions // A la fin : on veut répéter ça, on pourrait faire un for
  219 +```python
  220 +planetes = [ # x, y, masse, nom
  221 + [0, 0, 5.9736E24, "terre"],
  222 + [3.844E6, 0, 7.3477E22, "lune"] ]
  223 +G = 6.6742E-11 * 1E-6 # N km2 kg-2
  224 +ZERO = [0, 0]
  225 +{denser}
  226 +```
  227 +
  228 +```python
  229 +bob = [0, 6378.137] # km
  230 +bobm = 100 # kg
  231 +
  232 +for pl in planetes:
  233 + dx = pl[0] - bob[0]
  234 + dy = pl[1] - bob[1]
  235 + d = (dx * dx + dy * dy)**0.5
  236 + print("Bob est a", d, "km du centre de", pl[3])
  237 +
  238 +somme_forces = ZERO
  239 +for pl in planetes:
  240 + dx = pl[0] - bob[0]
  241 + dy = pl[1] - bob[1]
  242 + d = (dx * dx + dy * dy)**0.5
  243 + u = [dx / d, dy / d] # vecteur unitaire
  244 + df = [-G * bobm * pl[2] / d / d * u[0],
  245 + -G * bobm * pl[2] / d / d * u[1]]
  246 + somme_forces = [somme_forces[0] + df[0],
  247 + somme_forces[1] + df[1]]
  248 +
  249 +print("Somme des forces sur Bob :", somme_forces, "newtons")
  250 +{z}
  251 +```
  252 +- @anim: .z>span:nth-of-type(4), .z>span:nth-of-type(8)
  253 +- @anim: .z>span:nth-of-type(5), .z>span:nth-of-type(6)
  254 +- @anim: .z>span:nth-of-type(7)
  255 +- @anim: .z>span:nth-of-type(10), .z>span:nth-of-type(21)
  256 +- @anim: .z>span:nth-of-type(11), .z>span:nth-of-type(12), .z>span:nth-of-type(13)
  257 +- @anim: .z>span:nth-of-type(14)
  258 +- @anim: .z>span:nth-of-type(15)
  259 +- @anim: .z>span:nth-of-type(16), .z>span:nth-of-type(17)
  260 +- @anim: .z>span:nth-of-type(18), .z>span:nth-of-type(19)
  261 +
  262 +
  263 +## Fonctions : Répétitions Contrôlées
  264 +```python
  265 +planetes = [ # x, y, masse, nom
  266 + [0, 0, 5.9736E24, "terre"],
  267 + [3.844E6, 0, 7.3477E22, "lune"] ]
  268 +G = 6.6742E-11 * 1E-6 # N km2 kg-2
  269 +ZERO = [0, 0]
  270 +{denser}
  271 +```
  272 +
  273 +```python
  274 +def info_bob(bob, bobm):
  275 + for pl in planetes:
  276 + dx = pl[0] - bob[0]
  277 + dy = pl[1] - bob[1]
  278 + d = (dx * dx + dy * dy)**0.5
  279 + print("Bob est a", d, "km du centre de", pl[3])
  280 +
  281 + somme_forces = ZERO
  282 + for pl in planetes:
  283 + dx = pl[0] - bob[0]
  284 + dy = pl[1] - bob[1]
  285 + d = (dx * dx + dy * dy)**0.5
  286 + u = [dx / d, dy / d] # vecteur unitaire
  287 + df = [-G * bobm * pl[2] / d / d * u[0],
  288 + -G * bobm * pl[2] / d / d * u[1]]
  289 + somme_forces = [somme_forces[0] + df[0],
  290 + somme_forces[1] + df[1]]
  291 +
  292 + print("Somme des forces sur Bob :", somme_forces, "newtons")
  293 +
  294 +info_bob([0, 6378.137], 100)
  295 +info_bob([6378.137, 0], 100)
  296 +{z dense}
  297 +```
  298 +- @anim: %+class:highlight:.z>span:nth-of-type(1),.z>span:nth-of-type(21),.z>span:nth-of-type(22)
  299 +
  300 +## Fonctions : Ne Pas Se Répéter
  301 +```python
  302 +planetes = [ # x, y, masse, nom
  303 + [0, 0, 5.9736E24, "terre"],
  304 + [3.844E6, 0, 7.3477E22, "lune"] ]
  305 +G = 6.6742E-11 * 1E-6 # N km2 kg-2
  306 +ZERO = [0, 0]
  307 +{denser}
  308 +```
  309 +
  310 +```python
  311 +def dist(a, b):
  312 + dx = b[0] - a[0]
  313 + dy = b[1] - a[1]
  314 + return ( dx**2 + dy**2 )**0.5
  315 +
  316 +def info_bob(bob, bobm):
  317 + for pl in planetes:
  318 + d = dist(pl, bob)
  319 + print("Bob est a", d, "km du centre de", pl[3])
  320 +
  321 + somme_forces = ZERO
  322 + for pl in planetes:
  323 + d = dist(pl, bob)
  324 + u = [ (pl[0] - bob[0]) / d, (pl[1] - bob[1]) / d]
  325 + df = [-G * bobm * pl[2] / d / d * u[0],
  326 + -G * bobm * pl[2] / d / d * u[1]]
  327 + somme_forces = [somme_forces[0] + df[0],
  328 + somme_forces[1] + df[1]]
  329 +
  330 + print("Somme des forces sur Bob :", somme_forces, "newtons")
  331 +
  332 +info_bob([0, 6378.137], 100)
  333 +{z dense}
  334 +```
  335 +- @anim: %+class:highlight:.z>span:nth-of-type(1),.z>span:nth-of-type(8),.z>span:nth-of-type(13)
  336 +
  337 +
  338 +## Fonctions : Meilleures Abstractions
  339 +```python
  340 +planetes = [ # x, y, masse, nom
  341 + [0, 0, 5.9736E24, "terre"],
  342 + [3.844E6, 0, 7.3477E22, "lune"] ]
  343 +G = 6.6742E-11 * 1E-6 # N km2 kg-2
  344 +ZERO = [0, 0]
  345 +{denser}
  346 +```
  347 +
  348 +```python
  349 +def vec_addmul(a, m, b): # retourne a + m*b (en 2d)
  350 + return [ a[0]+m*b[0], a[1]+m*b[1] ]
  351 +
  352 +def dist(a, b):
  353 + d = vec_addmul(b, -1, a) # b - a
  354 + return ( d[0]**2 + d[1]**2 )**0.5
  355 +
  356 +def info_bob(bob, bobm):
  357 + for pl in planetes:
  358 + d = dist(pl, bob)
  359 + print("Bob est a", d, "km du centre de", pl[3])
  360 + somme_forces = ZERO
  361 + for pl in planetes:
  362 + d = dist(pl, bob)
  363 + u = vec_addmul(bob, -1, pl) # pl - bob
  364 + u = vec_addmul(ZERO, 1/d, u) # u / d
  365 + df = vec_addmul(ZERO, -G * bobm * pl[2] / d / d, u)
  366 + somme_forces = vec_addmul(somme_forces, 1, df)
  367 +
  368 + print("Somme des forces sur Bob :", somme_forces, "newtons")
  369 +
  370 +info_bob([0, 6378.137], 100)
  371 +{z dense}
  372 +```
  373 +- @anim: %+class:highlight:.z>span:nth-of-type(1),.z>span:nth-of-type(5),.z>span:nth-of-type(15),.z>span:nth-of-type(16),.z>span:nth-of-type(17),.z>span:nth-of-type(18)
  374 +
  375 +
  376 +<!- ######################################## ->
  377 +# @copy:#plan: %+class:inred: .principale
  378 +
  379 +## Portée et Visibilité des Variables {libyli}
  380 +```python
  381 +a = 1
  382 +b = 2
  383 +c = 3
  384 +def fun(b, d): # b cache le b global
  385 + print(a) # lecture seulement -> lit le a global
  386 + c = 10 # affectation -> nouvelle, qui cache le c global
  387 + print(c) # 10
  388 + e = 3.14 # variable locale
  389 +
  390 +fun(1, 1) # 1 10
  391 +print(c) # 3
  392 +{}
  393 +```
  394 +- Variable globale
  395 + - définie (affectées) dans la partie principale du programme <br/> (sans indentation, ou dans un if, for, while)
  396 + - visible de partout dans le programme
  397 +- Variable locale
  398 + - définie dans une fonction (ou en paramètre d'une fonction)
  399 + - visible uniquement dans la fonction, changée à chaque appel
  400 + - cache possiblement une variable globale du même nom
  401 +- Ne pas utiliser trop de variables globales !
  402 +
  403 +<!--
  404 +# @chunk: chunks/q/py-func-2.md
  405 +# @chunk: chunks/q/py-func-1.md
  406 +-->
  407 +
  408 +## Technique de la fonction « principale » {libyli}
  409 +- But : n'avoir aucune variable globale
  410 + - pas de risque de partager des variables sans le savoir
  411 + - moins de risque d'erreur
  412 + - programme plus sûr
  413 +- Technique {libyli}
  414 + - définir une fonction « principale »
  415 + - (dont le nom est au choix mais est souvent `principale` ou `main`)
  416 + - se limiter dans son fichier python à
  417 + - des définitions de fonctions
  418 + - un appel à la fonction « principale »
  419 +```python
  420 +def puissance(a, b):
  421 + print("notons que a vaut", a)
  422 + return a**b
  423 +
  424 +def principale():
  425 + v = puissance(2*21, 4)
  426 + v2 = puissance(v, 2)
  427 + print(v, v2)
  428 +
  429 +principale()
  430 +{slide}
  431 +```
  432 +
  433 +
  434 +<!- ######################################## ->
  435 +# @copy:#plan: %+class:inred: .simulation
  436 +
  437 +## Une « simulation » ? {libyli}
  438 +- _Imitation du comportement d'un système au cours du temps_
  439 +- Exemples {libyli}
  440 + - physique : pendule, gravité, fusée au décollage, …
  441 + - chimie : cinétique, dosage, évaporation, molécules 3d, …
  442 + - jeux : chomp, snake, tetris, angry birds, …
  443 +- Principes de bases
  444 + - le système a un état
  445 + - le temps ou les événements externes changent l'état
  446 + - on peut représenter l'état du système
  447 +- Questions à se poser
  448 + - à quels événements réagit le système ?
  449 + - que faut-il pour afficher l'état du système ?
  450 + - que faut-il pour réagir aux événements/temps ?
  451 + - &rArr; de quoi est fait l'état du système ?
  452 +
  453 +
  454 +## Technique de la simulation {libyli}
  455 +- Étape 1 : initialisation de l'état {dense}
  456 +- Étape 2 :, en boucle {dense}
  457 + - affichage de l'état
  458 + - attente et gestion d'événements (externes et temps)
  459 +```python
  460 +# Imports des modules nécessaires
  461 +...
  462 +# Définitions de fonctions utilitaires
  463 +...
  464 +
  465 +
  466 +def main(): # Technique de la fonction principale
  467 +
  468 + # initialisation de l'état du système
  469 + ...
  470 +
  471 + while not «condition-de-fin»:
  472 + # affichage de l'état du système
  473 + ...
  474 +
  475 + # attente d'un événement (ou du temps)
  476 + ...
  477 + # mise à jour de l'état du système
  478 + ...
  479 +
  480 +main() # Appel de la fonction principale
  481 +{slide dense}
  482 +```
  483 +
  484 +## Simulation : mouvement linéaire {libyli}
  485 +```python
  486 +# Imports des modules nécessaires
  487 +from qtido import *
  488 +# Définitions de fonctions utilitaires
  489 +
  490 +
  491 +
  492 +def main(): # Technique de la fonction principale
  493 + f = creer(800, 600)
  494 + # initialisation de l'état du système
  495 + pos = [400, 300]
  496 +
  497 + while not «condition-de-fin»:
  498 + while not est_fermee(f):
  499 + # affichage de l'état du système
  500 + effacer(f)
  501 + disque(f, pos[0], pos[1], 20)
  502 +
  503 + # attente d'un événement (ou du temps)
  504 + attendre_pendant(f, 10)
  505 + # mise à jour de l'état du système
  506 + pos = [ pos[0]+3, pos[1]-1 ]
  507 +
  508 +main() # Appel de la fonction principale
  509 +{slide dense z anim-continue}
  510 +```
  511 +
  512 +- @anim: %%class:opacity0:.z>span:nth-of-type(13)
  513 +- @anim: .z>span:nth-of-type(10)
  514 +- @anim: .z>span:nth-of-type(15), .z>span:nth-of-type(16)
  515 +- @anim: .z>span:nth-of-type(2) | .z>span:nth-of-type(8)
  516 +- @anim: .z>span:nth-of-type(19) | .z>span:nth-of-type(21)
  517 +- @anim: %-class:opacity0:.z>span:nth-of-type(13) + %%class:opacity0:.z>span:nth-of-type(12)
  518 +
  519 +
  520 +## Simulation : avec rebond {libyli}
  521 +- Comment gérer le rebond à droite ? {dense}
  522 +```python
  523 +# Imports des modules nécessaires
  524 +from qtido import *
  525 +# Définitions de fonctions utilitaires
  526 +
  527 +def main(): # Technique de la fonction principale
  528 + f = creer(800, 600)
  529 + # initialisation de l'état du système
  530 + pos = [400, 300]
  531 + vit = [3, 1]
  532 +
  533 + while not est_fermee(f):
  534 + # affichage de l'état du système
  535 + effacer(f)
  536 + disque(f, pos[0], pos[1], 20)
  537 +
  538 + # attente d'un événement (ou du temps)
  539 + attendre_pendant(f, 10)
  540 + # mise à jour de l'état du système
  541 + if pos[0] > 790: # on a touché à droite
  542 + # changer de direction
  543 + vit = [ -vit[0], vit[1] ]
  544 + # déplacer pos dans la bonne direction
  545 + pos = [ pos[0]+vit[0], pos[1]-vit[1] ]
  546 +
  547 +main() # Appel de la fonction principale
  548 +{slide dense z}
  549 +```
  550 +
  551 +- @anim: %+class:highlight:.z>span:nth-of-type(9),.z>span:nth-of-type(19),.z>span:nth-of-type(20),.z>span:nth-of-type(22)
  552 +- @anim: .z>span:nth-of-type(9) | .z>span:nth-of-type(23) | .z>span:nth-of-type(21)
  553 +
  554 +
  555 +## Simulation : et le chomp ? {libyli}
  556 +- État du système
  557 + - quelles cases sont mangées
  558 + - un tableau à deux dimensions (liste de liste), `1` si mangé
  559 +- Initialisation
  560 + - rien de mangé, `creer_liste_de_listes(...)`
  561 +- Affichage
  562 + - effacer la fenêtre
  563 + - tracer chaque carreau non mangé en marron
  564 +- Attente d'événements
  565 + - attente d'un click souris &rArr; manger des cases
  566 + - ignorer tout le reste
  567 +- Imports
  568 + - `qtido`, `random`, …
  569 +- Fonctions utilitaires
  570 + - `coordonnees_click`, `dessiner_carre`, …
  571 +
  572 +<!- ######################################## ->
  573 +# @copy:#plan: %+class:inred: .pile
  574 +
  575 +## Pile d'Appels de Fonctions
  576 +- Qu'affiche ce programme ? // en débat ?
  577 +```python
  578 +x=42
  579 +def mystere(x, p):
  580 + if x <= 1:
  581 + res = 1
  582 + else:
  583 + res = x * mystere(x-1, p+1)
  584 + print(p*" ", res)
  585 + return res
  586 +
  587 +x = mystere(4, 0)
  588 +print(x)
  589 +{}
  590 +```
  591 +- Pile d'appels {slide}
  592 + - chaque appel de fonction a ses propres variables
  593 + - copie des valeurs passées en argument
  594 + - stockage dans une pile en cas d'appels récursifs
  595 +
  596 +
  597 +
  598 +
  599 +
  600 +
  601 +
  602 +
  603 +
  604 +
  605 +<!-- ######################################## -->
  606 +## Points Clés {key deck-status-fake-end}
  607 +- Définition de nos propres fonctions
  608 +
  609 +
  610 +</section>
  611 +
  612 + <!-- deck.status snippet -->
  613 + <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>
  614 +
  615 + <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>
  616 +
  617 + <a class="ujm" data-progress-size=": spe.top(15, 525); height: 65*designRatio; left: slide.left; width: 130*designRatio" target="_blank"></a>
  618 +
  619 +</div>
  620 +<!-- clicky Cla -->
  621 +<script type="text/javascript">
  622 +var clicky_site_ids = clicky_site_ids || [];
  623 +clicky_site_ids.push(100779706);
  624 +(function() {
  625 + var s = document.createElement('script');
  626 + s.type = 'text/javascript';
  627 + s.async = true;
  628 + s.src = '//static.getclicky.com/js';
  629 + ( document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0] ).appendChild( s );
  630 +})();
  631 +</script>
  632 +<noscript><p><img alt="Clicky" width="1" height="1" src="//in.getclicky.com/100779706ns.gif" /></p></noscript>
  633 +
  634 +
  635 +<!-- Histats.com START (aync)-->
  636 +<script type="text/javascript">var _Hasync= _Hasync|| [];
  637 +_Hasync.push(['Histats.start', '1,2767123,4,0,0,0,00010000']);
  638 +_Hasync.push(['Histats.fasi', '1']);
  639 +_Hasync.push(['Histats.track_hits', '']);
  640 +(function() {
  641 +var hs = document.createElement('script'); hs.type = 'text/javascript'; hs.async = true;
  642 +hs.src = ('http://s10.histats.com/js15_as.js');
  643 +(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(hs);
  644 +})();</script>
  645 +<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>
  646 +<!-- Histats.com END -->
  647 +</body>
  648 +</html>
... ... @@ -41,8 +41,8 @@
41 41 <a href="cours-05.html">Slides 5 <br/> boucles,bibliothèques</a>
42 42 <a href="raw/fichiers-des-cours-a.zip">archive zip : fichiers des cours jusque 5</a>
43 43 <a href="cours-06.html">Slides 6 <br/> fonctions</a>
44   - <!--
45 44 <a href="cours-07.html">Slides 7 <br/> fonctions, suite</a>
  45 + <!--
46 46 <a href="cours-08.html">Slides 8 <br/> tests, algos</a>
47 47 <a href="cours-09.html">Slides 9 <br/> snake</a>
48 48 -->
49 49  
... ... @@ -52,8 +52,8 @@
52 52 <a href="export-cours-04.pdf">Slides 4 <br/> (en PDF)</a>
53 53 <a href="export-cours-05.pdf">Slides 5 <br/> (en PDF)</a>
54 54 <a href="export-cours-06.pdf">Slides 6 <br/> (en PDF)</a>
55   - <!--
56 55 <a href="export-cours-07.pdf">Slides 7 <br/> (en PDF)</a>
  56 + <!--
57 57 -->
58 58 <!--a href="../static/export_cours_1_2_3_4.pdf">Slides 1,2,3,4 <br/> en PDF</a-->
59 59 </div>