Classes

Les classes permettent des créer des objets appelés instances qui partagent des caractéristiques communes. Une classe est en fait un gabarit qui nous permet de créer un certain type d’objets.

Plus d’informations : Introduction OpenClassrooms, Documentation Python 3, Wikilivres

Structure d’une classe

Les objets d’une classe partagent des caractéristiques communes à la classe:

  1. des attributs, des variables propres à aux instances;

  2. des méthodes, des fonctions propres aux instances et qui agissent par exemple sur leurs attributs.

Définition d’une classe et création d’objets

Pour définir une classe, la syntaxe est la suivante:

class MaClasse:
    pass

Lorsqu’on lance l’exécution d’un module Python, l’interpréteur exécute le contenu du corps de toutes les classes qu’il rencontre pour la première fois. Ainsi si l’on exécute :

class Foo:
    print('bar')

La console affichera bar. Pour créer une instance de classe, il faut appeler la classe. Appeler une classe revient à appeler son , composé d’un créateur d’objet et d’un initialiseur. En reprenant la classe Foo:

>>> Foo # évaluation de la classe Foo
<class '__main__.Foo'>
>>> Foo() # création d'un objet Foo
<__main__.Foo object at 0x7f193dd99630>

Attributs

Créons un objet :

>>> foo = Foo()

Cet objet est pour l’instant vide, on peut lui donner un attribut:

>>> foo.attr = 1
>>> foo.attr
1

Les informations concernant les attributs d’une instance sont stockées dans le dictionnaire de l’instance, un attribut spécial nommé __dict__.

>>> foo.__dict__
{'attr': 1}

Lorsqu’on accède un attribut avec la syntaxe foo.attr, cette syntaxe est par défaut équivalente à:

>>> foo.__dict__['attr']
1

Pour modifier la valeur d’un attribut, on lui assigne tout simplement une nouvelle valeur:

>>> foo.attr = 456
>>> foo.attr
456
>>> foo.__dict__['attr'] = 789 # équivalent
>>> foo.attr
789

Une classe peut également définir des attributs de classe:

class Foo:
    class_attr = "I'm a class attribute."

Toutes les instances y ont accès:

>>> Foo.class_attr
"I'm a class attribute."
>>> foo = Foo()
>>> foo.class_attr
"I'm a class attribute."

Pourtant, cet attribut n’est pas dans foo.__dict__. En effet, lorsqu’on accède à un attribut, Python va le rechercher dans le dictionnaire de l’instance, mais aussi de sa classe s’il ne l’a pas trouvé. Ainsi:

  • Modifier un attribut de classe pour une instance ajoutera une entrée dans son dictionnaire (on n’accède ainsi par la suite plus à l’attribut de classe mais au nouvel attribut d’instance, on peut dire qu’on l’a surchargé).

  • Modifier un attribut de classe via la classe le modifie pour toutes les instances qui ne l’ont pas surchargé, ainsi que pour toutes les instances qui seront créées ensuite.

>>> foo.class_attr = 'New value'
>>> objet.__dict__
{'class_attr': 'New value'}
>>> bar = Foo()
>>> bar.__dict__
{}
>>> Foo.class_attr = "I just got a new value."
>>> bar.class_attr
"I just got a new value."
>>> foo.class_attr
'New value'

Méthodes

Les méthodes se définissent comme des fonctions dans le corps de la classe, elles agissent en général sur les instances de la classe. Python leur passe toujours l’instance sur laquelle elles sont appliquées en premier paramètre. Par convention, il est noté self.

class MaClasse:

    def methode(self, arg1, arg2):
        print(locals())

Ensuite on les appelle de la manière suivante:

>>> objet = MaClasse()
>>> objet
<__main__.MaClasse object at 0x7f13337e50f0>
>>> objet.methode(arg1, arg2)
{'self': <__main__.MaClasse object at 0x7f13337e50f0>, 'arg1': 123, 'arg2': 'ABC'}

C’est grâce à cette variable self que l’on peut agir sur l’instance.

Initialiseur

L’initialiseur est une méthode spéciale appelée __init__(), il est appelé lorsqu’une instance vient d’être créée et permet d’en initialiser les attributs. L’exemple suivant permet d’initialiser deux attributs:

class MaClasse:

    def __init__(self, att1, att2):
        """Initialiseur"""
        self.attribut1 = att1
        self.attribut2 = att2

Ces deux attributs sont initialisés lorsqu’on crée un nouvel objet. Les valeurs initiales des attributs sont automatiquement passés à __init__() lorsqu’on appelle la classe pour instancier:

>>> objet = MaClasse(123, 'ABC')
>>> objet.__dict__
{'attribut1': 123, 'attribut2': 'ABC'}

Héritage

Principe

