理解Python的Dataclasses

介绍
例子
dataclass作为一个可调用的装饰器
后期初始化处理
数据类的基石——dataclasses.field
一些常用函数
dataclass继承
总结
参考

介绍

Dataclasses是Python的一个模块，适用于存储数据对象。你可能会问什么是数据对象？下面是定义数据对象的一个不太详细的特性列表：

它们存储数据并代表某种数据类型。例如：一个数字。对于熟悉ORM的人来说，模型实例就是一个数据对象。它代表一种特定的实体。它包含那些定义或表示实体的属性。
它们可以与同一类型的其他对象进行比较。例如：一个数字可以是 greater than（大于）、less than（小于）或 equal（等于）另一个数字。

当然还有更多的特性，但是这个列表足以帮助你理解问题的关键。
为了理解 Dataclasses，我们将实现一个包含数字的简单类，并允许我们执行上面提到的操作。首先，我们将使用普通类，然后我们再使用Dataclasses来实现相同的结果。
在我们开始之前，先来谈谈 Dataclasses 的用法。Python3.7提供了一个装饰器dataclass，用于将类转换为 dataclass。你所要做的就是将类包在装饰器中：

from dataclasses import dataclass
@dataclass
class A:
 ...

现在，让我们深入了解一下 dataclass 带给我们的变化和用途。

例子

初始化

通常是这样：

class Number:
    def __init__(self, val):
        self.val = val
>>> one = Number(1)
>>> one.val
>>> 1

用 dataclass 是这样：

@dataclass
class Number:
    val:int 
>>> one = Number(1)
>>> one.val
>>> 1

以下是 dataclass装饰器带来的变化：

无需定义 __init__，然后将值赋给 self，dataclass 负责处理它
我们以更加易读的方式预先定义了成员属性，以及类型提示。我们现在立即能知道 val 是 int 类型。这无疑比一般定义类成员的方式更具可读性。

它也可以定义默认值：

@dataclass
class Number:
    val:int = 0

表示

对象表示指的是对象的一个有意义的字符串表示，它在调试时非常有用。
默认的 Python 对象表示不是很直观：

class Number:
    def __init__(self, val = 0):
    self.val = val
>>> a = Number(1)
>>> a
>>> <__main__.Number object at 0x7ff395b2ccc0>

这让我们无法知悉对象的作用，并且会导致糟糕的调试体验。一个有意义的表示可以通过在类中定义一个 __repr__ 方法来实现。

def __repr__(self):
    return self.val
>>> a = Number(1)
>>> a
>>> 1

dataclass 会自动添加一个 __repr__ 函数，这样我们就不必手动实现它了。

@dataclass
class Number:
    val: int = 0
>>> a = Number(1)
>>> a
>>> Number(val = 1)

数据比较

通常，数据对象之间需要相互比较。两个对象 a 和 b 之间的比较通常包括以下操作：

a < b
a > b
a == b
a >= b
a <= b

在Python中，能够在可以执行上述操作的类中定义这些操作的实现。我们这里将只展示 == 和 < 的实现。通常这样写：

class Number:
    def __init__( self, val = 0):
       self.val = val
    def __eq__(self, other):
        return self.val == other.val
    def __lt__(self, other):
        return self.val < other.val

使用dataclass：

@dataclass(order = True)
class Number:
    val: int = 0

是的，就是这样简单。我们不需要定义 __eq__ 和 __lt__ 方法，因为当 order = True 被调用时，dataclass 装饰器会自动将它们添加到我们的类定义中。
那么，它是如何做到的呢？
当你使用dataclass时，它会在类定义中添加函数__eq__和__lt__ 。我们已经知道这点了。那么，这些函数是怎样知道如何检查相等并进行比较呢？

生成 __eq__ 函数的 dataclass 类会比较两个由属性构成的元组，一个元祖由自己属性构成的，另一个元祖由同类的其他实例的属性构成。在我们的例子中，自动生成的 __eq__ 函数相当于：

def __eq__(self, other):
    return (self.val,) == (other.val,)

让我们来看一个更详细的例子，我们会编写一个 dataclass 类 Person 来保存 name 和 age:

@dataclass(order = True)
class Person:
    name: str
    age:int = 0

