Fini section 4, attaque la section 5

examples/mini-serveur.py

@@ -0,0 +1,31 @@
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+# HTTPRequestHandler class
+class MiniHTTPServerRequestHandler(BaseHTTPRequestHandler):
+
+  # GET
+  def do_GET(self):
+        # Send response status code
+        self.send_response(200)
+
+        # Send headers
+        self.send_header('Content-type','text/html')
+        self.end_headers()
+
+        # Send message back to client
+        message = "Hello world!"
+        # Write content as utf-8 data
+        self.wfile.write(bytes(message, "utf8"))
+        return
+
+def run():
+  print('starting server...')
+
+  # Server settings
+  # Choose port 8080, for port 80, which is normally used for a http server, you need root access
+  server_address = ('127.0.0.1', 8081)
+  httpd = HTTPServer(server_address, MiniHTTPServerRequestHandler)
+  print('running server...')
+  httpd.serve_forever()
+
+run()

react-tuto/src/markdown/4. Bases de Python/01. Premier programme.md

@@ -37,3 +37,5 @@ Quelques remarques... À propos, c'est le moment de **prendre des notes**
 > Autre chose qui doit te sembler étrange : où sont les accolades `{}` pour délimiter le corps de la boucle `while`, et ceux du `try` et du `catch` ? Disparues ! En Python, c'est **le carcactère `:` et l'indentation** qui permettent de déterminer le début et la fin d'un bloc d'instructions. Tout ce qui se trouve entre `age = ...` et `break` forme le corps du `while`. De la même façon, ici `try` et `except` ont chacun un bloc d'instructions constitué d'une seule ligne.
 
 > Il n'est pas nécessaire de mettre des points-virgule à la fin des lignes. Ils sont acceptés, mais en pratique, *personne* dans la communauté Python ne les utilise. Leur seule utilité éventuelle est de séparer des instructions sur une même ligne.
+
+> Les lignes commençant par `#` sont des commentaires.

react-tuto/src/markdown/4. Bases de Python/03. Classes et objets.md

@@ -1,29 +1,47 @@
-Crée le fichier `03-classes.md` :
+Voici un extrait du fichier `03-classes-starwars.py` :
 
 ```python
-class Vehicle:
-  speed = 0
-
-  def __init__(self, model):
-    self.model = model
-
-  def __str__(self):
-    return self.model + ' (speed: %d km/h)' % (self.speed)
-
-  def increase_spead(self, speed_increment):
-    self.speed += speed_increment
-
-car = Vehicle('Land Rover')
-car.increase_spead(80)
-print(car)
+class ForceSensitive:
+    capacites_base = ["soulever des objets"]
+    # Ceci va être une variable "statique" (de classe)
+    nb_instances = 0
+
+    def __init__(self, nom, capacites=[]):
+    	# Assignation de deux
+        self.nom = nom
+        self.capacites = self.capacites_base + capacites
+        ForceSensitive.nb_instances += 1
+
+    def __str__(self):
+        return "Je suis {nom} ({genre}) et j'ai {nb} capacités :\n  - {capacites}\n".format(
+            nom=self.nom, genre=type(self).__name__, nb=self.nb_capacites(), capacites="\n  - ".join(self.capacites)
+        )
+
+    def nb_capacites(self):
+        return len(self.capacites)
+
+class Jedi(ForceSensitive):
+    capacites_base = [
+        "soulever des objets",
+        "combattre au sabre laser",
+        "influencer les esprits"
+    ]
+
+leia = ForceSensitive("Leia", ["jouer à Mary Poppins"])
+luke = Jedi("Luke", ["lancer un sabre avec classe", "entrer en lévitation"])
 ```
 
-On utilise le même mot-clé `class` qu'en Java pour déclarer une classe. Logiquement, pas de `{}`,  mais à nouveau l'indentation pour délimiter la classe : arrivé à la ligne qui instancie un `Vehicle`, l'interpréteur sait que le corps de la classe est terminé, car on est revenu au même niveau d'indentation que celui où on l'a déclarée.
+On utilise le même mot-clé `class` qu'en Java pour déclarer une classe.
+
+Logiquement, on utilise toujours l'indentation pour délimiter le corps de la classe. : arrivé à la ligne qui instancie un `Vehicle`, l'interpréteur sait que le corps de la classe est terminé, car on est revenu au même niveau d'indentation que celui où on l'a déclarée.
 
