我目前正在尝试 Python 3.7 中引入的新数据类结构。我目前坚持尝试对父类进行一些继承。看起来参数的顺序被我当前的方法搞砸了，因此子类中的 bool 参数在其他参数之前传递。这会导致类型错误。

from dataclasses import dataclass

@dataclass
class Parent:
    name: str
    age: int
    ugly: bool = False

    def print_name(self):
        print(self.name)

    def print_age(self):
        print(self.age)

    def print_id(self):
        print(f'The Name is {self.name} and {self.name} is {self.age} year old')

@dataclass
class Child(Parent):
    school: str
    ugly: bool = True


jack = Parent('jack snr', 32, ugly=True)
jack_son = Child('jack jnr', 12, school = 'havard', ugly=True)

jack.print_id()
jack_son.print_id()

当我运行这段代码时，我得到这个 TypeError:

TypeError: non-default argument 'school' follows default argument

我该如何解决这个问题？

最佳答案

数据类组合属性的方式使您无法在基类中使用具有默认值的属性，然后在子类中使用没有默认值的属性(位置属性)。

这是因为属性组合是从MRO底部开始，按照先见的顺序构建属性的有序列表；覆盖保留在其原始位置。所以 Parent 以 ['name', 'age', 'ugly'] 开头，其中 ugly 有一个默认值，然后是 Child 将 ['school'] 添加到该列表的末尾(ugly 已经在列表中)。这意味着你最终得到 ['name', 'age', 'ugly', 'school'] 并且因为 school 没有默认值，这会导致__init__ 的参数列表无效。

这在 PEP-557 Dataclasses 中有记录, 在 inheritance 下:

When the Data Class is being created by the @dataclass decorator, it looks through all of the class's base classes in reverse MRO (that is, starting at object) and, for each Data Class that it finds, adds the fields from that base class to an ordered mapping of fields. After all of the base class fields are added, it adds its own fields to the ordered mapping. All of the generated methods will use this combined, calculated ordered mapping of fields. Because the fields are in insertion order, derived classes override base classes.

及以下 Specification :

TypeError will be raised if a field without a default value follows a field with a default value. This is true either when this occurs in a single class, or as a result of class inheritance.

您确实有几个选项可以避免此问题。

第一个选项是使用单独的基类将具有默认值的字段强制置于 MRO 顺序中的后面位置。不惜一切代价避免在要用作基类的类上直接设置字段，例如 Parent。

以下类层次结构有效:

# base classes with fields; fields without defaults separate from fields with.
@dataclass
class _ParentBase:
    name: str
    age: int
    
@dataclass
class _ParentDefaultsBase:
    ugly: bool = False

@dataclass
class _ChildBase(_ParentBase):
    school: str

@dataclass
class _ChildDefaultsBase(_ParentDefaultsBase):
    ugly: bool = True

# public classes, deriving from base-with, base-without field classes
# subclasses of public classes should put the public base class up front.

@dataclass
class Parent(_ParentDefaultsBase, _ParentBase):
    def print_name(self):
        print(self.name)

    def print_age(self):
        print(self.age)

    def print_id(self):
        print(f"The Name is {self.name} and {self.name} is {self.age} year old")

@dataclass
class Child(_ChildDefaultsBase, Parent, _ChildBase):
    pass

通过将字段提取到具有不带默认值的字段和带默认值的字段的单独的基类中，并仔细选择继承顺序，您可以生成一个 MRO，它将所有不带默认值的字段放在有默认值的字段之前。 Child 的反向 MRO(忽略 object)是:

_ParentBase
_ChildBase
_ParentDefaultsBase
Parent
_ChildDefaultsBase

请注意，虽然 Parent 没有设置任何新字段，但它确实继承了 _ParentDefaultsBase 的字段并且应该 不 以 'last ' 在字段列表顺序中；上述顺序将 _ChildDefaultsBase 放在最后，因此其字段“获胜”。数据类规则也满足；具有无默认字段的类(_ParentBase 和 _ChildBase)位于具有默认字段的类(_ParentDefaultsBase 和 _ChildDefaultsBase )。

结果是 Parent 和 Child 类的健全字段较旧，而 Child 仍然是 Parent:

>>> from inspect import signature
>>> signature(Parent)
<Signature (name: str, age: int, ugly: bool = False) -> None>
>>> signature(Child)
<Signature (name: str, age: int, school: str, ugly: bool = True) -> None>
>>> issubclass(Child, Parent)
True

因此您可以创建两个类的实例:

>>> jack = Parent('jack snr', 32, ugly=True)
>>> jack_son = Child('jack jnr', 12, school='havard', ugly=True)
>>> jack
Parent(name='jack snr', age=32, ugly=True)
>>> jack_son
Child(name='jack jnr', age=12, school='havard', ugly=True)

另一种选择是仅使用具有默认值的字段；您仍然可以通过在 __post_init__ 中提高一个值来提供不提供 school 值的错误:

_no_default = object()

@dataclass
class Child(Parent):
    school: str = _no_default
    ugly: bool = True

    def __post_init__(self):
        if self.school is _no_default:
            raise TypeError("__init__ missing 1 required argument: 'school'")

但这确实改变了字段顺序； school 在 ugly 之后结束:

<Signature (name: str, age: int, ugly: bool = True, school: str = <object object at 0x1101d1210>) -> None>

类型提示检查器会提示 _no_default 不是字符串。

您也可以使用 attrs project ，这是启发 dataclasses 的项目。它使用不同的继承合并策略；它将子类中被覆盖的字段拉到字段列表的末尾，因此 Parent 类中的 ['name', 'age', 'ugly'] 变为 ['name', 'age', 'school', 'ugly'] 在 Child 类中；通过使用默认值覆盖该字段，attrs 允许覆盖而无需进行 MRO 舞蹈。

attrs 支持在没有类型提示的情况下定义字段，但请坚持使用 supported type hinting mode通过设置 auto_attribs=True:

import attr

@attr.s(auto_attribs=True)
class Parent:
    name: str
    age: int
    ugly: bool = False

    def print_name(self):
        print(self.name)

    def print_age(self):
        print(self.age)

    def print_id(self):
        print(f"The Name is {self.name} and {self.name} is {self.age} year old")

@attr.s(auto_attribs=True)
class Child(Parent):
    school: str
    ugly: bool = True

关于python - Python 3.7 数据类中的类继承，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/51575931/