Les classes Python – attributs, méthodes et héritage

Les classes Python sont une autre façon pour gérer et stocker les données. Tous les types de données intégrés à Python sont des classes, et Python fournit des outils puissants pour manipuler tous les aspects d’une classe.

Comment fonctionne la POO (programmation orienté objet) ?
C’est une manière de programmer qui essaie de simuler la réalité. La POO est donc un certain niveau d’abstraction au-dessus de la programmation habituelle. Le composant de base est un objet qui correspond à un objet du monde réel, par exemple un objet humain ou un objet de base de données. Les objets possèdent des attributs et des méthodes.

Les attributs d’un objet sont ses propriétés, par exemple le nom et l’âge.

Les méthodes sont les fonctionnalités qu’un objet peut exécuter, par exemple marcher ou saluer.

Les avantages des classes en Python

• Les classes fournissent un moyen facile pour conserver les données et les méthodes ensemble en un seul endroit, ce qui aide à garder le programme plus organisé.
• L’utilisation de classes fournit également une autre fonctionnalité, à savoir l’héritage.
• Les classes aident à remplacer n’importe quel opérateur standard.
• L’utilisation de classes offre la possibilité de réutiliser le code, ce qui rend le programme plus efficace.
• Regrouper les fonctions et les conserver à l’intérieur d’une classe fournit une structure propre au code qui améliore la lisibilité.

Comment créer une classe ?

En fait, les instructions d’une classe Python, sont généralement des affectations de variables et des définitions de fonctions.
Par convention, l’identifiant d’une classe Python commence par une lettre majuscule.

Nous définissons une classe avec l’instruction class.

class Maclasse:
  """un exemple de classe"""
  variable = 1

>>> Maclasse
<class '__main__.Maclasse'>

Après avoir défini la classe, vous pouvez créer un nouvel objet du type classe (une instance de la classe) en appelant le nom de la classe en tant que fonction.

instance = Maclasse()

Tout en Python est un objet. Cela signifie que tout en Python possède des méthodes et des valeurs.
Par conséquent, chaque donnée en Python est basée sur une classe.

Au moment de l’instanciation d’un objet, il est toujours vide. Cependant, l’instance possède un lien vers la classe à partir de laquelle elle a été générée.

#vérifier l'espace de nom de l'instance
print(instance.__dict__)

{}

Voici un exemple dans lequel nous allons créer une chaîne de caractère.

dire_bonjour = "bonjour"

Nous avons une chaîne de caractère affectée à la variable dire_bonjour.

>>> type(dire_bonjour)
<class 'str'>

Python a automatiquement déterminé le type d’objet que vous avez créé.

Nous allons utiliser la fonction dir() pour afficher des informations sur l’objet.

>>> dir(dire_bonjour)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Lorsque vous avez créé un objet chaîne, Python vous donne la possibilité d’utiliser toutes les méthodes applicables sur une chaîne et qui existe déjà dans la classe intégrée str.

Mais qu’est-ce que cela signifie ?

Cela signifie qu’un objet est créé à partir d’une classe et que cet objet est une instance de cette classe. Mais le plus important dans l’histoire est que l’instance va hériter les attributs de la classe.

Un autre exemple de classe

Prenons un exemple dans lequel nous allons définir l’attribut d’une instance à l’extérieur d’une classe. Ça sera l’attribut texte.

class Saluer:
    """ Une classe pour saluer une personne """
    def dire_bonjour(self, nom):
        print(f"{self.texte} {nom}!")

# Créer une instance obj de la classe Saluer
obj = Saluer()
# Définir l'attribut d'instance texte
obj.texte = "Bonjour"
# Appeler la méthode dire_bojour
obj.dire_bonjour("Jack")

L’exécution du code.

Bonjour Jack!

Pour afficher une docstring d’une classe, exécutez le code suivant.

>>> print(Saluer.__doc__)
Une classe pour saluer une personne

À présent, vérifions l’espace de nom de l’instance obj.

print(obj.__dict__)

{'texte': 'Bonjour'}

Un attribut ‘texte’ a été créé dans l’instance.

