Si vienes de lenguajes como Java o C++, probablemente estés acostumbrado a escribir métodos como get_precio() y set_precio().

En este post, vamos a aprender a usar el decorador @property para gestionar el acceso a los datos de forma elegante, manteniendo la simplicidad de una variable pero con las ventajas de un método.

¿Por qué no usar Getters y Setters tradicionales?

En Python, la filosofía es que el código debe ser lo más limpio posible. Si puedes acceder a un dato con objeto.precio, ¿por qué escribir objeto.get_precio()?

Sin embargo, a veces necesitamos añadir lógica (como validación) cuando alguien intenta cambiar un valor. Aquí es donde entra en juego el decorador @property.

Usando @property para Getters

El decorador @property convierte un método en un “atributo de lectura”.

class Producto:
    def __init__(self, precio):
        self._precio = precio  # Atributo protegido

    @property
    def precio(self):
        """Este es el getter"""
        return f"${self._precio:.2f}"

item = Producto(100)
print(item.precio)  # Salida: $100.00

@setter y @deleter

Para permitir que alguien modifique el valor, usamos el decorador .setter. Para borrarlo, usamos .deleter.

class Producto:
    def __init__(self, precio):
        self._precio = precio

    @property
    def precio(self):
        return self._precio

    @precio.setter
    def precio(self, valor):
        if valor > 0:
            self._precio = valor
        else:
            print("Error: El precio debe ser un número positivo")

    @precio.deleter
    def precio(self):
        print("Eliminando el precio del producto...")
        del self._precio

# Uso:
item = Producto(50)
item.precio = 60       # Llama al setter (Válido)
item.precio = -10      # Llama al setter (Error)
del item.precio        # Llama al deleter

Tip: El uso de @property permite que el código sea retrocompatible. Si en el futuro necesitas añadir validación a un atributo que antes era público, puedes convertirlo en una propiedad sin que los usuarios de tu clase tengan que cambiar su código.

Beneficios del Encapsulamiento con @property

  1. Validación de Datos: Evitas que se asignen valores inválidos (como precios negativos).
  2. Atributos Calculados: Puedes crear atributos que se calculen en tiempo real sin almacenarlos (ej. area de un círculo basado en el radio).
  3. Encapsulamiento real: Proteges los datos internos de tu clase mientras ofreces una interfaz limpia hacia afuera.

Conclusión: Tu camino hacia un código limpio

El decorador @property es una de las herramientas más poderosas para mantener tus clases profesionales. No te limites a usarlo solo para validaciones sencillas; piensa en cómo puede mejorar la legibilidad de todo tu proyecto.

Deja de escribir get_ y set_ y empieza a usar las ventajas de Python.