Python, de zéro

Pour l'attribut c'est implicite dès lors qu'il est défini en dehors de toute méthode. À partir de là, depuis l'extérieur, l’accès à cet attribut se fera depuis le nom de la classe elle‑même.

Exemple : création d’un compteur d’instances

class personne:
    cpt=0                                  # Compteur de personnes (membre statique)
    def __init__(self, nom):
        self.__nom=nom
        personne.cpt+=1                    # Une personne de plus
    def __del__(self):
        personne.cpt-=1                    # Une personne de moins

>>> p1=personne("Pierre")
>>> p2=personne("Paul")
>>> p3=personne("Jacques")
>>> personne.cpt
3
>>> del p3
>>> personne.cpt
2

Bien que l’accès à l’attribut se fasse depuis le nom de la classe elle‑même, il peut aussi se faire depuis une instance de la classe et se comporte alors comme un « attribut d’instance » tout en restant attribut de classe (donc unique dans la classe).

class toto: item=123

>>> toto.item
123
>>> p1=toto()
>>> p1.item
123
>>> p2=toto()
>>> p2.item
123
>>> toto.item=456
>>> toto.item
456
>>> p2.item
456
>>> p1.item
456
>>> p3=toto()
>>> p3.item
456

L’attribut de classe peut toutefois devenir un vrai attribut d’instance si on le modifie (recrée) dans l’instance. Tout comme pour les variables globales et locales, l’attribut d’instance prend alors le pas sur l’attribut de classe.

>>> class toto: item=123
...
>>> p1=toto()
>>> p2=toto()
>>> toto.item
123
>>> p1.item
123
>>> p2.item
123
>>> p1.item=456
>>> p1.item
456
>>> p2.item
123
>>> toto.item
123

Pour la méthode, cela se fait en l’encapsulant dans une surcouche staticmethod(). À ce moment‑là, la méthode ne recevra plus d’instance de classe dans ses arguments et n’a donc plus à définir de self.

class point:
    def __milieu(x, y):
        return (x.__v + y.__v) / 2
    milieu1=staticmethod(__milieu)                              # Méthode statique
    milieu2=staticmethod(lambda x, y : (x.__v + y.__v) / 2)     # Méthode statique
    def __init__(self, v):
        self.__v=v

>>> p1=point(4)
>>> p2=point(8)
>>> point.milieu1(p1, p2)
6.0
>>> point.milieu2(p1, p2)
6.0

Comme on le voit, les méthodes milieu1() ou milieu2(), permettant de calculer le milieu barycentrique de deux points, ne peuvent pas s’appliquer à un point en particulier. Elles ne peuvent donc pas être utilisées comme des méthodes d’instance. Cependant, elles ne concernent que des points et s’appliquent donc à tous les points en général et peuvent par conséquent être intégrées dans l’objet point (ce qui renforce la modularité du code). La solution est d’en faire alors des « méthodes statiques ».

À noter : la méthode interne __milieu() étant définie dans la classe, elle bénéficie quand même d’un accès à tous les attributs de la classe, y compris ses attributs privés (elle reçoit en paramètre deux instances de point x et y, elle a alors accès à x.__v et y.__v). Et les méthodes statiques milieu1() et milieu2() ont aussi cette possibilité.

Et de même que pour les getters/setters/deleters, il existe un sucre syntaxique @staticmethod qui permet de raccourcir cette surcouche staticmethod().

class point:
    @staticmethod                            # Préparation à la méthode de classe
    def milieu(x, y):                        # Définition de la méthode de classe
        return (x.__v + y.__v) / 2
    def __init__(self, v):
        self.__v=v

>>> p1=point(4)
>>> p2=point(8)
>>> point.milieu(p1, p2)
6.0

L’attribut __dict__ référence tous les attributs créés dans l’instance.

class xxx:
    def __init__(self):
        self.s="Hello"
        self.i=123

>>> x=xxx()
>>> print(x.__dict__)
{'s': 'Hello', 'i': 123}

Tout nouvel attribut viendra compléter cet attribut interne…

>>> x.f=3.1416
>>> print(x.__dict__)
{'s': 'Hello', 'i': 123, 'f': 3.1416}

De même, tout remplissage manuel de cet attribut équivaudra à la création (ou la modification) de l’attribut correspondant…

>>> x.__dict__["i"]=456
>>> print(x.i)
456

La méthode __delattr__() est automatiquement appelée à chaque fois qu’un attribut est supprimé de son instance.