Les composants et le fonctionnement d’une classe Python

Vous avez compris le concept, à présent nous allons nous intéréssés aux composants et au fonctionnement d’une classe Python.

Une classe est comme une machine, qui construit un type précis de produit. Cette machine à besoin d’un mécanisme qui démarrera le processus, c’est ce qu’on appelle un constructeur, qui sera défini par le mot clé __init__.

Afin de récupérer notre produit final, notre machine à besoin d’une matière première. Cette matière première possède certainement un emplacement précis pour qu’elle soit accueillie dans notre machine.

D’où, le recours au mot clé self qui sera remplacé par notre objet créé, ou l’instance de la classe.

En fait, cette explication m’est venue au moment même de l’écriture de ces lignes, puisque j’ai voulu simplifier le concept afin que vous puissiez comprendre une fois pour toute. Sachez que certains trouvent les classes un peu compliquées, la raison en est, qu’il n’ont pas bien assimilé le concept.

Très bien, puisque vous avez compris ce que fait __init__ (constructeur) et self (identificateur de l’objet créé), passons à l’étape suivante.

Instanciation d’un objet de classe Python

Les classes possèdent une méthode spéciale appelée __init__ (pour l’initialisation). Cette méthode est appelée chaque fois que vous créez (ou instanciez) un objet basé sur cette classe.

La méthode __init__ n’est appelée qu’une seule fois et ne doit pas être appelée à nouveau dans le programme. L’autre terme de __init__ est constructeur, bien que ce terme ne soit pas beaucoup utilisé en Python.
Vous vous demandez peut-être pourquoi on dit toujours méthode au lieu de fonction.

Une fonction change son nom en méthode, lorsqu’elle se trouve dans une classe.

Prenons un exemple, mais cette fois nous allons ajouter une méthode.

>>> class Maclasse:
	"""un exemple de classe"""
	variable = 1
	def som(self, a, b):
		return a + b

Nous allons tester notre classe.

Nous allons instancier un objet de notre classe Maclasse.

>>> mon_objet = Maclasse()

Appeler la variable de classe.

mon_objet.variable
1

Nous avons utilisé l’opérateur « point » . pour accéder à la variable de classe.

Appeler la méthode de classe.

>>> mon_objet.som(2, 3)
5

Je crois que ça commence à devenir plus clair.

La méthode __init__()

C’est une méthode dite magique, que nous pouvons utiliser pour initialiser les valeurs des classes. Donc init() représente le code d’initialisation.
En fait, la méthode init() est exécutée lorsque nous instancions la classe.
De plus, vous pouvez utiliser cette méthode pour faire tout ce que vous voulez faire lors de la création de l’objet.
Par exemple, afficher un message dans le constructeur pour vérifier si l’objet a été créé.

>>> class Fruit:
    def __init__(self, couleur, poids_g):
        print("J'aime manger des fruits.")
        self.nom = 'fruit'
        self.couleur = couleur
        self.poids_g = poids_g

Nous avons créé la classe Fruit.
Nous allons créer un objet orange et accéder à ses valeurs.

>>> orange = Fruit("orange", 100)
J’aime manger des fruits

Comme vous pouvez le constater, l’instruction print() qui se trouve à l’intérieur de __init__, a été exécutée automatiquement.

>>> print(orange.nom)
fruit
>>> orange.couleur
'orange'
>>> orange.poids_g
100

L’objet orange ou l’instance de la classe Fruit a un nom, une couleur et un poids. Le nom de tous les fruits est la variable nom, et la couleur et le poids sont transmises comme arguments. Ainsi, l’orange est un objet avec une couleur orange et un poids de 100 g. Nous avons pu accéder à ces valeurs avec l’opérateur point.

Que fait self dans une class Python

De plus, notre objet orange a remplacé le mot clé self dans chaque appel. Comme une sorte de réservation de place. En fait, le mot self est utilisé comme une sorte de convention, si vous le remplacez par un autre mot, vous aurez le même résultat.

En termes orienté objet, self est l’instance nouvellement créé, quant à couleur et poids_g deviennent des informations d’état – des données descriptives enregistrées dans un objet pour une utilisation ultérieure.