-Plusieurs choses là encore :
+Plusieurs choses concernant les classes. Retiens surtout les points 1, 2, 4 et 5 qui seront les plus utiles et les plus fréquemment utilisés !
 
-- Les propriétés d'instance (ici `speed`) sont déclarées les premières, juste en leur attribuant une valeur initiale.
-- Le constructeur de n'importe quelle classe est la méthode `__init__()`.
-- Note que celui-ci, **ainsi que les autres méthodes d'instance**, acceptent comme premier argument `self` (équivalent de `this` en Java ou JS). Oui, on passe à chaque méthode la référence à l'instance, c'est une habitude à prendre de 
-- La méthode `__str__()` est l'équivalent de `toString()` en Java : elle renvoie une représentation en texte de l'objet.
-- Enfin, contrairement à Java ou JS, pas de mot-clé `new` pour créer une instance, mais juste le nom de la classe, avec les arguments requis par le constructeur entre parenthèses.
+1. Contrairement à Java ou JS, pas de mot-clé `new` pour créer une instance, mais juste le nom de la classe, avec les arguments requis par le constructeur entre parenthèses.
+2. Pour hériter d'une classe, on met le nom de la classe parente entre parenthèses, après le nom de la nouvelle classe (`Jedi` hérite de `ForceSensitive`).
+3. Les propriétés (ici `capacites_base` et `nb_instances`) sont déclarées les premières, juste en leur attribuant une valeur initiale. Note qu'on va utiliser `nb_instances` comme variable statique pour stocker le nombre d'instances. C'est le fait qu'on la référence via `ForceSensitive.nb_instances` qui en fait une propriété statique.
+4. Le constructeur de n'importe quelle classe est la méthode `__init__()`.
+5. Note que celui-ci, **ainsi que les autres méthodes d'instance**, acceptent comme premier argument `self` (équivalent de `this` en Java ou JS). Oui, on passe à chaque méthode la référence à l'instance, c'est une habitude à prendre de
+6. La méthode `__str__()` est l'équivalent de `toString()` en Java : elle renvoie une représentation en texte de l'objet.
+7. Dans cette dernière, on utilise une chaîne avec des emplacements nommés (`{nom}`, etc.), puis on insère les valeurs souhaitées grâce à `.format()` à laquelle on passe des *arguments nommés* (constate que les noms des arguments correspondent aux noms des emplacements).
+8. Pour récupérer le nom de la classe dont l'objet est une instance, on utilise `type(self).__name__` (tu n'es pas obligé de retenir ça !).

react-tuto/src/markdown/4. Bases de Python/04. Intro au TDD.md

@@ -0,0 +1,32 @@
+> Attention, ceci est une page de théorie pure ! Si ça te semble un peu trop pour l'instant, n'hésite pas à passer à la section suivante pour un **exemple**.
+
+##### Comment développer une application fiable et maintenable ?
+
+C'est une question importante, à laquelle le TDD apporte une réponse. TDD signifie **Test-Driven Development**, ou en français **Développement piloté par les tests**.
+
+<img src="https://media.giphy.com/media/g8XkcuerwzVS0/giphy.gif" alt="collapse" style="float: left; padding: 0 25px 25px 0;" />
+
+Les applications informatiques ont des durées de développement - et de "vie" - variées. Certaines peuvent être développées en continu sur des années !
+
+Il est donc primordial de pouvoir **maintenir et faire évoluer** le code, sans "casser" ce qui existe.
+
+Cela n'a pas toujours été simple, et de ce fait, bien des projets se sont **terminés en désastres** techniques et financiers.
+
+L'approche TDD inverse le cycle "traditionnel" de développement.
+
+Auparavant, on planifiait beaucoup :
+- Spécification fonctionnelle pour exprimer ce que devait faire l'application (du point de vue de l'utilisateur).
+- Spécification technique pour détailler les technologies qu'on prévoyait d'utiliser.
+- Etc., etc.
+
+On pouvait y passer beaucoup de temps, et pour autant, cet effort de réflexion ne permettait pas toujours d'anticiper certains "pépins" rencontrés dans la pratique.
+
+Le TDD a une portée résolument *pratique* et utilise quelques concepts simples :
+- Avant d'écrire du code pour *faire* quelque chose, on écrit *d'abord* un test qui va **vérifier que le code qu'on écrit va se comporter comme on l'a prévu**.
+- Au lieu de planifier énormément de choses en amont, on cherche d'abord à créer un **produit minimal** utilisable par des utilisateurs. A partir de cette base, on ajoute des fonctionnalités de façon *incrémentale*, par petites touches.
+
+Le fait d'**écrire les tests en premier** a une conséquence logique : quand on lance les tests juste après les avoir écrits, ils échouent ! Et c'est voulu ! Une fois qu'on a un test qui échoue, on écrit le code qui permet de faire passer le test.
+
+> Attention, "moins planifier" ne signifie pas non plus "se plonger tête baissée dans le *cooooooode*", sans réfléchir :).
+
+D'ailleurs, d'une certaine façon, les tests servent à la fois de spécification et de documentation du code. Ecrire des tests nous aide à clarifier notre intention, avant de nous attaquer au code de l'application proprement dit.