class xxx:
    def __init__(self):
        self.s="Hello"
        self.i=123
    def __delattr__(self, attr):
        print("deleting [%s]" % attr)
        super().__delattr__(attr)

>>> x=xxx()
>>> print(x.i)
123
>>> del x.i
deleting [i]
>>> print(x.i)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'xxx' object has no attribute 'i'

Toutefois, la méthode n’est pas invoquée si l’attribut est supprimé par le __dict__.

>>> del x.__dict__["s"]
>>> print(x.s)
Traceback (most recent call last):
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'xxx' object has no attribute 's'

La méthode __getattr__() est automatiquement appelée à chaque fois qu’une instance invoque un attribut inexistant.

En revanche, pour des raisons de performances, si l’attribut existe, alors la méthode n’est pas appelée.

class xxx:
    def __init__(self):
        self.s="Hello"
        self.i=123
    def __getattr__(self, attr):
        print("getting [%s]" % attr)
        return "perdu"

>>> x=xxx()
>>> print(x.s)
Hello
>>> print(x.i)
123
>>> print(x.j)
getting [j]
Perdu

La méthode __getattribute__() est automatiquement appelée à chaque fois qu’un attribut est invoqué par son instance.

class xxx:
    def __init__(self):
        self.s="Hello"
        self.i=123
    def __getattribute__(self, attr):
        print("getting [%s]" % attr)
        return super().__getattribute__(attr)

>>> x=xxx()
>>> print(x.i)
getting [i]
123

Contrairement à ce qui se passe dans la méthode __delattr__(), ici, passer par le __dict__ pour tenter de contourner cette méthode en y cherchant directement l’attribut implique quand même un accès à l’attribut __dict__ ce qui provoque alors tout de même l’appel de la méthode.

>>> print(x.__dict__["i"])
getting [__dict__]
123

La méthode __setattr__() est automatiquement appelée à chaque fois qu’un attribut est créé ou modifié par son instance.

class xxx:
    def __init__(self):
        self.s="Hello"
        self.i=123
    def __setattr__(self, attr, value):
        print("setting [%s]: (%d)" % (attr, value))
        super().__setattr__(attr, value)

>>> x=xxx()
setting [s]: (Hello)
setting [i]: (123)
>>> print(x.i)
123
>>> x.i=456
setting [i]: (456)
>>> print(x.i)
456

Cependant, la méthode n’est pas invoquée si l’attribut est créé ou modifié par le __dict__ et la modification du __dict__ n’entraine pas non plus l’appel de cette méthode.

>>> x.__dict__["i"]=789
>>> print(x.i)
789

En Python, la méthode spéciale __init__() est souvent appelée constructeur de l’objet. Il s’agit en fait d’un abus de langage : la méthode __init__() ne construit pas l’objet, elle intervient après la création de ce dernier pour l’initialiser.

Le vrai constructeur d’une classe est la méthode __new__(). Cette méthode est une méthode statique (un cas particulier qui n’a pas besoin d’être déclaré comme tel) qui prend une classe en premier paramètre (le paramètre self n’existe pas encore puisque l’objet n’est pas encore créé), et doit renvoyer l’objet nouvellement créé. Les autres paramètres sont identiques à ceux reçus par __init__() puisque la méthode doit ensuite appeler cette dernière en lui passant les paramètres qu’elle attend (ce qui se fait alors de façon automatique).

class cercle:
    def __new__(cls, rayon):
        print("new [%s], rayon=%d" % (cls, rayon))
        return super().__new__(cls)
    def __init__(self, rayon):
        print("init [%s], rayon=%d" % (self, rayon))

>>> c=cercle(5)
new [<class '__main__.cercle'>], rayon=5
init [<__main__.cercle object at 0x7feff77427b8>], rayon=5
>>> print(c)
<__main__.cercle object at 0x7feff77427b8>

Cette méthode est particulièrement utile pour les objets immuables (str, tuple). En effet, il est impossible d’agir sur les objets dans la méthode __init__(), puisque celle-ci intervient après la création de l’objet, et que de fait, l’objet créé n’est alors plus modifiable.

Si l’on souhaite hériter d’un type immuable et agir sur l’initialisation de l’objet, il est donc nécessaire de redéfinir __new__(). Par exemple, pour créer une classe point qui hériterait de tuple…

class point(tuple):
    def __new__(cls, x, y):
        print("new [%s], x=%s, y=%s" % (cls, x, y))
        return super().__new__(cls, (x, y))
    x=property(lambda self: self[0])
    y=property(lambda self: self[1])