Mais dans self.couleur = couleur et self.poids_g = poids_g, pourquoi les noms d’arguments apparaissent deux fois ?
Ce code peut même sembler un peu redondant au début, mais ce n’est pas le cas. L’argument couleur, par exemple, est une variable locale dans la portée de la fonction __init__, mais self.couleur est un attribut de l’instance qui sera appelé par la méthode. Donc, ce sont deux variables différentes, qui ont le même nom.

En affectant la variable locale couleur à l’attribut self.couleur, nous sauvegardons l’attribut couleur de l’instance pour une utilisation ultérieure.

Remarque : Python utilise un constructeur par défaut pour toute classe dans laquelle vous n’ajoutez pas le vôtre.

Les attributs d’instance

Les attributs d’instance sont les attributs ou les propriétés d’une instance de classe définis dans le constructeur __init__.

Dans l’exemple précédent, les attributs d’instance sont : nom, couleur et poids_g.

Les méthodes dans une classes Python

Reprenons l’exemple des fruits, nous allons ajouter une méthode pour définir le prix de nos fruits.

Les méthodes agissent sur un objet et peuvent le modifier. Chaque méthode doit prendre self comme premier paramètre. C’est avec self qu’on va accueillir notre objet.
Définissons une méthode dans la classe Fruit. Et, ajoutons un paramètre nom à la méthode __init__().

>>> class Fruit:
	def __init__(self, nom, couleur, poids_g):
		print("J'aime manger des fruits")
		self.nom = nom
		self.couleur = couleur
		self.poids_g = poids_g
	def prix_fruit(self, prix):
		"""Définir le prix d'un fruit"""
		self.prix = prix
		print (f"Le prix d'une {self.nom} d'un poids de {self.poids_g} grammes est de € { prix}.")

Le nombre et le type de paramètres doivent être compatibles avec les paramètres reçus dans le constructeur.

>>> pomme = Fruit("pomme", "verte", 100)
J’aime manger des fruits

Dans le Shell Python, saisissez le code ci dessous et appuyez sur la touche Tab, vous allez avoir une liste déroulante qui contient tous les composant de votre objet. N’oubliez pas le point.

>>> pomme.

Choisissez prix_fruit, puis appuyez sur la touche Entrée.

>>> pomme.prix_fruit
<bound method Fruit.prix_fruit of <__main__.Fruit object at 0x7fefcec67910>>

# remplacer le paramètre prix
>>> pomme.prix_fruit(1)
Le prix d’une pomme d’un poids de 100 grammes est de € 1.

Modification des propriétés des objets

Il est également possible de modifier les attributs et les méthodes des objets.

>>> pomme.poids = 80
>>> pomme.poids
80

De plus, il est possible de les supprimer avec le mot-clé del.

>>> del pomme.poids
>>> pomme.poids
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    pomme.poids
AttributeError: 'Fruit' object has no attribute 'poids'

Ou encore, supprimer complètement l’objet.

>>> del pomme
>>> pomme.poids
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    pomme.poids
NameError: name 'pomme' is not defined

Les attributs de classe

Les attributs de classe sont différents des attributs d’instance. Un attribut dont la valeur est la même pour toutes les instances d’une classe est appelé un attribut de classe. Par conséquent, la valeur de l’attribut de classe est partagée par tous les objets.

Les attributs de classe sont définis au niveau de la classe plutôt qu’à l’intérieur de la méthode __init__(). Contrairement aux attributs d’instance, les attributs de classe sont accessibles à l’aide du nom de la classe.

>>> class Fruit:
	nom = 'fruit'
	def __init__(self, couleur, poids_g):
            print("J'aime manger des fruits")           
            self.couleur = couleur
            self.poids_g = poids_g

L’attribut nom appartient à toute la classe Fruit.

>>> pomme = Fruit("verte", 100)
J’aime manger des fruits
>>> pomme.nom
'fruit'
>>> Fruit.nom
'fruit'

La modification de l’attribut de classe à l’aide du nom de la classe affectera toutes les instances d’une classe.

