创新互联Python教程：dataclasses—-数据类

dataclasses —- 数据类

源码： Lib/dataclasses.py

创新互联服务项目包括站前网站建设、站前网站制作、站前网页制作以及站前网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，站前网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到站前省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

这个模块提供了一个装饰器和一些函数，用于自动添加生成的 special method，例如 __init__() 和 __repr__() 到用户定义的类。 它最初描述于 PEP 557 。

在这些生成的方法中使用的成员变量是使用 PEP 526 类型标注来定义的。 例如以下代码:

 
 
 
 
    
  
  
  
  
  1. from dataclasses import dataclass
    2. 
  
  
  
  
    3. 
  
  
  
  
  3. @dataclass
    4. 
  
  
  
  
  4. class InventoryItem:
    5. 
  
  
  
  
  5.  """Class for keeping track of an item in inventory."""
    6. 
  
  
  
  
  6.  name: str
    7. 
  
  
  
  
  7.  unit_price: float
    8. 
  
  
  
  
  8.  quantity_on_hand: int = 0
    9. 
  
  
  
  
    10. 
  
  
  
  
  10.  def total_cost(self) -> float:
    11. 
  
  
  
  
  11.  return self.unit_price * self.quantity_on_hand
    12.

将在添加的内容中包括如下所示的 __init__():

 
 
 
 
    
  
  
  
  
  1. def __init__(self, name: str, unit_price: float, quantity_on_hand: int = 0):
    2. 
  
  
  
  
  2.  self.name = name
    3. 
  
  
  
  
  3.  self.unit_price = unit_price
    4. 
  
  
  
  
  4.  self.quantity_on_hand = quantity_on_hand
    5.

请注意，此方法会自动添加到类中：它不会在上面显示的 InventoryItem 定义中直接指定。

3.7 新版功能.

模块内容

@dataclasses.dataclass(**, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False*)

这个函数是 decorator ，用于将生成的 special method 添加到类中，如下所述。

dataclass() 装饰器会检查类以查找 field。 field 被定义为具有 类型标注 的类变量。 除了下面描述的两个例外，在 dataclass() 中没有什么东西会去检查在变量标注中所指定的类型。

所有生成的方法中的字段顺序是它们在类定义中出现的顺序。

dataclass() 装饰器将向类中添加各种“dunder”方法，如下所述。 如果所添加的方法已存在于类中，则行为将取决于下面所列出的参数。 装饰器会返回调用它的类本身；不会创建新的类。

如果 dataclass() 仅用作没有参数的简单装饰器，它就像它具有此签名中记录的默认值一样。也就是说，这三种 dataclass() 用法是等价的:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class C:
    3. 
  
  
  
  
  3.  ...
    4. 
  
  
  
  
    5. 
  
  
  
  
  5. @dataclass()
    6. 
  
  
  
  
  6. class C:
    7. 
  
  
  
  
  7.  ...
    8. 
  
  
  
  
    9. 
  
  
  
  
  9. @dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False)
    10. 
  
  
  
  
  10. class C:
    11. 
  
  
  
  
  11.  ...
    12.

