28

决定从数据类中删除__slots__对 Python 3.7 的直接支持。

尽管如此，__slots__仍然可以与数据类一起使用：

from dataclasses import dataclass

@dataclass
class C():
    __slots__ = "x"
    x: int

但是，由于工作方式的原因，__slots__无法为数据类字段分配默认值：

from dataclasses import dataclass

@dataclass
class C():
    __slots__ = "x"
    x: int = 1

这会导致错误：

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'x' in __slots__ conflicts with class variable

如何使默认字段__slots__和默认dataclass字段一起工作？

4

6 回答 6

33

__slots__2021 年更新： python 3.10 添加了对的直接支持。我将这个答案留给后代，不会更新它。

这个问题并不是数据类独有的。任何有冲突的类属性都会在一个插槽上踩踏：

>>> class Failure:
...     __slots__ = tuple("xyz")
...     x=1
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'x' in __slots__ conflicts with class variable

这就是插槽的工作方式。发生错误是因为__slots__为每个插槽名称创建了一个类级描述符对象：

>>> class Success:
...     __slots__ = tuple("xyz")
...
>>>
>>> type(Success.x)
<class 'member_descriptor'>

为了防止这种冲突的变量名错误，必须在实例化类对象之前更改类命名空间，以使类中没有两个对象竞争相同的成员名：

  • 指定的（默认）值*
  • 插槽描述符（由插槽机器创建）

出于这个原因，__init_subclass__父类上的方法是不够的，类装饰器也不足够，因为在这两种情况下，类对象在这些函数接收到类以对其进行更改时已经创建。

当前选项：编写元类

直到插槽机制被更改以允许更大的灵活性，或者语言本身提供了在类对象实例化之前更改类名称空间的机会，我们唯一的选择是使用元类。

为解决此问题而编写的任何元类必须至少：

  • 从命名空间中删除冲突的类属性/成员
  • 实例化类对象以创建插槽描述符
  • 保存对插槽描述符的引用
  • 将先前删除的成员及其值放回类中__dict__（以便dataclass机器可以找到它们）
  • 将类对象传递给dataclass装饰器
  • 将插槽描述符恢复到各自的位置
  • 还要考虑很多极端情况（例如如果有__dict__插槽怎么办）

至少可以说，这是一项极其复杂的工作。像下面这样定义类会更容易——没有默认值，这样就不会发生冲突——然后再添加一个默认值。

当前选项：在类对象实例化后进行更改

未更改的数据类如下所示：

@dataclass
class C:
    __slots__ = "x"
    x: int

改动很简单。更改__init__签名以反映所需的默认值，然后更改__dataclass_fields__以反映默认值的存在。

from functools import wraps

def change_init_signature(init):
    @wraps(init)
    def __init__(self, x=1):
        init(self,x)
    return __init__

C.__init__ = change_init_signature(C.__init__)

C.__dataclass_fields__["x"].default = 1

测试：

>>> C()
C(x=1)
>>> C(2)
C(x=2)
>>> C.x
<member 'x' of 'C' objects>
>>> vars(C())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: vars() argument must have __dict__ attribute

有用！

当前选项：setmember装饰器

通过一些努力，可以使用所谓的setmember装饰器以上述方式自动更改类。这将需要偏离数据类 API，以便在类主体内部以外的位置定义默认值，可能类似于：

@setmember(x=field(default=1))
@dataclass
class C:
    __slots__="x"
    x: int

同样的事情也可以通过__init_subclass__父类上的方法来完成：

class SlottedDataclass:
    def __init_subclass__(cls, **kwargs):
        cls.__init_subclass__()
        # make the class changes here

class C(SlottedDataclass, x=field(default=1)):
    __slots__ = "x"
    x: int

未来的可能性：改变老虎机机制

如上所述，另一种可能性是让 python 语言改变插槽机制以提供更大的灵活性。这样做的一种方法可能是更改槽描述符本身以在类定义时存储类级别数据。

这可以通过提供 adict作为__slots__参数来完成（见下文）。类级数据（x 为 1，y 为 2）可以只存储在描述符本身上，以便以后检索：

class C:
    __slots__ = {"x": 1, "y": 2}

assert C.x.value == 1
assert C.y.value == y

一个困难：可能希望只slot_member.value在某些插槽上放礼物，而在其他插槽上不放。这可以通过从新slottools库中导入空槽工厂来解决：

from slottools import nullslot

class C:
    __slots__ = {"x": 1, "y": 2, "z": nullslot()}

assert not hasattr(C.z, "value")

上面建议的代码风格会偏离数据类 API。然而，slots 机器本身甚至可以被改变以允许这种风格的代码，特别考虑到数据类 API 的适应：

class C:
    __slots__ = "x", "y", "z"
    x = 1  # 1 is stored on C.x.value
    y = 2  # 2 is stored on C.y.value

assert C.x.value == 1
assert C.y.value == y
assert not hasattr(C.z, "value")

未来的可能性：“准备”类体内的类命名空间

另一种可能性是更改/准备（与元类的方法同义__prepare__）类名称空间。

目前，没有机会（除了编写元类）在类对象实例化之前编写更改类名称空间的代码，并且插槽机制开始工作。这可以通过创建一个用于预先准备类名称空间的钩子来更改，并使其仅在该钩子运行后才产生抱怨名称冲突的错误。

这个所谓的__prepare_slots__钩子可能看起来像这样，我认为这还不错：

from dataclasses import dataclass, prepare_slots

@dataclass
class C:
    __slots__ = ('x',)
    __prepare_slots__ = prepare_slots
    x: int = field(default=1)

