class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @property
    def area(self):
        return 3.1416 * self._radius ** 2

c = Circle(5)
print(c.radius)  # 5
print(c.area)    # 78.54

class Person:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if not value:
            raise ValueError("Name cannot be empty")
        self._name = value

p = Person("Alice")
p.name = "Bob"  # 正常
p.name = ""     # 拋出異常

class Secret:
    def __init__(self):
        self._token = "abc123"

    @property
    def token(self):
        return self._token

    @token.deleter
    def token(self):
        print("Token deleted")
        del self._token

s = Secret()
del s.token  # 調(diào)用自定義的刪除邏輯

from functools import cached_property

class Expensive:
    @cached_property
    def result(self):
        print("Calculating...")
        return sum(i * i for i in range(10**6))

obj = Expensive()
print(obj.result)  # 第一次：執(zhí)行計(jì)算
print(obj.result)  # 第二次：返回緩存結(jié)果

class cached_property:
    def __init__(self, func):
        self.func = func
        self.attrname = None
        self.__doc__ = func.__doc__
        self.lock = RLock()

    def __set_name__(self, owner, name):
        if self.attrname is None:
            self.attrname = name
        elif name != self.attrname:
            raise TypeError(
                "Cannot assign the same cached_property to two different names "
                f"({self.attrname!r} and {name!r})."
            )

    def __get__(self, instance, owner=None):
        if instance is None:
            return self
        if self.attrname is None:
            raise TypeError(
                "Cannot use cached_property instance without calling __set_name__ on it.")
        try:
            cache = instance.__dict__
        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
            msg = (
                f"No '__dict__' attribute on {type(instance).__name__!r} "
                f"instance to cache {self.attrname!r} property."
            )
            raise TypeError(msg) from None
        val = cache.get(self.attrname, _NOT_FOUND)
        if val is _NOT_FOUND:
            with self.lock:
                # check if another thread filled cache while we awaited lock
                val = cache.get(self.attrname, _NOT_FOUND)
                if val is _NOT_FOUND:
                    val = self.func(instance)
                    try:
                        cache[self.attrname] = val
                    except TypeError:
                        msg = (
                            f"The '__dict__' attribute on {type(instance).__name__!r} instance "
                            f"does not support item assignment for caching {self.attrname!r} property."
                        )
                        raise TypeError(msg) from None
        return val

class cached_property:
    def __init__(self, name, func):
        self.func = func
        self.attrname = name  # 必須手動(dòng)傳入
    ...

class MyClass:
    result = cached_property("result", lambda self: 42)

class User:
    @cached_property
    def profile(self): ...

    @cached_property
    def permissions(self): ...

elif name != self.attrname:
	raise TypeError(
	     "Cannot assign the same cached_property to two different names "
	     f"({self.attrname!r} and {name!r})."
	 )

shared = cached_property(lambda self: 123)

class Foo:
    a = shared
    b = shared  # ? 拋出異常

def __set_name__(self, owner, name):
    if self.attrname is None:
        self.attrname = name  # 第一次綁定成功
    elif name != self.attrname:
        raise TypeError(...)  # 第二次綁定，不一致就報(bào)錯(cuò)

instance.__dict__[self.attrname] = self.func(instance)

class Foo:
    @cached_property
    def a(self):
        return 1

    @cached_property
    def b(self):
        return 2