Python中的Slotting机制：`__slots__`与继承链中的属性查找优化 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Python中的Slotting机制：`slots`与继承链中的属性查找优化

大家好，今天我们来深入探讨Python中一个鲜为人知但功能强大的特性：__slots__。它主要用于优化类的内存使用和属性访问速度，尤其是在创建大量类实例时。我们将从__slots__的基本概念入手，逐步分析其工作原理、继承行为，以及在实际应用中的注意事项。

1. __slots__：声明类的“槽”

在Python中，当我们创建一个类的实例时，通常会使用一个字典 (__dict__) 来存储实例的属性。这个字典是动态的，可以随时添加新的属性。虽然这种灵活性非常方便，但也带来了一定的内存开销和属性查找速度上的损失。

__slots__的出现就是为了解决这个问题。它允许我们显式地声明一个类实例能够拥有的属性名称，从而避免使用动态字典。可以把__slots__理解为预先定义好的“槽”，每个槽对应一个属性。

下面是一个简单的例子：

class Point:
    __slots__ = ['x', 'y']

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(10, 20)
print(p.x, p.y)  # 输出: 10 20

# 尝试添加未声明的属性会导致AttributeError
try:
    p.z = 30
except AttributeError as e:
    print(e) # 输出: 'Point' object has no attribute 'z'

在这个例子中，我们定义了一个Point类，并使用__slots__ = ['x', 'y']声明了它只能拥有x和y两个属性。当我们尝试添加未声明的属性z时，会抛出AttributeError。

好处:

减少内存占用: 由于不再使用__dict__，每个实例的内存占用会减少，尤其是在创建大量实例时效果显著。
提高属性访问速度: 访问__slots__中声明的属性通常比访问__dict__中的属性更快，因为它避免了字典查找的开销。

坏处:

灵活性降低: 无法动态添加未声明的属性。
多重继承的复杂性: 在复杂的继承关系中，__slots__的使用需要特别注意。
不支持弱引用: 如果一个类定义了__slots__并且没有包含'__weakref__'，那么它的实例将无法被弱引用。

2. __slots__的工作原理

当我们定义了__slots__时，Python会做以下几件事：

禁用__dict__: 它不会为实例创建__dict__属性，除非__slots__中显式地声明了'__dict__'。
创建描述器: 对于__slots__中声明的每个属性，Python会创建一个描述器对象。描述器是一种实现了__get__、__set__和__delete__方法的对象，它可以控制属性的访问行为。
替代属性访问: 当访问一个__slots__属性时，Python会调用相应的描述器方法，而不是直接访问__dict__。

这种机制避免了字典查找的开销，从而提高了属性访问速度。

3. __slots__与继承

__slots__的继承行为比较复杂，需要仔细考虑以下几种情况：

子类未定义__slots__: 如果父类定义了__slots__，而子类没有定义，那么子类实例将拥有__dict__属性，可以动态添加属性。但是，从父类继承的__slots__属性仍然有效，不能通过实例直接修改。

class Parent:
    __slots__ = ['x']
    def __init__(self, x):
        self.x = x

class Child(Parent):
    pass

c = Child(10)
c.y = 20  # 可以动态添加属性
print(c.x, c.y) # 输出: 10 20

try:
    c.x = 30  # 仍然可以修改父类定义的属性
    print(c.x) # 输出: 30
except AttributeError as e:
    print(e)

子类定义了__slots__:

子类__slots__与父类__slots__不冲突: 如果子类定义的__slots__与父类定义的__slots__中的属性名称没有重叠，那么子类实例将同时拥有父类和子类定义的属性。

class Parent:
    __slots__ = ['x']
    def __init__(self, x):
        self.x = x

class Child(Parent):
    __slots__ = ['y']
    def __init__(self, x, y):
        super().__init__(x)
        self.y = y

c = Child(10, 20)
print(c.x, c.y) # 输出: 10 20

子类__slots__与父类__slots__冲突: 如果子类定义的__slots__与父类定义的__slots__中的属性名称有重叠，会导致TypeError。

class Parent:
    __slots__ = ['x']
    def __init__(self, x):
        self.x = x

class Child(Parent):
    __slots__ = ['x', 'y']  # 与父类的 'x' 冲突
    def __init__(self, x, y):
        super().__init__(x)
        self.y = y
try:
    c = Child(10, 20)
except TypeError as e:
    print(e) # 输出: multiple bases have instance lay-out conflict

多重继承: 在多重继承的情况下，如果多个父类都定义了__slots__，并且存在属性名称冲突，同样会导致TypeError。解决这个问题的一种方法是在子类中重新定义__slots__，并包含所有父类的属性名称。

class Parent1:
    __slots__ = ['x']
    def __init__(self, x):
        self.x = x

class Parent2:
    __slots__ = ['y']
    def __init__(self, y):
        self.y = y

class Child(Parent1, Parent2):
    __slots__ = ['x', 'y', 'z']  # 包含所有父类的属性
    def __init__(self, x, y, z):
        Parent1.__init__(self, x)
        Parent2.__init__(self, y)
        self.z = z

c = Child(10, 20, 30)
print(c.x, c.y, c.z) # 输出: 10 20 30

4. __dict__和__weakref__

__dict__: 如果需要在使用了__slots__的类中仍然允许动态添加属性，可以在__slots__中包含'__dict__'。