>>> banane = Fruit("jaune", 100)
J’aime manger des fruits
>>> banane.nom
'fruit'

Cependant, la modification de l’attribut de classe à l’aide de l’instance n’affectera pas la classe et les autres instances. Cela n’affectera que l’instance modifiée.

>>> pomme.nom = "fruit d'été"
>>> pomme.nom
"fruit d'été"
>>> Fruit.nom
'fruit'
>>> banane.nom
'fruit'

Utilisez les attributs de classe pour stocker des valeurs constantes, suivre les données de toutes les instances (l’exemple du compteur ci-dessous) et définir les valeurs par défaut pour toutes les instances de la classe.

L’utilisation de plusieurs instances avec une classe Python

La vraie puissance de la programmation orientée objet et des classes Python est dans la création de plusieurs instances de notre classe.
Lorsque nous construisons plusieurs objets à partir d’une classe, nous pouvons définir différentes valeurs initiales pour chacun des objets. Nous pouvons transmettre des données aux constructeurs pour donner à chaque objet une valeur initiale différente.

Nous allons à présent créer un attribut de classe qui va compter les instances de la classe lorsqu’elles seront crées.

>>> class Compteur:
	count = 0
	def __init__(self):
	    Compteur.count = Compteur.count + 1

count est un attribut de la classe Compteur. Chaque fois qu’un nouvel objet est créé, la valeur de count est incrémentée de 1. Vous pouvez désormais accéder à l’attribut count après avoir créé les objets.

>>> obj_1 = Compteur()
>>> obj_1.count
1
>>> obj_2 = Compteur()
>>> obj_2.count
2
>>> obj_3 = Compteur()
>>> obj_3.count
3

Les attributs de classe intégrés

Python fournit des attributs de classe intégrés que nous pouvons utiliser pour obtenir plus d’informations sur une classe.

__dict__: que vous connaissez certainement, c’est un dictionnaire constitué de l’espace de noms de la classe.

>>> Fruit. __dict__
mappingproxy({'__module__': '__main__', 'nom': 'fruit', '__init__': <function Fruit.__init__ at 0x7fa601abfb80>, '__dict__': <attribute '__dict__' of 'Fruit' objects>, '__weakref__': <attribute '__weakref__' of 'Fruit' objects>, '__doc__': None})

__doc__ : c’est la classe docstring, mais vaut None s’il n’y a pas de docstring ou un commentaire dans la classe.

__name__ : c’est le nom de la classe.

>>> Fruit.__name__
'Fruit'

__module__ : représente le nom du module dans lequel la classe est définie. Et comme nous somme en mode interactif, c’est main.

>>> Fruit. __module__
'__main__'

Pour faciliter la recherche d’attributs, chaque instance possède un lien vers sa classe grâce à __class__.

print(pomme.__class__)

<class '__main__.Fruit'>

L’héritage des classes Python

En plus de servir de fabrique pour générer plusieurs objets d’instances, les classes nous permettent également d’apporter des modifications en introduisant de nouveaux composants (appelés sous-classes), au lieu de changer les composants existants.

L’héritage est l’un des aspects les plus importants de la programmation orientée objet. En répétant le code de nombreuses fois, des situations surviennent où nous devons écrire quelques classes avec des fonctionnalités communes et spécifiques à la classe, qui incluent à la fois des variables et des méthodes.

En Python, l’héritage est la capacité d’une classe (parente) à transmettre certaines de ses propriétés ou méthodes à une autre classe (classe enfant). Par exemple, la voiture, le bus et le vélo sont des véhicules. Le véhicule représente une classe parente ou la classe de base tandis que la voiture, le bus et le vélo sont des classes enfants ou dérivées.

L’objectif principal est de permettre aux classes de construire et de personnaliser des objets en même temps. D’une part, nous allons pouvoir minimiser la redondance du code (donc réduire les coûts de maintenance) en partageant une seule implémentation. D’une autre part, ça nous permet de personnaliser ce qui existe déjà, plutôt que de tout modifier, ce qui pourrait être fastidieux.