自动生成的 __eq__ 方法等同于：

def __eq__(self, other):
    return (self.name, self.age) == ( other.name, other.age)

请注意属性的顺序。它们总是按照你在 dataclass 类中定义的顺序生成。

同样，等效的 __le__ 函数类似于：

def __le__(self, other):
    return (self.name, self.age) <= (other.name, other.age)

当你需要对数据对象列表进行排序时，通常会出现像 __le__ 这样的函数的定义。Python 内置的 sorted 函数依赖于比较两个对象。

dataclass作为一个可调用的装饰器

定义所有的dunder(这是指双下划线方法，即魔法方法）方法并不总是值得的。你的用例可能只包括存储值和检查相等性。因此，你只需定义 __init__ 和 __eq__ 方法。如果我们可以告诉装饰器不生成其他方法，那么它会减少一些开销，并且我们将在数据对象上有正确的操作。幸运的是，这可以通过将dataclass装饰器作为可调用对象来实现。从官方文档来看，装饰器可以用作具有如下参数的可调用对象：

@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False)
class C:
 …

init：默认将生成 __init__ 方法。如果传入 False，那么该类将不会有 __init__ 方法。
repr：__repr__ 方法默认生成。如果传入 False，那么该类将不会有 __repr__ 方法。
eq：默认将生成 __eq__ 方法。如果传入 False，那么 __eq__ 方法将不会被 dataclass 添加，但默认为 object.__eq__。
order：默认将生成 __gt__、__ge__、__lt__、__le__ 方法。如果传入 False，则省略它们。

有默认值的属性必须定义在没有默认值的属性之后，和对kw参数的要求一样。
现在回到我们的用例，以下是我们需要的__init__,__eq__,默认会生成这些函数，因此我们需要的是不生成其他函数。那么我们该怎么做呢？很简单，只需将相关参数作为 false 传入即可。

@dataclass(repr = False) # order, unsafe_hash and frozen are False
class Number:
    val: int = 0
>>> a = Number(1)
>>> a
>>> <__main__.Number object at 0x7ff395afe898>
>>> b = Number(2)
>>> c = Number(1)
>>> a == b
>>> False
>>> a < b
>>> Traceback (most recent call last):
 File “<stdin>”, line 1, in <module>
TypeError: ‘<’ not supported between instances of ‘Number’ and ‘Number’

下面我们来看一下frozen参数的使用例子。
Frozen实例是在初始化对象后无法修改其属性的对象。有了dataclass，就可以通过使用 dataclass装饰器作为可调用对象配合参数frozen=True 来定义一个 frozen 对象。

无法创建真正不可变的 Python 对象

当实例化一个frozen对象时，任何企图修改对象属性的行为都会引发 FrozenInstanceError。

@dataclass(frozen = True)
class Number:
    val: int = 0
>>> a = Number(1)
>>> a.val
>>> 1
>>> a.val = 2
>>> Traceback (most recent call last):
 File “<stdin>”, line 1, in <module>
 File “<string>”, line 3, in __setattr__
dataclasses.FrozenInstanceError: cannot assign to field ‘val’

因此，一个frozen实例是一种很好方式来存储：

常数
设置

这些通常不会在应用程序的生命周期内发生变化，任何企图修改它们的行为都应该被禁止。

后期初始化处理

有了dataclass，需要定义一个 __init__ 方法来将变量赋给 self 这种初始化操作已经得到了处理。但是我们失去了在变量被赋值之后，立即需要的函数调用或处理的灵活性。
让我们来讨论一个用例，在这个用例中，我们定义一个 Float 类来包含浮点数，然后在初始化之后立即计算整数和小数部分。

import math
class Float:
    def __init__(self, val = 0):
        self.val = val
        self.process()
    def process(self):
        self.decimal, self.integer = math.modf(self.val)
>>> a = Float( 2.2)
>>> a.decimal
>>> 0.2000
>>> a.integer
>>> 2.0

幸运的是，使用__post_init__方法已经能够处理后期初始化操作。生成的__init__方法在返回之前调用 __post_init__ 返回。因此，可以在函数中进行任何处理。