L’héritage est un moyen de créer des classes dérivées (classes filles) d’une classe de base (classe mère). Une classe fille hérite de toutes les méthodes et attributs de sa classe mère. Pour indiquer les classes parentes d’une nouvelle classe, on les indique en paramètres lors de sa définition. L’héritage en action dans un exemple on ne peut plus simple:

>>> class Mere:
...     attr = 1
...
>>> class Fille(Mere):
...     pass
...
>>> Fille().attr
1

Il est possible de surcharger (d’écraser) une méthode héritée en la redéfinissant dans la classe fille. Si on veut accéder à une méthode héritée alors qu’on l’a redéfinie dans la classe fille, on utilise la fonction super() qui permet d’appeler la méthode de la classe mère de la classe présente (sans l’argument self).

Exemple :

class Meuble:
    def __init__(self, couleur, materiau):
        self.couleur = couleur
        self.materiau = materiau

class Bibliotheque(Meuble):
    def __init__(self, couleur, materiau, n):
        super().__init__(couleur, materiau)
        self.nb_livres = n

On peut utiliser deux fonctions pour vérifier l’héritage: isinstance renvoie True si l’objet est une instance de la classe ou de ses classes filles ; issubclass permet de voir si une classe est fille d’une autre.

>>> bibli = Bibliotheque('blanc', 'vert', 150)
>>> bibli.__dict__
{'couleur': 'blanc', 'materiau': 'vert', 'nb_livres': 150}
>>> isinstance(bibli, Meuble)
True
>>> isinstance(bibli, Bibliotheque)
True
>>> issubclass(Bibliotheque, Meuble)
True
>>> issubclass(Meuble, Bibliotheque)
False
>>> isinstance(bibli, int)
False
>>> isinstance(bibli, object)
True

Plus d’informations : OpenClassrooms, Documentation Python 3, Programiz

Ordre de résolution de méthode

Classe mère object

On a dit précédemment que le constructeur était composé d’un initialiseur et d’un créateur d’instance ; cependant l’exemple ne définissait pas de créateur d’instance : c’est parce qu’il est défini dans une classe object. Toutes les classes en Python 3 héritent implicitement de cette classe. Elle définit de nombreuses méthodes, notamment les méthodes dites spéciales, que l’on peut surcharger pour les personnaliser.

>>> object
<class 'object'>
>>> help(object)
Help on class object in module builtins:

class object
 |  The most base type

>>> class Foo:
...    pass
...
>>> issubclass(Foo, object)
True

Propriétés

Les propriétés représentent en Python le principe d’encapsulation. Elles sont utiles si on souhaite contrôler l’accès à un attribut ou si on veut que le changement d’une valeur d’un attribut engendre des modifications sur d’autres attributs. Du côté utilisateur, ce mécanisme est complètement transparent car il permet de garder la syntaxe classique inst.attr = valeur. Les propriétés sont un cas particulier des descripteurs.

On crée les propriétés en utilisant des décorateurs. Elles contiennent un accesseur, un mutateur, un destructeur et une aide (docstring de l’accesseur). Dans certains cas, il n’est pas nécessaire d’avoir un attribut associé, un simple calcul suffit:

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @property
    def fahrenheit(self):
        """Propriété 'fahrenheit'."""
        return self.celsius * 1.8 + 32

    @fahrenheit.setter
    def fahrenheit(self, value):
        self.celsius = (value - 32) / 1.8

Ainsi, on peut écrire:

>>> temp = Temperature(20)
>>> temp.fahrenheit
68.0
>>> temp.fahrenheit = 69
>>> temp.celsius
20.555555555555554

Parfois, il est nécessaire d’ajouter des attributs cachés , par exemple si l’on veut aussi contrôler le changement de température en degrés Celsius, pour éviter une récursivité infinie:

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @property
    def celsius(self):
        """Propriété 'celsius'.

        Vérifie si la température est supérieure à -273°C avant d'assigner."""
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273:
            raise ValueError("Une température en degrés Celsius doit être supérieure à -273°C.")
        self._celsius = value

    @property
    def fahrenheit(self):
        """Propriété 'fahrenheit'."""
        return self.celsius * 1.8 + 32

    @fahrenheit.setter
    def fahrenheit(self, value):
        self.celsius = (value - 32) / 1.8

Dans d’autres cas, on peut stocker le résultat de calculs dans un attribut caché. Ici, le calcul des degrés Fahrenheit est rapide, mais il peut s’avérer utile de stocker le résultat pour ne pas avoir à recalculer à chaque fois.

On utilise la propriété de la manière suivante:

>>> help(Temperature.celsius)
Help on property:

    Propriété 'celsius'.

    Vérifie si la température est supérieure à -273°C avant d'assigner.

