Python property与__getattr__有什么区别？适用场景对比

一、底层机制：属性查找链路与触发时机

要透彻理解两者的区别，关键在于观察 Python 解释器在执行 obj.some_attr 时的内部解析顺序。Python 拥有严格且确定性的属性查找算法（MRO 链与描述符协议）。

当执行属性查找时，解释器不会立即去实例字典中翻找，也不会直接调用魔术方法，而是按照固定的层级逐级下探：

1. 检查类及基类的字典：如果找到了同名的数据描述符（即同时实现了 __get__ 与 __set__ 的类，例如通过 @property 定义的属性），则优先交由描述符处理，直接返回 getter 调用的结果。
2. 检查实例自身的字典 obj.__dict__：如果类上没有同名数据描述符，解释器会检索当前实例是否存储了该变量。若存在，直接返回其值。
3. 再次检查类字典：如果实例字典中不存在，继续检查类层级是否存在非数据描述符（例如普通类方法、静态方法、类属性）。若存在则绑定并返回。
4. 兜底调用 __getattr__：如果上述所有查找路径全部落空，Python 才会去寻找该类是否声明了 __getattr__ 方法。如果存在，传入属性名称字符串执行兜底逻辑；若仍未定义，抛出标准的 AttributeError 异常。

二、property：静态受控的显式属性封装

property 是 Python 内置的装饰器，其本质是标准描述符模式的封装。使用 property 时，目标属性名在代码编写时就已经确定。它把类中的方法包装成可以通过类似字段访问语法（obj.attr）直接调用的属性，同时可以在背后执行逻辑代码。

1. property 的典型职能

• 输入合法性验证：在赋值时拦截非法数据，防止对象处于无效状态。
• 只读属性控制：仅提供 @property getter 而不提供 @attr.setter，实现对外只读。
• 动态计算与惰性计算：根据已有状态派生属性（如长宽计算面积、出生年推算年龄），调用方无需显式调用函数括号。
• 平滑重构（API 兼容）：将原本直接对外公开的公共属性无缝改造为受控方法，外界调用代码一行无需变动。

2. 完整代码示例：数据模型校验与只读派生

class UserProfile:
    def __init__(self, username: str, age: int):
        self.username = username
        self._age = None
        self.age = age  # 触发 setter 校验逻辑

    @property
    def age(self) -> int:
        """受控属性的 getter"""
        return self._age

    @age.setter
    def age(self, value: int):
        """受控属性的 setter，包含强类型与业务范围校验"""
        if not isinstance(value, int):
            raise TypeError("年龄必须是整数")
        if value < 0 or value > 150:
            raise ValueError("年龄数值必须在 0 到 150 之间")
        self._age = value

    @property
    def is_adult(self) -> bool:
        """只读派生属性，无需显式存储在 __dict__ 中"""
        return self._age >= 18

# 示例操作
user = UserProfile("Alice", 20)
print(user.age)       # 示例输出: 20
print(user.is_adult)  # 示例输出: True

try:
    user.age = -5     # 触发非法赋值
except ValueError as e:
    print(e)          # 示例输出: 年龄数值必须在 0 到 150 之间

三、__getattr__：动态未命中时的兜底分发

与 property 需要预先在代码中写死每个属性名称不同，__getattr__(self, name) 是一个针对未知属性名的通用捕获入口。它接收一个参数 name（字符串类型的属性名），且**只有在属性无法通过常规手段找到时**才会被唤醒。

1. __getattr__ 的典型职能

• 动态 API 客户端包装：允许调用 client.get_users() 或 client.post_orders()，无需在类里手动编写上百个几乎重复的请求方法，而是通过 name 动态拆解 HTTP 动作与路由。
• 字典对象的点号访问（DotDict）：将 JSON/字典数据的键访问 data["key"] 转换为 data.key 风格。
• 对象代理与装饰模式（Proxy Pattern）：包装一个外部对象，本对象未显式定义的方法与属性全部自动委托给被包装对象执行。

2. 完整代码示例：动态 API 调度器