import math
@dataclass
class FloatNumber:
    val: float = 0.0
    def __post_init__(self):
        self.decimal, self.integer = math.modf(self.val)
>>> a = Number(2.2)
>>> a.val
>>> 2.2
>>> a.integer
>>> 2.0
>>> a.decimal
>>> 0.2

数据类的基石——dataclasses.field

上面我们偶尔提到了field的概念，我们所说的数据类属性，数据属性实际上都是被field的对象，它代表着一个数据的实体和它的元信息，下面我们了解一下dataclasses.field。
先看下field的原型：

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

通常我们无需直接使用，装饰器会根据我们给出的类型注解自动生成field，例如，

from dataclasses import dataclass

@dataclass(order=True)
class Car():
    price : float =0.0
    color : str = "red"

相当于

from dataclasses import dataclass
from dataclasses import field
@dataclass(order=True)
class Car():
    price : float = field(default = '0.0')
    color : str = field(default ="red")

但有时候我们也需要定制这一过程，这时dataclasses.field就显得格外有用了。
default和default_factory参数将会影响默认值的产生，它们的默认值都是None，意思是调用时如果未指定则产生一个为None的值。

其中default是field的默认值，
而default_factory控制如何产生值，它接收一个无参数或者全是默认参数的callable对象，然后用调用这个对象获得field的初始值
default和default_factory不能同时指定，

from dataclasses import dataclass
from dataclasses import field
@dataclass(order=True)
class Car():
    brand : str
    price : float
    color : str = "red"
    order_list : list[int] = field(default=[1,2,3],default_factory = list)

将报错误：Cannot specify both 'default' and 'default_factory'

我们不能直接指定mutable类型的默认值，对于mutable类型，我们必须得调用field函数，并通过指定default_factory参数的方式来办到，

from dataclasses import dataclass
from dataclasses import field

@dataclass(order=True)
class Car():
    brand : str
    price : float
    color : str = "red"
    order_list : list[int] = field(default_factory = list)

我们也可以使用default_factory参数进行复杂一点的初始化，比如

import random 
def random_color():
    color_list = ['red','gray', 'black']
    return random.choice(color_list)
from dataclasses import dataclass
from dataclasses import field

@dataclass
class Car():
    brand : str 
    price : float = 0.0
    color : str = field(default_factory=random_color)
>> bmw = Car('bmw', '500000')
>> tesla = Car("tesla", "300000", 'gray')
>> print(bmw, tesla)

Car(brand='bmw', price='500000', color='black') Car(brand='tesla', price='300000', color='gray')

init参数如果设置为False，表示不为这个field生成初始化操作，dataclass提供了hook——__post_init__供我们利用这一特性：

@dataclass
class C:
    a: int
    b: int
    c: int = field(init=False)
 
    def __post_init__(self):
        self.c = self.a + self.b

__post_init__在__init__后被调用，我们可以在这里初始化那些需要前置条件的field。

repr参数表示该field是否被包含进repr的输出，例如，

from dataclasses import dataclass
from dataclasses import field

@dataclass
class Car():
    brand : str 
    price : field(repr=False, default = 0.0)
    color : str = field(default_factory=list)
>> bmw = Car("bmw", 500000, "red")
>> print(bmw)
bmw, red

compare和hash参数表示field是否参与比较和计算hash值。
metadata不被dataclass自身使用，通常让第三方组件从中获取某些元信息时才使用，所以我们不需要使用这一参数。
如果指定一个field的类型注解为dataclasses.InitVar，那么这个field将只会在初始化过程中（__init__和__post_init__）可以被使用，当初始化完成后访问该field会返回一个dataclasses.Field对象而不是field原本的值，也就是该field不再是一个可访问的数据对象。举个例子，比如一个由数据库对象，它只需要在初始化的过程中被访问：

@dataclass
class C:
    i: int
    j: int = None
    database: InitVar[DatabaseType] = None
 
    def __post_init__(self, database):
        if self.j is None and database is not None:
            self.j = database.lookup('j')
 
c = C(10, database=my_database)

这个例子中会返回c.i和c.j的数据，但是不会返回c.database的。

一些常用函数

dataclasses模块中提供了一些常用函数供我们处理数据类。使用dataclasses.asdict和dataclasses.astuple我们可以把数据类实例中的数据转换成字典或者元组：