Continuons avec l’exemples de nos fruits.

Classe Fruit:
  pass
classe Pomme(Fruit) : 
  pass

La classe Pomme est dérivée de la classe Fruit.
L’instruction pass est utilisée pour créer une classe vide (vous pouvez également la trouver dans une fonction).

En fait, en Python, les instances héritent des classes et les classes héritent de la superclasse.

Les classes ont également un attribut __bases__, qui est un tuple qui fait référence à l’objet superclasse.

print(Pomme.__bases__)
print(Fruit.__bases__)

L’exécution du code.

(<class '__main__.Fruit'>,)
(<class 'object'>,)

L’héritage simple dans une classe Python

>>> class Fruit:
	def delice(self):
            print("Je suis un délicieux fruit")
           
>>> class Pomme(Fruit):
	def benefique(self):
            print("Les pommes sont bénéfiques")

Python dispose d’une fonction intégrée issubclass() pour vérifier si une classe est une sous-classe d’une autre.

>>> issubclass(Pomme, Fruit)
True

Exécutez ce code qui affichera la liste des attributs de la classe Pomme. Vous allez remarquer l’existence de la méthode delice de la classe Fruit.

print(dir(Pomme))

L’héritage multi-niveaux

Une classe enfant peut devenir parente d’une autre classe et ainsi de suite.

Créons une nouvelle classe Orange qui hérite de la classe Pomme, qui elle même a hérité de la classe Fruit.

>>> class Orange(Pomme):
	def vitamine_c(self):
            print("Les oranges sont riches en vitamine C")

Créons une instance de la classe Orange.

>>> vitamines = Orange()

À présent, nous allons vérifier si la classe Orange est une sub-classe des classes Pomme et Fruit.

>>> issubclass(Orange, Pomme)
True
>>> issubclass(Orange, Fruit)
True

Effectivement, essayons d’accéder aux différentes méthodes.

>>> vitamines.benefique()
Les pommes sont bénéfiques
>>> vitamines.delice()
Je suis un délicieux fruit
>>> vitamines.vitamine_c()
Les oranges sont riches en vitamine C

L’objet de la classe Orange peut accéder aux méthodes et propriétés des classes Pomme et Fruit.

L’héritage multiple des classes Python

Dans l’héritage multiple, Python nous permet d’hériter de plus d’une classe.

>>> class A:
    def methode_A(self):
	    print("Je suis la classe A")
	    
>>> class B:
    def methode_B(self):
	    print("Je suis la classe B")
	    
>>> class C(A,B):
    def methode_C(self):
	    print("Je suis la classe C et j'hérite des classe A et B.")

La classe C hérite des classes A et B en même temps.
Nous allons créer une instance de classe obj.

>>> obj = C()

>>> obj.methode_A()
Je suis la classe A

>>> obj.methode_B()
Je suis la classe B

>>> obj.methode_C()
Je suis la classe C et j’hérite des classe A et B.

L’objet de la classe C a hérité les attributs et les méthodes des classes A et B.

La fonction super() dans les classes Python

La fonction super() est utilisée pour faire référence à l’objet parent. Nous pouvons appeler la méthode super() pour accéder aux attributs et aux méthodes de la classe parente.

En effet, super() est une fonction prédéfinie en python. Par conséquent, elle permet à la classe enfant d’appeler le constructeur, les variables et les méthodes de la classe de base ou la super-classe.

En faisant référence à la classe de base, nous n’avons pas besoin d’écrire explicitement son nom.

>>> class A:
   def __init__(self):
       print("Le constructeur de la class de base A")

>>> class B(A):
   def __init__(self):
       print("Le constructeur de la class enfant B")
       super().__init__()

Nous avons appelé le constructeur de la classe parente à partir du constructeur de la classe enfant en utilisant la fonction super().

>>> obj = B()
Le constructeur de la class enfant B
Le constructeur de la class de base A

Si votre programme contient un héritage à plusieurs niveaux, la fonction super() vous sera très utile.

Modification d’une méthode héritée (Overriding)