react-tuto/src/markdown/4. Bases de Python/05. Intro au TDD.md

@@ -1,19 +0,0 @@
-On a suffisamment de bases pour entrer dans le vif du sujet, et aborder le TDD, ou Test-Driven Development, ou en français Développement piloté par les tests.
-
-> C'est la seule page de théorie pure... Si ça te semble encore un peu trop, n'hésite pas à passer à la section suivante pour un **exemple**.
-
-Le TDD s'intègre dans les "méthodes agiles". Il aide à répondre à la question : **comment développer une application à la fois fiable et maintenable ?**
-
-<img src="https://media.giphy.com/media/g8XkcuerwzVS0/giphy.gif" alt="collapse" style="float: left; padding: 0 15px 15px 0;" />
-
-C'est une question sensible quand le développement s'étale sur des années ! Bien des **projets** informatiques se sont **terminés en désastres** techniques et financiers, faute de pouvoir **maintenir et faire évoluer** le code.
-
-En quoi ça consiste ? Eh bien, c'est en quelque sorte une inversion du cycle "traditionnel" de développement dans les (grosses) entreprises. Avant, on passait du temps à écrire une "spec" parfois massive, détaillant tout ce que devait faire un logiciel. Mais cet effort de réflexion ne permettait pas toujours de prévoir certains "pépins" rencontrés dans la pratique.
-
-Le TDD a une portée résolument *pratique* et utilise quelques concepts simples :
-- Avant d'écrire du code pour *faire* quelque chose, on écrit *d'abord* un test qui va **vérifier que le code qu'on écrit va se comporter comme on l'a prévu**.
-- Au lieu de planifier énormément de choses en amont, on cherche d'abord à créer un **produit minimal** utilisable par des utilisateurs. A partir de cette base, on ajoute des fonctionnalités de façon *incrémentale*, par petites touches.
-
-Le fait d'**écrire les tests en premier** a une conséquence logique : quand on lance les tests juste après les avoir écrits, ils échouent ! Et c'est voulu ! Une fois qu'on a un test qui échoue, on écrit le code qui permet de faire passer le test.
-
-D'une certaine façon, les tests servent à la fois de spécification et de documentation du code. Ecrire des tests peut nous aider à clarifier notre intention avant de se lancer tête baissée dans le code.

react-tuto/src/markdown/4. Bases de Python/06. TDD - exemple 1.md

