Création de classes et d'objets

3.1 Création d'une classe

Créer des classes en Python est une partie importante de la programmation orientée objet (POO). Les classes permettent de créer de nouveaux types de données, qui peuvent avoir leurs propres attributs et méthodes. Voyons les concepts de base et des exemples de création de classes en Python.

Concepts de base

• Classe : un modèle pour créer des objets. Une classe définit les attributs et méthodes qui seront ceux des objets de cette classe.
• Objet : une instance d'une classe. Un objet a tous les attributs et méthodes définis dans la classe.
• Attribut : une variable associée à une classe ou un objet.
• Méthode : une fonction associée à une classe ou un objet.

Les attributs sont essentiellement les variables internes d'un objet ou d'une classe. Les méthodes sont les fonctions définies à l'intérieur d'une classe. Ces termes viennent de la POO et sont utilisés au même titre que les fonctions et variables.

Pour déclarer (créer) une nouvelle classe, on utilise le mot-clé class. La syntaxe générale de cette opération ressemble à ceci :

class NomDeClasse:
    variable1 = valeur1
    variableN = valeurN
          
    def fonction1(self):
        code de la fonction
            
    def fonctionM(self):
        code de la fonction

En gros, on peut dire qu'une classe est un petit programme (variables + fonctions) placé dans un espace nommé séparé - NomDeClasse.

Après avoir créé une classe, vous pouvez créer des objets (instances) de cette classe. Ce code est encore plus simple :

variableX = NomDeClasse()

Important! En Python, il est courant d'écrire les noms de variables et de méthodes avec une lettre minuscule. Les noms de classes avec une majuscule. De plus, les noms de classes ne contiennent pas de caractères de soulignement. Si le nom d'une classe se compose de plusieurs mots, chaque mot commence par une majuscule.

Si vous voulez accéder à une variable de classe/objet, le code ressemble généralement à ceci:

variableX.variable1 = 10
variableX.fonctionM()       

Mais ce n'est pas sans nuances, comme vous le verrez plus bas…

3.2 Travailler avec un objet

La classe et l'instance d'une classe (objet de classe) sont des objets, donc les deux peuvent avoir leurs propres variables et méthodes.

Il existe deux types de variables:

• Attribut/Variable/Champ de classe (class property)
• Attribut/Variable/Champ d'objet (object property)

Et trois types de méthodes:

• Méthode/Fonction de classe (class method)
• Méthode/Fonction d'objet (instance method)
• Méthode statique (static method)

Les méthodes diffèrent par la façon dont elles sont déclarées et comment elles sont appelées.

Méthodes d'objet

Lors de la déclaration d'une méthode d'objet, il faut transmettre le premier paramètre obligatoire — self. Lors de l'appel de la méthode, ce paramètre reçoit la référence à l'objet (instance).

class MyClass:

    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
                   

my_object = MyClass()
my_object.instance_method()
        

Dans l'exemple ci-dessus, lorsque la fonction instance_method() a commencé à s'exécuter, le paramètre self a reçu la référence à l'objet my_object.

Méthodes de classe

Lors de la déclaration d'une méthode de classe, il faut également transmettre le premier paramètre obligatoire — cls. Lors de l'appel de la méthode, ce paramètre reçoit la référence à la classe (class object). Il faut aussi marquer la méthode de classe avec le décorateur classmethod, comme dans l'exemple ci-dessous :

class MyClass:
    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
        
    @classmethod
    def class_method(cls):
        print(type(cls))  # <class 'type'>
                   

my_object = MyClass()
my_object.instance_method()
MyClass.class_method()
        

Dans l'exemple ci-dessus, lorsque la fonction class_method() a commencé à s'exécuter, le paramètre cls a reçu la référence à la classe MyClass.

Méthode statique

Lors de la déclaration d'une méthode statique, il n'y a rien à transmettre, mais elle ne peut pas non plus accéder aux données internes de la classe. La méthode doit aussi être marquée avec le décorateur staticmethod, comme dans l'exemple ci-dessous :

class MyClass:
    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
        
    @classmethod
    def class_method(cls):
        print(type(cls))  # <class 'type'>
        
    @staticmethod
    def static_method():
        return "Cette méthode ne dépend ni de l'instance ni de la classe"
                   
my_object = MyClass()
my_object.instance_method()
MyClass.class_method()
MyClass.static_method() 
        

Une méthode statique est appelée de manière très similaire à une méthode de classe, mais ni la référence à l'objet ni celle à la classe ne lui sont passées.

3.3 Variables de classe

Variables de classe

Pour déclarer une variable (attribut) de classe, il suffit de la déclarer n'importe où à l'intérieur de la classe. En général, cela se fait au début, avant la déclaration des méthodes de la classe. Exemple :

class MyClass:
    attribute = "Je suis un attribut de classe"
        
    @classmethod
    def class_method(cls):
        print(cls.attribute)  # Je suis un attribut de classe
                  
my_object = MyClass()
MyClass.class_method()

Si vous souhaitez lire ou écrire une valeur dans une variable de classe, utilisez l'objet cls.

En principe, on peut aussi accéder à une variable de classe par son nom:

class MyClass:
    attribute = "Je suis un attribut de classe"
        
    @classmethod
    def class_method(cls):
        print(MyClass.attribute)  # Je suis un attribut de classe
                  
my_object = MyClass()

print(MyClass.attribute)  # Je suis un attribut de classe

Variables/champs d'objet

Les variables d'objet (instance) sont les champs de l'objet self. Vous travaillez avec elles via self.name. C'est pour cela que l'objet self est passé dans chaque méthode d'objet.

Exemple :

class MyClass:
    attribute = "Je suis un attribut de classe"
        
    def set_name(self, name):
        self.name = name
        
    def print_name(self):
        print(self.name)    
                 
my_object = MyClass()
my_object.set_name("Champ d'objet appelé name") 
my_object.print_name()  # "Champ d'objet appelé name"
        

Chaque fois que vous appelez une méthode d'objet, en tant que premier paramètre (self), une référence à l'objet pour lequel vous appelez la méthode est passée. Différentes méthodes d'objet peuvent accéder à des données communes en utilisant l'objet self.