Python Academy · Lección

El decorador @property

Utilice property para crear getters, setters y deleters.

El decorador @property es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

Introducción

@property convierte un método en un atributo legible. @setter y @deleter completan el patrón de acceso controlado.

¿Por qué usar @property?

En lugar del estilo de Java getX()/setX(), Python utiliza @property. El acceso parece el de un atributo: obj.value, no obj.get_value().

class Circle:
    def __init__(self, r): self._r = r
    @property
    def radius(self): return self._r
c = Circle(5)
print(c.radius)  # no ()

Propiedades calculadas

Los métodos @property calculan el valor sobre la marcha. obj.area se calcula cada vez que se accede a él; no hace falta almacenar el valor.

import math
class Circle:
    def __init__(self, r): self._r = r
    @property
    def area(self): return math.pi * self._r**2
c = Circle(5)
print(round(c.area, 2))

Setter de una propiedad

@property_name.setter añade un setter. Ahora c.radius = 10 llama al método setter.

class Circle:
    def __init__(self, r): self._r = r
    @property
    def radius(self): return self._r
    @radius.setter
    def radius(self, val):
        if val <= 0: raise ValueError('radius must be positive')
        self._r = val
c = Circle(5)
c.radius = 10
print(c.radius)

Deleter de una propiedad

@property_name.deleter gestiona del obj.attr. Utilícelo para la lógica de limpieza.

class User:
    def __init__(self, name): self._name = name
    @property
    def name(self): return self._name
    @name.deleter
    def name(self): del self._name
u = User('Alice')
del u.name
print(hasattr(u, '_name'))

Propiedad de solo lectura

Defina únicamente el getter (sin setter). Intentar asignarle un valor provoca AttributeError.

class Const:
    def __init__(self, v): self._v = v
    @property
    def value(self): return self._v
c = Const(42)
print(c.value)
try: c.value = 99
except AttributeError as e: print(e)

Propiedad con validación

Los setters son el lugar ideal para validar datos: compruebe el tipo, el rango o el formato antes de almacenarlos.

class BoundedInt:
    def __init__(self, lo, hi): self.lo,self.hi=lo,hi; self._v=lo
    @property
    def value(self): return self._v
    @value.setter
    def value(self, v):
        if not self.lo <= v <= self.hi:
            raise ValueError(f'{v} out of [{self.lo},{self.hi}]')
        self._v = v
b = BoundedInt(0, 10)
b.value = 5
print(b.value)

Almacenamiento en caché con property

Combine @property con un valor almacenado en caché para calcularlo una vez y aplicar memoización.

class Expensive:
    _cache = None
    @property
    def result(self):
        if self._cache is None:
            self._cache = sum(range(1000))
        return self._cache
e = Expensive()
print(e.result)
print(e.result)

cached_property (Python 3.8+)

@functools.cached_property calcula la propiedad una vez y la almacena como atributo de la instancia; así evita cálculos repetidos.

from functools import cached_property
import math
class Circle:
    def __init__(self, r): self.r = r
    @cached_property
    def area(self): return math.pi * self.r**2
c = Circle(5)
print(round(c.area, 2))

Property frente a slots

__slots__ impide crear atributos arbitrarios y ahorra memoria. Las propiedades añaden lógica. Ambos mecanismos se complementan.

class Point:
    __slots__ = ('_x', '_y')
    def __init__(self, x, y): self._x,self._y=x,y
    @property
    def x(self): return self._x
p = Point(1, 2)
print(p.x)

Cuándo usar @property

Utilice @property cuando necesite validación, valores calculados o mantener la compatibilidad con versiones anteriores mientras cambia los detalles internos.

# Before: class Person:
#     def __init__(self, age): self.age = age
# After: add validation without changing caller code
class Person:
    def __init__(self, age): self.age = age
    @property
    def age(self): return self._age
    @age.setter
    def age(self, v):
        if v < 0: raise ValueError('negative age')
        self._age = v
p = Person(30)
print(p.age)

Comprobación rápida

¿Qué ocurre cuando intenta asignar un valor a una @property de solo lectura (sin setter definido)?

Resumen

@property: el getter se convierte en acceso a un atributo. @name.setter añade compatibilidad con la escritura. @name.deleter añade compatibilidad con del. @cached_property calcula una vez. Los setters sirven para validar.

Siga avanzando

¡Excelente progreso! Continúe para dominar el siguiente concepto.

Preguntas frecuentes

¿La lección «El decorador @property» es gratis?

Sí — el texto completo de «El decorador @property» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «El decorador @property»?

Utilice property para crear getters, setters y deleters. Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «El decorador @property»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Python Academy