# Python class variables: cómo crear y usar variables de clase

Las variables de clase en Python representan una forma estructurada de compartir datos entre distintas instancias de una clase. Además, los **cambios en una variable de clase** afectan a todas las instancias de la clase, por lo que no es necesario redefinirlas cada vez que se instancian.

## ¿Qué son las variables de clase en Python?

Las variables de clase en Python se crean dentro de una clase. A diferencia de las variables de instancia, que son específicas para cada instancia de una clase, las **variables de clase conservan el mismo valor para todas las instancias**. Por regla general, estas variables se definen antes del constructor y todas las instancias de la clase pueden acceder a ellas.

Las variables de clase suelen utilizarse para **almacenar información** que es común a todas las instancias de una clase, como los valores de configuración, los valores por defecto o estados comunes dentro de una jerarquía de clases. También puedes utilizar estas variables para definir métodos o atributos de clase compartidos por todas las instancias de una clase, lo que mejora la funcionalidad y la organización del código.

## ¿Cuál es la sintaxis de las variables de clase en Python?

Las variables de clase en Python se crean **dentro de la definición de la clase**, pero fuera de cualquier método dentro de esa clase.

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

Dentro de la clase `Car` (coche) se define la variable de clase `total_cars` para obtener el número total de coches. Cada vez que se crea una nueva instancia de la clase, se llama al constructor `__init__`. En cada instancia se establecen las **variables de instancia** `brand` (marca) y `model` (modelo), y la variable de clase `total_cars` (total de coches) se incrementa en 1 para reflejar la adición de un nuevo coche al total.

Además, en el ejemplo se llama al método `display_details()` para mostrar los detalles de cada instancia de coche. Para acceder a la variable de clase `total_cars` y obtener el número total de coches creados, se debe utilizar un f-string, que es un método de formato de cadena, también denominado [Python string format](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-string-format/).

## Ejemplos de uso de las variables de clase en Python

Para manejar las variables de clase en Python de manera segura, es importante entender cómo acceder a ellas, modificarlas y cómo interactúan con la herencia.

### Acceder a variables de clase

Puedes acceder a las variables de clase en Python utilizando el **nombre de la clase o una instancia**, seguido de un punto y el nombre 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
```

Al programar en Python, puedes acceder a las variables de clase en diferentes lugares:

- **Dentro del constructor** de la clase escribiendo la palabra clave `self` o el nombre de la clase.
- **Dentro de los métodos de instancia** de la misma manera que en el caso anterior, es decir, utilizando `self` o el nombre de la clase.
- **Fuera de la clase** usando la referencia al objeto o el nombre de la clase.

### Modificar variables de clase

Es posible modificar las variables de clase en Python utilizando directamente el nombre de la clase. No obstante, si una variable de instancia tiene el mismo nombre que una variable de clase e intentas modificarla a través de la instancia, **se crea una nueva variable de instancia** y la variable de clase queda sin modificar.

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

En este ejemplo, sobrescribimos la variable de clase `class_var` asignándola un nuevo valor a través de la clase `MyClass`, y la instancia `obj` se actualiza automáticamente para reflejar ese cambio.

### Variables de clase y herencia

Gracias a la herencia, las clases derivadas pueden **acceder a las variables de clase de la clase base** y utilizarlas sin tener que redefinirlas.

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

En el anterior ejemplo se define una clase base `BaseClass` que contiene la variable de clase `base_var`. La clase derivada `DerivedClass` hereda de la `BaseClass`. Gracias a la herencia, `DerivedClass` puede acceder a la variable de clase `base_var` de la clase base y utilizarla sin tener que volver a definirla.


This is a markdown version of: [https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-class-variables/](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-class-variables/) for AI/LLM consumption.