class Point:
    __slots__ = ['x', 'y', '__dict__']

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(10, 20)
p.z = 30  # 可以动态添加属性
print(p.x, p.y, p.z) # 输出: 10 20 30

__weakref__: 如果需要支持弱引用，也需要在__slots__中包含'__weakref__'。

import weakref

class Point:
    __slots__ = ['x', 'y', '__weakref__']

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(10, 20)
ref = weakref.ref(p)
print(ref()) # 输出: <__main__.Point object at 0x...>
del p
print(ref()) # 输出: None

5. 性能测试

为了验证__slots__的性能优势，我们可以进行简单的性能测试。下面是一个使用timeit模块的例子：

import timeit

# 不使用 __slots__ 的类
class PointWithoutSlots:
    def __init__(self, x, y):
        self.x = x
        self.y = y

# 使用 __slots__ 的类
class PointWithSlots:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

# 创建大量实例并访问属性
def test_without_slots(n):
    points = [PointWithoutSlots(i, i) for i in range(n)]
    for p in points:
        x = p.x
        y = p.y

def test_with_slots(n):
    points = [PointWithSlots(i, i) for i in range(n)]
    for p in points:
        x = p.x
        y = p.y

n = 1000000  # 创建一百万个实例

# 测量不使用 __slots__ 的时间
time_without_slots = timeit.timeit(lambda: test_without_slots(n), number=1)
print(f"不使用 __slots__ 的时间: {time_without_slots:.4f} 秒")

# 测量使用 __slots__ 的时间
time_with_slots = timeit.timeit(lambda: test_with_slots(n), number=1)
print(f"使用 __slots__ 的时间: {time_with_slots:.4f} 秒")

# 计算性能提升的百分比
improvement = (time_without_slots - time_with_slots) / time_without_slots * 100
print(f"性能提升: {improvement:.2f}%")

import sys

size_without_slots = sys.getsizeof(PointWithoutSlots(0,0))
size_with_slots = sys.getsizeof(PointWithSlots(0,0))

print(f"不使用 __slots__ 的对象大小: {size_without_slots} 字节")
print(f"使用 __slots__ 的对象大小: {size_with_slots} 字节")

运行结果会显示使用__slots__的类在创建大量实例并访问属性时，通常比不使用__slots__的类更快，并且占用更少的内存。具体的提升幅度取决于具体的应用场景和硬件环境。

示例结果:

类定义	创建时间(秒)	对象大小（字节）
`__slots__`未使用	1.2345	64
`__slots__`使用	0.9876	48

6. 使用__slots__的注意事项

只在必要时使用: __slots__会降低类的灵活性，所以只在需要优化内存使用和属性访问速度时才使用。
考虑继承关系: 在复杂的继承关系中，需要仔细考虑__slots__的继承行为，避免出现冲突。
避免重复声明: 不要在子类中重复声明父类已经声明的属性。
包含__dict__和__weakref__: 如果需要支持动态属性或弱引用，需要在__slots__中包含'__dict__'或'__weakref__'。
了解描述器: 理解描述器的工作原理有助于更好地理解__slots__的实现机制。

7. 属性查找优化

__slots__除了节省内存外，还优化了属性查找速度。 Python的属性查找顺序通常是：

实例的__dict__ (如果存在)
类的__dict__
父类的__dict__ (按继承顺序)
描述器的__get__方法 (如果属性是一个描述器)
抛出AttributeError

当使用__slots__时，实例不再有__dict__，属性查找会直接到类的__slots__中查找对应的描述器。这避免了字典查找的开销，因此速度更快。

8. 适用场景

__slots__非常适合以下场景：

数据类: 表示简单数据结构的类，例如坐标点、颜色、矩形等。
ORM (对象关系映射) 类: 将数据库表映射到对象的类，通常需要创建大量实例。
游戏开发: 表示游戏对象（例如角色、物品、敌人）的类，对性能要求较高。
内存敏感的应用: 在内存资源有限的环境中运行的应用，例如嵌入式系统。

9. 一些需要避免的情况

频繁修改属性: 如果类的属性需要频繁修改，使用__slots__可能不会带来明显的性能提升，因为描述器的开销可能会抵消字典查找的优势。
需要高度灵活性的类: 如果类需要能够动态添加任意属性，那么不应该使用__slots__。
代码可读性: 过度使用__slots__可能会降低代码的可读性，特别是对于不熟悉__slots__的开发者来说。

10. __slots__的本质

__slots__本质上是一种编译优化手段，它通过预先声明类的属性，避免了运行时动态创建属性字典的开销。这使得Python解释器能够以更高效的方式访问和存储属性。这种优化在创建大量对象时尤其明显，可以显著减少内存占用并提高程序执行速度。

11. __slots__在大型项目中的应用

在大型项目中，合理使用__slots__可以带来可观的性能提升。例如，在Web框架中，可以使用__slots__优化请求对象和响应对象的内存占用。在科学计算库中，可以使用__slots__优化数值对象的性能。

优化属性访问，减少内存消耗

总的来说，__slots__是Python中一个强大的优化工具，但需要谨慎使用。只有在充分了解其工作原理和适用场景的情况下，才能发挥其最大的作用，提高程序的性能和效率。记住，优化代码的关键在于权衡利弊，选择最适合当前场景的方案。

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

Python中的Slotting机制：__slots__与继承链中的属性查找优化

发表回复 取消回复

Python中的Slotting机制：`slots`与继承链中的属性查找优化

发表回复取消回复