>>> t=point(2, 3)
new [<class '__main__.point'>], x=2, y=3
>>> print(t[0])
2
>>> print(t.x)
2
>>> print(t[1])
3
>>> print(t.y)
3

… tout en gardant le bénéfice de l’immuabilité du tuple.

>>> t.x=123
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute

En Python, la méthode spéciale __init_subclass__() est appelée par un objet quand il est instancié par l’un de ses héritiers.

C’est une méthode là aussi statique qui prend également une classe en premier paramètre.

Elle permet de créer si besoin des attributs statiques dans la classe fille en les créant « à la volée » dans la classe mère.

Prenons un exemple simple : une gestion de figures géométriques avec nombre de sommets.

Première solution : des classes simples…

class carre:
    sommets=4
    def __init__(self, cote):
        print("carre init: %s (cote=%d)" % (self, cote))
        self.cote=cote

class pentagone:
    sommets=5
    def __init__(self, cote):
        print("pentagone init: %s (cote=%d)" % (self, cote))
        self.cote=cote

>>> c=carre(10)
carre init: <__main__.carre object at 0x7f02cc573470> (cote=10)
>>> c.cote
10
>>> c.sommets
4
>>> p=pentagone(12)
pentagone init: <__main__.pentagone object at 0x7f02cc573438> (cote=12)
>>> p.cote
12
>>> p.sommets
5

C’est dommage qu’il n’y ait pas quelque part une espèce de centralisation des éléments redondants (ici le nombre de sommets).

Donc seconde solution : des classes qui héritent d’une classe mère en lui passant les sommets qu’elle a à gérer…

class figure:
    def __init__(self, sommets):
        print("figure init: %s (sommets=%d)" % (self, sommets))
        self.sommets=sommets

class carre(figure):
    def __init__(self, cote):
        super().__init__(4)
        print("carre init: %s (cote=%d)" % (self, cote))
        self.cote=cote

class pentagone(figure):
    def __init__(self, cote):
        super().__init__(5)
        print("pentagone init: %s (cote=%d)" % (self, cote))
        self.cote=cote

>>> c=carre(10)
figure init: <__main__.carre object at 0x7fcf87fea438> (sommets=4)
carre init: <__main__.carre object at 0x7fcf87fea438> (cote=10)
>>> c.cote
10
>>> c.sommets
4
>>> p=pentagone(12)
figure init: <__main__.pentagone object at 0x7fcf87fbcb38> (sommets=5)
pentagone init: <__main__.pentagone object at 0x7fcf87fbcb38> (cote=12)
>>> p.cote
12
>>> p.sommets
5

C’est fonctionnel, mais les sommets d’une figure n’ayant pas vocation à changer au cours du temps, c’est dommage de ne pas les stocker de façon statique.

D’où la 3° méthode : passer par __init_subclass__() qui aura pour rôle de paramétrer l’attribut statique de la classe mère en fonction de la configuration de la classe fille.

class figure:
    def __init__(self):
        print("figure init: %s" % self)

    def __init_subclass__(cls, sommets):
        super().__init_subclass__()
        print("figure init_subclass: %s (sommets=%d)" % (cls, sommets))
        cls.sommets=sommets

>>> class carre(figure, sommets=4):
...    def __init__(self, cote):
...        super().__init__()
...        print("carre init: %s (cote=%d)" % (self, cote))
...        self.cote=cote
...
figure init_subclass: <class '__main__.carre'> (sommets=4)

>>> class pentagone(figure, sommets=5):
...    def __init__(self, cote):
...        super().__init__()
...        print("pentagone init: %s (cote=%d)" % (self, cote))
...        self.cote=cote
...
figure init_subclass: <class '__main__.pentagone'> (sommets=5)

>>> c=carre(10)
figure init: <__main__.carre object at 0x7fd04a525b70>
carre init: <__main__.carre object at 0x7fd04a525b70> (cote=10)
>>> print(c.cote)    
10
>>> print(c.sommets)
4
>>> p=pentagone(12)
figure init: <__main__.pentagone object at 0x7fd04a525b00>
pentagone init: <__main__.pentagone object at 0x7fd04a525b00> (cote=12)
>>> print(p.cote)
12
>>> print(p.sommets)
5

C’est un peu le principe en allégé de la métaclasse que l’on verra un peu plus tard.