Supposons que nous voulions modifier une méthode de la classe parente à l’intérieure de la classe enfant.

>>> class A:
    def methode(self):
        print("A est la classe parente")
        
>>> class B(A):
    def methode(self):
        print("B est la classe enfant")

Créer une instance de la classe B.

>>> objet = B()
>>> objet.methode()
B est la classe enfant

La classe B a hérité de la classe A et nous avons la même methode dans les deux classes. La méthode de la classe A a été remplacée par la méthode de la classe B.

En réalité, les recherches dans un héritage vont des instances aux sous-classes aux superclasses, s’arrêtant à la première apparition du nom d’attribut trouvé. Par conséquent, le nom methode de la classe B a été trouvé avant celui de la classe A. En terme de programmation, on dit que la classe B a surchargé la méthode methode de la classe A.

De plus, sachez que la personnalisation introduite dans B est complètement externe à A. Autrement dit, cela n’affecte pas les objets existants ou futurs de A.

En règle générale, parce que l’héritage nous permet de faire des modifications en externe (sous-classes), les classes prennent souvent en charge l’extension et la réutilisation du code mieux que les fonctions ou les modules.

La surcharge de méthodes en Python (Overloading)

Contrairement à d’autres langages de programmation comme C, C ++ ou Java, deux méthodes ne peuvent pas avoir le même nom en Python. Cependant, la surcharge de méthode en Python est une fonctionnalité qui permet au même opérateur d’avoir des significations différentes.

Par conséquent, vous pouvez avoir une méthode qui a zéro, un ou plusieurs paramètres.

Créer deux fonctions avec le même nom.

>>> def bonjour():
	print("Bonjour à tous")

>>> def bonjour(nom):
	print("Bonjour", nom)

Nous appelons les deux fonctions.

>>> bonjour("Christophe")
Bonjour Christophe

>>> bonjour()
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    bonjour()
TypeError: bonjour() missing 1 required positional argument: 'nom'

Python à pris en considération la dernière fonction et a écrasé la première.

Nous pouvons résoudre ce problème en définissant le paramètre à None.

>>> def bonjour(nom=None):
	if nom is not None:
		print("Bonjour", nom)
	else:
		print("Bonjour à tous")

Nous pouvons à présent appeler notre fonction avec et sans paramètre.

>>> bonjour()
Bonjour à tous
>>> bonjour("Christophe")
Bonjour Christophe

En fait, ces deux derniers concept sont connus sous le nom de polymorphisme. Ce qui signifie, plusieurs formes ou lorsque la même méthode est déclarée plusieurs fois, à des fins multiples et dans différentes classes Python.

Le polymorphisme des opérateurs dans des classes Python

Le même opérateur peut effectuer différentes opérations en fonction du type de données.

Par exemple, l’opérateur + agit sur des données de type différent différemment.

• Lorsqu’il est utilisé avec des nombres, il effectue une opération d’addition.
• Il concatène deux chaînes de caractères.
• Et, il fusionne les listes.

Conclusion

Étant donné que chaque instance d’une classe possède ses propres attributs, les classes sont un moyen naturel pour stocker des informations de plusieurs objets. Tout comme les types de données intégrés tels que les listes et les dictionnaires, les classes servent de constructeurs d’objets.

Les classes et les instances ne sont que des objets possédant des espaces de noms, avec des attributs créés à la volée par affectation. Ces affectations ont généralement eu lieu au sein de la classe, mais elles peuvent se produire partout où vous avez une référence à l’un des objets dans l’arborescence.

J’espère que cet article sur les classes Python vous a été utile. En fait, j’ai essayé de simplifier les choses et d’aller étape par étape pour que vous puissiez assimiler les concepts.

Comment accéder aux attributs d’une classe ?
Les méthodes de classes et statiques
Les attributs et les méthodes privés
Les méthodes spéciales pour renforcer vos classes
@property – un décorateur à utiliser dans vos classes Python
L’héritage des classes Python et l’ordre de résolution des méthodes
Les classes abstraites en Python pour un code plus propre
Les descripteurs Python et l’accès aux attributs (avancé)
La documentation officielle de Python