该dataclasses.prepare_slots函数将只是一个函数——类似于__prepare__方法——它接收类名称空间并在创建类之前对其进行更改。特别是在这种情况下，默认数据类字段值将存储在其他方便的位置，以便在创建槽描述符对象后可以检索它们。

dataclasses.field* 请注意，如果正在使用与插槽冲突的默认字段值，也可能由数据类机制创建。

于 2018-05-04T18:04:50.967 回答
10

正如答案中已经指出的那样，来自数据类的数据类不能生成槽，原因很简单，槽必须在创建类之前定义。

事实上，数据类的 PEP明确提到了这一点：

至少对于初始版本，__slots__将不受支持。__slots__需要在创建类时添加。Data Class 装饰器在类创建后被调用，因此为了添加__slots__装饰器必须创建一个新类 set__slots__并返回它。因为这种行为有点令人惊讶，数据类的初始版本将不支持自动设置__slots__。

我想使用槽，因为我需要在另一个项目中初始化很多很多数据类实例。我最终编写了自己的数据类替代实现，它支持这一点，还有一些额外的特性：dataclassy。

dataclassy 使用具有许多优点的元类方法 - 它支持装饰器继承，大大降低了代码复杂性，当然还有插槽的生成。使用 dataclassy 可以进行以下操作：

from dataclassy import dataclass

@dataclass(slots=True)
class Pet:
    name: str
    age: int
    species: str
    fluffy: bool = True

打印Pet.__slots__输出预期的{'name', 'age', 'species', 'fluffy'}，实例没有__dict__属性，因此对象的整体内存占用较低。这些观察表明__slots__已经成功生成并且是有效的。另外，正如所证明的那样，默认值工作得很好。

于 2020-06-18T15:26:02.197 回答
5

我为这个问题找到的最少涉及的解决方案是指定一个自定义__init__使用object.__setattr__来分配值。

@dataclass(init=False, frozen=True)
class MyDataClass(object):
    __slots__ = (
        "required",
        "defaulted",
    )
    required: object
    defaulted: Optional[object]

    def __init__(
        self,
        required: object,
        defaulted: Optional[object] = None,
    ) -> None:
        super().__init__()
        object.__setattr__(self, "required", required)
        object.__setattr__(self, "defaulted", defaulted)
于 2019-10-08T09:24:15.800 回答
3

另一种解决方案是从类型化的注释中生成类体内的 slot 参数。这看起来像：

@dataclass
class Client:
    first: str
    last: str
    age_of_signup: int
    
     __slots__ = slots(__annotations__)

slots函数是：

def slots(anotes: Dict[str, object]) -> FrozenSet[str]:
    return frozenset(anotes.keys())

运行将生成一个如下所示的插槽参数： frozenset({'first', 'last', 'age_of_signup})

这需要它上面的注释并生成一组指定的名称。这里的限制是您必须为每个类重新键入该__slots__ = slots(__annotations__)行，并且它必须位于所有注释下方，并且它不适用于具有默认参数的注释。这还有一个优点，即 slot 参数永远不会与指定的注释冲突，因此您可以随意添加或删除成员，而不必担心维护单独的列表。

于 2020-08-30T14:29:07.200 回答
3

在 Python 3.10+ 中，您可以使用slots=Truewith adataclass来提高内存效率：

from dataclasses import dataclass

@dataclass(frozen=True, slots=True)
class Point:
    x: int = 0
    y: int = 0

这样您也可以设置默认字段值。

于 2021-10-21T12:18:28.917 回答
3

按照Rick Teachey的建议，我创建了一个slotted_dataclass装饰器。它可以在关键字参数中采用您在数据类中指定[field]: [type] =的任何内容，而无需__slots__- 字段的默认值和field(...). 指定应该转到旧@dataclass构造函数的参数也是可能的，但在字典对象中作为第一个位置参数。所以这：

@dataclass(frozen=True)
class Test:
    a: dict = field(repr=False)
    b: int = 42
    c: list = field(default_factory=list)

会成为：

@slotted_dataclass({'frozen': True}, a=field(repr=False), b=42, c=field(default_factory=list))
class Test:
    __slots__ = ('a', 'b', 'c')
    a: dict
    b: int
    c: list

这是这个新装饰器的源代码：

def slotted_dataclass(dataclass_arguments=None, **kwargs):
    if dataclass_arguments is None:
        dataclass_arguments = {}

    def decorator(cls):
        old_attrs = {}

        for key, value in kwargs.items():
            old_attrs[key] = getattr(cls, key)
            setattr(cls, key, value)

        cls = dataclass(cls, **dataclass_arguments)
        for key, value in old_attrs.items():
            setattr(cls, key, value)
        return cls

    return decorator

代码说明

上面的代码利用了dataclasses模块通过调用getattr类来获取默认字段值这一事实。这使得我们可以通过替换__dict__类中的适当字段来提供我们的默认值（这是通过使用setattr函数在代码中完成的）。装饰器生成的类@dataclass将与通过指定之后生成的类完全相同=，就像我们在类不包含__slots__.

但是由于__dict__类的__slots__包含member_descriptor对象：

>>> class C:
...     __slots__ = ('a', 'b', 'c')
...
>>> C.__dict__['a']
<member 'a' of 'C' objects>
>>> type(C.__dict__['a'])
<class 'member_descriptor'>

一件好事是备份这些对象并在@dataclass装饰器完成其工作后恢复它们，这是通过使用old_attrs字典在代码中完成的。

于 2019-09-02T23:56:28.520 回答