diff --git a/saison-2/sessions/Makefile b/saison-2/sessions/Makefile
index c61109b..e8e040c 100644
--- a/saison-2/sessions/Makefile
+++ b/saison-2/sessions/Makefile
@@ -1,4 +1,4 @@
-all: python-S02-E05.pdf
+all: python-S02-E06.pdf
 
 %.pdf: %.md
 	pandoc --pdf-engine=xelatex -t beamer $< -o $@
diff --git a/saison-2/sessions/python-S02-E06.md b/saison-2/sessions/python-S02-E06.md
index af304c3..2133a7e 100644
--- a/saison-2/sessions/python-S02-E06.md
+++ b/saison-2/sessions/python-S02-E06.md
@@ -4,164 +4,383 @@
 
 #
 
-\center \huge Rappels sur les classes
+\center \huge Modules
 
-# Classes vides
+# Un fichier = un module
+
+À un fichier `mon_module.py` correspond _toujours_ un module `mon_module`.
+(La réciproque n'est pas vraie)
+
+# Code dans un module
 
-Définition:
 ```python
-class MonObjet:
-    pass
+# Dans bonjour.py
+a = 42
 ```
 
-Instanciation:
+Le module `bonjour` contient contient un *attribut* `a`
+dont la valeur est 42.
+
+# Importer un module
+
+Avec le mot-clé `import`, suivi du nom du module,
+_sans guillemets_.
+
 ```python
->>> objet_1 = MonObjet()
+$ python
+>>> import bonjour
+>>> bonjour.a
+42
 ```
 
-# Attributs
+# Une fonction dans un module
 
 ```python
->>> mon_instance = MonObjet()
->>> mon_instance.x = 42
->>> mon_instance.mon_attribut
-42
+# toujours dans bonjour.py
+a = 42
+def dire_bonjour():
+    print("Bonjour!")
 ```
 
-# Méthodes
+# Appeler une fonction depuis un module
 
-Définition:
 ```python
-class MonObjet:
-    def ma_méthode(self):
-        return 42
+>>> import bonjour
+>>> bonjour.dire_bonjour()
+Bonjour!
 ```
 
-Appel:
+**note**: différent de `python3 bonjour.py`.
+
+# Interaction - 1
+
+
+```python
+>>> import bonjour
+>>> bonjour.dire_bonjour()
+Bonjour!
+>>> bonjour.dire_bonjour()
+Bonjour!
+```
+
+# Interaction - 2
+
 ```python
-class MonObjet:
-    def ma_méthode(self):
-            return 42
->>> ma_méthode()
-Erreur
->>> mon_instance = MonObjet()
->>> mon_instance.ma_méthode()
+>>> import bonjour
+>>> bonjour.a
 42
+>>> bonjour.a = 36
+>>> bonjour.a
+36
+```
+
+# Les imports ne sont faits qu'une seule fois
+
+
+```python
+# Dans bonjour.py
+print("Je suis le module bonjour!")
+```
+
+```python
+>>> import bonjour
+Je suis le module bonjour!
+>>> import bonjour
+<rien>
 ```
 
+# La bibliothèque standard
+
+La bibliothèque standard est une collection de modules directement utilisables fournis à l'installation de Python.
+
+Exemple: `sys`, `random`, ...
+
+Toute la bibliothèque standard est documentée - et la traduction en Français est en cours:
+
+https://docs.python.org/fr/3/library/index.html
 
-# self - 1
+Mettez ce lien dans vos favoris - il vous sera très utile.
 
-`self` *prend la valeur de l'instance courante* quand la méthode est appelée.
+
+# sys
+
+Contient notamment `sys.argv`, une liste de chaînes de caractères, qui
+n'est *jamais vide*.
+
+Dans l'interpréteur intéractif, le premier élément est le
+chemin du binaire python:
+
+```bash
+$ python3
+>>> import sys
+>>> sys.argv
+["/usr/bin/python3"]
+```
+
+# sys.argv avec un fichier
 
 ```python
-class MonObjet:
-    def affiche_attribut_x(self):
-        print(self.x)
+# Dans lancez_moi.py
+import sys
 
->>> mon_instance = MonObjet()
->>> mon_instance.x = 42
->>> mon_instance.affiche_attribut_x()
-42
+def main():
+   print(sys.argv)
+```
+
+\vfill
+
+Le premier élément est alors le nom du fichier:
+
+```bash
+$ python3 lancez_moi.py
+["lancez_moi.py"]
 ```
 
-# self - 2
+# sys.argv avec un fichier - 2
 
-On peut aussi *créer* des attributs dans une méthode:
+Si on rajoute des mots après le nom du fichier, ils apparaissent dans `sys.argv`:
 
 ```python
-class MonObjet:
-    def crée_attribut_x(self):
-        self.x = 42
-    def affiche_attribut_x(self):
-        print(self.x)
+# dans lancez_moi.py
+import sys
 
->>> mon_instance = MonObjet()
->>> mon_instance.affiche_attribut_x()
-# Erreur: `mon_instance` n'a pas d'attribut `x`
+def main():
+   print(sys.argv)
+```
 
->>> mon_instance.crée_attribut_x()
->>> mon_instance.affiche_attribut_x()
-42
+\vfill
+
+```bash
+$ python3 lancez_moi.py un deux trois
+["lancez_moi.py", "un", "deux", "trois"]
+```
+
+# Les scripts Python
+
+Pour interagir avec l'utilisateur, on a souvent utilisé `input()`, passer par
+`sys.argv` est plus commun.
+
+Exemple:
+
+```bash
+$ python3 faire_le_café
+$ python3 faire_le_café --sans-sucre
+```
+
+#
+
+\center \huge QCM
+
+
+#
+
+```python
+def dire_bonjour():
+    return "Bonjour"
+
+x = dire_bonjour()
+print(x)
 ```
 
-# Méthodes avec arguments
+1. Erreur
+2. Affiche "Bonjour"
+
+\pause
+
+Réponse: 2
+
+
+#
 
 ```python
-class MonObjet
-    def crée_attribut_x(self, valeur_de_x):
-        self.x = valeur_de_x
+def dire_bonjour():
+    print("Bonjour")
 
-    def affiche_attribut_x(self);
-        print(self.x)
+x = dire_bonjour()
+print(x)
+```
 
->>> mon_instance = MonObjet()
->>> mon_instance.crée_attribut_x(42)
->>> mon_instance.affiche_attribut_x()
-42
+1. Erreur
+2. Affiche "Bonjour"
+3. Affiche 'None"
+
+\pause
+
+Réponse: 3 - pas de return, la fonction
+renvoie None
+
+#
+
+```python
+def dire_bonjour():
+    return "Bonjour"
+
+dire_bonjour()
+```
+
+1. N'affiche rien
+2. Affiche "Bonjour"
+3. Affiche 'None"
+
+
+\pause
+
+Réponse 1 - la fonction renvoie une valeur, mais
+on n'en fait rien.
+
+
+#
+
+```python
+# Dans mon_module.py
+ma_variable = 42
+```
+
+```python
+>>> import "mon_module"
+>>> print(ma_variable)
+```
+
+1. Erreur
+2. Affiche '42'
+
+\pause
+
+Réponse 1: les noms de modules ne sont pas des strings!
+
+#
+
+```python
+# Dans mon_module.py
+ma_variable = 42
 ```
 
-# Méthodes appelant d'autres méthodes - 1
+```python
+>>> import mon_module
+>>> print(ma_variable)
+```
+
+1. Erreur
+2. Affiche '42'
+
+\pause
+
+Réponse 1: `ma_variable` est un *attribut* de `mon_module`.
+
+#
+
+```python
+# Dans mon_module.py
+ma_variable = 42
+```
 
 ```python
-class MonObjet:
-    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")
+>>> import mon_module
+>>> mon_module.ma_variable = 43
+>>> mon_module.ma_variable
+```
+
+1. Erreur
+2. Affiche '43'
 
+\pause
 
-    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")
+Réponse 2: on peut lire et écrire les attributs des modules
+importés!
+
+#
+
+```python
+# Dans mon_script.py
+print(sys.argv[0])
 ```
 
-# Méthodes appelant d'autres méthodes - 2
+```bash
+$ python mon_script mon_argument
+```
+
+1. Erreur
+2. Affiche 'mon_script'
+
+\pause
+
+Réponse 1: il faut donner le vrai nom du fichier!
+
+#
 
 ```python
->>> mon_instance = MonObjet()
->>> mon_instance.méthode_2()
+# Dans mon_script.py
+print(sys.argv[0])
 ```
 
-```text
-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
+```bash
+$ python mon_script.py mon_argument
 ```
 
-# Constructeur sans arguments
+1. Erreur
+2. Affiche 'mon_script'
+
+\pause
+
+Réponse 1: il faut importer `sys` avant de pouvoir l'utiliser
+
+#
 
 ```python
-class MonObjet:
-    def __init__(self):
-        self.x = 1
-        self.y = 2
+# Dans mon_script.py
+import sys
+print(sys.argv[0])
+```
 
->>> mon_instance = MonObjet()
->>> mon_instance.x
-1
->>> mon_instance.y
-2
+```bash
+$ python mon_script.py mon_argument
 ```
 
-# Constructeur avec arguments
+1. Erreur
+2. Affiche 'mon_argument'
+
+\pause
+
+C'est un piège! `argv[0]` est le chemin du script!
+
+#
 
 ```python
-class MonObjet:
-    def __init__(self, x, y):
-        self.x = x
-        self.y = y
+# Dans mon_script.py
+import sys
+print(sys.argv[1])
 ```
 
+```bash
+$ python mon_script.py mon_argument
 ```
->>> mon_instance = MonObjet(3, 4)
->>> mon_instance.x
-3
->>> mon_instance.y
-4
+
+1. Erreur
+2. Affiche 'mon_argument'
+
+\pause
+
+Réponse 2 :)
+
+#
+
+```python
+# Dans mon_script.py
+import sys
+print(sys.argv[1])
 ```
+
+```bash
+$ python mon_script.py
+```
+
+1. Erreur
+2. Affiche 'mon_script.py'
+
+\pause
+
+Réponse 1. `argv` a une taille 1, et on accède à l'index 1.
+
+#
+
+\center \huge Atelier