Python Academy · Lezione

Il decorator @property

Utilizzi property per getter, setter e deleter.

Il decorator @property è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Introduzione

@property trasforma un metodo in un attributo leggibile. @setter e @deleter completano il pattern di accesso controllato.

Perché usare @property?

Anziché usare getX()/setX() come in Java, Python utilizza @property. L'accesso ha l'aspetto di quello a un attributo: obj.value, non 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 ()

Proprietà calcolate

I metodi @property effettuano i calcoli al momento dell'accesso. obj.area viene calcolato ogni volta che vi si accede: non è necessario memorizzare alcun valore.

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 di una proprietà

@property_name.setter aggiunge un setter. Ora c.radius = 10 richiama il metodo 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 di una proprietà

@property_name.deleter gestisce del obj.attr. Lo utilizzi per la logica di pulizia.

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'))

Proprietà in sola lettura

Definisca solo il getter, senza setter. Un tentativo di assegnazione genera 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)

Proprietà con validazione

I setter sono il luogo ideale per validare i dati: verifichi il tipo, l'intervallo o il formato prima di memorizzarli.

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)

Caching con property

Combini @property con un valore memorizzato nella cache per eseguire il calcolo una sola volta e memoizzarlo.

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 calcola la proprietà una sola volta e la memorizza come attributo dell'istanza, evitando calcoli ripetuti.

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 vs slots

__slots__ impedisce la creazione di attributi arbitrari e consente di risparmiare memoria. Le proprietà aggiungono logica. Sono complementari.

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)

Quando usare @property

Utilizzi @property quando è necessaria la validazione, quando deve calcolare valori o quando vuole mantenere la compatibilità con le versioni precedenti modificando l'implementazione interna.

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

Controllo rapido

Che cosa accade quando si tenta di assegnare un valore a una @property in sola lettura, senza setter definito?

Riepilogo

@property: il getter diventa un accesso a un attributo. @name.setter aggiunge il supporto alla scrittura. @name.deleter aggiunge il supporto a del. @cached_property calcola una sola volta. I setter servono per la validazione.

Continui

Ottimi progressi! Continui per padroneggiare il prossimo concetto.

Domande Frequenti

La lezione «Il decorator @property» è gratuita?

Sì — il testo completo di «Il decorator @property» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «Il decorator @property»?

Utilizzi property per getter, setter e deleter. Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Il decorator @property»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Python Academy