怎样优化Python代码中的频繁属性访问（如点号操作）

访客性能优化 2026-06-05 08:40:23 1

本文目录导读：

局部变量绑定（最常用、最有效）
方法本地化
使用 __slots__（类级别优化）
使用属性访问器优化
模块级别常量绑定
使用 __getattr__ 和 __setattr__ 优化
性能对比
总结建议

优化Python中频繁属性访问（点号操作）的核心思路是减少属性查找的次数，Python的点号操作涉及字典查找，有一定开销，以下是几种有效的优化方法：

局部变量绑定（最常用、最有效）

将频繁访问的属性绑定到局部变量,避免重复查找：

# ❌ 不优化
class Example:
    def __init__(self):
        self.data = list(range(1000))
    def process_slow(self):
        result = 0
        for i in range(1000):
            result += self.data[i]  # 每次循环都查找 self.data
        return result
# ✅ 优化后
class Example:
    def __init__(self):
        self.data = list(range(1000))
    def process_fast(self):
        result = 0
        data = self.data  # 局部变量绑定
        for i in range(1000):
            result += data[i]
        return result

方法本地化

对于频繁调用的方法,同样可以绑定到局部变量：

# ❌ 不优化
def process_items_slow(items):
    result = []
    for item in items:
        result.append(item.upper())  # 每次查找 upper 方法
    return result
# ✅ 优化后
def process_items_fast(items):
    result = []
    append = result.append  # 方法本地化
    upper = str.upper  # 也可以这样
    for item in items:
        append(upper(item))
    return result

使用 `slots`（类级别优化）

对于大量实例,使用 __slots__ 避免字典开销：

# ❌ 不优化 - 每个实例都有 __dict__
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
# ✅ 优化后 - 使用 __slots__
class PointOptimized:
    __slots__ = ('x', 'y')  # 声明固定属性
    def __init__(self, x, y):
        self.x = x
        self.y = y
# 性能差异明显
points = [Point(i, i) for i in range(10000)]
points_opt = [PointOptimized(i, i) for i in range(10000)]

使用属性访问器优化

对于高频属性访问,使用 @property 的同时注意缓存：

# ❌ 重复计算
class Circle:
    def __init__(self, radius):
        self.radius = radius
    @property
    def area(self):
        return 3.14159 * self.radius ** 2  # 每次都计算
# ✅ 带缓存的属性
class CircleOptimized:
    def __init__(self, radius):
        self.radius = radius
        self._area = None
    @property
    def area(self):
        if self._area is None:
            self._area = 3.14159 * self.radius ** 2
        return self._area

模块级别常量绑定

对于模块属性,提前绑定到局部变量：

# ❌ 每次都查找 os.path.join
import os
def process_paths_slow(paths):
    return [os.path.join('base', p) for p in paths]
# ✅ 提前绑定
import os
join = os.path.join  # 模块级别绑定
def process_paths_fast(paths):
    return [join('base', p) for p in paths]

使用 `getattr` 和 `setattr` 优化

当需要动态属性时,可以重写这些方法：

# ❌ 使用 __dict__ 直接访问
class LazyAttributes:
    def __getattr__(self, name):
        if name.startswith('computed_'):
            return self._compute(name)
        raise AttributeError(name)
# ✅ 使用 __slots__ + 缓存
class LazyAttributesOptimized:
    __slots__ = ('_cache',)
    def __init__(self):
        object.__setattr__(self, '_cache', {})
    def __getattr__(self, name):
        if name in self._cache:
            return self._cache[name]
        if name.startswith('computed_'):
            value = self._compute(name)
            self._cache[name] = value
            return value
        raise AttributeError(name)

性能对比

import timeit
# 测试代码
setup = """
class A:
    def __init__(self):
        self.x = 1
        self.y = 2
    def compute(self):
        return self.x + self.y
a = A()
def slow():
    for _ in range(1000):
        result = a.x + a.y + a.x + a.y
def fast():
    x, y = a.x, a.y
    for _ in range(1000):
        result = x + y + x + y
"""
print(timeit.timeit('slow()', setup=setup, number=10000))
print(timeit.timeit('fast()', setup=setup, number=10000))