Initial commit

source/07-objects/inheritance/aggregation.py

@@ -0,0 +1,115 @@
+from typing import List, Set
+
+
+class User(object):
+    """
+    Classe représentant un utilisateur.
+
+    """
+    name: str = None
+    first_name: str = None
+    email: str = None
+    password: str = None
+
+    def __init__(self, name, first_name, email, password):
+        """
+        Initialiser un nouvel utilisateur.
+
+        Args:
+            name: nom
+            first_name: prénom
+            email: email
+            password: mot de passe
+
+        """
+        self.name = name
+        self.first_name = first_name
+        self.email = email
+        self.password = password
+
+    def __repr__(self):
+        """
+        Texte affiché pour l'objet quand on le passe dans `print()` ou surtout
+        que sa représentation textuelle est demandée.
+
+        Returns:
+            Le nom de l'utilisateur.
+
+        """
+        return self.name
+
+
+class Group(object):
+    """
+    Classe de groupe d'utilisateurs.
+
+    """
+    name: str = None
+    description: str = None
+    # Ici on a un attribut qui est une liste d'objets d'une autre classe.
+    # C'est ce qu'on appelle l'agrégation.
+    # Si on supprime le groupe, les objets utilisateurs existent toujours indépendamment,
+    # on a ici simplement un lien vers des utilisateurs.
+    users: Set[User] = None
+
+    def __init__(self, name, description=None):
+        """
+        Initialiser un nouveau groupe d'utilisateurs.
+
+        Args:
+            name: nom du groupe
+            description: texte descriptif, facultatif
+
+        """
+        self.name = name
+        self.description = description
+
+    def __repr__(self):
+        """
+        Texte affiché pour l'objet quand on le passe dans `print()`
+
+        Returns:
+            Le nom du groupe.
+
+        """
+        return self.name
+
+    def add_user(self, user: User):
+        """
+        Ajouter un utilisateur au groupe.
+
+        Args:
+            user: instance d'utilisateur à ajouter
+
+        """
+        self.users = self.users or set()
+        self.users.add(user)
+
+    def get_users(self):
+        """
+        Renvoie la liste des utilisateurs dans le groupe.
+
+        Returns:
+            La liste des utilisateurs ajoutés au groupe.
+
+        """
+        return self.users
+
+
+if __name__ == "__main__":
+    # Créer quelques utilisateurs
+    user1 = User("Martin", "Jacques", "jmartin@example.com", "jmartin")
+    user2 = User("Carletti", "Audrey", "acarletti@example.com", "acarletti")
+    user3 = User("Richard", "Luc", "lrichard@example.com", "lrichard")
+    user4 = User("Havel", "Vaclav", "vhavel@example.com", "vhavel")
+    # Créer un groupe ou deux
+    group1 = Group("Amicale des amateurs de froid")
+    group2 = Group("Amicale des amateurs de chaud")
+    # Ajouter des utilisateurs aux groupes
+    group1.add_user(user1)
+    group1.add_user(user2)
+    group1.add_user(user3)
+    group2.add_user(user4)
+    # Afficher les utilisateurs pour chaque groupe
+    print(f"Utilisateurs du groupe {group1.name} : {group1.get_users()}")
+    print(f"Utilisateurs du groupe {group2.name} : {group2.get_users()}")

source/07-objects/inheritance/polymorphism.py

@@ -0,0 +1,64 @@
+from typing import Optional
+
+
+class Animal(object):
+    """
+    Classe de base pour tous les animaux.
+
+    """
+    pattes: int = None
+    vertebre: Optional[bool] = None
+
+    def manger(self):
+        """
+        Méthode de base pour que l'animal mange.
+
+        On ne définit aucun comportement particulier ici.
+
+        """
+        print("Je suis un animal et je mange.")
+
+
+class Chien(Animal):
+    """
+    Classe pour le chien.
+
+    """
+    pattes: int = 4
+    vertebre = True
+
+    def manger(self):
+        """
+        Méthode pour faire manger le chien.
+
+        """
+        super().manger()  # Exécute le code ligne 19
+        print("Je dirais même plus *wouf* ! Je suis un chien qui mange.")
+
+
+class Escargot(Animal):
+    """
+    Classe pour l'escargot.
+
+    """
+    pattes: int = 0
+    vertebre = False
+
+    def manger(self):
+        """
+        Méthode pour faire manger l'escargot.
+
+        """
+        print("Slurp *mange, mais on ne sait pas comment*")
+
+
+if __name__ == "__main__":
+    # Créer des nouvelles instances d'animaux
+    escargot = Escargot()
+    chien = Chien()
+    # Et voir comment ça se comporte quand on appelle la méthode `manger`.
+    # Le fait que plusieurs classes héritant d'une autre classe ont des comportements
+    # différents pour les mêmes méthodes s'appelle du polymorphisme.
+    # Les méthodes peuvent aussi avoir des arguments différents mais le même nom.
+    print(escargot.manger())
+    print(chien.manger())

