1

首先让我说我了解插槽和元类在 Python 中是如何工作的。玩弄这两个，我遇到了一个有趣的问题。这是一个最小的例子：

def decorator(cls):
    dct = dict(cls.__dict__)
    dct['__slots__'] = ('y',)
    return type('NewClass', cls.__bases__, dct)

@decorator
class A(object):
    __slots__= ('x',)
    def __init__(self):
        self.x = 'xx'

A()

这会产生以下异常：

Traceback (most recent call last):
  File "p.py", line 12, in <module>
    A()
  File "p.py", line 10, in __init__
    self.x = 'xx'
TypeError: descriptor 'x' for 'A' objects doesn't apply to 'NewClass' object

现在，我知道为什么会发生这种情况了：为插槽创建的描述符x必须能够引用插槽的保留空间。只有 A 类的实例或 A 的子类的实例才有这个保留空间，因此只有那些实例才能使用描述符x。在上面的例子中，元类创建了一个新类型，它是 A 的基类的子类，但不是 A 本身的子类，所以我们得到了异常。很简单。

当然，在这个简单的例子中，以下两个定义中的任一个decorator都可以解决这个问题：

def decorator(cls):
    dct = dict(cls.__dict__)
    dct['__slots__'] = ('y',)
    return type('NewClass', (cls,) + cls.__bases__, dct)

def decorator(cls):
    class NewClass(cls):
        __slots__ = ('y',)
    return NewClass

但是这些变通办法与原来的不完全相同，因为它们都将 A 添加为基类。他们可能会在更复杂的设置中失败。例如，如果继承树更复杂，您可能会遇到以下异常：TypeError: multiple bases have instance lay-out conflict.

所以我非常具体的问题是：

有没有办法通过调用来创建一个新类来type修改__slots__现有类的属性，但不将现有类添加为新类的基类？

编辑：

我知道对于我上面的示例，严格的元类是另一种解决方法。有很多方法可以使最小的示例起作用，但我的问题是关于通过new基于现有类创建一个类，而不是关于如何使示例工作。对困惑感到抱歉。

编辑2：

评论中的讨论让我提出了一个比我最初提出的更精确的问题：

是否可以通过调用创建一个类，该类type使用现有类的插槽和描述符，而不是该类的后代？

如果答案是“不”，我会很感激为什么不这样做的消息来源。

4

2 回答 2

3

__slots__不，不幸的是，在创建类之后（这就是调用它们的装饰器的时候），没有办法对 做任何事情。唯一的方法是使用元类，并__slots__在调用type.__new__.

这种元类的一个例子：

class MetaA(type):
    def __new__(mcls, name, bases, dct):
        slots = set(dct.get('__slots__', ()))
        slots.add('y')
        dct['__slots__'] = tuple(slots)
        return super().__new__(mcls, name, bases, dct)

class BaseA(metaclass=MetaA):
    pass

class A(BaseA):
    __slots__ = ('x',)

    def __init__(self):
        self.x = 1
        self.y = 2

print(A().x, A().y)

如果没有元类，您可以做一些魔术并从已定义的类中复制所有内容并动态创建一个新的，但是该代码有异味；）

def decorator(cls):
    slots = set(cls.__slots__)
    slots.add('y')
    dct = cls.__dict__.copy()
    for name in cls.__slots__:
        dct.pop(name)
    dct['__slots__'] = tuple(slots)
    return type(cls)(cls.__name__, cls.__bases__, dct)

@decorator
class A:
    __slots__ = ('x',)
    def __init__(self):
        self.x = self.y = 42

print(A().x, A().y)

此类代码的主要缺点是，如果有人在您的之前应用了另一个装饰器，并且比方说，在某处创建对装饰类的引用，那么他们最终将存储对不同类的引用。元类也一样——它们会执行两次。因此，元类方法更好，因为没有副作用。

为什么在创建类后不能真正改变的确切答案__slots__取决于您正在使用的 python 解释器的实现细节。例如，在 CPython 中，对于您定义的每个插槽，类都有一个描述符（请参阅CPython 源代码中的PyMemberDescr_Type&PyMemberDef结构），该描述符具有一个偏移参数，该参数表示插槽值在内部对象存储中对齐的位置。而且你根本没有在公共 Python API 中操作这些东西的工具。您可以用灵活性换取更少的内存使用（同样，在 CPython 中，就像在 PyPy 中一样，您会自动为所有类获得相同的内存效果）。

如果__slots__绝对需要修改 ，您可能可以编写一个 C 扩展（或使用ctypes）并进行操作，但这并不是一个可靠的解决方案。

于 2013-11-20T03:48:54.353 回答
1

您可以使用元类来做到这一点：

class MetaSlot(type):
    def __new__(mcs, name, bases, dic):
        dic['__slots__'] += ('y',)
        return type.__new__(mcs, name, bases, dic)


class C(metaclass=MetaSlot):  # Python 3 syntax
    __slots__ = ('x',)

现在两者x都y可以使用：

>>> c = C()
>>> c.y = 10
>>> c.x = 10
于 2013-11-20T03:51:43.313 回答