Classes Python : __init__, self, méthodes, héritage et dataclasses

Une classe enveloppe les données et ce que tu en fais

Une classe te permet de définir un type de chose — un utilisateur, un compte bancaire, une configuration, une requête — et tout ce que cette chose devrait pouvoir faire. La chose est une instance de la classe. Les actions s'appellent des méthodes.

Voici la classe la plus simple possible :

Décomposons :

• class User: commence une définition de classe. Les noms de classes utilisent PascalCase par convention.
• __init__ est l'initialiseur. Il s'exécute automatiquement quand tu crées une nouvelle instance. Il met en place les attributs de l'instance avec self.whatever = ....
• greet est une méthode. self est la façon dont une méthode fait référence à l'instance sur laquelle elle a été appelée.
• User("Rosa", "rosa@example.com") crée une instance. Python appelle __init__ avec self défini à la nouvelle instance et les autres arguments passés.
• user.greet() appelle la méthode. Python passe user comme self automatiquement.

self n'est que le premier argument

self n'est pas un mot-clé. C'est le nom que Python donne au premier paramètre des méthodes d'instance — l'instance sur laquelle la méthode tourne. Tu pourrais l'appeler autrement ; tout le monde utilise self parce que tout le monde l'utilise.

Chaque méthode d'instance prend self comme premier paramètre. C'est comme ça qu'une méthode sait sur quelle instance lire ou modifier.

Ajouter du comportement

Les méthodes peuvent lire et muter l'état :

__repr__ est une autre méthode spéciale — un hook « comment afficher cet objet quand imprimé ? ». En définir un bon paie des dividendes pendant le débogage.

Attributs de classe vs attributs d'instance

Les attributs définis dans le corps de la classe (en dehors de __init__) sont partagés entre toutes les instances. Les attributs affectés à self sont par instance :

Utilise les attributs de classe pour des valeurs vraiment partagées — constantes, compteurs, config. Mets les données spécifiques à l'instance dans __init__.

Héritage

Une classe peut hériter d'une autre, obtenant ses méthodes et attributs gratuitement et en ajoutant ou redéfinissant au besoin :

super() te donne accès à la classe parente — couramment utilisée dans __init__ pour initialiser les attributs du parent avant d'ajouter les tiens :

L'héritage est utile mais facile à surutiliser. Un nouveau programmeur Python utilise souvent l'héritage quand la composition — garder un objet comme attribut — serait plus claire. Commence avec une structure de classes plate et n'introduis l'héritage que quand tu as une vraie relation « est-un ».

Dataclasses : un meilleur défaut pour les enregistrements

Quand tu veux surtout qu'une classe contienne quelques attributs avec un comportement d'égalité et de représentation, @dataclass épargne beaucoup de boilerplate :

Compare ça à écrire __init__, __repr__ et __eq__ à la main. Les dataclasses sont le bon premier choix quand tu écrirais sinon class Thing avec rien que __init__ qui met des attributs.

Propriétés : attributs calculés

Parfois tu veux un « attribut » qui est en fait calculé. @property fait que ça ressemble à un accès d'attribut :

Utilise les propriétés quand tu écrirais obj.get_something() — le remplacer par une propriété rend l'API plus naturelle. Ne les utilise pas pour cacher des opérations coûteuses ; un utilisateur s'attend à ce que l'accès aux attributs soit rapide.

Privé par convention

Python n'a pas de vrai privé. Par convention, les attributs avec un underscore au début sont censés être privés — les lecteurs sont censés ne pas y toucher depuis l'extérieur de la classe :

class Cache:
    def __init__(self):
        self._store = {}

    def put(self, key, value):
        self._store[key] = value

    def get(self, key, default=None):
        return self._store.get(key, default)

Les noms à double underscore (__name) déclenchent le name mangling, qui ajoute le nom de la classe à l'attribut. C'est un outil pour éviter les collisions en héritage, pas une mesure de sécurité.

Quand ne pas utiliser une classe

Si tout ce que tu as, c'est un paquet de données liées, une dataclass ou un simple dict ou un named tuple feront l'affaire. Si tout ce que tu as, c'est une fonction, elle n'a pas besoin d'une classe pour la contenir. Utilise les classes quand tu as à la fois état et comportement liés ensemble — surtout quand tu auras beaucoup d'instances du même genre.

Un exemple final

Un petit buffer de log de type fichier :

Remarque __len__ — une autre méthode magique. La définir fait que len(logger) marche, parce que len(x) est en fait un appel à x.__len__(). Python a des dizaines de ces hooks ; tu les prendras au besoin.

Ensuite : les générateurs

Les classes lient données et comportement. Le prochain chapitre regarde une sorte d'abstraction différente — l'itération — en commençant par les générateurs : des fonctions qui produisent des valeurs une à la fois, en faisant une pause entre les deux. Elles se marient magnifiquement avec les gestionnaires de contexte / l'instruction with que tu rencontreras juste après.