1️⃣ __getattr__ 基础回顾

Python

运行

class Foo:

def __init__(self):

self.existing = 42

def __getattr__(self, name):

print(f"访问动态属性: {name}")

return f"{name}_value"

f = Foo()

print(f.existing) # 直接访问，不触发 __getattr__

print(f.dynamic) # 触发 __getattr__

关键点：

__getattr__ 只在普通属性查找失败时才会被调用。

对不存在的属性，Python 会调用它，每次访问都会调用一次。

2️⃣ 性能陷阱

(1) 每次访问都会调用函数

因为 __getattr__ 是按需计算的，访问不存在的属性，每次都会执行函数体。

示例：

Python

运行

class Foo:

def __getattr__(self, name):

# 假设有复杂计算

return sum(range(1000000))

f = Foo()

f.a # 每次都要 sum 一次

f.a # 再次 sum

💥 隐蔽问题：如果访问频繁，这里会导致巨大的 CPU 消耗。

(2) 与 __dict__ 缓存不自动结合

__getattr__ 不会自动缓存计算结果，如果你想缓存，必须自己写：

Python

运行

class Foo:

def __getattr__(self, name):

value = name.upper()

self.__dict__[name] = value # 缓存

return value

不加缓存，每次访问都会重新计算，性能差异巨大。

(3) dir() 和属性枚举问题

__getattr__ 生成的动态属性不会被 dir(obj) 或 vars(obj) 枚举。

如果你频繁用 hasattr, getattr 判断属性存在性，会多次触发 __getattr__：

Python

运行

for name in ['a','b','c']:

if hasattr(f, name): # 每次都触发 __getattr__

...

💥 访问很多动态属性时，会造成性能瓶颈。

(4) 递归陷阱

Python

运行

class Foo:

def __getattr__(self, name):

return getattr(self, name) # ⚠️无限递归

很容易因为访问其他属性触发 __getattr__ 而递归爆栈。

隐蔽场景：你在 __getattr__ 内部调用另一个不存在属性或方法。

(5) 与 __getattribute__ 混用风险

__getattribute__ 在每次访问属性时都会被调用，而 __getattr__ 只在找不到属性时调用。

混用时容易造成重复计算或调用开销：

Python

运行

class Foo:

def __getattribute__(self, name):

print(f"访问: {name}")

return super().__getattribute__(name)

def __getattr__(self, name):

print(f"动态生成: {name}")

return 42

访问动态属性时会先走 __getattribute__，再走 __getattr__，两次函数调用叠加开销。

(6) 方法调用与绑定问题

如果你返回的是函数对象，每次访问都会生成新的方法对象：

Python

运行

class Foo:

def __getattr__(self, name):

return lambda x: x*2

f = Foo()

f.func1(10) # lambda 每次生成新函数

f.func1(20) # 又生成一个新函数

💥 频繁方法调用会导致对象生成压力，尤其在循环或高并发环境。

3️⃣ 优化建议

缓存动态属性

Python

运行

class Foo:

def __getattr__(self, name):

value = name.upper()

self.__dict__[name] = value

return value

避免复杂计算放在 __getattr__

可以先生成静态属性或 lazy 属性，避免每次触发高开销逻辑。

注意递归访问

内部访问尽量用 self.__dict__.get(name) 或 object.__getattribute__(self, name)，避免再次触发 __getattr__。

对方法绑定缓存

Python

运行

class Foo:

def __getattr__(self, name):

def method(*args):

return sum(args)

setattr(self, name, method)

return method

💡 总结：

__getattr__ 看似方便动态属性，但每次访问都会计算，没有自动缓存。

高频访问、递归访问、多方法绑定都会导致 CPU、内存和栈溢出隐患。

最安全的做法是带缓存 + 避免复杂计算 + 避免递归。

ITPub博客

python使用 getattr 动态属性时的性能陷阱

最新文章

ITPub博客

python使用 __getattr__ 动态属性时的性能陷阱

最新文章

python使用 getattr 动态属性时的性能陷阱