# 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.

```python
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é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.

```python
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.

```python
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.

```python
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.


This is a markdown version of: [https://www.ionos.com/fr-ch/digitalguide/sites-internet/developpement-web/python-class-variables/](https://www.ionos.com/fr-ch/digitalguide/sites-internet/developpement-web/python-class-variables/) for AI/LLM consumption.