Il a été vu dans le chapitre sur les objets qu’il est possible de leur créer de nouveaux attributs de façon manuelle et externe…

class personne:
    def __init__(self, nom):
        self.nom=nom

>>> p=personne("LeRoi")
>>> p.prenom="Arthur"
>>> p.nom
'LeRoi'
>>> p.prenom
'Arthur'

… ce qui est rarement une bonne chose…

>>> p1=personne("LeRoi")
>>> p1.prenom="Arthur"
>>> p2=personne("Autre")
>>>
>>> for x in (p1, p2):
...    print(x.nom, x.prenom)
...
LeRoi, Arthur
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: personne' object has no attribute 'prenom'

L’attribut __slots__ (attribut statique) permet de protéger son objet contre de telles manipulations.

Il suffit de le créer dans son objet en lui donnant l’attribut ou la liste des attributs permis pour l’objet. Toute création d’un attribut non présent dans cette liste provoquera une exception.

class personne:
    __slots__=("nom", "prenom")

    def __init__(self, nom, prenom):
        self.nom=nom
        self.prenom=prenom

>>> p=personne("LeRoi", "Arthur")
>>> p.age=800
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'personne' object has no attribute 'age'

Ce verrouillage se fait au travers de l’attribut __dict__ qui est alors purement supprimé de l’objet.

>>> print(p.__dict__)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'personne' object has no attribute '__dict__'

Une classe peut devenir « callable » ; c’est-à-dire qu’une instance de cette classe peut être appelée en tant que fonction ; par le biais de la méthode spécifique __call__().

class ccc:
    def __call__(self, x, y):
        print("ici (%s, %s)" % (x, y))

>>> x=ccc()                    # Création d’un objet "ccc" instancié dans une variable "x"
>>> x(2, 3)                    # Appel de "x" comme si c’était une fonction
ici (2, 3)

Une classe peut devenir « indexable » ; c’est-à-dire être utilisée comme si elle était une séquence (tuple, liste ou dictionnaire) dans laquelle on accèderait à un élément indexé ou slicé ; par le biais des méthodes spécifiques __getitem__() (pour récupérer un élément) et __setitem__() (pour positionner un élément).

Cela se pratique généralement quand la classe contient un attribut de nature séquentiel et qu’on désire accéder aux éléments distincts de l’attribut sans passer par son nom (surtout si cet attribut séquentiel est un attribut privé).

class maListe:
    def __init__(self, tab=None):
        self.__tab=list(tab or ())
    def __getitem__(self, idx):
        print("getitem (%d)" % idx)
        return self.__tab[idx]
    def __setitem__(self, idx, n):
        print("setitem (%d, %s)" % (idx, n))
        self.__tab[idx]=n

>>> m=maListe(("Pim", "Pam", "Poum"))
>>> print(m[2])
getitem (2)
Poum
>>> m[2]="toto"
setitem (2, toto)
>>> print(m[2])
toto

Une classe peut devenir « itérable » ; c’est-à-dire être utilisable dans une boucle d’itération ; par le biais de la méthode spécifique __iter__().

Cela se pratique généralement quand la classe contient un attribut de nature séquentielle et qu’on désire itérer directement sur les éléments distincts de l’attribut sans passer par son nom (surtout si cet attribut séquentiel est un attribut privé) ni avoir besoin de passer par son indexation.

class maListe:
    def __init__(self, tab=None):
        self.__tab=list(tab or ())
    def __iter__(self):
        yield from self.__tab                # for x in self.__tab: yield x (en Python 2)

>>> m=maListe(("Pim", "Pam", "Poum"))
>>> for x in m : print(x)
Pim
Pam
Poum
>>> print(tuple(m))
('Pim', 'Pam', 'Poum')

Une telle classe qui se veut itérable peut aussi implémenter la méthode spécifique __next__() permettant alors d’y appliquer la fonction next().

class maListe:
    def __init__(self, tab=None):
        self.__tab=list(tab or ())
        self.__idx=0
    def __next__(self):
        if self.__idx == len(self.__tab):
            raise StopIteration
        t=self.__tab[self.__idx]
        self.__idx+=1
        return t

>>> m=maListe(("Pim", "Pam", "Poum"))
>>> while True: print(next(m))
...
Pim
Pam,
Poum
Traceback (most recent call last):
  File "<stdin>", line 13, in <module>
    while True: print(next(m))
  File "<stdin>", line 7, in __next__
    raise StopIteration
StopIteration