dataclass() 的参数有：

  • init: 如果为真值（默认），将生成一个 __init__() 方法。

    如果类已定义 __init__() ，则忽略此参数。

  • repr ：如果为真值（默认），将生成一个 __repr__() 方法。 生成的 repr 字符串将具有类名以及每个字段的名称和 repr ，按照它们在类中定义的顺序。不包括标记为从 repr 中排除的字段。 例如：InventoryItem(name='widget', unit_price=3.0, quantity_on_hand=10)。

    如果类已定义 __repr__() ，则忽略此参数。

  • eq ：如果为true（默认值），将生成 __eq__() 方法。此方法将类作为其字段的元组按顺序比较。比较中的两个实例必须是相同的类型。

    如果类已定义 __eq__() ，则忽略此参数。

  • order ：如果为真值（默认为 False ），则 __lt__() 、 __le__() 、 __gt__() 和 __ge__() 方法将生成。 这将类作为其字段的元组按顺序比较。比较中的两个实例必须是相同的类型。如果 order 为真值并且 eq 为假值 ，则引发 ValueError 。

    如果类已经定义了 __lt__() 、 __le__() 、 __gt__() 或者 __ge__() 中的任意一个，将引发 TypeError 。

  • unsafe_hash ：如果为 False （默认值），则根据 eq 和 frozen 的设置方式生成 __hash__() 方法。

    __hash__() 由内置的 hash() 使用，当对象被添加到散列集合（如字典和集合）时。有一个 __hash__() 意味着类的实例是不可变的。可变性是一个复杂的属性，取决于程序员的意图， __eq__() 的存在性和行为，以及 dataclass() 装饰器中 eq 和 frozen 标志的值。

    默认情况下， dataclass() 不会隐式添加 __hash__() 方法，除非这样做是安全的。 它也不会添加或更改现有的明确定义的 __hash__() 方法。 设置类属性 __hash__ = None 对 python 具有特定含义，如 __hash__() 文档中所述。

    如果 __hash__() 没有显式定义，或者它被设为 None，则 dataclass() 可能 会添加一个隐式 __hash__() 方法。 虽然并不推荐，但你可以用 unsafe_hash=True 来强制 dataclass() 创建一个 __hash__() 方法。 如果你的类在逻辑上不可变但却仍然可被修改那么可能就是这种情况。 这是一个特殊用例并且应当被仔细地考虑。

    以下是隐式创建 __hash__() 方法的规则。请注意，你不能在数据类中都使用显式的 __hash__() 方法并设置 unsafe_hash=True ；这将导致 TypeError 。

    如果 eq 和 frozen 都是 true，默认情况下 dataclass() 将为你生成一个 __hash__() 方法。如果 eq 为 true 且 frozen 为 false ，则 __hash__() 将被设置为 None ，标记它不可用（因为它是可变的）。如果 eq 为 false ，则 __hash__() 将保持不变，这意味着将使用超类的 __hash__() 方法（如果超类是 object ，这意味着它将回到基于id的hash）。

  • frozen: 如为真值 (默认值为 False)，则对字段赋值将会产生异常。 这模拟了只读的冻结实例。 如果在类中定义了 __setattr__() 或 __delattr__() 则将会引发 TypeError。 参见下文的讨论。

  • match_args: 如果为真值 (默认值为 True)，则将根据传给生成的 __init__() 方法的形参列表来创建 __match_args__ 元组 (即使没有生成 __init__() 也会创建，见上文)。 如果为假值，或者如果 __match_args__ 已在类中定义，则将不生成 __match_args__。

3.10 新版功能.

  • kw_only: If true (the default value is False), then all fields will be marked as keyword-only. If a field is marked as keyword-only, then the only effect is that the __init__() parameter generated from a keyword-only field must be specified with a keyword when __init__() is called. There is no effect on any other aspect of dataclasses. See the parameter glossary entry for details. Also see the KW_ONLY section.

3.10 新版功能.

  • slots: 如果为真值 (默认值为 False)，则将生成 __slots__ 属性并将返回一个新类而非原来的类。 如果 __slots__ 已在类中定义，则会引发 TypeError。

3.10 新版功能.

在 3.11 版更改: If a field name is already included in the __slots__ of a base class, it will not be included in the generated __slots__ to prevent overriding them. Therefore, do not use __slots__ to retrieve the field names of a dataclass. Use fields() instead. To be able to determine inherited slots, base class __slots__ may be any iterable, but not an iterator.

  • weakref_slot: If true (the default is False), add a slot named “__weakref__“, which is required to make an instance weakref-able. It is an error to specify weakref_slot=True without also specifying slots=True.

3.11 新版功能.

fields 可以选择使用普通的 Python 语法指定默认值:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class C:
    3. 
  
  
  
  
  3.  a: int # 'a' has no default value
    4. 
  
  
  
  
  4.  b: int = 0 # assign a default value for 'b'
    5.