from dataclasses import dataclass
@dataclass 
class Lang: 
"""a dataclass that describes a programming language""" 
    name: str = 'python' 
    strong_type: bool = True 
    static_type: bool = False 
    age: int = 28
>>> from dataclasses import asdict, astuple
>>> asdict(Lang())
{'name': 'python', 'strong_type': True, 'static_type': False, 'age': 28}
>>> astuple(Lang())
('python', True, False, 28)

使用dataclasses.is_dataclass可以判断一个类或实例对象是否是数据类：

>>> from dataclasses import is_dataclass
>>> is_dataclass(Lang)
True
>>> is_dataclass(Lang())
True

dataclass继承

Dataclasses支持继承，就像普通的Python类一样。因此，父类中定义的属性将在子类中可用。

@dataclass
class Person:
    age: int = 0
    name: str
@dataclass
class Student(Person):
    grade: int
>>> s = Student(20, "John Doe", 12)
>>> s.age
>>> 20
>>> s.name
>>> "John Doe"
>>> s.grade
>>> 12

请注意，Student的参数是在类中定义的字段的顺序(先父类，再当前类)。
继承过程中__post_init__的行为是怎样的？由于__post_init__只是另一个函数，因此必须以传统方式调用它：

@dataclass
class A:
    a: int
    def __post_init__(self):
        print("A")
@dataclass
class B(A):
    b: int
    def __post_init__(self):
        print("B")
>>> a = B(1,2)
>>> B

在上面的例子中，只有B的__post_init__被调用，那么我们如何调用A的__post_init__呢？因为它是父类的函数，所以可以用super来调用它。

@dataclass
class B(A):
    b: int
    def __post_init__(self):
        super().__post_init__() # 调用 A 的 post init
        print("B")
>>> a = B(1,2)
>>> A
    B

python3.7引入dataclass的一大原因就在于相比namedtuple，dataclass可以享受继承带来的便利。dataclass装饰器会检查当前class的所有基类，如果发现一个dataclass，就会把它的字段按顺序添加进当前的class，随后再处理当前class的field。所有生成的方法也将按照这一过程处理，因此如果子类中的field与基类同名，那么子类将会无条件覆盖基类。子类将会根据所有的field重新生成一个构造函数，并在其中初始化基类。

@dataclass 
class Lang: 
"""a dataclass that describes a programming language""" 
    name: str = 'python' 
    strong_type: bool = True 
    static_type: bool = False 
    age: int = 28
@dataclass
class Python(Lang):
    tab_size: int = 4
    is_script: bool = True
 
>>> Python()
Python(name='python', strong_type=True, static_type=False, age=28, tab_size=4, is_script=True)
 
@dataclass
class Base:
    x: float = 25.0
    y: int = 0
 
@dataclass
class C(Base):
    z: int = 10
    x: int = 15
 
>>> C()
C(x=15, y=0, z=10)

Lang的field被Python继承了，而C中的x则覆盖了Base中的定义。

总结

合理使用dataclass将会大大减轻开发中的负担，将我们从大量的重复劳动中解放出来，这既是dataclass的魅力，不过魅力的背后也总是有陷阱相伴，最后我想提几点注意事项：

dataclass通常情况下是unhashable的，因为默认生成的__hash__是None，所以不能用来做字典的key，如果有这种需求，那么应该指定你的数据类为frozen dataclass
小心当你定义了和dataclass生成的同名方法时会引发的问题
当使用可变类型（如list）时，应该考虑使用field的default_factory
数据类的属性都是公开的，如果你有属性只需要初始化时使用而不需要在其他时候被访问，请使用dataclasses.InitVar

只要避开这些陷阱，dataclass一定能成为提高生产力的利器。

参考

https://linux.cn/article-9974-1.html

https://www.cnblogs.com/apocelipes/p/10284346.html

https://zhuanlan.zhihu.com/p/555359585

https://medium.com/mindorks/understanding-python-dataclasses-part-1-c3ccd4355c34

posted on 2023-01-29 21:45 朴素贝叶斯阅读(1130) 评论(0) 编辑收藏举报

刷新页面返回顶部

朴素贝叶斯