Python class variables : tout savoir sur les variables de classe

Les variables de classe Python (class variables en anglais) représentent une manière structurée de partager des données entre différentes instances d’une classe. De plus, les modifications apportées à une variable de classe se répercutent sur toutes les instances de la classe. Ainsi, elles n’ont pas besoin d’être redéfinies à chaque instanciation.

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

En Python, on crée des variables de classe au sein d’une classe. Contrairement aux variables d’instance qui sont spécifiques à chaque instance d’une classe, les variables de classe conservent la même valeur pour toutes les instances. Ces variables sont généralement définies avant le constructeur et sont accessibles à toutes les instances de la classe.

Les variables de classe Python sont souvent utilisées pour stocker des informations communes à toutes les instances d’une classe, comme des valeurs de configuration, des valeurs par défaut ou des états communs dans une hiérarchie 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éliorant ainsi la fonctionnalité et l’organisation du code.

Python class variables : syntaxe

Les variables de classe Python sont créées à l’intérieur de la définition 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}")
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éfinissons la variable de classe total_cars pour suivre le nombre total de voitures. Le constructeur __init__ est appelé lorsqu’une nouvelle instance de la classe est créée. A chaque instanciation, 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’utilisation des variables de classe Python

Pour une utilisation sûre des variables de classe en Python, ce sont surtout l’accès, la modification 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écupérées à différents endroits :

• Dans le constructeur : la variable de classe peut être appelée à l’intérieur du constructeur, 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 directement 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 remplaçons la variable de classe class_var en lui attribuant une nouvelle valeur via la classe MyClass. La modification est automatiquement 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éfinissons 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.