在这个例子中， a 和 b 都将包含在添加的 __init__() 方法中，它们将被定义为:

 
 
 
 
    
  
  
  
  
  1. def __init__(self, a: int, b: int = 0):
    2.

如果具有默认值的字段之后存在没有默认值的字段，将会引发 TypeError。 无论此情况是发生在单个类中还是作为类继承的结果，都是如此。

dataclasses.field(**, default=MISSING, default_factory=MISSING, init=True, repr=True, hash=None, compare=True, metadata=None, kw_only=MISSING*)

对于常见和简单的用例，不需要其他功能。但是，有些数据类功能需要额外的每字段信息。为了满足这种对附加信息的需求，你可以通过调用提供的 field() 函数来替换默认字段值。例如:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class C:
    3. 
  
  
  
  
  3.  mylist: list[int] = field(default_factory=list)
    4. 
  
  
  
  
    5. 
  
  
  
  
  5. c = C()
    6. 
  
  
  
  
  6. c.mylist += [1, 2, 3]
    7.

如上所示， MISSING 值是一个哨兵对象，用于检测一些参数是否由用户提供。这个哨兵对象的使用是因为``None``是一些具有独特意义的参数的有效值。 任何代码都不应该直接使用 MISSING 值。

field() 参数有：

  • default ：如果提供，这将是该字段的默认值。这是必需的，因为 field() 调用本身会替换一般的默认值。

  • default_factory ：如果提供，它必须是一个零参数可调用对象，当该字段需要一个默认值时，它将被调用。除了其他目的之外，这可以用于指定具有可变默认值的字段，如下所述。 同时指定 default 和 default_factory 将产生错误。

  • init ：如果为true（默认值），则该字段作为参数包含在生成的 __init__() 方法中。

  • repr ：如果为true（默认值），则该字段包含在生成的 __repr__() 方法返回的字符串中。

  • hash ：这可以是布尔值或 None 。如果为true，则此字段包含在生成的 __hash__() 方法中。如果为 None （默认值），请使用 compare 的值，这通常是预期的行为。如果字段用于比较，则应在 hash 中考虑该字段。不鼓励将此值设置为 None 以外的任何值。

    设置 hash=False 但 compare=True 的一个可能原因是，如果一个计算 hash 的代价很高的字段是检验等价性需要的，但还有其他字段可以计算类型的 hash 。 即使从 hash 中排除某个字段，它仍将用于比较。

  • compare ：如果为true（默认值），则该字段包含在生成的相等性和比较方法中（ __eq__() ， __gt__() 等等）。

  • metadata ：这可以是映射或 None 。 None 被视为一个空的字典。这个值包含在 MappingProxyType() 中，使其成为只读，并暴露在 Field 对象上。数据类根本不使用它，它是作为第三方扩展机制提供的。多个第三方可以各自拥有自己的键值，以用作元数据中的命名空间。

  • kw_only: 如果为真值，则此字段将被标记为仅限关键字。 这将在当计算出所生成的 __init__() 方法的形参时被使用。

3.10 新版功能.

如果通过调用 field() 指定字段的默认值，则该字段的类属性将替换为指定的 default 值。如果没有提供 default ，那么将删除类属性。目的是在 dataclass() 装饰器运行之后，类属性将包含字段的默认值，就像指定了默认值一样。例如，之后:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class C:
    3. 
  
  
  
  
  3.  x: int
    4. 
  
  
  
  
  4.  y: int = field(repr=False)
    5. 
  
  
  
  
  5.  z: int = field(repr=False, default=10)
    6. 
  
  
  
  
  6.  t: int = 20
    7.

类属性 C.z 将是 10 ，类属性 C.t 将是 20，类属性 C.x 和 C.y 将不设置。

class dataclasses.Field

