dataclasses库的使用

1.简介

Dataclasses是一些适合于存储数据对象（data object）的Python类。

他们存储并表示特定的数据类型。例如：一个数字。

并且他们能够被用于和同类型的其他对象进行比较。

2.用法

Python3.7 提供了一个装饰器dataclass，用以把一个类转化为dataclass。

你需要做的就是把类包裹进装饰器里：

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

3.初始化

正常的初始化过程：

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装饰器带来的变化：

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

它也可以定义默认值：

@dataclass
class Number:
    val:int = 0

4.表示

对象表示指的是对象的一个有意义的字符串表示，它在调试时非常有用。

默认的 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)

5.数据比较

通常，数据对象之间需要相互比较。

两个对象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)

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

定义所有的魔法方法（下一篇详细介绍）并不总是值得的。你的用例可能只包括存储值和检查相等性。因此，你只需定义__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，则省略它们。
  我们在接下来会讨论frozen。由于unsafe_hash参数复杂的用例，它值得单独发布一篇文章。

现在回到我们的用例，以下是我们需要的：

1. init
2. 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’

7.Frozen（不可变） 实例

Frozen 实例是在初始化对象后无法修改其属性的对象。

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

以下是我们期望不可变对象能够做到的：

>>> a = Number(10) #Assuming Number class is immutable
>>> a.val = 10 # Raises Error

有了dataclass，就可以通过使用dataclass装饰器作为可调用对象配合参数frozen=True来定义一个frozen对象。

当实例化一个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 实例是一种很好方式来存储：

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

8.后期初始化处理

有了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

9.继承

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

10.field

我们已经知道Dataclasses会生成他们自身的__init__方法。它同时把初始化的值赋给这些字段。

• 变量名
• 数据类型

这些内容仅给我们有限的dataclass字段使用范围。让我们讨论一下这些局限性，以及它们如何通过dataclass.field被解决。

1.复合初始化

import random
from typing import List
def get_random_marks():
    retun [random.randint(1,10) for _ in range(5)]

@dataclass
class Student:
    marks:List[int]
    def __post_init__(seif):
    self.marks = get_random_marks() #Assign random speeds

>>>a= Student()
>>>a.marks
>>>[1,4,2,6,9]

数据类Student产生了一个名为marks的列表。我们不传递marks的值，而是使用__post_init__方法初始化。这是我们定义的单一属性。此外，我们必须在__post_init__里调用get_random_marks函数。这些工作是额外的。

辛运的是，Python为我们提供了一个解决方案。我们可以使用dataclasses.field来定制化dataclass字段的行为以及它们在dataclass的影响。

仍然是上述的使用情形，让我们从__post_init__里去除get_random_marks的调用。以下是使用dataclasses.field的情形：

from dataclasses import field
@dataclass
c1ass Student:
marks:List[int]= field(default_factory=get_random_marks)
>>>s = Student()
>>>s.marks
>>>[1,4,2,6,9]

dataclasses.field接受了一个名为default_factory的参数，它的作用是：如果在创建对象时没有赋值，则使用该方法初始化该字段。

default_factory必须是一个可以调用的无参数方法（通常为一个函数）。

2.使用全部字段进行数据比较

我们了解到，dataclass能够自动生成<,=,>,<=和>=这些比较方法。但是这些比较方法的一个缺陷是，它们使用类中的所有字段进行比较，而这种情况往往不常见。更经常地，这种比较方法会给我们使用dataclasses造成麻烦。

考虑以下的使用情形：你有一个数据类用于存放用户的信息。现在，它可能存在以下字段：

• 姓名
• 年龄
• 身高
• 体重

你仅想比较用户对象的年龄、身高和体重。你不想比较姓名。这是后端开发者经常会遇到的使用情景。

@dataclass(order=True)
class User:
    name:str
    age：int
    height:float
	weight:float

自动生成的比较方法会比较以下的数组：

(self.name，self.agerself.height， self.weight)

这将会破坏我们的意图。我们不想让姓名（name）用于比较。那么，如何使用dataclasses.field来实现我们的想法呢？

@dataclass(orde=True)
class User:
	name:str=field(compare=False)
	age:int
	weight:float
	height:float
>>>user_1=User("John Doe",23,70,1.70)
>>>user_2=User("Adam",24,65,1.60)
>>>user_1<user_2
>>>True

默认情况下，所用的字段都用于比较，因此我们仅仅需要指定哪些字段用于比较，而实现方法是直接把不需要的字段定义为filed（compare=False）。

3.使用全部字段进行数据表示

自动生成的__repr__方法使用所有的字段用于表示。当然，这也不是大多数情形下的理想选择，尤其是当你的数据类有大量的字段时。单个对象的表示会变得异常臃肿，对调试来说也不利。

我们也能够个性化这种行为。考虑一个类似的使用场景，也许最合适的用于表示的属性是姓名（name）。那么对__repr__，我们仅使用它：

@dataclass(order=True)
class User:
	name:str=field(compare=false)
	age:int= field(repr=False)
	height:float= field(repr=False)
	weight:float= field(repr=False)
	city:str=field(repr=False,compare=False)
	country:str=field(repr=False,compare=False)
	
>>>a=User("john Doe",24,1.7,70,"Massachusetts","United States ofAmerica")
>>>b=User("Adam",24,1.6,65,"San Jose","United Statesof America")

>>>a
>>>User(name='john Doe')
>>>b
>>>User(name='Adam')
>>>b>a
>>>True

4.从初始化中省略字段

目前为止我们看到的所有例子，都有一个共同特点——即我们需要为所有被声明的字段传递值，除了有默认值之外。在那种情形下（指有默认值的情况下），我们可以选择传递值，也可以不传递。

但是，还有一种情形：我们可能不想在初始化时设定某个字段的值。这也是一种常见的使用场景。也许你在追踪一个对象的状态，并且希望它在初始化时一直被设为False。更一般地，这个值在初始化时不能够被传递。

那么，我们如何实现上述想法呢？以下是具体内容：

@dataclass
class User:
	email:str= field(repr= True)
	verified:bool=field(repr = False,init=False,default=False)
	#Omit verified from representation as well as __init__


>>>a = User("a@test.com")
>>>User(email='a@test.com')
>>>a.verified
>>>False
        
        
>>>b= User("betest.com",True)#Let us try to pass the value of verified
>>>Traceback(most recent cal1 last):
    File"<stdin>",line1,in<module>
	TypeError:__init__()