Python class variables : tout savoir sur les variables de classe

Les variables de classe Python (class variables en anglais) re­pré­sen­tent une manière struc­tu­rée de partager des données entre dif­fé­rentes instances d’une classe. De plus, les mo­di­fi­ca­tions apportées à une variable de classe se ré­per­cu­tent sur toutes les instances de la classe. Ainsi, elles n’ont pas besoin d’être re­dé­fi­nies à chaque ins­tan­cia­tion.

Python class variables : qu’est-ce que c’est ?

En Python, on crée des variables de classe au sein d’une classe. Con­trai­re­ment aux variables d’instance qui sont spé­ci­fiques à chaque instance d’une classe, les variables de classe con­ser­vent la même valeur pour toutes les instances. Ces variables sont gé­né­ra­le­ment définies avant le cons­truc­teur et sont ac­ces­sibles à toutes les instances de la classe.

Les variables de classe Python sont souvent utilisées pour stocker des in­for­ma­tions communes à toutes les instances d’une classe, comme des valeurs de con­fi­gu­ra­tion, des valeurs par défaut ou des états communs dans une hié­rar­chie de classes. En outre, les variables de classe peuvent être utilisées pour définir des méthodes ou des attributs de classe qui sont partagés par toutes les instances d’une classe, amé­lio­rant ainsi la fonc­tion­na­lité et l’or­ga­ni­sa­tion du code.

Python class variables : syntaxe

Les variables de classe Python sont créées à l’intérieur de la dé­fi­ni­tion de la classe et en dehors des méthodes.

class Car:
    total_cars = 0  # Class variable to track the total number of cars
    def __init__(self, brand, model):
        self.brand = brand  # Instance variable for the car brand
        self.model = model  # Instance variable for the car model
        Car.total_cars += 1  # Increment the total number of cars upon each instantiation
    def display_details(self):
        print(f"Brand: {self.brand}, Model: {self.model}")
# Creating instances of Car
car1 = Car("BMW", "X3")
car2 = Car("Audi", "A4")
# Accessing class variable and instance variables
print(f"Total number of cars: {Car.total_cars}")  # Output: 2
car1.display_details()  # Output: Brand: BMW, Model: X3
car2.display_details()  # Output: Brand: Audi, Model: A4

À l’intérieur de la classe Car, nous dé­fi­nis­sons la variable de classe total_cars pour suivre le nombre total de voitures. Le cons­truc­teur __init__ est appelé lorsqu’une nouvelle instance de la classe est créée. A chaque ins­tan­cia­tion, les variables d’instance brand et model sont définies et la variable de classe total_cars est augmentée de 1.

En appelant la méthode display_details(), nous affichons les détails de chaque instance de voiture. Dans une f-String, une méthode de formatage de chaînes Python; nous accédons à la variable de classe total_cars pour afficher le nombre total de voitures créées.

Exemples d’uti­li­sa­tion des variables de classe Python

Pour une uti­li­sa­tion sûre des variables de classe en Python, ce sont surtout l’accès, la mo­di­fi­ca­tion et l’héritage qui jouent un rôle.

Accéder aux variables de classe

L’accès aux variables de classe Python se fait par le nom de la classe ou de l’instance, suivi d’un point et du nom de la variable.

class MyClass:
    class_var = "This is a class variable"
# using class name to access class variable
print(MyClass.class_var)  # Output: This is a class variable
# using instance to access class variable
obj = MyClass()
print(obj.class_var)  # Output: This is a class variable

En Python, les variables de classe peuvent être ré­cu­pé­rées à dif­fé­rents endroits :

• Dans le cons­truc­teur : la variable de classe peut être appelée à l’intérieur du cons­truc­teur, soit par le mot-clé self, soit par le nom de la classe.
• Dans les méthodes d’instance : la variable de classe peut être appelée à l’intérieur des méthodes d’instance soit par le mot-clé self soit par le nom de la classe.
• En dehors de la classe : en dehors de la classe, on peut accéder à la variable de classe soit par la référence de l’objet, soit par le nom de la classe.

Modifier les variables de classe

Les class variables Python peuvent être modifiées di­rec­te­ment par le nom de la classe. Si une variable d’instance a le même nom qu’une variable de classe et que vous essayez de modifier la variable via l’instance, une nouvelle variable d’instance sera créée et la variable de classe restera inchangée.

class MyClass:
    class_var = "Original class variable"
obj = MyClass()
print(obj.class_var)  # Output: Original class variable
MyClass.class_var = "Modified class variable"
print(obj.class_var)  # Output: Modified class variable

Dans cet exemple, nous rem­pla­çons la variable de classe class_var en lui at­tri­buant une nouvelle valeur via la classe MyClass. La mo­di­fi­ca­tion est au­to­ma­ti­que­ment prise en compte par l’instance obj.

Variables de classe et héritage

Grâce à l’héritage, les classes dérivées peuvent accéder aux variables de classe de la classe de base et les utiliser sans avoir à les redéfinir.

class BaseClass:
    base_var = "Base variable"
class DerivedClass(BaseClass):
    pass
print(DerivedClass.base_var)  # Output: Base variable

Nous dé­fi­nis­sons ici une classe de base BaseClass qui contient la variable de classe base_var. La classe dérivée DerivedClass hérite de BaseClass. Grâce à l’héritage, DerivedClass peut accéder à la variable de classe base_var de la classe de base et l’utiliser sans devoir la redéfinir.