Field 对象描述每个定义的字段。这些对象在内部创建，并由 fields() 模块级方法返回（见下文）。用户永远不应该直接实例化 Field 对象。 其有文档的属性是：

  • name ：字段的名字。

  • type ：字段的类型。

  • default, default_factory, init, repr, hash, compare, metadata 和 kw_only 具有与 field() 函数中对应参数相同的含义和值。

可能存在其他属性，但它们是私有的，不能被审查或依赖。

dataclasses.fields(class_or_instance)

返回 Field 对象的元组，用于定义此数据类的字段。 接受数据类或数据类的实例。如果没有传递一个数据类或实例将引发 TypeError 。 不返回 ClassVar 或 InitVar 的伪字段。

dataclasses.asdict(obj, **, dict_factory=dict*)

将数据类``obj``转换为一个字典（通过使用工厂函数``dict_factory``）。 每个数据类被转换为其字段的字典，作为``name: value``键值对。数据类、字典、列表和元组被递归到。 其他对象用 copy.deepcopy() 来复制。

在嵌套的数据类上使用 asdict() 的例子:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class Point:
    3. 
  
  
  
  
  3.  x: int
    4. 
  
  
  
  
  4.  y: int
    5. 
  
  
  
  
    6. 
  
  
  
  
  6. @dataclass
    7. 
  
  
  
  
  7. class C:
    8. 
  
  
  
  
  8.  mylist: list[Point]
    9. 
  
  
  
  
    10. 
  
  
  
  
  10. p = Point(10, 20)
    11. 
  
  
  
  
  11. assert asdict(p) == {'x': 10, 'y': 20}
    12. 
  
  
  
  
    13. 
  
  
  
  
  13. c = C([Point(0, 0), Point(10, 4)])
    14. 
  
  
  
  
  14. assert asdict(c) == {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}
    15.

要创建一个浅拷贝，可以使用以下方法:

 
 
 
 
    
  
  
  
  
  1. dict((field.name, getattr(obj, field.name)) for field in fields(obj))
    2.

如果 obj 不是一个数据类实例, asdict() 引发 TypeError 。

dataclasses.astuple(obj, **, tuple_factory=tuple*)

将数据类``obj``转换为一个元组（通过使用工厂函数``tuple_factory``）。 每个数据类被转换为其字段值的元组。数据类、字典、列表和元组被递归到。其他对象用 copy.deepcopy() 来复制。

继续前一个例子:

 
 
 
 
    
  
  
  
  
  1. assert astuple(p) == (10, 20)
    2. 
  
  
  
  
  2. assert astuple(c) == ([(0, 0), (10, 4)],)
    3.

要创建一个浅拷贝，可以使用以下方法:

 
 
 
 
    
  
  
  
  
  1. tuple(getattr(obj, field.name) for field in dataclasses.fields(obj))
    2.

如果``obj``不是一个数据类实例， astuple() 引发 TypeError 。

dataclasses.make_dataclass(cls_name, fields, **, bases=(), namespace=None, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False*)

Creates a new dataclass with name cls_name, fields as defined in fields, base classes as given in bases, and initialized with a namespace as given in namespace. fields is an iterable whose elements are each either name, (name, type), or (name, type, Field). If just name is supplied, typing.Any is used for type. The values of init, repr, eq, order, unsafe_hash, frozen, match_args, kw_only, slots, and weakref_slot have the same meaning as they do in dataclass().

此函数不是严格要求的，因为用于任何创建带有 __annotations__ 的新类的 Python 机制都可以应用 dataclass() 函数将该类转换为数据类。提供此功能是为了方便。例如:

 
 
 
 
    
  
  
  
  
  1. C = make_dataclass('C',
    2. 
  
  
  
  
  2.  [('x', int),
    3. 
  
  
  
  
  3.  'y',
    4. 
  
  
  
  
  4.  ('z', int, field(default=5))],
    5. 
  
  
  
  
  5.  namespace={'add_one': lambda self: self.x + 1})
    6.

