Rewrite episode 6

5 years ago · cfe0a39b55
--- 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 $@
--- 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