Une introduction à Python 3

Une classe est équivalente à un nouveau type de données. On connaît déjà par exemple les classes list ou str et les nombreuses méthodes permettant de les manipuler, par exemple :

• [3, 5, 1].sort()
• casse.upper()

Un objet ou une instance est un exemplaire particulier d'une classe. Par exemple [3, 5, 1] est une instance de la classe list et casse est une instance de la classe str.

Les objets ont généralement deux sortes d'attributs : les données nommées simplement attributs et les fonctions applicables appelées méthodes.

Par exemple un objet de la classe complex possède :

• deux attributs : imag et real ;
• plusieurs méthodes, comme conjugate(), abs()…

La plupart des classes encapsulent à la fois les données et les méthodes applicables aux objets. Par exemple un objet str contient une chaîne de caractères Unicode (les données) et de nombreuses méthodes.

On peut définir un objet comme une capsule contenant des attributs et des méthodes :

UML propose une grande variété de diagrammes (classes, objets, états, activités, etc.). En première approche, le diagramme de classes est le plus utile pour concevoir les classes et leurs relations.

Cette instruction permet d'introduire la définition d'une nouvelle classe (c'est-à-dire d'un nouveau type de données).

>>> class C:
...     """Documentation de la classe C."""
...     x = 23

Dans cet exemple, C est le nom de la classe (qui commence conventionnellement par une majuscule), et x est un attribut de classe, local à C.