等价于

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class C:
    3. 
  
  
  
  
  3.  x: int
    4. 
  
  
  
  
  4.  y: 'typing.Any'
    5. 
  
  
  
  
  5.  z: int = 5
    6. 
  
  
  
  
    7. 
  
  
  
  
  7.  def add_one(self):
    8. 
  
  
  
  
  8.  return self.x + 1
    9.

dataclasses.replace(obj, /, \*changes*)

创建一个与``obj``类型相同的新对象，将字段替换为来自``changes``的值。如果``obj``不是数据类，则引发 TypeError 。如果``changes``里面的值没有指定字段，引发 TypeError 。

新返回的对象通过调用数据类的 __init__() 方法创建。这确保了如果存在 __post_init__() ，其也被调用。

如果存在没有默认值的仅初始化变量，必须在调用 replace() 时指定，以便它们可以传递给 __init__() 和 __post_init__() 。

changes 包含任何定义为 init=False 的字段是错误的。在这种情况下会引发 ValueError 。

提前提醒 init=False 字段在调用 replace() 时的工作方式。如果它们完全被初始化的话，它们不是从源对象复制的，而是在 __post_init__() 中初始化。估计 init=False 字段很少能被正确地使用。如果使用它们，那么使用备用类构造函数或者可能是处理实例复制的自定义 replace() （或类似命名的）方法可能是明智的。

dataclasses.is_dataclass(obj)

如果其形参为 dataclass 或其实例则返回 True，否则返回 False。

如果你需要知道一个类是否是一个数据类的实例（而不是一个数据类本身），那么再添加一个 not isinstance(obj, type) 检查:

 
 
 
 
    
  
  
  
  
  1. def is_dataclass_instance(obj):
    2. 
  
  
  
  
  2.  return is_dataclass(obj) and not isinstance(obj, type)
    3.

dataclasses.MISSING

一个表示缺失 default 或 default_factory 的监视值。

dataclasses.KW_ONLY

一个用作类型标注的监视值。 任何在伪字段之后的类型为 KW_ONLY 的字段会被标记为仅限关键字字段。 请注意在其他情况下 KW_ONLY 类型的伪字段会被完全忽略。 这包括此类字段的名称。 根据惯例，名称 _ 会被用作 KW_ONLY 字段。 仅限关键字字段指明当类被实例化时 __init__() 形参必须以关键字形式来指定。

在这个例子中，字段 y 和 z 将被标记为仅限关键字字段:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class Point:
    3. 
  
  
  
  
  3.  x: float
    4. 
  
  
  
  
  4.  _: KW_ONLY
    5. 
  
  
  
  
  5.  y: float
    6. 
  
  
  
  
  6.  z: float
    7. 
  
  
  
  
    8. 
  
  
  
  
  8. p = Point(0, y=1.5, z=2.0)
    9.

在单个数据类中，指定一个以上 KW_ONLY 类型的字段将导致错误。

3.10 新版功能.

exception dataclasses.FrozenInstanceError

在使用 frozen=True 定义的数据类上调用隐式定义的 __setattr__() 或 __delattr__() 时引发。 这是 AttributeError 的一个子类。

初始化后处理

生成的 __init__() 代码将调用一个名为 __post_init__() 的方法，如果在类上已经定义了 __post_init__() 。它通常被称为 self.__post_init__() 。但是，如果定义了任何 InitVar 字段，它们也将按照它们在类中定义的顺序传递给 __post_init__() 。 如果没有 __init__() 方法生成，那么 __post_init__() 将不会被自动调用。

在其他用途中，这允许初始化依赖于一个或多个其他字段的字段值。例如:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class C:
    3. 
  
  
  
  
  3.  a: float
    4. 
  
  
  
  
  4.  b: float
    5. 
  
  
  
  
  5.  c: float = field(init=False)
    6. 
  
  
  
  
    7. 
  
  
  
  
  7.  def __post_init__(self):
    8. 
  
  
  
  
  8.  self.c = self.a + self.b
    9.