@@ -17,6 +17,8 @@ if __name__ == '__main__':
     unittest.main()
 ```
 
+Note ici une nouveauté : l'usage de `import unittest` pour, comme son nom l'indique, pouvoir utiliser les fonctionnalités fournies par un "module" ou "package" ; que ce soit un package livré en standard avec Python (comme `unittest`) ou un package installé via `pip` (comme `selenium`).
+
 La classe `TestIsMajor` hérite de `TestCase` et de ses méthodes. Parmi celles-ci, des *assertions*, qui permettent de s'assurer qu'on obtient bien le résultat voulu.
 Les deux utilisées ici, `assertTrue()` et `assertFalse()`, veulent s'assurer que l'expression qu'elles reçoivent en paramètre est respectivement vrai ou faux.
 

react-tuto/src/markdown/4. Bases de Python/06. TDD - exercice.md

@@ -0,0 +1,16 @@
+Un deuxième exemple. Ccedil;a va être à toi de jouer !
+
+Voici l'énoncé : on veut écrire une fonction `est_bissextile(annee)` pour déterminer si une année est bissextile.
+Elle va donc prendre un paramètre entier et renvoyer un booléen.
+
+Google peut probablement te donner la solution, mais il s'agit d'apprendre les réflexes du TDD (crois-moi, plus tôt tu commences, mieux c'est) :
+
+1. Ecrire un test qui, forcément, échoue
+2. Ecrire du code pour faire passer le test
+3. Recommencer à chaque nouvelle fonctionnalité
+
+Quelques précisions et indices :
+* Pour l'instant, ne t'occupe pas des cas où on te fournit un paramètre d'entrée incorrect.
+* Inspire toi du test de la section précédente.
+* On sait que, "en gros", on a une année bissextile tous les 4 ans ! Mais il y a des *cas particuliers*, et ce sont ceux-ci qui nous intéressent. Par exemple 1900 ne l'était pas mais 2000 l'était... Intègre ces cas particuliers dans ton test !
+* Allez, je suis (trop) gentil, [Wikipédia te détaille l'algorithme](https://fr.wikipedia.org/wiki/Ann%C3%A9e_bissextile#Règle_actuelle), avec en plus des exemples.

react-tuto/src/markdown/5. Mini-serveur web/01. Mise en route.md

@@ -1,8 +1,10 @@
+Cette partie est basée sur [cet article](https://daanlenaerts.com/blog/2015/06/03/create-a-simple-http-server-with-python-3/), en anglais et qui donne peu de détails.
+
 ```python
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
 # HTTPRequestHandler class
-class testHTTPServer_RequestHandler(BaseHTTPRequestHandler):
+class MiniHTTPServerRequestHandler(BaseHTTPRequestHandler):
 
   # GET
   def do_GET(self):
@@ -25,9 +27,22 @@ def run():
   # Server settings
   # Choose port 8080, for port 80, which is normally used for a http server, you need root access
   server_address = ('127.0.0.1', 8081)
-  httpd = HTTPServer(server_address, testHTTPServer_RequestHandler)
+  httpd = HTTPServer(server_address, MiniHTTPServerRequestHandler)
   print('running server...')
   httpd.serve_forever()
 
 run()
-```
+```
+
+Python fournit un package `http` qui lui-même contient des sous-modules comme `server`. Ce dernier fournit une base, à partir de laquelle on peut écrire très rapidement un "mini-serveur" web.
+
+Deux choses essentiellement à voir ici :
+
+- La fonction `run()` qui est définie, et invoquée à la toute fin. C'est elle qui crée une "instance" du serveur (`HTTPServer`), associée à la machine locale (appelée par convention `localhost` et dont l'IP est *toujours* `127.0.0.1`).
+- La classe `MiniHTTPServerRequestHandler` qui est, comme son nom l'indique, un *handler* ou gestionnaire (ça ne vous rappelle pas jQuery et ses handlers d'évènement ?). On passe la *classe elle-même* au constructeur de `HTTPServer`, qui instanciera elle-même le handler.
+
+Petite subtilité : la classe `MiniHTTPServerRequestHandler` s'appelle handler, mais en fait ce sont réellement ses méthodes `do_GET()` et `do_POST()` (non utilisée ici) qui "gèreront" (handle) les requêtes HTTP, et renverront les réponses appropriées.
+
+On le démarre comme pour les autres programmes : `python server.py` (Windows) ou `python3 server.py` (OS X / Linux).
+
+Il écoute sur le port 8081. Ouvre donc ton navigateur à l'adresse [http://localhost:8081](http://localhost:8081) pour voir le résultat.

react-tuto/src/resources/const.js

@@ -3,8 +3,8 @@ Cette appli est une intro au **développement web en Python**, qui s'adresse à
 qui connaissent déjà d'autres langages - Java et JavaScript en l'occurence.
 
 On va aborder :
-- > Les bases *minimales* de Python
-- > Les bases du protocole HTTP
-- > Le framework web Django
+- > Des bases *minimales* de Python, qui seront suffisantes pour notre usage (ne sois pas découragé par "encore un autre langage !!").
 - > Le TDD ou "Test-Driven Développement" (fr: "Développement piloté par les tests"), une méthodologie efficace pour coder des applications **fiables** et **maintenables**.
+- > Les bases du protocole HTTP, avec un mini-serveur web en Python !
+- > Le framework web Django
 `;