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:
	…

Tester les types

isinstance

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

type

print(type(a))

La dernière mise à jour de cette page date de mai 2024.

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.