Python的`__getattr__`与`__getattribute__`的调用顺序与性能差异

Python 的 __getattr__ 与 __getattribute__：调用顺序、性能差异与应用场景

大家好，今天我们来深入探讨 Python 中两个非常重要的属性访问控制方法：__getattr__ 和 __getattribute__。理解它们的调用顺序、性能差异以及适用场景，对于编写健壮、高效的 Python 代码至关重要。

属性访问机制概览

在深入 __getattr__ 和 __getattribute__ 之前，我们需要先了解 Python 中属性访问的基本机制。当试图访问一个对象的属性时（例如 obj.attribute），Python 解释器会按照以下顺序查找：

1. 数据描述符 (Data Descriptor)：如果 attribute 是一个定义了 __get__、__set__ 和 __delete__ 方法的类属性 (例如 property)，则调用该描述符的 __get__ 方法。

2. 实例字典 (Instance Dictionary)：如果 attribute 存在于 obj.__dict__ 中，则直接返回该值。

3. 类型字典 (Type Dictionary)：如果 attribute 存在于 obj 的类型 (obj.__class__.__dict__) 中，则返回该值。

4. 非数据描述符 (Non-Data Descriptor)：如果 attribute 是一个定义了 __get__ 方法但没有 __set__ 方法的类属性(例如方法)，则调用该描述符的 __get__ 方法。

5. __getattr__ 方法：如果在以上步骤中都找不到 attribute，并且 obj 的类定义了 __getattr__ 方法，则调用该方法。

6. 抛出 AttributeError：如果 __getattr__ 方法也没有找到 attribute，则抛出 AttributeError 异常。

__getattr__：属性查找的最后防线

__getattr__ 是一个“后备”方法，只有当 Python 解释器在常规属性查找过程中找不到属性时，才会调用它。它的签名如下：

def __getattr__(self, name):
    """
    当访问不存在的属性时调用。

    Args:
        self: 对象实例。
        name: 要访问的属性的名称（字符串）。

    Returns:
        属性的值。
        如果属性不存在，可以抛出 AttributeError 异常。
    """
    # ... 实现逻辑 ...

示例：

class MyClass:
    def __init__(self, data):
        self.data = data

    def __getattr__(self, name):
        if name.startswith("custom_"):
            return f"Custom attribute: {name[7:]}"
        else:
            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")

obj = MyClass({"key1": "value1"})

print(obj.data)  # 输出: {'key1': 'value1'}
print(obj.custom_attribute)  # 输出: Custom attribute: attribute
try:
    print(obj.nonexistent_attribute)
except AttributeError as e:
    print(e)  # 输出: 'MyClass' object has no attribute 'nonexistent_attribute'

在这个例子中，当我们尝试访问 obj.custom_attribute 时，由于 MyClass 中没有名为 custom_attribute 的属性，Python 会调用 __getattr__ 方法。__getattr__ 检查属性名称是否以 "custom_" 开头，如果是，则返回一个自定义字符串。否则，它会抛出 AttributeError 异常。

应用场景：

• 动态属性: 实现动态属性，例如基于配置文件或数据库中的数据创建属性。
• 属性代理: 将属性访问委托给另一个对象。
• 拼写校正/模糊匹配: 尝试猜测用户想要访问的属性，并提供建议或返回近似值。
• 延迟加载: 在实际需要属性时才进行加载。

__getattribute__：属性访问的拦截器

__getattribute__ 则是一个更强大的方法，它会拦截所有属性访问，无论属性是否存在。它的签名如下：

def __getattribute__(self, name):
    """
    拦截所有属性访问。

    Args:
        self: 对象实例。
        name: 要访问的属性的名称（字符串）。

    Returns:
        属性的值。
        如果属性不存在，可以抛出 AttributeError 异常。
    """
    # ... 实现逻辑 ...

重要提示： 在 __getattribute__ 中访问实例属性时，必须使用 super().__getattribute__(name) 来避免无限递归。

示例：

class MyClass:
    def __init__(self, data):
        self.data = data

    def __getattribute__(self, name):
        print(f"Accessing attribute: {name}")
        try:
            return super().__getattribute__(name)
        except AttributeError:
            print(f"Attribute '{name}' not found, delegating to __getattr__")
            return super().__getattr__(name)

    def __getattr__(self, name):
        if name.startswith("custom_"):
            return f"Custom attribute: {name[7:]}"
        else:
            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")

obj = MyClass({"key1": "value1"})

print(obj.data)
print(obj.custom_attribute)
try:
    print(obj.nonexistent_attribute)
except AttributeError as e:
    print(e)

在这个例子中，每次访问属性时，__getattribute__ 都会打印一条消息。它首先尝试使用 super().__getattribute__(name) 获取属性。如果属性存在，则返回该值。如果属性不存在，则捕获 AttributeError 异常并调用 __getattr__ 方法。

应用场景：

• 属性访问日志记录: 记录所有属性访问，用于调试或审计。
• 访问控制: 限制对某些属性的访问。
• 性能分析: 测量属性访问的频率和时间。
• 属性转换: 在访问属性之前或之后对其进行转换（例如，自动将字符串转换为数字）。
• 实现单例模式: 拦截 __new__ 方法，确保只创建一个实例。

调用顺序对比

操作	调用顺序
访问存在的属性	1. 数据描述符 2. 实例字典 3. 类型字典 4. 非数据描述符 5. __getattribute__
访问不存在的属性	1. 数据描述符 2. 实例字典 3. 类型字典 4. 非数据描述符 5. __getattribute__ 6. __getattr__

