diff --git a/cours/TODO b/cours/TODO
index 7ccfccb..497bd9c 100644
--- a/cours/TODO
+++ b/cours/TODO
@@ -1,2 +1,5 @@
 explication des exercices
 insérer exercices pour chaque épisode de la saison 2
+
+
+Explications sur `globals()` et `locals()`
diff --git a/cours/source/02-premiers-pas/04-maths-simples.rst b/cours/source/02-premiers-pas/04-maths-simples.rst
index e1c57a8..1ffadc5 100644
--- a/cours/source/02-premiers-pas/04-maths-simples.rst
+++ b/cours/source/02-premiers-pas/04-maths-simples.rst
@@ -74,3 +74,18 @@ et on peut utiliser des parenthèses pour grouper les opérations::
 
     print((1 + 2) * 3)
     # affiche: 9
+
+Combiner opération et assignation
+----------------------------------
+
+La notation ``+=`` permet de combiner addition et assignation::
+
+   x = 3
+   x = x + 1
+   print(x)
+   # affiche :: 4
+
+   x = 3
+   x += 1
+   print(x)
+   # affiche :: 4
diff --git a/cours/source/04-booléens/index.rst b/cours/source/04-booléens/index.rst
new file mode 100644
index 0000000..b38c5fe
--- /dev/null
+++ b/cours/source/04-booléens/index.rst
@@ -0,0 +1,72 @@
+Chapitre 4 - Booléens et conditions
+===================================
+
+En Python, les variables ``True`` et ``False`` sont toujours définies
+et servent à représenter une valeur vraie ou fausse.
+
+(Notez qu'elles commencent par une majuscule)
+
+Assignation
+-----------
+
+On peut assigner des variables à True ou False::
+
+
+    la_terre_est_plate = False
+    python_c_est_genial = True
+
+
+Comparaisons
+------------
+
+Certaines opérations renvoient des booléens:
+
++------+-----------------------------+
+|``=`` | égal                        |
++------+-----------------------------+
+|``!=``| différent                   |
++------+-----------------------------+
+|``>`` | strictement supérieur       |
++------+-----------------------------+
+|``>=``| supérieur ou égal           |
++------+-----------------------------+
+|``<`` | strictement inférieur       |
++------+-----------------------------+
+|``<=``| inférieur                   |
++------+-----------------------------+
+
+Par example::
+
+   a = 2
+   b = 3
+   print(a > b)
+   # affiche: False
+
+   print(2 + 2 == 4)
+   # affiche: True
+
+.. warning::
+
+    Ne pas confondre: ``==`` pour la comparaison et ``=`` pour l'assignation
+
+
+Enfin, on peut écrire des encadrements::
+
+    a = 3
+    print(2 <= a < 4)
+    # affiche: True
+
+
+not
+---
+
+Enfin, on peut utiliser ``not`` pour inverser une condition::
+
+    a = 3
+    if not a == 4:
+        print("a est différent de 4")
+    # affiche: a est différent de 4
+
+    la_terre_est_plate = False
+    print(not la_terre_est_plate)
+    # affiche: True
diff --git a/cours/source/04-code-source/index.rst b/cours/source/04-code-source/index.rst
deleted file mode 100644
index 0c4f642..0000000
--- a/cours/source/04-code-source/index.rst
+++ /dev/null
@@ -1,98 +0,0 @@
-Chapitre 4 - code source
-========================
-
-Non persistance des variables
-------------------------------
-
-.. code-block:: console
-
-    $ python3
-    >>> a = 2
-    >>> quit()
-    ```
-
-.. code-block:: console
-
-   $ python3
-   >>> a
-   Traceback (most recent call last):
-     File "<stdin>", line 1, in <module>
-   NameError: name 'a' is not defined
-
-
-Du code dans un fichier
------------------------
-
-Aussi appelé: "code source", ou "source".
-
-L'essence du logiciel libre :)
-
-
-
-Installation d'un éditeur de texte simple
-------------------------------------------
-
-* Linux; ``gedit``, ``kate``, ...
-* macOS: ``CotEditor``
-* Windows: ``Notepad++``
-
-J'insiste sur **simple**. Inutile d'installer un IDE pour le moment.
-
-
-Configuration
--------------
-
-* Police de caractères à chasse fixe
-* Indentation de *4 espaces*
-* Remplacer tabulation par des espaces
-* Activer la coloration syntaxique
-
-
-
-Notre premier fichier source
------------------------------
-
-
-Insérez le code suivant dans votre éditeur de texte
-
-.. code-block:: python
-
-   # Affiche un message
-   print("Bonjour, monde")
-
-
-Sauvegardez dans un fichier `bonjour.py` dans `Documents/e2l/python` par exemple
-
-
-Lancer du code en ligne de commande
------------------------------------
-
-
-.. code-block:: console
-
-   cd Documents/e2l/python/
-   python3 bonjour.py
-   Bonjour, monde
-
-* Les lignes commençant par dièse (``#``) ont été ignorées - ce sont des *commentaires*.
-* ``print()`` affiche la valeur, comme dans le REPL.
-
-
-Note importante
----------------
-
-Vous avez juste besoin:
-
-* d'un éditeur de texte
-* de Python3 installé
-* d'une ligne de commande
-
-Pas la peine d'installer quoique ce soit de plus pour le moment
-
-
-1. *Recopiez* le code affiché dans votre éditeur, à la suite du code
-   déjà écrit
-2. Lancez le code depuis la ligne de commande
-3. Réparez les erreurs éventuelles
-4. Recommencez
-
diff --git a/cours/source/05-flot-de-controle/01-flot-de-contrôle.rst b/cours/source/05-flot-de-controle/01-flot-de-contrôle.rst
index 2be92d0..20bddb8 100644
--- a/cours/source/05-flot-de-controle/01-flot-de-contrôle.rst
+++ b/cours/source/05-flot-de-controle/01-flot-de-contrôle.rst
@@ -1,25 +1,36 @@
 Flot de contrôle
 ================
 
-L'essence de la programmation!
+Pour l'instant, toutes les instructions que nous avons
+écrites ont été exécutée une par une et dans l'ordre
+d'apparition dans le code source.
+
+Modifier l'ordre d'exécution de ces lignes s'appelle modifier le flot de
+contrôle, et c'est  l'essence de la programmation!
 
 
 if
---
+++
 
-.. code-block:: python
+On peut utiliser le mot ``if`` pour autoriser ou empécher
+l'éxcution du code en-dessous::
 
    a = 3
    b = 4
    if a == b:
        print("a et b sont égaux")
    print("on continue")
+   # affiche juste
+   # on continue
 
+La 4ème ligne n'est pas éxécutée parce la condition
+est fausse.
 
 Notes:
 
-* deux points à la fin de la ligne
-* indentation après les deux points
+* il y a le caractère ``:`` (deux points) à la fin de la ligne
+* le code en-dessous du ``if`` commence par 4 espaces: on appelle
+  cela une *indentation*
 * si la condition n'est pas vraie, rien ne se passe
 
 Notez qu'on peut mettre uniquement une variable ou une valeur
@@ -27,14 +38,25 @@ après le if. Ceci ne fonctionne pas::
 
     if a = 3:
     	print("a égale 3")
+    # affiche: SyntaxError
+
+On parle aussi de "bloc" si plusieurs lignes sont identées::
 
-et fait une erreur de syntaxe
+   a = 3
+   b = 4
+   if a == b:
+       # début du bloc
+       print("a et b sont égaux")
+       c = 2 * a
+       # fin du block
+   print("on continue")
 
 
 if / else
 ---------
 
-.. code-block::
+On peut utiliser le mot ``else`` après un condition en ``if``
+pour éxécutér un bloc si la condition est fausse::
 
    a = 3
    b = 4
@@ -42,52 +64,58 @@ if / else
        print("a et b sont égaux")
    else:
        print("a et b sont différent")
+   # affiche: a et b sont différents
 
 
 if / elif
 ---------
 
-.. code-block::
+On peut utiliser ``if``, ``elif`` et ``else`` pour enchaîner plusieurs
+conditions::
 
+    age = 23
     if age < 10:
-    	print("inférieur à dix")
+    	print("âge inférieur à dix")
     elif 10 <= age < 20:
     	print("âge entre 10 et 20")
     elif 20 <= age < 40:
     	print("âge entre 20 et 40")
     else:
     	print("âge supérieur à 40")
-
-On peut mettre autont de `elif` qu'on veut!
-Le derier `else` s'éxécute en dernier
+    # affiche: âge entre 20 et 40
 
 
 while
 -----
 
-Répéter tant qu'une condition est vraie::
+On peut utiliser ``while`` pour répéter un bloc tant qu'une condition
+est vraie::
 
     i = 0
     while i < 3:
         print(i)
         i = i + 1
 
-.. code-block:: console
+.. code-block:: text
 
    0
    1
    2
 
+Notez que la variable ``i`` passe par plusieurs valeurs différentes.
 
-Notre première boucle infinie
------------------------------
+Boucle infinie
+--------------
 
-.. code-block::
+On parle de *boucle infinie* si la condition ne devient jamais fausse::
 
     while True:
     	print("spam!")
 
-CTRL-C pour interrompre
+Dans ce cas, il faut appuyer sur ``CTRL-C`` pour interrompre
+le programme.
+
+Notez ici qu'on a mis directement la valeur ``True``, et non une comparaison.
 
 
 Combiner while et if
diff --git a/cours/source/06-fonctions/01-functions.rst b/cours/source/06-fonctions/01-functions.rst
index ccfc890..911fc87 100644
--- a/cours/source/06-fonctions/01-functions.rst
+++ b/cours/source/06-fonctions/01-functions.rst
@@ -11,15 +11,23 @@ Définition::
 
 
 * avec `def`
-* avec un `:` à la fin et un *bloc indenté* (appelé le "corps")
+* avec un `:` à la fin et un *bloc indenté* (appelé *le corps de la fonction*).
 
 Appel::
 
-    >>> dire_bonjour()
-    Bonjour
+    dire_bonjour()
 
 * avec le nom de la fonction et des parenthèses
 
+Example complet::
+
+    def dire_bonjour():
+        print("Bonjour")
+
+    bonjour()
+    # Affiche: bonjour'
+
+
 Le pouvoir des fonctions
 ------------------------
 
@@ -35,6 +43,7 @@ programmation.
 
 
 Fonction avec un argument
+--------------------------
 
 Définition: avec l'argument à l'intérieur des parenthèses::
 
@@ -43,17 +52,10 @@ Définition: avec l'argument à l'intérieur des parenthèses::
 
 Appel: en passant une variable ou une valeur dans les parenthèses::
 
-    >>> dire_bonjour("Germaine")
-    Bonjour Germaine
-
-     >>> prénom_de_charlotte = "Charlotte"
-     >>> dire_bonjour(prénom_de_charlotte)
-     Bonjour Charlotte
-
-Exécution d'une fonction
-------------------------
+    dire_bonjour("Germaine")
 
-C'est exatement comme si on assignait les arguments de la fonction avant d'éxécuter le code
+L'éxécution de l'appel à une foctionne exactement  comme si on assignait
+les arguments de la fonction avant d'éxécuter le code
 dans le corps::
 
     # Ceci:
@@ -65,3 +67,16 @@ dans le corps::
 
     # Lui-même équivalent à:
     print("Bonjour " + "Dimitri")
+
+Example complet::
+
+
+    def dire_bonjour(prénom):
+    	print("Bonjour " + prénom)
+    dire_bonjour("Germaine")
+    # affiche: Bonjour Germaine
+
+    prénom_de_charlotte = "Charlotte"
+    dire_bonjour(prénom_de_charlotte)
+    # affiche: Bonjour Charlotte
+
diff --git a/cours/source/06-fonctions/02-portée-des-variables.rst b/cours/source/06-fonctions/02-portée-des-variables.rst
index 4e53c27..4dc09a0 100644
--- a/cours/source/06-fonctions/02-portée-des-variables.rst
+++ b/cours/source/06-fonctions/02-portée-des-variables.rst
@@ -22,8 +22,8 @@ Les variables en dehors des fonctions sont disponibles partout::
 Une variable peut avoir en "cacher" une autre si elle a une portée différente::
 
     def dire_bonjour(prénom):
-    	print("Bonjour " + prénom)   # portée: uniquement dans
-    								 # le corps dire_bonjour
+        print("Bonjour " + prénom)   # portée: uniquement dans
+                                     # le corps dire_bonjour
 
-    prénom = "Dimitri"  # portée: dans tout le programme
+    prénom = "Dimitri"   # portée: dans tout le programme
     dire_bonjour(prénom) # Ok
diff --git a/cours/source/06-fonctions/04-par-défaut.rst b/cours/source/06-fonctions/04-par-défaut.rst
index 77b5ee6..2de3e95 100644
--- a/cours/source/06-fonctions/04-par-défaut.rst
+++ b/cours/source/06-fonctions/04-par-défaut.rst
@@ -11,9 +11,11 @@ On peut aussi mettre des valeurs par défaut::
 
 Appel::
 
-    >>> dire_bonjour("Thomas", enthousiaste=True)
-    Bonjour Thomas!
-    >>> dire_bonjour("Thomas", enthousiaste=False)
-    Bonjour Thomas
-    >>> dire_bonjour("Thomas")
-    Bonjour Thomas
+    dire_bonjour("Thomas", enthousiaste=True)
+    # affiche: Bonjour Thomas!
+
+    dire_bonjour("Thomas", enthousiaste=False)
+    # affiche: Bonjour Thomas
+
+    dire_bonjour("Thomas")
+    # affiche: Bonjour Thomas
diff --git a/cours/source/06-fonctions/05-fonctions-natives.rst b/cours/source/06-fonctions/05-fonctions-natives.rst
index 536a243..9e59e1a 100644
--- a/cours/source/06-fonctions/05-fonctions-natives.rst
+++ b/cours/source/06-fonctions/05-fonctions-natives.rst
@@ -18,19 +18,31 @@ On peut passer autant d'arguments qu'on veut à ``print`` et:
 * Il les sépare par des espaces
 * Ajoute un retour à la ligne à la fin::
 
-    >>> prénom = "Charlotte"
+    prénom = "Charlotte"
     print("Bonjour", pŕenom)
+    print("Ça va ?")
+
+.. code-block:: text
+
     Bonjour Charlotte
+    Ça va ?
+
 
 On peut demander à `print` de changer son séparateur::
 
-    >>> a = "chauve"
-    >>> b = "souris"
-    >>> print(a, b, sep="-")
+    a = "chauve"
+    b = "souris"
+    print(a, b, sep="-")
+
+.. code-block:: text
+
     chauve-souris
 
 Ou de changer le caractère de fin::
 
-    >>> print("Ceci tient", end="")
-    >>> print("sur une seule ligne")
-    Ceci tient sur une seule ligne
+    print("Ceci tient", end="")
+    print("sur une seule ligne")
+
+.. code-block:: text
+
+   Ceci tient sur une seule ligne
diff --git a/cours/source/06-fonctions/06-return.rst b/cours/source/06-fonctions/06-return.rst
index 682008f..e0f691b 100644
--- a/cours/source/06-fonctions/06-return.rst
+++ b/cours/source/06-fonctions/06-return.rst
@@ -26,9 +26,17 @@ corps de la fonction::
     		return
     	print("Heureux de faire votre connaissance")
 
-    >>> dire_bonjour("Dimitri", première_fois=True)
+    dire_bonjour("Dimitri", première_fois=True)
+
+.. code-block:: text
+
     Bonjour Dimitri
     Heureux de faire votre connaissance
 
-    >>> dire_bonjour("Dimitri", première_fois=False)
+.. code-block:: python
+
+    dire_bonjour("Dimitri", première_fois=False)
+
+.. code-block:: text
+
     Bonjour Dimitri
diff --git a/cours/source/07-listes/index.rst b/cours/source/07-listes/index.rst
index 98aa53a..d5338da 100644
--- a/cours/source/07-listes/index.rst
+++ b/cours/source/07-listes/index.rst
@@ -33,41 +33,48 @@ Connaître la taille d'une liste
 
 Avec ``len()`` - encore une fonction native::
 
-    >>> liste_vide = []
-    >>> len(liste_vide)
-    0
-    >>> trois_entiers = [1, 2, 3]
-    >>> len(trois_entiers)
-    3
+    liste_vide = []
+    taille = len(liste_vide)
+    print(taille)
+    # affiche:  0
+
+    trois_entiers = [1, 2, 3]
+    taille = len(trois_entiers)
+    print(taille)
+    # affiche:  3
 
 Concaténation de listes
 -----------------------
 
 Avec ``+``::
 
-    >>> prénoms = ["Alice", "Bob"]
-    >>> prénoms += ["Charlie", "Eve"]
-    >>> prénoms
-    ['Alice', 'Bob', "Charlie", 'Eve']
+    prénoms = ["Alice", "Bob"]
+    prénoms += ["Charlie", "Eve"]
+    print(prénoms)
+    # affiche: ['Alice', 'Bob', "Charlie", 'Eve']
 
 On ne peut concaténer des listes que avec d'autres listes::
 
-    >>> scores = [1, 2, 3]
-    >>> scores += 4  # TypeError
-    >>> scores += [4]  # OK
+    scores = [1, 2, 3]
+    scores += 4
+    # erreur
+
+    scores += [4]
+    print(scores)
+    # affiche: [1,2,3,4]
 
 Test d'appartenance
 -------------------
 
 Avec ``in``::
 
-    >>> prénoms = ["Alice", "Bob"]
-    >>> "Alice" in prénoms
-    True
+    prénoms = ["Alice", "Bob"]
+    print("Alice" in prénoms)
+    # affiche: True
 
-    >>> prénoms = ["Alice", "Bob"]
-    >>> "Charlie" in prénoms
-    False
+    prénoms = ["Alice", "Bob"]
+    print("Charlie" in prénoms)
+    # affiche: False
 
 Itérer sur les élements d'une liste
 ------------------------------------
@@ -80,35 +87,43 @@ Avec ``for ... in``::
    	# élément de la liste
        print("Bonjour", prénom)
 
+.. code-block:: text
+
    Bonjour Alice
    Bonjour Bob
    Bonjour Charlie
 
-## Indéxer une liste
+Indéxer une liste
+------------------
 
-* Avec `[]` et un entier
+* Avec ``[]`` et un entier
 
-* Les index valides vont de 0 à `n-1` où `n` est la
+* Les index valides vont de 0 à ``n-1`` où ``n`` est la
   taille de la liste::
 
-    >>> fruits = ["pomme", "orange", "poire"]
-    >>> fruits[0]
-    "pomme"
-    >>> fruits[1]
-    "orange"
-    >>> list[2]
-    "poire"
-    >>> fruits[3] # IndexError
+    fruits = ["pomme", "orange", "poire"]
+
+    print(fruits[0])
+    # affiche: "pomme"
+
+    print(fruits[1])
+    # affiche: "orange"
+
+    print(list[2])
+    # affiche: "poire"
+
+    fruits[3]
+    # erreur: IndexError
 
 Modifier une liste
 -------------------
 
 Encore une assignation::
 
-    >>> fruits = ["pomme", "orange", "poire"]
-    >>> fruits[0] = "abricot"
-    >>> fruits
-    ["abricot", "orange", "poire"]
+    fruits = ["pomme", "orange", "poire"]
+    fruits[0] = "abricot"
+    print(fruits)
+    # affiche: ["abricot", "orange", "poire"]
 
 Les strings sont aussi des listes (presque)
 --------------------------------------------
@@ -128,17 +143,45 @@ On peut itérer sur les caractères d'une string::
 
 On peut tester si un caractère est présent::
 
-    >>> "e" in "vache"
-    True
-    >>> "x" in "vache"
-    False
+    print("e" in "vache")
+    # affiche: True
+
+    print(x" in "vache")
+    # affiche: False
 
 
 Mais on neut peut pas modifier une string::
 
-   >>> prénom = "Charlotte"
-   >>> prénom[0]
-   "C"
-   >>> prénom[3]
-   "r"
-   >>> prénom[0] = "X" # TypeError
+   prénom = "Charlotte"
+   l = prénom[0]
+   print(l)
+   # affiche: "C"
+
+   l = prénom[3]
+   print(l)
+   # affiche: "r"
+
+   prénom[0] = "X"
+   # erreur: TypeError
+
+
+Falsy et truthy
+----------------
+
+
+En réalité on peut mettre autre chose qu'une comparaison ou une variable booléenne après le if.
+
+Si on met une liste vide, ``if`` se comportera comme si on avait mis une valeur fausse, et si
+la liste n'est pas vide , ``if`` se comportera comme si on avait mis une valeur vraie.::
+
+    ma_liste = [1, 2, 3]
+    if ma_liste:
+        print("ma_liste n'est pas vide")
+    # affiche: ma_liste n'est pas vide
+
+    mon_autre_liste = []
+    if not mon_autre_liste:
+        print("mon_autre_liste est vide")
+    # affiche: mon_autre_liste est vide
+
+On dit que les listes vides sont *Falsy* et les listes non-vides *Truthy*
diff --git a/cours/source/08-none-et-pass/01-none.rst b/cours/source/08-none-et-pass/01-none.rst
index db96ae2..ccdc4bc 100644
--- a/cours/source/08-none-et-pass/01-none.rst
+++ b/cours/source/08-none-et-pass/01-none.rst
@@ -8,17 +8,6 @@ Définition
 
 Un peu comme ``True`` et ``False`` qui sont deux valeurs qui servent à représenter tous les booléens.
 
-Représenter l'absence
-----------------------
-
-L'interpréteur intéractif n'affiche rien quand la valeur est None::
-
-    >>> a = 42
-    >>> a
-    42
-    >>> b = None
-    >>> b
-
 Retourner None
 ----------------
 
@@ -26,11 +15,12 @@ En réalité, *toutes* les fonctions pythons retournent *quelque chose*, même q
 elle ne contiennent pas le mot-clé ``return``.::
 
    def ne_renvoie_rien():
-       print("je ne fais qu'afficher quelque chose")
+       x = 2
 
-   >>> resultat = ne_renvoie_rien()
-   "je ne fais qu'afficher quelque chose"
-   >>> resultat
+   resultat = ne_renvoie_rien()
+
+   print(resultat)
+   # affiche: None
 
 Opérations avec None
 ---------------------
@@ -38,17 +28,26 @@ Opérations avec None
 La plupart des fonctions que nous avons vues échouent si on leur passe ``None``
 en argument::
 
-    >>> len(None)
-    TypeError: object of type 'NoneType' has no len()
-    >>> None < 3
-    TypeError: '<' not supported between instances of
-      'NoneType' and 'int'
-    >>> int(None)
-    TypeError: int() argument must be a string,
-      a bytes-like object or a number,
-      not 'NoneType'
-    >>> str(None)
-    'None'
+    x = len(None)
+    # erreur: TypeError
+
+    x = None < 3
+    # erreur: TypeError
+
+    x = int(None)
+    # erreur: TypeError
+
+Mais ``str`` fonctionne::
+
+    x = str(None)
+    print(x)
+    # affiche: 'None'
+
+On peut vérifier si une variable vaut ``None`` avec ``is None``::
+
+    x = ne_renvoie_rien()
+    print(x is None)
+    # affiche: True
 
 Example d'utilisation
 ----------------------
@@ -61,20 +60,10 @@ Example d'utilisation
                 return element
         return None
 
-    >>> trouve_dans_liste(2, [1, 2, 3])
-    2
-    >>> trouve_dans_liste(False, [True, False])
-    False
-    >>> trouve_dans_liste(1, [3, 4])
-
-
-None est Falsy, et on peut vérifier si une variable vaut ``None`` avec ``is None``::
+    x = trouve_dans_liste(2, [1, 2, 3])
+    print(x)
+    # affiche: 2
 
-    # hypothèse: `ma_valeur` n'est pas None
-    mon_element = trouve_dans_liste(ma_valeur, ma_liste)
-    if mon_element is None:
-        print("élément absent de la liste")
-    if not mon_element:
-        # Peut-être que l'élément n'était pas dans la liste,
-        # ou peut-être y était-il, mais avec une valeur falsy
-        ...
+    x = trouve_dans_liste(1, [3, 4])
+    print(x)
+    # affiche: None
diff --git a/cours/source/09-dictionnaires/index.rst b/cours/source/09-dictionnaires/index.rst
index a256d1f..77d7e7a 100644
--- a/cours/source/09-dictionnaires/index.rst
+++ b/cours/source/09-dictionnaires/index.rst
@@ -31,49 +31,57 @@ Accès aux valeurs
 
 Avec ``[]``, comme pour les listes, mais avec une *clé* à la place d'un *index*::
 
-    >>> scores = {"john": 10, "bob": 42}
-    >>> scores["john"]
-    10
-    >>> scores["bob"]
-    42
-    >>> scores["charlie"]
-    KeyError
+    scores = {"john": 10, "bob": 42}
+
+    print(scores["john"])
+    # affiche: 10
+
+    print(scores["bob"])
+    # affiche: 42
+
+    print(scores["charlie"])
+    # erreur: KeyError
 
 Test d'appartenance
 ---------------------
 
 Avec ``in``, comme le listes::
 
-    >>> scores = {"john": 10, "bob": 42}
-    >>> "charlie" in scores
-    False
+    scores = {"john": 10, "bob": 42}
+    print("charlie" in scores)
+    # affiche: False
 
 Modifier la valeur d'une clé
 -----------------------------
 
 Comme pour les listes, avec une assignation::
 
-    >>> scores = {"john": 10, "bob": 42}
-    >>> scores["john"] = 20
-    >>> scores
-    {"john": 20, "bob": 42}
+    scores = {"john": 10, "bob": 42}
+    scores["john"] = 20
+    print(scores)
+    # affiche: {"john": 20, "bob": 42}
 
 Créer une nouvelle clé
 -----------------------
 
-Même méchanisme que pour la modification des clés existantes::
+Même mécanisme que pour la modification des clés existantes::
+
+    scores = {"john": 10, "bob": 42}
+    scores["charlie"] = 30
+    print(scores)
+    # affiche: {"john": 20, "bob": 42, "charlie": 30}
 
-    >>> scores = {"john": 10, "bob": 42}
-    >>> scores["charlie"] = 30
-    >>> scores
-    {"john": 20, "bob": 42, "charlie": 30}
+*rappel*: ceci ne fonctionne pas avec les listes: on ne peut
+pas "créer" de nouveaux éléments dans la liste juste
+avec un index::
 
-*rappel*: ceci ne fonctionne pas avec les listes!::
-    >>> ma_liste = ["a", "b"]
-    >>> ma_liste[1] = "c" # ok
-    ["a", "c"]
-    >>> ma_liste[3] = "d"
-    IndexError
+    ma_liste = ["a", "b"]
+    ma_liste[1] = "c"
+    print(ma_liste)
+    # affiche: ["a", "c"]
+
+    ma_liste[3] = "d"
+    # erreur: IndexError
 
 Itérer sur les clés
 -------------------
@@ -84,8 +92,14 @@ Avec ``for ... in ...``, comme pour les listes::
     for nom in scores:
     	# `nom` est assigné à "john" puis "bob"
     	score_associé_au_nom = scores[nom]
+        # score_associé_au_nom est assigné à '10' puis '42'
     	print(nom, score_associé_au_nom)
 
+.. code-block::
+
+    john 10
+    bob 42
+
 del
 ---
 
@@ -94,83 +108,31 @@ Détruire une clé
 
 Avec ``del`` - un nouveau mot-clé::
 
-    >>> scores = {"john": 10, "bob": 42}
-    >>> del scores["bob"]
-    >>> scores
-    {"john": 10}
+    scores = {"john": 10, "bob": 42}
+    del scores["bob"]
+    print(scores)
+    # affiche: {"john": 10}
 
 Détruire un élément d'une liste
 ++++++++++++++++++++++++++++++++
 
 Aussi avec ``del``::
 
-    >>> fruits = ["pomme", "banane", "poire"]
-    >>> del fruits[1]
-    >>> fruits
-    ["pomme", "poire"]
+    fruits = ["pomme", "banane", "poire"]
+    del fruits[1]
+    print(fruits)
+    # affiche: ["pomme", "poire"]
 
 Détruire une variable
 +++++++++++++++++++++
 
 Encore et toujours ``del``::
 
-    >>> mon_entier = 42
-    >>> mon_entier += 3
-    >>> mon_entier
-    45
-    >>> del mon_entier
-    >>> mon_entier == 45
-    NameError: name 'mon_entier' is not defined
-
-Des dictionnaires partout
----------------------------
-
-Les variables globales d'un programme Python sont dans un dictionnaire,
-accessible avec la fonction native `globals()`::
-
-   $ python3
-   >>> globals()
-   {
-       ...
-       '__doc__': None,
-       '__name__': '__main__',
-       ...
-   }
-
-On reparlera de `__doc__` et `__name__` un autre jour ...::
-
-
-    $ python3
-    >>> a = 42
-    >>> globals()
-    {
-     ...
-     '__doc__': None,
-     '__name__': '__main__',
-     ...
-     'a': 42
-    }
-    ```
-
-.. code-block::
-
-    python
-    $ python3
-    >>> a = 42
-    >>> del globals()["a"]
-    >>> a
-    NameError: name 'a' is not defined
-
-
-On peut accéder aux variables locales d'une fonction avec ``locals()``::
-
-    def ma_fonction():
-        a =  42
-        b = 3
-        c = a + b
-        print(locals())
-
-    >>> ma_fonction()
-    {'a': 42, 'b': 3, 'c': 45}
+    mon_entier = 42
+    mon_entier += 3
+    print(mon_entier)
+    # affiche: 45
 
-En revanche, il n'est pas conseillé de modifier le dictionaire renvoyé par ``locals()`` ...
+    del mon_entier
+    mon_entier += 1
+    # erreur: NameError
diff --git a/cours/source/10-tuples/index.rst b/cours/source/10-tuples/index.rst
index c666360..b68577d 100644
--- a/cours/source/10-tuples/index.rst
+++ b/cours/source/10-tuples/index.rst
@@ -35,10 +35,11 @@ Accès
 Avec ``[]`` et l'index de l'élément dans le tuple::
 
     mon_tuple = (42, "bonjour")
-    mon_tuple[0]
-    42
-    mon_tuple[1]
-    "bonjour"
+    print(mon_tuple[0])
+    # affiche: 42
+
+    print(mon_tuple[1])
+    # affiche: "bonjour"
 
 Modification
 ------------
@@ -47,7 +48,7 @@ Interdit::
 
     mon_tuple = (42, "bonjour")
     mon_tuple[0] = 44
-    TypeError: 'tuple' object does not support item assignment
+    # erreur: TypeError: 'tuple' object does not support item assignment
 
 
 Test d'appartenance
@@ -55,26 +56,28 @@ Test d'appartenance
 
 Avec ``in``:
 
-   >>> mon_tuple = (42, 14)
-   >>> 42 in mon_tuple
-   True
+   mon_tuple = (42, 14)
+   print(42 in mon_tuple)
+   # affiche: True
+
+   print(14 in mon_tuple)
+   # affiche: True
 
-   >>> 14 in mon_tuple
-   True
-   >>> 13 in mon_tuple
-   False
+   print(13 in mon_tuple)
+   # affiche: False
 
 Déstructuration
 ----------------
 
 Créer plusieurs variables en une seule ligne::
 
-    >>> couple = ("Batman", "Robin")
-    >>> héros, side_kick = couple
-    >>> héros
-    'Batman'
-    >>> side_kick
-    'Robin'
+    couple = ("Batman", "Robin")
+    héros, side_kick = couple
+    print(héros)
+    # affiche: Batman
+
+    print(side_kick)
+    # affiche: Robin
 
 
 Quelques erreurs classiques
@@ -82,15 +85,15 @@ Quelques erreurs classiques
 
 .. code-block:: python
 
-   >>> héros, side_kick, ennemi = couple
-   ValueError (3 != 2)
+   héros, side_kick, ennemi = couple
+   # erreur: ValueError (3 != 2)
 
-   >>> (héros,) = couple
-   ValueError (1 != 2)
+   (héros,) = couple
+   # erreur: ValueError (1 != 2)
 
    # Gare à la virgule:
-   >>> héros, = couple
-   ValueError (1 != 2)
+   héros, = couple
+   # erreur: ValueError (1 != 2)
 
 Pièges
 ------
@@ -110,16 +113,19 @@ Pièges
 
 On peut aussi déstructurer des listes::
 
-    >>> fruits = ["pomme", "banane", "orange"]
-    >>> premier, deuxième, troisième = fruits
-    >>> premier
-    "pomme"
-    >>> deuxième
-    "banane"
-    >>> troisième
-    "orange"
+    fruits = ["pomme", "banane", "orange"]
+    premier, deuxième, troisième = fruits
+
+    print(premier)
+    # affiche: pomme
+
+    print(deuxième)
+    # affiche: banane
+
+    print(troisième)
+    # affiche: orange
 
-On dit aussi: unpacking
+On dit aussi: *unpacking*
 
 Utilisations des tuples
 ------------------------
@@ -147,6 +153,6 @@ Pour retourner plusieurs valeurs::
 
     v, c = tire_carte()
     print(v, "de", c)
-    # 10 de trèfle
+    # affiche: 10 de trèfle
 
 Ce n'est pas une nouvelle syntaxe, juste de la manipulation de tuples!
diff --git a/cours/source/11-classes-01/index.rst b/cours/source/11-classes-01/index.rst
index a195fd6..1a11365 100644
--- a/cours/source/11-classes-01/index.rst
+++ b/cours/source/11-classes-01/index.rst
@@ -105,14 +105,14 @@ Le code suivant fait exactement la même chose, mais avec une ligne de moins::
 
 On peut *créer* des attributs dans *n'importe quel instance*, en utilisant l'*assignation*::
 
-   >>> mon_instance = MaClasse()
+   mon_instance = MaClasse()
 
    # Création de l'attribut `x` dans `mon_instance`
-   >>> mon_instance.x = 42
+   mon_instance.x = 42
 
    # Accés à l'attribut `x` dans `mon_instance`
-   >>> mon_instance.mon_attribut
-   42
+   print(mon_instance.mon_attribut)
+   # affiche: 42
 
 Méthodes - définition
 ----------------------
@@ -135,12 +135,14 @@ la classe::
     class MaClasse:
         def ma_méthode(self):
                 return 42
-    >>> ma_méthode()
-    Erreur
 
-    >>> mon_instance = MaClasse()
-    >>> mon_instance.ma_méthode()
-    42
+    ma_méthode()
+    # erreur: NameError
+
+    mon_instance = MaClasse()
+    résultat = mon_instance.ma_méthode()
+    print(résultat)
+    # affiche: 42
 
 Notez qu'on ne passe *pas* d'argument quand on apelle `ma_méthode` depuis l'instance.
 
@@ -158,10 +160,10 @@ On peut le voir en utilisant des attributs::
             print(self.x)
 
 
-    >>> mon_instance = MaClasse()
-    >>> mon_instance.x = 42
-    >>> mon_instance.affiche_attribut_x()
-    42
+    mon_instance = MaClasse()
+    mon_instance.x = 42
+    mon_instance.affiche_attribut_x()
+    # Affiche: 42
 
 On peut aussi *créer* des attributs dans une méthode::
 
@@ -171,13 +173,13 @@ On peut aussi *créer* des attributs dans une méthode::
         def affiche_attribut_x(self):
             print(self.x)
 
-    >>> mon_instance = MaClasse()
-    >>> mon_instance.affiche_attribut_x()
-    # Erreur: `mon_instance` n'a pas d'attribut `x`
+    mon_instance = MaClasse()
+    mon_instance.affiche_attribut_x()
+    # erreur: `mon_instance` n'a pas d'attribut `x`
 
-    >>> mon_instance.crée_attribut_x()
-    >>> mon_instance.affiche_attribut_x()
-    42
+    mon_instance.crée_attribut_x()
+    mon_instance.affiche_attribut_x()
+    # affiche: 42
 
 Les méthodes peuveunt aussi prendre plusieurs arguments, en plus de ``self`` - mais ``self`` doit
 toujours être le premier argument.
@@ -192,10 +194,10 @@ Par example, pour créer un attribut avec une certaine valeur::
         def affiche_attribut_x(self);
             print(self.x)
 
-    >>> mon_instance = MaClasse()
-    >>> mon_instance.crée_attribut_x(42)
-    >>> mon_instance.affiche_attribut_x()
-    42
+    mon_instance = MaClasse()
+    mon_instance.crée_attribut_x(42)
+    mon_instance.affiche_attribut_x()
+    # affiche: 42
 
 Méthodes appelant d'autres méthodes
 ------------------------------------
@@ -217,8 +219,8 @@ les unes les autres::
             print("fin de la méthode 2")
 
 
-    >>> mon_instance = MaClasse()
-    >>> mon_instance.méthode_2()
+    mon_instance = MaClasse()
+    mon_instance.méthode_2()
 
 .. code-block::
 
@@ -246,13 +248,13 @@ On utilise souvent ``__init__`` pour créer des attributs::
             self.x = 1
             self.y = 2
 
-    >>> mon_instance = MaClasse()
+    mon_instance = MaClasse()
 
     # __init__ est appelée automatiquement!
-    >>> mon_instance.x
-    1
-    >>> mon_instance.y
-    2
+    print(mon_instance.x)
+    # affiche: 1
+    print(mon_instance.y)
+    # affiche: 2
 
 On prend souvent les *valeurs* des attributs à créer en arguments de la méthode ``__init__``::
 
@@ -264,11 +266,11 @@ On prend souvent les *valeurs* des attributs à créer en arguments de la métho
 Dans ce cas, les arguments de la méthode ``__init__`` apparaissent à l'intérieur des parenthèses après le
 nom de la classe::
 
-    >>> mon_instance = MaClasse(3, 4)
-    >>> mon_instance.x
-    3
-    >>> mon_instance.y
-    4
+    mon_instance = MaClasse(3, 4)
+    print(mon_instance.x)
+    # affiche: 3
+    print(mon_instance.y)
+    # affiche: 4
 
 .. note::
 
diff --git a/cours/source/12-modules-01/index.rst b/cours/source/12-modules-01/index.rst
index dea7cad..bad1782 100644
--- a/cours/source/12-modules-01/index.rst
+++ b/cours/source/12-modules-01/index.rst
@@ -16,27 +16,27 @@ Importer un module
 
 Ou: accéder à du code provenant d'un *autre* fichier source.
 
-Imaginons un fichier `bonjour.py` contenant seulement une assignation
+Créons un fichier `bonjour.py` contenant seulement une assignation
 d'une variable `a` à l'entier 42 ::
 
     # Dans bonjour.py
     a = 42
 
-On peut accéder à cette variable en important le module, par
-exemple depuis l'interpréteur, en utilisant le mot-clé `import`
-suivi du nom du module::
+Comme un fichier = un module, on vient de crée un module ``bonjour`` contenant une variable ``a``.
 
-    $ python
-    >>> import bonjour
-    >>> bonjour.a
-    42
+Si maintenant on crée un fichier ``salutations.py`` dans le même répertoire,
+on peut accéder à cette variable en *important* le module::
 
-Notez que pour que cela fonctionne:
+    # Dans salutations.py
+    import bonjour
+    print(bonjour.a)
+    # affiche: 42
 
-* Le nom du module est écrit directement, ce n'est *pas* une
+
+.. note::
+
+  Le nom du module est écrit directement, ce n'est *pas* une
   chaîne de caractères.
-* Il faut lancer la commande `python` sans argument
-* Il faut la lancer depuis le répertoire qui contient `bonjour.py`.
 
 On voit que l'assignation de la variable `a` dans `bonjour.py` est devenue
 un *attribut* du module `bonjour` lorsque `bonjour` a été importé
@@ -44,52 +44,26 @@ un *attribut* du module `bonjour` lorsque `bonjour` a été importé
 
 Si maintenant on rajoute une fonction ``dire_bonjour`` dans ``bonjour.py``::
 
-    # toujours dans bonjour.py
+    # Dans bonjour.py
     a = 42
     def dire_bonjour():
         print("Bonjour!")
 
-On peut appeler la fonction ``dire_bonjour`` depuis l'interpréteur en accédant
-à l'attribut ``dire_bonjour`` du module ``bonjour``::
-
-   >>> import bonjour
-   >>> bonjour.dire_bonjour()
-   Bonjour!
-
-Différence avec la commande python
------------------------------------
-
-Notez bien que lancer l'interpréteur et taper `import bonjour` dedans n'est pas
-la même chose que lancer `python bonjour.py`.
-
-Dans le deuxième cas, tout le code dans `bonjour.py` est exécuté, puis la commande python
-se termine.
-
-Dans le cas de l'interpréteur, on peut utiliser tous les attributs du module et appeler
-les fonctions autant de fois qu'on veut::
-
-    >>> import bonjour
-    >>> bonjour.dire_bonjour()
-    Bonjour!
-    >>> bonjour.dire_bonjour()
-    Bonjour!
-
-On peut aussi modifier les valeurs des attributs::
-
-    >>> import bonjour
-    >>> bonjour.a
-    42
-    >>> bonjour.a = 36
-    >>> bonjour.a
-    36
+On peut appeler la fonction ``dire_bonjour`` depuis ``salutations.py``
+en utilisant l'attribut ``dire_bonjour`` du module ``bonjour``::
 
+   # Dans salutations.py
+   import bonjour
+   bonjour.dire_bonjour()
+   # affiche: Bonjour!
 
 Les imports ne sont faits qu'une seule fois
 -------------------------------------------
 
-Il est important de noter que le code à l'intérieur d'un
-module n'est *pas* ré-éxécuté si le module a déjà été
-importé auparavant.
+Il est important de noter que:
+
+* **tout** le code à l'intérieur d'un module est éxécuté lors du premier import
+* mais il n'est *pas* ré-éxécuté si le module a déjà été importé auparavant.
 
 On peut le voir en mettant du code dans `bonjour.py`,
 en plus des simples définitions de fonctions et assignations
@@ -97,15 +71,20 @@ de variables::
 
     # Dans bonjour.py
     print("Je suis le module bonjour et tu viens de m’importer")
+    def dire_bonjour():
+        ....
+
+.. code-block:: python
+
+    # Dans salutation.py
+    import bonjour
+    # affiche: Je suis le module bonjour et tu viens de m’importer
 
-    >>> import bonjour
-    Je suis le module foo et tu viens de m’importer
-    >>> import bonjour
-    <rien>
+    import bojour
+    # n'affiche rien
 
-Il faudra donc redémarrer l'interpréteur à chaque fois que le code dans `bonjour.py` change.
 
-a bibliothèque standard
+La bibliothèque standard
 ------------------------
 
 La bibliothèque standard est une collection de modules directement utilisables fournis à l'installation de Python.
diff --git a/cours/source/13-classes-02/02-couplage.rst b/cours/source/13-classes-02/01-couplage.rst
similarity index 79%
rename from cours/source/13-classes-02/02-couplage.rst
rename to cours/source/13-classes-02/01-couplage.rst
index 0852c30..162e95e 100644
--- a/cours/source/13-classes-02/02-couplage.rst
+++ b/cours/source/13-classes-02/01-couplage.rst
@@ -18,16 +18,17 @@ On peut utiliser pour cela deux classes: `Chat` et `Humain`::
         def __init__(self, nom):
             self.nom = nom
 
-    >>> chat = Chat("Monsieur Moustaches")
-    >>> chat.nom
-    'Monsieur Moustaches'
+    chat = Chat("Monsieur Moustaches")
+    prin(chat.nom)
+    # affiche: Monsieur Moustaches
 
     class Humain:
         def __init__(self,  prénom):
             self.prénom = prénom
-    >>> alice = Humain(prénom="Alice")
-    >>> alice.prénom
-    "Alice"
+
+    alice = Humain(prénom="Alice")
+    print(alice.prénom)
+    # affiche: Alice
 
 Maintenant on veut que les humains puissent adopter des chats.
 Pour cela, on peut rajouter la méthode ``adopte`` dans la classe
@@ -43,10 +44,10 @@ classe ``Chat``::
         def adopte(self, chat):
             print(self.prénom, "adopte un chat")
 
-    >>> boule_de_poils = Chat("Boule de Poils")
-    >>> alice = Humain("Alice")
-    >>> alice.adopte(boule_de_poils)
-    "Alice adopte un chat"
+    boule_de_poils = Chat("Boule de Poils")
+    alice = Humain("Alice")
+    alice.adopte(boule_de_poils)
+    # affiche: "Alice adopte un chat"
 
 On peut accéder au nom du chat depuis la méthode ``adopte``,
 en utilisant la syntaxe ``nom.attribut`` vue précédemment::
@@ -58,10 +59,10 @@ en utilisant la syntaxe ``nom.attribut`` vue précédemment::
         def adopte(self, chat):
             print(self.prénom, "adopte", chat.nom)
 
-    >>> boule_de_poils = Chat("Boule de Poils")
-    >>> alice = Humain("Alice")
-    >>> alice.adopte(boule_de_poils)
-    "Alice adopte Boule de Poils"
+    boule_de_poils = Chat("Boule de Poils")
+    alice = Humain("Alice")
+    alice.adopte(boule_de_poils)
+    # affiche: Alice adopte Boule de Poils
 
 Couplage
 --------
diff --git a/cours/source/13-classes-02/01-rappels.rst b/cours/source/13-classes-02/01-rappels.rst
deleted file mode 100644
index 1e42dff..0000000
--- a/cours/source/13-classes-02/01-rappels.rst
+++ /dev/null
@@ -1,176 +0,0 @@
-Rappels
-=======
-
-// TODO: drop?
-
-.. note::
-
-   ceci est surtout un rappel du chapitre 11. N'hésitez pas à vous y
-   reporter si les exemples de code ne vous paraissent pas clairs.
-
-
-Classes vides
--------------
-
-Définition::
-
-    class MaClasse:
-        pass
-
-Instanciation::
-
-    instance_1 = MaClasse()
-
-Attributs
----------
-
-Un attribut est une variable *à l'intérieur* d'autre chose (par exemple une instance de classe).
-
-La syntaxe consiste en l'instance à gauche et l'attribut à droite après un point::
-
-    >>> mon_instance = MaClasse()
-    # création de l'attribut `x` dans mon_instance:
-    >>> mon_instance.x = 42
-    # accès à l'attribut `x` dans mon_instance:
-    >>> mon_instance.x
-    42
-
-Méthodes
---------
-
-Une méthode est une fonction définie à l'intérieur d'une classe:
-
-Définition::
-
-    class MaClasse:
-        def ma_méthode(self):
-            return 42
-
-Les méthodes sont des attributs des instances de classes::
-
-    class MaClasse:
-        def ma_méthode(self):
-                return 42
-    >>> ma_méthode()
-    Erreur
-    >>> mon_instance = MaClasse()
-    >>> mon_instance.ma_méthode()
-    42
-
-
-self
-----
-
-`self` *prend la valeur de l'instance courante* quand la méthode est appelée.::
-
-    class MaClasse:
-        def affiche_attribut_x(self):
-            print(self.x)
-
-    >>> mon_instance = MaClasse()
-    >>> mon_instance.x = 42
-    >>> mon_instance.affiche_attribut_x()
-    42
-
-On peut aussi *créer* des attributs dans une méthode::
-
-    class MaClasse:
-        def crée_attribut_x(self):
-            self.x = 42
-        def affiche_attribut_x(self):
-            print(self.x)
-
-    >>> mon_instance = MaClasse()
-    >>> mon_instance.affiche_attribut_x()
-    # Erreur: `mon_instance` n'a pas d'attribut `x`
-
-    >>> mon_instance.crée_attribut_x()
-    >>> mon_instance.affiche_attribut_x()
-    42
-
-Méthodes avec arguments
-------------------------
-
-.. code-block::
-
-   class MaClasse
-       def crée_attribut_x(self, valeur_de_x):
-           self.x = valeur_de_x
-
-       def affiche_attribut_x(self);
-           print(self.x)
-
-   >>> mon_instance = MaClasse()
-   >>> mon_instance.crée_attribut_x(42)
-   >>> mon_instance.affiche_attribut_x()
-   42
-
-Méthodes appelant d'autres méthodes
-------------------------------------
-
-.. code-block::
-
-   class MaClasse:
-       def méthode_1(self):
-           print("démarrage de la méthode 1")
-           print("la méthode 1 affiche bonjour")
-           print("bonjour")
-           print("fin de la méthode 1")
-
-
-       def méthode_2(self):
-           print("la méthode 2 appelle la méthode 1")
-           self.méthode_1()
-           print("fin de la méthode 2")
-
-
-   >>> mon_instance = MaClasse()
-   >>> mon_instance.méthode_2()
-
-.. code-block::
-
-   la méthode 2 appelle la méthode 1
-   démarrage de la méthode 1
-   la méthode 1 affiche bonjour
-   bonjour
-   fin de la méthode 1
-   fin de la méthode 2
-
-Constructeur sans arguments
----------------------------
-
-Un constructeur en Python désigne la méthode nomée ``__init__``,
-quand celle-ci existe.
-
-La méthode ``__init__`` est appelée automatiquement quand la
-classe est instanciée::
-
-    class MaClasse:
-        def __init__(self):
-            self.x = 1
-            self.y = 2
-
-    >>> mon_instance = MaClasse()
-    >>> mon_instance.x
-    1
-    >>> mon_instance.y
-    2
-
-Constructeur avec arguments
-----------------------------
-
-La méthode ``__init__`` peut avoir des arguments,
-dans ce cas, ceux ci doivent être fournis
-lors de l'instanciation::
-
-    class MaClasse:
-        def __init__(self, x, y):
-            self.x = x
-            self.y = y
-
-    >>> mon_instance = MaClasse(3, 4)
-    >>> mon_instance.x
-    3
-
-    >>> mon_instance.y
-    4
diff --git a/cours/source/13-classes-02/03-composition.rst b/cours/source/13-classes-02/02-composition.rst
similarity index 67%
rename from cours/source/13-classes-02/03-composition.rst
rename to cours/source/13-classes-02/02-composition.rst
index e546d36..e811c4c 100644
--- a/cours/source/13-classes-02/03-composition.rst
+++ b/cours/source/13-classes-02/02-composition.rst
@@ -10,20 +10,26 @@ Une classe à l'intérieur d'une autre classe.
 Dépendances entre fonctions
 -----------------------------
 
-Exemple: on veut dessiner un sapin dans le terminal::
+Exemple ::
 
-    def main():
-        largeur = demander_largeur()
-        dessine_sapin(largeur)
+    def calcule_x():
+        ...
+        # du code ici
 
-    main()
+    def fait_un_truc_avec_x(x):
+        ...
+        # du code ici
 
+    x = calcule_x()
+    fait_un_truc_avec_x(x)
 
-On voit que la fonction ``dessine_sapin()`` prend un argument ``largeur``, qui est retourné
-par la fonction ``demander_largeur()``.
 
-``dessine_sapin()`` doit donc être appelée *après* ``demander_largeur()``. On dit que ``dessine_sapin()``
-_dépend_ de ``demander_largeur()``.
+
+On voit que la fonction ``fait_un_truc_avec_x()`` prend un argument ``x``, qui est retourné
+par la fonction ``calcule_x()``.
+
+``fait_un_truc_avec_x()`` doit donc être appelée *après* ``calcule_x()``. On dit que ``fait_un_truc_avec_x()``
+*dépend* de ``calcule_x()``.
 
 Dépendances entre classes
 -------------------------
@@ -39,8 +45,8 @@ Revoyons la classe Chat::
 Comme le constructeur de la classe Chat prend un nom en argument, il est impossible de construire
 des chats sans nom::
 
-    >>> chat = Chat()
-    TypeError: __init__() missing 1 required positional argument: 'nom'
+    chat = Chat()
+    # erreur: TypeError: __init__() missing 1 required positional argument: 'nom'
 
 De la même façon, si on veut que tous les enfants aient un chat (pourquoi pas, après tout), on peut
 avoir une classe Enfant, dont le constructeur prend une instance de chat en plus du prénom::
@@ -50,11 +56,11 @@ avoir une classe Enfant, dont le constructeur prend une instance de chat en plus
             self.prénom = prénom
             self.chat = chat
 
-     >>> alice = Enfant("Alice")
-     TypeError: __init__() missing 1 required positional argument: 'chat'
+     alice = Enfant("Alice")
+     # erreur: TypeError: __init__() missing 1 required positional argument: 'chat'
 
-     >>> boule_de_poils = Chat("Boule de Poils")
-     >>> alice = Enfant("Alice", boule_de_poils)
+     boule_de_poils = Chat("Boule de Poils")
+     alice = Enfant("Alice", boule_de_poils)
      # OK!
 
 Utilisation de la composition
@@ -78,9 +84,9 @@ et ``ronronne()`` dans la classe chat::
             self.ronronne()
 
 
-    >>> boule_de_poils = Chat("Boule de Poils")
-    >>> boule_de_poils.caresse()
-    Boule de Poils fait "prrrrr"
+    boule_de_poils = Chat("Boule de Poils")
+    boule_de_poils.caresse()
+    # affiche: Boule de Poils fait "prrrrr"
 
 Ensuite, on peut rajouter la méthode ``console()`` dans la classe Enfant,
 qui va:
@@ -95,11 +101,11 @@ qui va:
         def console(self):
             self.chat.caresse()
 
-    >>> boule_de_poils = Chat("Boule de Poils")
-    >>> alice = Enfant("Alice", boule_de_poils)
+    boule_de_poils = Chat("Boule de Poils")
+    alice = Enfant("Alice", boule_de_poils)
     # Alice est triste, on la console
-    >>> alice.console()
-    Boule de Poils fait "prrrrr"
+    alice.console()
+    # affiche: Boule de Poils fait "prrrrr"
     # Alice est consolée :)
 
 On dit parfois qu'on a *délégué* l'implémentation de la méthode ``console()`` de la classe Enfant
diff --git a/cours/source/13-classes-02/index.rst b/cours/source/13-classes-02/index.rst
index 67d6b37..daeb2fa 100644
--- a/cours/source/13-classes-02/index.rst
+++ b/cours/source/13-classes-02/index.rst
@@ -4,6 +4,5 @@ Chapitre 13 - Classes (2ème partie)
 .. toctree::
    :maxdepth: 1
 
-   01-rappels
-   02-couplage
-   03-composition
+   01-couplage
+   02-composition
diff --git a/cours/source/14-bibliothèques-01/02-sys.path.rst b/cours/source/14-bibliothèques-01/02-sys.path.rst
index c5cbd80..eed3d7d 100644
--- a/cours/source/14-bibliothèques-01/02-sys.path.rst
+++ b/cours/source/14-bibliothèques-01/02-sys.path.rst
@@ -4,7 +4,7 @@ sys.path
 En Python, il existe une variable ``path`` prédéfinie dans le module ``sys`` qui fonctionne de manière similaire
 à la variable d'environnement ``PATH``.
 
-Si j'essaye de l'afficher sur ma machine, voici ce que j'obtiens:
+Si j'essaye de l'afficher sur ma machine, voici ce que j'obtiens::
 
     import sys
     print(sys.path)
diff --git a/cours/source/15-fichiers-et-données-binaires/01-données-binaires.rst b/cours/source/15-fichiers-et-données-binaires/01-données-binaires.rst
index e5545fe..2388718 100644
--- a/cours/source/15-fichiers-et-données-binaires/01-données-binaires.rst
+++ b/cours/source/15-fichiers-et-données-binaires/01-données-binaires.rst
@@ -147,6 +147,9 @@ On peut aussi interpréter des octets comme du texte - c'est la table ASCII
 
 .. image::  ../img/ascii-table.png
 
+La table se lit ainsi: si on veut connaître la suite de 0 et de 1 qui correspond à `B`: on lit
+les 3 premiers bits de haut en bas sur la colonne: `100`, puis les 4 bits sur la ligne: `0010`.
+Du coup 'B' en s'écrit en 7 bits: `1000010`, soit 66 en décimal, et 42 en héxadécimal
 
 ASCII - remarques
 -----------------
@@ -155,20 +158,20 @@ ASCII - remarques
 * Le A est pour American
 * Ça sert à *envoyer* du texte sur des terminaux d'où les "caractères" non-imprimables dans la liste
 * Mais c'est une convention *très* utilisée
-* Techniquement, on n'a besoin que de 7 bits, mais on préfère envoyer des octets
+* Un message de 4 lettres ASCII sera souvent envoyé comme 4 octets (même si seulement 7 bits sont nécessaires)
 
 Utiliser ASCII en Python
 ------------------------
 
 Avec ``chr`` et ``ord``::
 
-    x = chr(98)
+    x = chr(0x42)
     print(x)
-    # affiche: b
+    # affiche: B
 
-    x = ord('a')
+    x = ord('B')
     print(x)
-    # affiche: 97
+    # affiche: 66
 
 Affichage des bytearrays en Python
 ----------------------------------
diff --git a/cours/source/index.rst b/cours/source/index.rst
index a27a7b8..42451be 100644
--- a/cours/source/index.rst
+++ b/cours/source/index.rst
@@ -20,7 +20,7 @@ remarques.
    01-introduction/index
    02-premiers-pas/index
    03-variables-et-types/index
-   04-code-source/index
+   04-booléens/index
    05-flot-de-controle/index
    06-fonctions/index
    07-listes/index