由 dataclass() 所生成的 __init__() 方法不会调用基类的 __init__() 方法。 如果基类有需要被调用的 __init__() 方法，通常是在 __post_init__() 方法中调用此方法:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class Rectangle:
    3. 
  
  
  
  
  3.  height: float
    4. 
  
  
  
  
  4.  width: float
    5. 
  
  
  
  
    6. 
  
  
  
  
  6. @dataclass
    7. 
  
  
  
  
  7. class Square(Rectangle):
    8. 
  
  
  
  
  8.  side: float
    9. 
  
  
  
  
    10. 
  
  
  
  
  10.  def __post_init__(self):
    11. 
  
  
  
  
  11.  super().__init__(self.side, self.side)
    12.

但是请注意，一般来说 dataclass 生成的 __init__() 方法不需要被调用，因为派生的 dataclass 将负责初始化任何自身为 dataclass 的基类的所有字段。

有关将参数传递给 __post_init__() 的方法，请参阅下面有关仅初始化变量的段落。另请参阅关于 replace() 处理 init=False 字段的警告。

类变量

两个地方 dataclass() 实际检查字段类型的之一是确定字段是否是如 PEP 526 所定义的类变量。它通过检查字段的类型是否为 typing.ClassVar 来完成此操作。如果一个字段是一个 ClassVar ，它将被排除在考虑范围之外，并被数据类机制忽略。这样的 ClassVar 伪字段不会由模块级的 fields() 函数返回。

仅初始化变量

另一个 dataclass() 检查类型注解地方是为了确定一个字段是否是一个仅初始化变量。它通过查看字段的类型是否为 dataclasses.InitVar 类型来实现。如果一个字段是一个 InitVar ，它被认为是一个称为仅初始化字段的伪字段。因为它不是一个真正的字段，所以它不会被模块级的 fields() 函数返回。仅初始化字段作为参数添加到生成的 __init__() 方法中，并传递给可选的 __post_init__() 方法。数据类不会使用它们。

例如，假设在创建类时没有为某个字段提供值，初始化时将从数据库中取值:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class C:
    3. 
  
  
  
  
  3.  i: int
    4. 
  
  
  
  
  4.  j: int | None = None
    5. 
  
  
  
  
  5.  database: InitVar[DatabaseType | None] = None
    6. 
  
  
  
  
    7. 
  
  
  
  
  7.  def __post_init__(self, database):
    8. 
  
  
  
  
  8.  if self.j is None and database is not None:
    9. 
  
  
  
  
  9.  self.j = database.lookup('j')
    10. 
  
  
  
  
    11. 
  
  
  
  
  11. c = C(10, database=my_database)
    12.

在这种情况下， fields() 将返回 i 和 j 的 Field 对象，但不包括 database 。

冻结的实例

无法创建真正不可变的 Python 对象。但是，通过将 frozen=True 传递给 dataclass() 装饰器，你可以模拟不变性。在这种情况下，数据类将向类添加 __setattr__() 和 __delattr__() 方法。 些方法在调用时会引发 FrozenInstanceError 。

使用 frozen=True 时会有很小的性能损失： __ init__() 不能使用简单的赋值来初始化字段，并必须使用 object.__setattr__()。

继承

当数组由 dataclass() 装饰器创建时，它会查看反向 MRO 中的所有类的基类（即从 object 开始 ），并且对于它找到的每个数据类， 将该基类中的字段添加到字段的有序映射中。添加完所有基类字段后，它会将自己的字段添加到有序映射中。所有生成的方法都将使用这种组合的，计算的有序字段映射。由于字段是按插入顺序排列的，因此派生类会重载基类。一个例子:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class Base:
    3. 
  
  
  
  
  3.  x: Any = 15.0
    4. 
  
  
  
  
  4.  y: int = 0
    5. 
  
  
  
  
    6. 
  
  
  
  
  6. @dataclass
    7. 
  
  
  
  
  7. class C(Base):
    8. 
  
  
  
  
  8.  z: int = 10
    9. 
  
  
  
  
  9.  x: int = 15
    10.

最后的字段列表依次是 x 、 y 、 z 。 x 的最终类型是 int ，如类 C 中所指定的那样。

