Python property 数据管线：用声明式属性拦截构建 ETL 级数据流

class Person:
    def __init__(self, first, last):
        self.first = first
        self.last = last

    @property
    def full_name(self):
        # 不存字段，每次访问实时算
        return f"{self.first} {self.last}"

p = Person("Zhou", "Chengxin")
print(p.full_name)   # Zhou Chengxin

class Temperature:
    def __init__(self, celsius):
        self._c = celsius

    @property
    def celsius(self):
        return self._c

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("低于绝对零度")
        self._c = value

t = Temperature(25)
t.celsius = -300     # ValueError: 低于绝对零度

class Reading:
    def __init__(self, temp):
        self._temp = temp
        self._cached = None      # 缓存
        self._dirty = True       # 脏标记

    @property
    def temp(self):
        return self._temp

    @temp.setter
    def temp(self, value):
        self._temp = value
        self._dirty = True       # 原始值变了 → 缓存失效

    @property
    def heat(self):
        if self._cached is None or self._dirty:
            # 昂贵计算只在实际需要且缓存失效时才跑
            self._cached = self._temp * 1.8 + 32
            self._dirty = False
        return self._cached

r = Reading(25)
print(r.heat)   # 77.0（首次计算并缓存）
r.temp = 30
print(r.heat)   # 86.0（脏了，重算）

class Validated:
    """声明式校验描述符：赋值时拦截并规整。"""
    def __set_name__(self, owner, name):
        self.name = name              # 自动拿到属性名
        self.private = "_" + name     # 缓存对应的私有字段名

    def __init__(self, min_=None, max_=None, cast=float):
        self.min_, self.max_, self.cast = min_, max_, cast

    def __get__(self, obj, owner):
        return None if obj is None else getattr(obj, self.private)

    def __set__(self, obj, value):
        v = self.cast(value)          # 类型规整（脏字符串→数字）
        if self.min_ is not None and v < self.min_:
            raise ValueError(f"{self.name} 不能小于 {self.min_}")
        if self.max_ is not None and v > self.max_:
            raise ValueError(f"{self.name} 不能大于 {self.max_}")
        setattr(obj, self.private, v)
        obj._dirty = True             # 任何原始字段变化 → 派生缓存失效

class Validated:
    def __set_name__(self, owner, name):
        self.name = name
        self.private = "_" + name

    def __init__(self, min_=None, max_=None, cast=float):
        self.min_, self.max_, self.cast = min_, max_, cast

    def __get__(self, obj, owner):
        return None if obj is None else getattr(obj, self.private)

    def __set__(self, obj, value):
        v = self.cast(value)
        if self.min_ is not None and v < self.min_:
            raise ValueError(f"{self.name} 不能小于 {self.min_}")
        if self.max_ is not None and v > self.max_:
            raise ValueError(f"{self.name} 不能大于 {self.max_}")
        setattr(obj, self.private, v)
        obj._dirty = True


class Reading:
    # 校验层：声明即生效，无需手写字段名
    temp_c = Validated(min_=-40, max_=85)
    humidity = Validated(min_=0, max_=100)

    def __init__(self, temp_c, humidity):
        self._dirty = True
        self._heat_index = None
        self.temp_c = temp_c       # 走描述符 __set__：校验+规整+置脏
        self.humidity = humidity

    @property
    def heat_index(self):
        """派生层：酷热指数（简化示意公式），计算较贵，缓存之。"""
        if self._heat_index is None or self._dirty:
            t, h = self.temp_c, self.humidity
            hi = 0.5 * (t + 61 + (t - 68) * 1.2 + h * 0.094)
            self._heat_index = round(hi, 2)
            self._dirty = False
        return self._heat_index

    @property
    def level(self):
        """派生分级：纯计算、无状态，实时即可。"""
        return "危险" if self.heat_index > 40 else ("预警" if self.heat_index > 30 else "正常")


# ---------- 脏数据进，干净对象出 ----------
r = Reading(temp_c=33.5, humidity=70)
print(r.temp_c, r.humidity)   # 33.5 70.0（已 cast 为 float）
print(r.heat_index)           # 首次计算并缓存
print(r.level)                # 正常
r.temp_c = 41.0               # setter 触发校验 + 置脏
print(r.heat_index)           # 缓存失效，重算
try:
    r.humidity = 150          # 越界 → 描述符拦截
except ValueError as e:
    print("拦截:", e)