>>> temp.celsius = -300
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../*.py", line 18, in celsius
    raise ValueError("Une température en degrés Celsius doit être supérieure à -273°C.")
ValueError: Une température en degrés Celsius doit être supérieure à -273°C.
>>> temp.fahrenheit = -462 # ça marche aussi car cette propriété fait appel à celle des celsius !
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../*.py", line 18, in celsius
    raise ValueError("Une température en degrés Celsius doit être supérieure à -273°C.")
ValueError: Une température en degrés Celsius doit être supérieure à -273°C.

Plus d’informations :Documentation Python 3, Priorités entre propriété et méthodes spéciales

Méthodes statiques et méthodes de classes

Méthode statique

[sec:staticmethod]

Les méthodes que l’on a vues jusqu’à maintenant agissent sur les instances des classes : elles prennent toujours en premier argument le mot clé self qui correspond à l’instance elle même. Lorsque l’on appelle une telle méthode sur une instance comme ceci: |instance.methode(*args, **kwargs)| Python exécute en fait: |type(instance).methode(instance, *args, **kwargs)| Évaluer type() sur un objet renvoie sa classe.

En fait, ces deux objets sont différents. Classe.methode est une simple fonction, alors que instance.methode est une méthode partiellement évaluée sur l’instance (méthode liée, en anglais bound method ), c’est-à-dire que l’instance est mise en premier argument.

Parfois, on écrit des méthodes qui n’ont pas d’incidence sur les instances de la classe. Imaginons une classe Maths qui regrouperait des opérations basiques:

class Maths:
    def addition(x, y):
        return x + y

    def multiplication(x, y):
        return x * y

    def division(x, y):
        return x / y
>>> Math.addition(1, 3)
4

Jusqu’ici tout va bien. Mais imaginons que la classe se développe et que l’on instancie des objets Maths. On aura un soucis :

>>> Maths().addition(1, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: addition() takes 2 positional arguments but 3 were given

Le problème étant que Python a en fait exécuté:

|Maths.addition(Maths(), x, y)|

Pour remédier à cela, il existe le décorateur @staticmethod. On doit écrire alors:

class Maths:
    @staticmethod
    def addition(x, y):
        return x + y

    @staticmethod
    def multiplication(x, y):
        return x * y

    @staticmethod
    def division(x, y):
        return x / y

On peut ainsi écrire sans crainte:

>>> Maths().addition(1, 3)
4

Méthode de classe

[sec:classmethod]

Parfois, on veut pouvoir agir sur la classe et non sur l’instance. Dans ce cas, la méthode de classe prend en premier paramètre cls (la classe) au lieu de self (l’instance).

>>> class Foo:
...     CONSTANT = "Bar"
...     def print_constant(cls):
...         print(cls.CONSTANT)
...
>>> Foo().print_constant()
Bar

Deux problèmes surviennent. Tout d’abord, même si le premier paramètre s’appelle cls, c’est encore l’instance qui est mise en paramètre.

>>> foo = Foo()
>>> foo.CONSTANT = "Baz"
>>> foo.print_constant()
Baz # On veut Bar !

Deuxième problème: on ne peut pas appeler la méthode de classe sur la classe (même problème que pour les méthodes statiques):

>>> Foo.print_constant()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: print_constant() missing 1 required positional argument: 'cls'

Pour remédier à cela, on utilise le décorateur @classmethod.

>>> class Foo:
...     CONSTANT = "Bar"
...     @classmethod
...     def print_constant(cls):
...         print(cls.CONSTANT)
...
>>> foo = Foo()
>>> foo.CONSTANT = "Baz"
>>> foo.print_constant()
Bar # Youpi !
>>> Foo.print_constant()
Bar # Youyoupi !

Cas de l’héritage

En résumé:

  1. Les méthodes statiques sont des fonctions reliées à des classes, mais qui n’agissent pas sur celles-ci.

  2. Les méthodes de classe sont des fonctions qui prennent la classe en paramètre.

Une classe qui hérite d’une classe mère hérite de toutes les méthodes de celle-ci. Les méthodes statiques restent donc inchangées, tandis que les méthodes de classe s’adaptent à la nouvelle classe, car elles la prennent en premier argument.

Exemple : Un exemple d’utilisation de méthodes statiques et de classe sont la création de constructeurs alternatifs. On s’aperçoit de la différence des deux notions.

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

    @staticmethod
    def par_date_de_naissance(nom, date):
        return Personne(nom, 2018-date)

    @classmethod
    def par_date_de_naissance2(cls, nom, date):
        return cls(nom, 2018-date)

class Homme(Personne):
    sexe = 'homme'
>>> homme1 = Homme.par_date_de_naissance('Jean', 1997)
>>> homme2 = Homme.par_date_de_naissance2('Jean', 1997)
>>> type(homme1)
<class '__main__.Personne'>
>>> type(homme2)
<class '__main__.Homme'>

Pour avoir homme1 de type Homme, il faut redéfinir la méthode statique dans la classe fille.

Plus d’informations : Méthode statique sur Programiz, Méthode de classe sur Programiz, StackOverflow