为 C 生成的 __init__() 方法看起来像:

 
 
 
 
    
  
  
  
  
  1. def __init__(self, x: int = 15, y: int = 0, z: int = 10):
    2.

__init__() 中仅限关键字字段的重新排序

在计算出 __init__() 所需要的形参之后，任何仅限关键字形参会被移至所有常规（非仅限关键字）形参的后面。 这是 Python 中实现仅限关键字形参所要求的：它们必须位于非仅限关键字形参之后。

在这个例子中，Base.y, Base.w, and D.t 是仅限关键字字段，而 Base.x 和 D.z 是常规字段:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class Base:
    3. 
  
  
  
  
  3.  x: Any = 15.0
    4. 
  
  
  
  
  4.  _: KW_ONLY
    5. 
  
  
  
  
  5.  y: int = 0
    6. 
  
  
  
  
  6.  w: int = 1
    7. 
  
  
  
  
    8. 
  
  
  
  
  8. @dataclass
    9. 
  
  
  
  
  9. class D(Base):
    10. 
  
  
  
  
  10.  z: int = 10
    11. 
  
  
  
  
  11.  t: int = field(kw_only=True, default=0)
    12.

为 D 生成的 __init__() 方法看起来像是这样:

 
 
 
 
    
  
  
  
  
  1. def __init__(self, x: Any = 15.0, z: int = 10, *, y: int = 0, w: int = 1, t: int = 0):
    2.

请注意形参原来在字段列表中出现的位置已被重新排序：前面是来自常规字段的形参而后面是来自仅限关键字字段的形参。

仅限关键字形参的相对顺序会在重新排序的 __init__() 形参列表中保持原样。

默认工厂函数

如果一个 field() 指定了一个 default_factory ，当需要该字段的默认值时，将使用零参数调用它。例如，要创建列表的新实例，请使用:

 
 
 
 
    
  
  
  
  
  1. mylist: list = field(default_factory=list)
    2.

如果一个字段被排除在 __init__() 之外（使用 init=False ）并且字段也指定 default_factory ，则默认的工厂函数将始终从生成的 __init__() 函数调用。发生这种情况是因为没有其他方法可以为字段提供初始值。

可变的默认值

Python 在类属性中存储默认成员变量值。思考这个例子，不使用数据类:

 
 
 
 
    
  
  
  
  
  1. class C:
    2. 
  
  
  
  
  2.  x = []
    3. 
  
  
  
  
  3.  def add(self, element):
    4. 
  
  
  
  
  4.  self.x.append(element)
    5. 
  
  
  
  
    6. 
  
  
  
  
  6. o1 = C()
    7. 
  
  
  
  
  7. o2 = C()
    8. 
  
  
  
  
  8. o1.add(1)
    9. 
  
  
  
  
  9. o2.add(2)
    10. 
  
  
  
  
  10. assert o1.x == [1, 2]
    11. 
  
  
  
  
  11. assert o1.x is o2.x
    12.

请注意，类 C 的两个实例共享相同的类变量 x ，如预期的那样。

使用数据类， 如果 此代码有效:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class D:
    3. 
  
  
  
  
  3.  x: List = []
    4. 
  
  
  
  
  4.  def add(self, element):
    5. 
  
  
  
  
  5.  self.x += element
    6.

它生成的代码类似于:

 
 
 
 
    
  
  
  
  
  1. class D:
    2. 
  
  
  
  
  2.  x = []
    3. 
  
  
  
  
  3.  def __init__(self, x=x):
    4. 
  
  
  
  
  4.  self.x = x
    5. 
  
  
  
  
  5.  def add(self, element):
    6. 
  
  
  
  
  6.  self.x += element
    7. 
  
  
  
  
    8. 
  
  
  
  
  8. assert D().x is D().x
    9.