Une classe peut devenir « mesurable » ; c’est-à-dire indiquer sa longueur ; par le biais de la méthode spécifique __len__().

Cela se pratique généralement quand la classe contient un attribut de nature séquentielle et qu’on désire avoir la longueur de cet attribut sans passer par son nom (surtout si cet attribut séquentiel est un attribut privé) ni avoir besoin de passer par son indexation.

class maListe:
    def __init__(self, tab=None):
        self.__tab=list(tab or ())
    def __len__(self):
        return len(self.__tab)

>>> m=maListe(("Pim", "Pam", "Poum"))
>>> print(len(m))
3

Une classe peut indiquer une contenance ; c’est-à-dire vérifier si un élément est présent ou pas ; par le biais de la méthode spécifique __contains__().

Cela se pratique généralement quand la classe contient un attribut de nature séquentielle et qu’on désire simplement vérifier si cet attribut contient un élément particulier sans passer par son nom (surtout si cet attribut séquentiel est un attribut privé) ni avoir besoin de passer par son indexation ou son itération.

class maListe:
    def __init__(self, tab=None):
        self.__tab=list(tab or ())
    def __contains__(self, x):
        return x in self.__tab

>>> m=maListe(("Pim", "Pam", "Poum"))
>>> print("Poum" in m)
True

Une classe peut définir des opérateurs usuels (comme l’addition, soustraction, etc.) permettant ensuite de l’utiliser dans des opérations classiques.

class cPoint:
    def __init__(self, x=0, y=0):
        self.__x=x
        self.__y=y
    def __add__(self, n):                      # Redéfinit l’addition
        return cPoint(self.__x + n.__x, self.__y + n.__y)
    def __repr__(self):                        # Redéfinit la façon de représenter un objet
        return "x=%d, y=%d" % (self.__x, self.__y)

>>> a=cPoint(2, 3)
>>> b=cPoint(4, 5)
>>> a+b
x=6, y=8

Voici une liste non exhaustive des opérateurs les plus usuels :

• mathématiques :

  • __add__ (addition) : permet d’appeler objet+n

  • __radd__ (addition renversée) : permet d’appeler n+objet,

  • __iadd__ (addition inplace) : permet d’appeler objet+=n (si cette méthode n’est pas présente, ce sera __add__ qui sera utilisée à la place),

  • __sub__ (soustraction) : permet d’appeler objet‑n

  • __rsub__ (soustraction renversée) : permet d’appeler n‑objet,

  • __isub__ (soustraction inplace) : permet d’appeler objet‑=n (si cette méthode n’est pas présente, ce sera __sub__ qui sera utilisée à la place),

  • __mul__ (multiplication) : permet d’appeler objet*n,

  • __rmul__ (multiplication renversée) : permet d’appeler n*objet,

  • __imul__ (multiplication inplace) : permet d’appeler objet*=n (si cette méthode n’est pas présente, ce sera __mul__ qui sera utilisée à la place),

  • __div__ (division dans Python 2, n’existe pas dans Python 3) : permet d’appeler objet/n,

  • __rdiv__ (division renversée dans Python 2, n’existe pas dans Python 3) : permet d’appeler n/objet,

  • __idiv__ (division inplace renversée dans Python 2, n’existe pas dans Python 3) : permet d’appeler objet/=n (si cette méthode n’est pas présente, ce sera __div__ qui sera utilisée à la place),

  • __floordiv__ (division entière) : permet d’appeler objet//n,

  • __rfloordiv__ (division entière renversée) : permet d’appeler n//objet,

  • __ifloordiv__ (division entière inplace) : permet d’appeler objet//=n (si cette méthode n’est pas présente, ce sera __floordiv__ qui sera utilisée à la place),

  • __truediv__ (division exacte dans Python 3, n’existe pas dans Python 2) : permet d’appeler objet/n,

  • __rtruediv__ (division exacte renversée dans Python 3, n’existe pas dans Python 2) : permet d’appeler n/objet,

  • __itruediv__ (division exacte inplace dans Python 3, n’existe pas dans Python 2) : permet d’appeler objet/=n (si cette méthode n’est pas présente, ce sera __truediv__ qui sera utilisée à la place),

  • __mod__ (modulo) : permet d’appeler objet%n,

  • __rmod__ (modulo renversé) : permet d’appeler n%objet,

  • __imod__ (modulo inplace) : permet d’appeler objet%=n (si cette méthode n’est pas présente, ce sera __mod__ qui sera utilisée à la place),

  • __pow__ (puissance) : permet d’appeler objet**n,

  • __rpow__ (puissance renversée) : permet d’appeler n**objet,

  • __ipow__ (puissance inplace) : permet d’appeler objet**=n (si cette méthode n’est pas présente, ce sera __pow__ qui sera utilisée à la place),

  • __and__ (« et » bit à bit) : permet d’appeler objet&n,

  • __rand__ (« et » bit à bit renversé) : permet d’appeler n&objet,

  • __iand__ (« et » bit à bit inplace) : permet d’appeler objet&=n (si cette méthode n’est pas présente, ce sera __and__ qui sera utilisée à la place),

  • __or__ (« ou » bit à bit) : permet d’appeler objet|n,

  • __ror__ (« ou » bit à bit renversé) : permet d’appeler n|objet,

  • __ior__ (« ou » bit à bit inplace) : permet d’appeler objet|=n (si cette méthode n’est pas présente, ce sera __or__ qui sera utilisée à la place),

  • __xor__ (« ou exclusif » bit à bit) : permet d’appeler objet^n,

  • __rxor__ (« ou » bit à bit renversé) : permet d’appeler n^objet,

  • __ixor__ (« ou » bit à bit inplace) : permet d’appeler objet^=n (si cette méthode n’est pas présente, ce sera __xor__ qui sera utilisée à la place),

  • __lshift__ (décalage vers la gauche) : permet d’appeler objet << n,

  • __ilshift__ (décalage vers la gauche inplace) : permet d’appeler objet<<=n (si cette méthode n’est pas présente, ce sera __lshift__ qui sera utilisée à la place),

  • __rshift__ (décalage vers la droite) : permet d’appeler objet >> n,

  • __irshift__ (décalage vers la droite inplace) : permet d’appeler objet>>=n (si cette méthode n’est pas présente, ce sera __rshift__ qui sera utilisée à la place),

  • __neg__ (passage en négatif) : permet d’appeler ‑objet,

  • __pos__ (identité neutre) : permet d’appeler +objet,

  • __inv__ (inversion bit à bit) : permet d’appeler ~objet,

  • __abs__ (valeur absolue) ;

