Classes, annotations et environnements virtuels

Ce que tu vas apprendre

• Regrouper des données et des fonctions dans une classe.
• Indiquer les types attendus avec des annotations.
• Isoler un projet dans un environnement virtuel et y installer des paquets.

Une première classe

Une classe est un plan pour fabriquer des objets qui partagent la même structure et les mêmes comportements.

class Recette:
    def __init__(self, nom, portions):
        self.nom = nom
        self.portions = portions

    def afficher(self):
        print(f"{self.nom} ({self.portions} portions)")

crepes = Recette("Crêpes", 4)
crepes.afficher()

Le programme affiche « Crêpes (4 portions) ». Recette("Crêpes", 4) crée un objet, une instance de la classe.

__init__ et self

__init__ est la méthode appelée à la création de l'objet. Elle range les valeurs de départ dans ses attributs.

self désigne l'objet lui-même. C'est toujours le premier paramètre d'une méthode, c'est-à-dire d'une fonction définie dans une classe. Python le remplit tout seul : tu écris crepes.afficher() sans argument.

Chaque instance a ses propres valeurs :

gratin = Recette("Gratin", 6)
print(gratin.portions)
print(crepes.portions)

Résultat : 6 puis 4.

Ajouter un comportement

Une méthode peut modifier l'objet ou calculer à partir de ses attributs.

class Recette:
    def __init__(self, nom, portions):
        self.nom = nom
        self.portions = portions
        self.ingredients = []

    def ajouter(self, ingredient):
        self.ingredients.append(ingredient)

Chaque recette démarre avec sa propre liste vide. Après crepes.ajouter("farine"), la liste crepes.ingredients contient « farine » et celle de gratin reste vide.

Les annotations de types

Une annotation de type indique le type attendu d'une variable, d'un paramètre ou d'un retour. Elle s'écrit avec un : et une flèche ->.

def prix_total(prix: float, portions: int) -> float:
    return prix * portions

class Recette:
    def __init__(self, nom: str, portions: int) -> None:
        self.nom = nom
        self.portions = portions

Pour les listes et les dictionnaires, précise le contenu entre crochets : list[str], dict[str, int]. Une valeur facultative s'écrit str | None.

Pourquoi un environnement virtuel

Chaque projet a besoin de ses propres bibliothèques, parfois dans des versions différentes. Un environnement virtuel est un dossier qui contient une copie isolée de Python et ses paquets, propre à un projet.

Le module venv est livré avec Python. Il évite de mélanger les dépendances de tous tes projets.

Créer et activer un environnement

1. Crée l'environnement dans un dossier .venv :

python -m venv .venv

2. Active-le. La commande dépend de ton système :

3. Le terminal affiche (.venv) au début de la ligne. Tu peux en sortir avec deactivate.

Installer des paquets avec pip

pip est l'outil qui installe des paquets publiés par la communauté. Environnement activé :

pip install requests
pip list

Pour que quelqu'un d'autre retrouve les mêmes paquets, note-les dans un fichier :

pip freeze > requirements.txt
pip install -r requirements.txt

La première commande écrit la liste des paquets installés. La seconde les réinstalle sur une autre machine.

À retenir

• Une classe est un plan ; Recette(...) crée une instance qui a ses propres attributs.
• __init__ initialise l'objet, self le désigne dans chaque méthode.
• Les annotations (nom: str, -> float) documentent les types sans les imposer à l'exécution.
• python -m venv .venv crée un environnement, qu'on active selon son système.
• pip install ajoute un paquet, pip freeze > requirements.txt fige la liste.
• Le dossier .venv ne se commite pas ; requirements.txt, si.