class DynamicApiClient:
    def __init__(self, base_url: str):
        self.base_url = base_url

    def __getattr__(self, name: str):
        """当调用未显式声明的方法或属性时触发"""
        # 支持以 get_ 或 post_ 开头的动态请求分发
        if name.startswith("get_") or name.startswith("post_"):
            method, endpoint = name.split("_", 1)

            def request_handler(**kwargs):
                url = f"{self.base_url}/{endpoint}"
                # 模拟发送网络请求
                return {
                    "method": method.upper(),
                    "url": url,
                    "params": kwargs,
                    "status": "success"
                }

            return request_handler

        # 重点：对于无法处理的未知属性，必须主动抛出 AttributeError
        raise AttributeError(f"'{type(self).__name__}' 对象不存在属性 '{name}'")

# 示例操作
client = DynamicApiClient("https://api.example.com/v1")

# 类中未定义 get_users，自动落入 __getattr__ 并生成闭包
res1 = client.get_users(role="admin", page=1)
print(res1)  # 示例输出: {'method': 'GET', 'url': 'https://api.example.com/v1/users', 'params': {'role': 'admin', 'page': 1}, 'status': 'success'}

# 类中未定义 post_order
res2 = client.post_order(item_id=1024, amount=2)
print(res2)  # 示例输出: {'method': 'POST', 'url': 'https://api.example.com/v1/order', 'params': {'item_id': 1024, 'amount': 2}, 'status': 'success'}

try:
    _ = client.unknown_action()
except AttributeError as e:
    print(e)  # 示例输出: 'DynamicApiClient' 对象不存在属性 'unknown_action'

四、核心维度对比与选型法则

为了在实际架构与编码过程中做出正确决策，可以从触发优先级、声明方式、控制范围及执行性能四个核心维度进行系统对照：

清晰的选择决策路径

• 如果你明确知道要暴露的属性名称是什么（例如 price, email, radius），并且希望对其读写添加校验、缓存或派生计算，毫不犹豫选择 property。它不仅可读性好，还能被 IDE 自动补全和类型检查工具（MyPy）直接识别。
• 如果你要设计的类面对的是未知数量、在运行时由外部数据或调用方决定的属性名称（例如动态配置文件解析器、RPC 接口中转、跨语言接口桥接），选择 __getattr__。

五、常见误区与避坑提醒

1. 混淆 __getattr__ 与 __getattribute__ 导致无限递归

初学者容易将 __getattr__ 与 __getattribute__ 弄混：

• __getattribute__：无条件拦截所有属性访问。只要发生 obj.x，无论属性是否存在，都会最先调用它。如果在其内部直接书写 self.some_attr，又会再次触发 __getattribute__，从而瞬间导致栈溢出（RecursionError）。在其内部读取属性必须通过 super().__getattribute__(name)。
• __getattr__：仅在属性不存在时触发。因此正常使用时不易出现递归死循环，但如果在 __getattr__ 内部访问了另一个同样不存在的属性，也会引发级联调用。

2. 在 __getattr__ 中漏掉 AttributeError

Python 内置的 hasattr(obj, name) 函数底层原理是：调用 getattr(obj, name)，如果捕获到 AttributeError 则返回 False，若正常返回或抛出其他异常则返回 True。

如果自定义的 __getattr__ 在遇到无法处理的属性时直接返回 None，或者抛出 KeyError / ValueError，会导致 hasattr(obj, "any_random_name") 永远返回 True，从而彻底破坏 Python 标准库、序列化工具（如 pickle、copy）的运行机制。

# 正确的 __getattr__ 兜底范式
def __getattr__(self, name: str):
    if name in self._dynamic_storage:
        return self._dynamic_storage[name]
    # 必须显式抛出 AttributeError
    raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")

3. 试图用 __getattr__ 拦截属性赋值

__getattr__ 仅处理属性的读取。如果你执行 obj.unknown_attr = 100，Python 会直接将该键值写入 obj.__dict__，根本不会触发 __getattr__。下次再读取 obj.unknown_attr 时，因为实例字典已存在该键，__getattr__ 也不会被调用。如果需要动态拦截属性的写入，必须配套重写 __setattr__。