从上表可以看出，__getattribute__ 总是被首先调用，而 __getattr__ 只有在 __getattribute__ 无法找到属性时才会被调用。

性能差异分析

由于 __getattribute__ 会拦截所有属性访问，因此它比 __getattr__ 的开销更大。如果您的代码需要频繁访问属性，并且性能至关重要，则应尽可能避免使用 __getattribute__。

以下是一些提高性能的建议：

• 避免过度使用 __getattribute__: 只在真正需要拦截所有属性访问时才使用它。
• 缓存属性值: 如果某个属性的值计算成本很高，则可以将其缓存起来，以便下次访问时直接返回缓存的值。
• 使用 slots: 使用 __slots__ 可以减少对象的内存占用，并提高属性访问速度。
• 使用更高效的数据结构: 如果需要频繁查找属性，可以考虑使用字典或其他更高效的数据结构。

让我们通过一个简单的例子来演示性能差异：

import time

class MyClassWithGetattr:
    def __init__(self, data):
        self.data = data

    def __getattr__(self, name):
        if name.startswith("custom_"):
            return f"Custom attribute: {name[7:]}"
        else:
            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")

class MyClassWithGetattribute:
    def __init__(self, data):
        self.data = data

    def __getattribute__(self, name):
        try:
            return super().__getattribute__(name)
        except AttributeError:
            return super().__getattr__(name)

    def __getattr__(self, name):
        if name.startswith("custom_"):
            return f"Custom attribute: {name[7:]}"
        else:
            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")

# 测试 __getattr__
obj1 = MyClassWithGetattr({"key1": "value1"})
start_time = time.time()
for _ in range(1000000):
    try:
        obj1.nonexistent_attribute
    except AttributeError:
        pass
end_time = time.time()
print(f"__getattr__ time: {end_time - start_time:.4f} seconds")

# 测试 __getattribute__
obj2 = MyClassWithGetattribute({"key1": "value1"})
start_time = time.time()
for _ in range(1000000):
    try:
        obj2.nonexistent_attribute
    except AttributeError:
        pass
end_time = time.time()
print(f"__getattribute__ time: {end_time - start_time:.4f} seconds")

# 测试 __getattr__ (存在属性)
obj3 = MyClassWithGetattr({"key1": "value1"})
start_time = time.time()
for _ in range(1000000):
    obj3.data
end_time = time.time()
print(f"__getattr__ (existing attribute) time: {end_time - start_time:.4f} seconds")

# 测试 __getattribute__ (存在属性)
obj4 = MyClassWithGetattribute({"key1": "value1"})
start_time = time.time()
for _ in range(1000000):
    obj4.data
end_time = time.time()
print(f"__getattribute__ (existing attribute) time: {end_time - start_time:.4f} seconds")

运行这段代码，你会发现 __getattribute__ 的执行时间明显长于 __getattr__。即使是访问存在的属性，__getattribute__ 也会因为拦截所有访问而产生额外的开销。

何时使用哪个方法？

方法	适用场景	注意事项
__getattr__	动态属性 属性代理 拼写校正/模糊匹配 延迟加载 仅当属性不存在时才需要执行操作。	性能开销较低。 只能处理不存在的属性。
__getattribute__	属性访问日志记录 访问控制 性能分析 属性转换 * 实现单例模式 需要拦截所有属性访问。	性能开销较高。 必须使用 super().__getattribute__(name) 避免无限递归。 * 会拦截所有属性访问，包括内置属性和方法。

总而言之，选择哪个方法取决于你的具体需求。如果只需要处理不存在的属性，则使用 __getattr__。如果需要拦截所有属性访问，则使用 __getattribute__，但要注意性能影响。

实际案例分析

1. 动态配置加载

假设我们需要从配置文件中加载配置项，并将它们作为对象的属性公开。我们可以使用 __getattr__ 来实现这个功能：

import json

class Config:
    def __init__(self, config_file):
        with open(config_file, "r") as f:
            self._config = json.load(f)

    def __getattr__(self, name):
        if name in self._config:
            return self._config[name]
        else:
            raise AttributeError(f"Config option '{name}' not found.")

# config.json:
# {
#     "database_host": "localhost",
#     "database_port": 5432
# }

config = Config("config.json")
print(config.database_host)  # 输出: localhost
print(config.database_port)  # 输出: 5432

2. 属性访问控制

假设我们需要限制对某些属性的访问，例如，只允许管理员访问某些敏感数据。我们可以使用 __getattribute__ 来实现这个功能：

class User:
    def __init__(self, username, role, sensitive_data):
        self.username = username
        self.role = role
        self._sensitive_data = sensitive_data

    def __getattribute__(self, name):
        if name == "_sensitive_data" and self.role != "admin":
            raise AttributeError("Access to sensitive data is restricted.")
        return super().__getattribute__(name)

user = User("john", "user", "secret_password")
admin = User("admin", "admin", "secret_password")

print(user.username)  # 输出: john
try:
    print(user._sensitive_data)
except AttributeError as e:
    print(e)  # 输出: Access to sensitive data is restricted.

print(admin._sensitive_data)  # 输出: secret_password

使用场景与方法选择

__getattr__ 和 __getattribute__ 都是强大的工具，可以用来定制属性访问的行为。选择哪个方法取决于你的具体需求。 理解属性访问机制、调用顺序和性能差异，可以帮助我们编写更清晰、更高效的 Python 代码。

希望今天的讲解能够帮助大家更好地理解和使用这两个方法。 谢谢大家！

更多IT精英技术系列讲座，到智猿学院