• Les classes sont des fabriques d'objets : on construit d'abord l'usine avant de produire des objets !
• On instancie un objet (c'est-à-dire qu'on le produit à partir de l'usine) en appelant le nom de sa classe comme s'il s'agissait d'une fonction :

class C :
    """Documentation de la classe C."""
    x = 23 # attribut de classe
    y = 'un string'
    z = [1, x, 3, y]

# a est un objet de la classe C (ou une instance)
a = C()
# Affichage des attributs de l'instance a
print(a.x)
print(a.y)
print(a.z)

On a déjà vu les espaces de noms(23) locaux (lors de l'appel d'une fonction), globaux (liés aux modules) et internes (fonctions standard), ainsi que la règle « Local Global Interne » (cf. section 5.3Espaces de noms) qui définit dans quel ordre ces espaces sont parcourus pour résoudre un nom.

Les classes ainsi que les objets instances définissent de nouveaux espaces de noms, et il y a là aussi des règles pour résoudre les noms :

• les classes peuvent utiliser les variables définies au niveau principal, mais elles ne peuvent pas les modifier ;
• les instances peuvent utiliser les variables définies au niveau de la classe, mais elles ne peuvent pas les modifier (pour cela elles sont obligées de passer par l'espace de noms de la classe, par exemple C.x = 3).

Exemple de masquage d'attribut :

class C :
    """Documentation de la classe C."""
    x = 23 # attribut de classe

a = C() # a est un objet de la classe C (ou une instance)
a.x # 23 : affiche la valeur de l'attribut de l'instance a
a.x = 12 # modifie son attribut d'instance (attention#8230;)
a.x # 12
C.x # 23 mais l'attribut de classe est inchangé
C.z = 6 # z : nouvel attribut de classe
a.y = 44 # y : nouvel attribut de l'instance a
b = C() # b est un autre objet de la classe C (une autre instance)
b.x # 23 : b connaît bien son attribut de classe, mais#8230;
b.y # ... b n'a pas d'attribut y !
"""
Retraçage (dernier appel le plus récent) :
Fichier"/home/ipy/Phi/3-corps/ch07/src/7_025.py", ligne 14, dans 0
builtins.AttributeError : 'C' object has no attribute 'y'
"""

7-2-3-a. Recherche des noms▲

>>> v = 5
>>> class C:
...     x = v + 3 # utilisation d'une variable globale dans la définition de classe
...     y = x + 1 # recherche dans l'espace de noms de la classe lors de la définition
...
>>> a = C()
>>> a.x # utilisation sans modification de la variable de classe en passant par l'objet
8
>>> a.x = 2 # création d'une variable d'instance pour l'objet a
>>> a.x
2
>>> C.x # la variable de classe n'est pas modifiée
8
>>> C.x = -1 # on peut modifier la variable de classe en passant par l'espace de noms de la classe
>>> C.x
-1

In [1]: class C:
    ...:     """Une classe simple."""
    ...:     x = 2
    ...:     y = 5
    ...:

In [2]: C.__dict__
Out[2]: mappingproxy({'x': 2, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'C' objects>, '__dict__': <attribute '__

In [3]: for key in C.__dict__.keys():
    ...: print(key)
    ...:
x
__module__
__weakref__
__dict__
y
__doc__

In [4]: C.__dict__['__doc__']
Out[4]: 'Une classe simple.'

In [5]: C.__dict__['y']
Out[5]: 5

In [6]: a = C()

In [7]: a.__class__
Out[7]: __main__.C

In [8]: a.__doc__ # notation compacte
Out[8]: 'Une classe simple.'

In [9]: a.y # notation compacte
Out[9]: 5

Lors de l'instanciation d'un objet, la structure de base de l'objet est créée en mémoire, et la méthode __init__ est automatiquement appelée pour initialiser l'objet. C'est typiquement dans cette méthode spéciale que sont créés les attributs d'instance avec leur valeur initiale.

>>> class C:
...     def __init__(self, n):
...         self.x = n # initialisation de l'attribut d'instance x
...
>>> une_instance = C(42) # paramètre obligatoire, affecté à n
>>> une_instance.x
42

C'est une procédure automatiquement invoquée lors de l'instanciation : elle ne retourne aucune valeur.

La surcharge permet à un opérateur de posséder un sens différent suivant le type de ses opérandes.

Par exemple, l'opérateur + permet :

x = 7 + 9 # addition entière
s = 'ab' + 'cd' # concaténation

Python possède des méthodes de surcharge pour :

• tous les types (__call__, __str__…) ;
• les nombres (__add__, __div__…) ;
• les séquences (__len__, __iter__…).

Soient deux instances, obj1 et obj2, les méthodes spéciales suivantes permettent d'effectuer les opérations arithmétiques courantes(24) :

Voir l'Abrégé dense, les méthodes spéciales (cf. chapitre 16Mémento des bases de Python 3).

Dans l'exemple suivant, nous surchargeons l'opérateur d'addition pour le type Vecteur2D.

Nous surchargeons également la méthode spéciale __str__ utilisée pour l'affichage(25) par print().

>>> class Vecteur2D:
...     def __init__(self, x0, y0):
...         self.x = x0
...         self.y = y0
...     def __add__(self, second): # addition vectorielle
...         return Vecteur2D(self.x + second.x, self.y + second.y)
...     def __str__(self): # affichage d'un Vecteur2D
...         return "Vecteur({:g}, {:g})".format(self.x, self.y)
...
>>> v1 = Vecteur2D(1.2, 2.3)
>>> v2 = Vecteur2D(3.4, 4.5)
>>>
>>> print(v1 + v2)
Vecteur(4.6, 6.8)

Dans l'exemple suivant, la classe QuadrupedeDebout hérite de la classe mère Quadrupede, et la méthode piedsAuContactDuSol() est polymorphe :

>>> class Quadrupede:
...     def piedsAuContactDuSol(self):
...         return 4
...
>>> class QuadrupedeDebout(Quadrupede):
...     def piedsAuContactDuSol(self):
...         return 2
...
>>> chat = Quadrupede()
>>> chat.piedsAuContactDuSol()
4
>>> homme = QuadrupedeDebout()
>>> homme.piedsAuContactDuSol()
2

L'implémentation Python utilisée est généralement l'intégration d'autres objets dans le constructeur de la classe conteneur :

class Point :
    def __init__(self, x, y) :
        self.px, self.py = x, y

class Segment :
    """Classe conteneur utilisant la classe Point."""
    def __init__(self, x1, y1, x2, y2) :
        self.orig = Point(x1, y1)
        self.extrem = Point(x2, y2)

    def __str__(self) :
        return ("Segment : [({ :g}, { :g}), ({ :g}, { :g})]"
                .format(self.orig.px, self.orig.py, self.extrem.px, self.extrem.py))

s = Segment(1.0, 2.0, 3.0, 4.0)
print(s) # Segment : [(1, 2), (3, 4)]

7-6-1-a. Agrégation▲

7-6-1-b. Composition▲

On utilise dans ce cas le mécanisme de l'héritage.

L'implémentation Python utilisée est généralement l'appel à l'initialisateur de la classe parente dans l'initialisateur de la classe dérivée (utilisation de la fonction super()).

Dans l'exemple suivant, un Carre « est-un » Rectangle particulier pour lequel on appelle l'initialisateur de la classe mère avec les paramètres longueur=cote et largeur=cote :

>>> class Rectangle:
...     def __init__(self, longueur=30, largeur=15):
...         self.L, self.l = longueur, largeur
...         self.nom = "rectangle"
...     def __str__(self):
...         return "nom : {}".format(self.nom)
...
>>> class Carre(Rectangle): # héritage simple
...     """Sous-classe spécialisée de la super-classe Rectangle."""
...     def __init__(self, cote=20):
...         # appel au constructeur de la super-classe de Carre :
...         super().__init__(cote, cote)
...         self.nom = "carré" # surcharge d'attribut
...
>>> r = Rectangle()
>>> c = Carre()
>>> print(r)
nom : rectangle
>>> print(c)
nom : carré