source/07-objects/inheritance/simple.py

@@ -0,0 +1,92 @@
+
+class Person(object):
+    """
+    Classe représentant une personne.
+
+    """
+    nom: str = None
+    prenom: str = None
+    age: int = None
+
+    def __init__(self, *_args, **kwargs):
+        """
+        Initialiser les valeurs d'une nouvelle personne.
+
+        Args:
+            *_args: Liste d'arguments non positionnels
+            **kwargs: Arguments nommés, utilisés pour initialiser les attributs de notre objet.
+
+        """
+        self.nom = kwargs.get("nom", None)
+        self.prenom = kwargs.get("prenom", None)
+        self.age = kwargs.get("age", None)
+
+    def set_nom_complet(self, nom, prenom):
+        """
+        Méthode pour définir les noms et prénom de l'individu.
+
+        Args:
+            nom: Nom de famille à attribuer
+            prenom: Prénom à attribuer à l'objet
+
+        """
+        self.prenom = prenom
+        self.nom = nom
+
+    def get_nom_complet(self):
+        """
+        Méthode pour retrouver d'un coup le nom complet de l'individu.
+
+        Returns:
+            Nom complet, sous la forme "<prenom> <nom>"
+
+        """
+        if self.prenom and self.nom:
+            return f"{self.prenom} {self.nom}"
+        else:
+            return "Nom complet non renseigné"
+
+
+class Professional(Person):
+    """
+    Classe représentant un professionel, héritant de `Person`.
+
+    """
+    telephone_pro: str = None
+    job: str = None
+
+    def __init__(self, *_args, **kwargs):
+        """
+        Initialiser les données d'un nouveau professionel.
+
+        On peut également initialiser le prénom, nom et âge.
+
+        Args:
+            *_args: Liste d'arguments non positionnels
+            **kwargs: Liste d'arguments nommés, utilisés pour initialiser les attributs de notre objet.
+
+        """
+        super().__init__(*_args, **kwargs)
+        self.telephone_pro = kwargs.get("telephone_pro", None)
+        self.job = kwargs.get("job", None)
+
+    def get_nom_complet(self):
+        """
+        Méthode pour retrouver d'un coup le nom complet de l'individu.
+
+        Returns:
+            Nom complet, sous la forme "<prenom> <nom>"
+
+        """
+        base_nom = super().get_nom_complet()
+        return f"{base_nom} ({self.job})"
+
+
+if __name__ == "__main__":
+    # Ici on se crée plusieurs objets, 2 professionnels et une personne
+    pro1 = Professional(nom="Mario", prenom="Mario", age=38, telephone_pro="0799999999", job="Jardinier")
+    pro2 = Professional(nom="Mario", prenom="Luigi", age=37, telephone_pro="0799999999", job="Plombier")
+    mec = Person(nom="Bertrand", prenom="Julien", age=30)
+    # Les deux classe Person et Professional ont des méthodes `get_nom_complet()` différentes, tester
+    print(mec.get_nom_complet())
+    print(pro1.get_nom_complet())

source/07-objects/introspection/base.py

@@ -0,0 +1,42 @@
+import pdir
+
+
+def use_dir():
+    """
+    Découvrir l'introspection via la fonction `dir()`
+
+    Nécessite pdir2 pour montrer une sortie plus sympa aux étudiants.
+
+    """
+    # En python, tout est un objet, et a donc des attributs et des méthodes.
+    # Le truc bien, c'est qu'en Python, on peut aussi manipuler et retrouver les
+    # propriétés de ces attributs et méthodes.
+    chaine = "Bonjour"
+    # À la place de `pdir` on pouvait utiliser `dir` qui fait partie de python,
+    # mais qui affiche la liste des attributs de l'objet de façon beaucoup moins
+    # lisible.
+    print(pdir(chaine))
+
+
+def check_attrs():
+    """
+    Via l'introspection, accéder à des attributs d'objets programmatiquement.
+
+    """
+    chaine = "Bonjour"
+    # Une chaîne a toujours une méthode `capitalize`, donc ça va fonctionner
+    if hasattr(chaine, "capitalize"):
+        print("L'objet a bien une fonction `capitalize`.")
+        print(getattr(chaine, "capitalize"))
+    # Mais une chaîne n'a pas d'attribut `doesnotexist`.
+    if hasattr(chaine, "doesnotexist"):
+        print("L'objet a un attribut `doesnotexist`.")
+    else:
+        print("L'objet n'a pas d'attribut `doesnotexist`.")
+
+
+if __name__ == "__main__":
+    print("Utilisation de la fonction `dir` :")
+    use_dir()
+    print("Utilisation de l'introspection d'attributs :")
+    check_attrs()

source/07-objects/magics/deletion.py

@@ -0,0 +1,11 @@
+class DelTest:
+    def __del__(self):
+        print("Suppression.")
+
+
+a = DelTest()
+b = a
+
+# On s'attend à afficher Suppression avant d'afficher la référence de b.
+del a
+print(b)