Python : éléments sur les classes

Sommaire :
• Membres spéciaux
• __class__.__name__
• __slots__
• Méthodes spéciales
• __repr__(), __str__()
• Opérateurs
• Protocole hashable
• Autres méthodes spéciales notables
• Décorateurs
• Méthodes statiques
• @staticmethod
• @classmethod
• Méthodes virtuelles
• @dataclass
• @property
• Annotations de type
• Tester les types
• isinstance
• type

Membres spéciaux

__class__.__name__

Permet d'obtenir le nom de la classe d'une instance.

__slots__

__slots__ permet de fixer les membres d'une classe, éliminant l'utilisation de __dict__, ce qui réduit la taille des objets et rend l'accès aux membres plus rapide.
Ceci est indiqué lorsque l'on a d'énormes quantités de petits objets.

class A:
    __slots__ = ['toto', 'tata']
    toto: int
    tata: int
    …

Méthodes spéciales

__repr__(), __str__()

__repr__() est appelé par "%r" % …. Il doit donner une représentation unique et exhaustive de l'objet.

__str__() est appelé par "%s" % …, print() et f"{…}". Il doit donner une représentation lisible de l'objet.

Si __str__() n'est pas défini, __repr__() est appelé à la place de __str__().

class A:

    def __repr__(self):
       return f"…"

    def __str__(self):
       return f"…"

Opérateurs

Opérateurs mathématiques: __add__(), __sub__(), __mul__(), __div__(), __and__(), __or__(), etc.

Opérateurs de comparaison: __eq__(), __ne__(), __lt__(), __le__(), __gt__(), __ge__().

Protocole hashable

Un Protocole est un ensemble de méthodes spéciales.

Le protocole hashable est __hash__() et __eq__().

__hash__() ne doit être défini que sur des objets non mutables car sinon ça ne fonctionne pas du tout comme attendu lorsque l'on utilise les objets dans les collections.

    def __key(self):
        return self.row, self.column

    def __hash__(self):
        return hash(self.__key())

    def __eq__(self, other):
        if isinstance(other, Position):
            return self.__key() == other.__key()  # pylint: disable=protected-access
        return NotImplemented

Autres méthodes spéciales notables

• __bool__() : implémente la fonction bool(), notamment utilisée dans les conditions if.
• __getitem__() : implémente l'opérateur [] ; cela rend l'objet itérable.
• __contains__() : implémente l'opérateur in.
• __len__() : implémente la fonction len().
• __call__() : implémente l'opérateur ().

Décorateurs

Méthodes statiques

@staticmethod

class A:
    @staticmethod
    def toto(…):
       …

@classmethod

class A:
    @classmethod
    def toto(cls, …):
       …

Méthodes virtuelles

Il faut utiliser @abc.abstractmethod.

@dataclass

@dataclass permet de générer automatiquement __init__(), __repr__(), et les méthodes de comparaisons.

from dataclasses import dataclass

@dataclass
class Position:
    x: float = 0.0
    y: float = 0.0

Paramètres de @dataclass :

• - @dataclass(frozen=True) : instances non mutables, ce qui permet d'avoir une fonction de hash.
• - @dataclass(order=True) : autorise les comparaisons d'ordre.

@property

@property est un décorateur permettant d'accéder au résultat d'une méthode comme si c'était un membre :

class A:
    def __init__(self):
        self._toto = …

    @property
    def toto(self):
       …
       return self._toto

    @toto.setter
    def toto(self, value):
        …
        self._toto = value

    @toto.deleter
    def toto(self):
        …
        del self._toto

a = A()
a.toto = …

On peut faire la même chose avec la fonction property :

class A:
    def __init__(self):
        self._toto = …

    def _get_toto(self):
       …
       return self._toto

    def _set_toto(self, value):
        …
        self._toto = value

    def _del_toto(self):
        …
        del self._toto

    toto = property(_get_toto, _set_toto, _del_toto, "toto description")

On peut aussi faire la même chose avec un descripteur :

class Toto:
    def __get__(self, instance, instance_type):
        …
        return instance._toto

    def __set__(self, instance, value):
        …
        self._toto = value

class A:
    def __init__(self):
        self.toto = …

    toto = Toto()

Annotations de type

Pour utiliser une classe comme annotation de type dans elle-même :

from __future__ import annotations

class Position:
    def __add__(self,
                other: Position) -> Position:
	…

Ceci n'est plus nécessaire à partir de Python 3.14 grâce aux “lazy annotations”.

Tester les types

isinstance

isinstance(a, fractions.Fraction) -> True / False

type

print(type(a))

La dernière mise à jour de cette page date d'octobre 2025.

Le contenu de ce site est, en tant qu'œuvre originale de l'esprit, protégé par le droit d'auteur.
Pour tout commentaire, vous pouvez m'écrire à xavier.lamorlette@gmail.com.