This has the same issue as the original example using class C. That is, two instances of class D that do not specify a value for x when creating a class instance will share the same copy of x. Because dataclasses just use normal Python class creation they also share this behavior. There is no general way for Data Classes to detect this condition. Instead, the dataclass() decorator will raise a TypeError if it detects an unhashable default parameter. The assumption is that if a value is unhashable, it is mutable. This is a partial solution, but it does protect against many common errors.

使用默认工厂函数是一种创建可变类型新实例的方法，并将其作为字段的默认值:

 
 
 
 
    
  
  
  
  
  1. @dataclass
    2. 
  
  
  
  
  2. class D:
    3. 
  
  
  
  
  3.  x: list = field(default_factory=list)
    4. 
  
  
  
  
    5. 
  
  
  
  
  5. assert D().x is not D().x
    6.

在 3.11 版更改: Instead of looking for and disallowing objects of type list, dict, or set, unhashable objects are now not allowed as default values. Unhashability is used to approximate mutability.

Descriptor-typed fields

Fields that are assigned descriptor objects as their default value have the following special behaviors:

  • The value for the field passed to the dataclass’s __init__ method is passed to the descriptor’s __set__ method rather than overwriting the descriptor object.

  • Similarly, when getting or setting the field, the descriptor’s __get__ or __set__ method is called rather than returning or overwriting the descriptor object.

  • To determine whether a field contains a default value, dataclasses will call the descriptor’s __get__ method using its class access form (i.e. descriptor.__get__(obj=None, type=cls). If the descriptor returns a value in this case, it will be used as the field’s default. On the other hand, if the descriptor raises AttributeError in this situation, no default value will be provided for the field.

 
 
 
 
    
  
  
  
  
  1. class IntConversionDescriptor:
    2. 
  
  
  
  
  2.  def __init__(self, *, default):
    3. 
  
  
  
  
  3.  self._default = default
    4. 
  
  
  
  
    5. 
  
  
  
  
  5.  def __set_name__(self, owner, name):
    6. 
  
  
  
  
  6.  self._name = "_" + name
    7. 
  
  
  
  
    8. 
  
  
  
  
  8.  def __get__(self, obj, type):
    9. 
  
  
  
  
  9.  if obj is None:
    10. 
  
  
  
  
  10.  return self._default
    11. 
  
  
  
  
    12. 
  
  
  
  
  12.  return getattr(obj, self._name, self._default)
    13. 
  
  
  
  
    14. 
  
  
  
  
  14.  def __set__(self, obj, value):
    15. 
  
  
  
  
  15.  setattr(obj, self._name, int(value))
    16. 
  
  
  
  
    17. 
  
  
  
  
  17. @dataclass
    18. 
  
  
  
  
  18. class InventoryItem:
    19. 
  
  
  
  
  19.  quantity_on_hand: IntConversionDescriptor = IntConversionDescriptor(default=100)
    20. 
  
  
  
  
    21. 
  
  
  
  
  21. i = InventoryItem()
    22. 
  
  
  
  
  22. print(i.quantity_on_hand) # 100
    23. 
  
  
  
  
  23. i.quantity_on_hand = 2.5 # calls __set__ with 2.5
    24. 
  
  
  
  
  24. print(i.quantity_on_hand) # 2
    25.

Note that if a field is annotated with a descriptor type, but is not assigned a descriptor object as its default value, the field will act like a normal field.

当前名称：创新互联Python教程：dataclasses—-数据类
分享地址：http://www.shufengxianlan.com/qtweb/news17/268667.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

微信小程序知识

分类信息网站

移动机房服务器托管　　 　西部信息机房　　 　app软件开发　　 　成都网站建设公司　　 　成都app软件开发公司　　 　堡垒主机　　 　成都网站建设　　 　成都画册设计　　 　四川广汉锦华　　 　成都网站运营维护　　 　遂宁海缘科技　　 　四川绵阳主机托管　　 　企业网站建设　　 　郫县明安消防器材　　 　服务器租用　　 　什邡网站建设　　 　成都办公窗帘　　 　四川门窗　　 　成都响应式网站建设　　 　移动服务器托管