• booléens : __eq__ (égal à), __ne__ (différent de), __lt__ (inférieur à), __le__ (inférieur ou égal à), __gt__ (supérieur à), __ge__ (supérieur ou égal à), et . À noter sous Python 2 la présence de __cmp__ (comparaison riche devant renvoyer -1/0/1 si le premier élément est inférieur, égal ou supérieur au second élément et peut se substituer à tous les autres opérateurs booléens, mais ayant disparu dans Python 3).

Une classe peut redéfinir des opérations de cast qui lui seront appliquées. Ainsi, elle peut redéfinir __bool__ (booléen), __float__ (flottant), __int__ (entier), __bytes__ (chaîne), __str__ (chaîne) : permettent de surcharger le cast d’un objet en bool, float, int, bytes, str. À noter sous Python 2 que __bool__ se nomme alors __nonzero__ ainsi que la présence supplémentaire de __long__ et __unicode__ qui permettent de surcharger le cast d’un objet en long et en unicode. De plus, __bytes__ n’existe pas dans cette version.

Elle peut aussi redéfinir __repr__ (représentation) utilisé par repr().

Une classe peut devenir « hashable » ; c’est-à-dire pouvoir faire l’objet d’un calcul d’empreinte numérique ; par le biais de la méthode spécifique __hash__().

class maClass:
    def __hash__(self):
        return 123

>>> m=maClass()
>>> print(hash(m))
123

Il est possible de contrôler la liste des attributs donnés par la fonction dir() ; par le biais de la méthode spécifique __dir__(). Cette méthode, si elle est implémentée, doit impérativement renvoyer un itérable qui sera finalement transformé en liste.

class maClass:
    def __dir__(self):
        return "123"

>>> m=maClass()
>>> dir(m)
[1, 2, 3]

Il est possible de contrôler l’affichage d’une classe grâce à la méthode format() ou celle des « f-strings ».

class maClass:
    def __init__(self, n):
        self.n=n
    def __format__(self, fmt):
        print("fmt: [%s]" % fmt)
        return "{0:{1}}".format(self.n, fmt)

>>> m=maClass(42)
>>> print("{:05d}".format(m))
fmt: [05d]
00042
>>> print(f"{m:04d}")
fmt: [04d]
0042