Python3.7 新特性之dataclass裝飾器

更新時間：2019年05月27日 08:59:33 作者：linupy

Python 3.7中一個令人興奮的新特性是 data classes 。這篇文章主要介紹了Python3.7 新特性之dataclass裝飾器,需要的朋友可以參考下

Python 3.7中一個令人興奮的新特性是 data classes 。數(shù)據(jù)類通常是一個主要包含數(shù)據(jù)的類，盡管實際上沒有任何限制。它是使用新的 @dataclass 裝飾器創(chuàng)建的，如下所示:

from dataclasses import dataclass
@dataclass
class DataClassCard:
 rank: str
 suit: str

此代碼以及本教程中的所有其他示例僅適用于 Python 3.7 及更高版本。

注意：

當(dāng)然在 Python 3.6 版本也可以使用這個功能，不過需要安裝 dataclasses 這個庫，使用 pip install dataclasses 命令就可以輕松安裝， Github地址： dataclass （在 Python 3.7 版本中 dataclasses 已經(jīng)作為一個標(biāo)準(zhǔn)庫存在了）

dataclass 類帶有已實現(xiàn)的基本功能。例如，你可以直接實例化，打印和比較數(shù)據(jù)類實例。

>>> queen_of_hearts = DataClassCard('Q', 'Hearts')
>>> queen_of_hearts.rank
'Q'
>>> queen_of_hearts
DataClassCard(rank='Q', suit='Hearts')
>>> queen_of_hearts == DataClassCard('Q', 'Hearts')
True

將 dataclass 其與其他普通類進行比較的話。最基本的普通類看起來像這樣：

class RegularCard:
 def __init__(self, rank, suit):
 self.rank = rank
 self.suit = suit

雖然沒有太多代碼需要編寫，但是你應(yīng)該已經(jīng)看到了不好的地方：為了初始化一個對象， rank 和 suit 都會重復(fù)出現(xiàn)三次。此外，如果你嘗試使用這個普通類，你會注意到對象的表示不是很具有描述性，并且由于某種原因， queen_of_hearts 和 DataClassCard('Q', 'Hearts') 會不相等，如下：

>>> queen_of_hearts = RegularCard('Q', 'Hearts')
>>> queen_of_hearts.rank
'Q'
>>> queen_of_hearts
<__main__.RegularCard object at 0x7fb6eee35d30>
>>> queen_of_hearts == RegularCard('Q', 'Hearts')
False

似乎 dataclass 類在在背后幫我們做了什么。默認情況下， dataclass 實現(xiàn)了一個 __repr__() 方法，用來提供一個比較好的字符串表示方式，并且還實現(xiàn)了 __eq__() 方法，這個方法可以實現(xiàn)基本對象之間的比較。如果要使 RegularCard 類模擬上面的 dataclass 類，還需要添加下面這些方法：

class RegularCard:
 def __init__(self, rank, suit):
 self.rank = rank
 self.suit = suit

 def __repr__(self):
 return (f'{self.__class__.__name__}'
 f'(rank={self.rank!r}, suit={self.suit!r})')

 def __eq__(self, other):
 if other.__class__ is not self.__class__:
 return NotImplemented
 return (self.rank, self.suit) == (other.rank, other.suit)

在本教程中，你能夠確切地了解 dataclass 類提供了哪些便利。除了良好的表示形式和對象比較之外，你還會看到：

dataclass
dataclass
dataclass

接下來，我們將深入研究 dataclass 類的這些特性?；蛟S，你可能認為你以前看到過類似的內(nèi)容。

1. 先說說 dataclass 的替代方案

對于簡單的數(shù)據(jù)結(jié)構(gòu)，你可能會使用 tuple 或 dict 。你可以用以下兩種方式表示紅心Q 撲克牌：

>>> queen_of_hearts_tuple = ('Q', 'Hearts')
>>> queen_of_hearts_dict = {'rank': 'Q', 'suit': 'Hearts'}

這樣寫，是沒有問題的。但是，作為一名程序員，你還需要注意：

你需要你記住紅心Q、紅心K... 等等，所有的變量所代表的撲克牌
對于上邊使用 tuple 的版本，你需要記住元素的順序。比如，寫 ('黑桃'，'A') ，順序就亂了，但是程序卻可能不會給你一個容易理解的錯誤信息
如果你使用了 dict 的方式，必須確保屬性的名稱是一致的。例如，如果寫成 {'value'：'A'，'suit'：'Spades'} ，同樣無法達到預(yù)期的目的。

另外，使用這些結(jié)構(gòu)并不是最好的：

>>> queen_of_hearts_tuple[0] # 不能通過名稱訪問
'Q'
>>> queen_of_hearts_dict['suit'] # 這樣的話還不如使用 `.suit` 
'Hearts'

所以，這里有一個更好的替代方案是：使用 namedtuple 。

它長期以來被用于創(chuàng)建可讀的小數(shù)據(jù)結(jié)構(gòu)（用以構(gòu)建只有少數(shù)屬性但是沒有方法的對象）。我們可以使用 namedtuple 重新創(chuàng)建上面的 dataclass 類示例：

from collections import namedtuple
NamedTupleCard = namedtuple('NamedTupleCard', ['rank', 'suit'])

NamedTupleCard 的這個定義將與我們之前的的 DataClassCard 示例，有完全相同的輸出。

>>> queen_of_hearts = NamedTupleCard('Q', 'Hearts')
>>> queen_of_hearts.rank
'Q'
>>> queen_of_hearts
NamedTupleCard(rank='Q', suit='Hearts')
>>> queen_of_hearts == NamedTupleCard('Q', 'Hearts')
True

那么，為什么還要使用 dataclass 類呢?

首先， dataclass 類具有的特性比目前看到的要多得多。與此同時， namedtuple 還有其他一些不一定需要的功能。

按照設(shè)計， namedtuple 是一個普通的元組。這一點可以從如下代碼的比較中看出：

>>> queen_of_hearts == ('Q', 'Hearts')
True

雖然這似乎是一件好事，但如果缺乏對其自身類型的認識，會導(dǎo)致細微且難以發(fā)現(xiàn)的 bug ，特別是因為它也可以友好地比較兩個不同的 namedtuple 類，如下：

>>> Person = namedtuple('Person', ['first_initial', 'last_name']
>>> ace_of_spades = NamedTupleCard('A', 'Spades')
>>> ace_of_spades == Person('A', 'Spades')
True

namedtuple 也有一些限制。例如，很難為 namedtuple 中的某些字段添加默認值。 namedtuple 本質(zhì)上也是不可變的。也就是說， namedtuple 的值永遠不會更改。在某些應(yīng)用程序中，這是一個很棒的特性，但是在其他設(shè)置中，如果有更多的靈活性就更好了。

>>> card = NamedTupleCard('7', 'Diamonds')
>>> card.rank = '9'
AttributeError: can't set attribute

dataclass 不會取代 namedtuple 的所有用法。例如，如果你需要你的數(shù)據(jù)結(jié)構(gòu)像元組一樣，那么 namedtuple 是一個很好的選擇！

dataclass 的另一種選擇(也是 dataclass 的靈感之一)是 attrs 庫。安裝了 attrs 之后（可以通過 pip install attrs 命令安裝），你可以按如下方式編寫 Card 類：

import attr
@attr.s
class AttrsCard:
 rank = attr.ib()
 suit = attr.ib()

可以使用與前面的 DataClassCard 和 NamedTupleCard 示例完全相同的方法。 attrs 非常棒，并且支持了一些 DataClass 不支持的特性，比如轉(zhuǎn)換器和驗證器。此外， attrs 已經(jīng)出現(xiàn)了一段時間，并且支持 Python 2.7 和 Python 3.4 及以上版本。但是，由于 attrs 不在標(biāo)準(zhǔn)庫中，所以它確實需要為項目添加了一個外部依賴項。通過 dataclass ，可以在任何地方使用類似的功能。

除了 tuple ， dict ， namedtuple 和 attrs 之外，還有許多其他類似的項目，包括 yping.NamedTuple ， namedlist ， attrdict ， plumber 和 fields 。雖然 dataclass 是一個很好的新選擇，但仍有一些舊版本適合更好的用例。例如，如果需要與期望元組的特定API兼容，或者遇到需要 dataclass 中不支持的功能。

2. dataclass 基本要素

讓我們繼續(xù)回到 dataclass 。例如，我們將創(chuàng)建一個 Position 類，它將使用名稱以及緯度和經(jīng)度來表示地理位置。

from dataclasses import dataclass
@dataclass
class Position:
 name: str
 lon: float
 lat: float

類定義上面的 @dataclass 裝飾器定義了 Position 類為 dataclass 類型。在類 Position: 行下面，只需列出 dataclass 類中需要的字段。用于字段的 :表示法使用了Python 3.6中的一個稱為變量注釋的新特性。我們將很快討論更多關(guān)于這種表示法的內(nèi)容，以及為什么要指定像 str 和 float 這樣的數(shù)據(jù)類型。

只需幾行代碼即可。新創(chuàng)建的類可以使用了：

>>> pos = Position('Oslo', 10.8, 59.9)
>>> print(pos)
Position(name='Oslo', lon=10.8, lat=59.9)
>>> pos.lat
59.9
>>> print(f'{pos.name} is at {pos.lat}°N, {pos.lon}°E')
Oslo is at 59.9°N, 10.8°E

你還可以使用類似于創(chuàng)建命名元組的方式創(chuàng)建 dataclass 類。下面的方式(幾乎)等價于上面位置的定義：

from dataclasses import make_dataclass
Position = make_dataclass('Position', ['name', 'lat', 'lon'])

dataclass 類是一個普通的Python類。唯一使它與眾不同的是，它有一些以及實現(xiàn)的基本數(shù)據(jù)模型方法，比如： __init__() , __repr__() ，以及 __eq__() 。

2.1 添加默認值

向 dataclass 類的字段添加默認值很容易：

from dataclasses import dataclass
@dataclass
class Position:
 name: str
 lon: float = 0.0
 lat: float = 0.0

這與普通類的 __init__() 方法的定義中指定默認值完全相同：

>>> Position('Null Island')
Position(name='Null Island', lon=0.0, lat=0.0)
>>> Position('Greenwich', lat=51.8)
Position(name='Greenwich', lon=0.0, lat=51.8)
>>> Position('Vancouver', -123.1, 49.3)
Position(name='Vancouver', lon=-123.1, lat=49.3)

接下來，將了解到 default_factory ，這是一種提供更復(fù)雜默認值的方法。

2.2 類型提示

到目前為止，我們還沒有對 dataclass 類支持開箱即用的事實大做文章。你可能已經(jīng)注意到，我們使用類型提示的方式來定義字段， name: str ：表示 name 應(yīng)該是一個文本字符串(str類型)。

實際上，在定義 dataclass 類中的字段時，必須添加某種類型的提示。如果沒有類型提示，該字段將不 dataclass 類的一部分。但是，如果不想向 dataclass 類添加顯式類型，可以使用 typing.Any ：

from dataclasses import dataclass
from typing import Any
@dataclass
class WithoutExplicitTypes:
 name: Any
 value: Any = 42

雖然在使用 dataclass 類時需要以某種形式添加類型提示，但這些類型在運行時并不是強制的。下面的代碼運行時沒有任何問題：

>>> Position(3.14, 'pi day', 2018)
Position(name=3.14, lon='pi day', lat=2018)

這就是Python進行輸入通常的工作方式：Python現(xiàn)在是，將來也永遠是一種動態(tài)類型語言。要實際捕獲類型錯誤，可以在你的代碼中運行 Mypy 之類的類型檢查器。

2.3 添加方法

前邊已經(jīng)提到， dataclass 類也只是一個普通類。這意味著你可以自由地將自己的方法添加到 dataclass 類中。舉個例子，讓我們計算一個位置與另一個位置之間沿地球表面的距離。一種方法是使用 hasrsine公式：

你可以像使用普通類一樣將 distance_to() 方法添加到數(shù)據(jù)類中：

from dataclasses import dataclass
from math import asin, cos, radians, sin, sqrt

@dataclass
class Position:
 name: str
 lon: float = 0.0
 lat: float = 0.0

 def distance_to(self, other):
 r = 6371 # Earth radius in kilometers
 lam_1, lam_2 = radians(self.lon), radians(other.lon)
 phi_1, phi_2 = radians(self.lat), radians(other.lat)
 h = (sin((phi_2 - phi_1) / 2)**2
 + cos(phi_1) * cos(phi_2) * sin((lam_2 - lam_1) / 2)**2)
 return 2 * r * asin(sqrt(h))

正如你所期望的那樣：

>>> oslo = Position('Oslo', 10.8, 59.9)
>>> vancouver = Position('Vancouver', -123.1, 49.3)
>>> oslo.distance_to(vancouver)
7181.7841229421165

3.更靈活的 dataclass

到目前為止，你已經(jīng)看到了 dataclass 類的一些基本特性：它提供了一些方便的方法、可以添加默認值和其他方法。現(xiàn)在，你將了解一些更高級的特性，比如 @dataclass 裝飾器的參數(shù)和 field() 方法。在創(chuàng)建 dataclass 類時，它們一起給你提供了更多的控制權(quán)。

讓我們回到你在本教程開始時看到的 playingcard示例，并且添加一個包含一副紙牌的類：

from dataclasses import dataclass
from typing import List
@dataclass
class PlayingCard:
 rank: str
 suit: str
@dataclass
class Deck:
 cards: List[PlayingCard]

可以創(chuàng)建一副簡單的牌組，這副牌組只包含兩張牌，如下所示：

>>> queen_of_hearts = PlayingCard('Q', 'Hearts')
>>> ace_of_spades = PlayingCard('A', 'Spades')
>>> two_cards = Deck([queen_of_hearts, ace_of_spades])
Deck(cards=[PlayingCard(rank='Q', suit='Hearts'),
   PlayingCard(rank='A', suit='Spades')])

3.1 默認值的高級用法

假設(shè)你想給牌組提供默認值。例如， Deck() 很方便就可以創(chuàng)建一個由52張撲克牌組成的普通牌組。首先，指定不同的數(shù)字（ ranks ）和花色（ suits ）。然后，添加一個方法 make french deck() ，該方法創(chuàng)建 PlayingCard 的實例列表：

RANKS = '2 3 4 5 6 7 8 9 10 J Q K A'.split()
SUITS = '♣ ♢ ♡ ♠'.split()
def make_french_deck():
 return [PlayingCard(r, s) for s in SUITS for r in RANKS]

這里為了直觀展示，使用了 Unicode符號指定了四種不同的花色。

注意：上面，我們在源代碼中直接使用了像♠這樣的Unicode字形。我們能這樣做，是因為Python支持默認以UTF-8編寫源代碼。有關(guān)如何在你的系統(tǒng)中輸入這些內(nèi)容的信息，請參閱：Unicode input 。你還可以使用 \N 命名字符轉(zhuǎn)義(如 \N{BLACK SPADE SUIT}) 或 \u Unicode 轉(zhuǎn)義 (如\u2660) 為花色輸入 Unicode 符號。

為了以后簡化紙牌的比較，也按通常的順序列出了數(shù)字和花色。

>>> make_french_deck()
[PlayingCard(rank='2', suit='♣'), PlayingCard(rank='3', suit='♣'), ...
 PlayingCard(rank='K', suit='♠'), PlayingCard(rank='A', suit='♠')]

理論上，現(xiàn)在可以使用這個方法為 Deck.cards 指定一個默認值：

from dataclasses import dataclass
from typing import List
@dataclass
class Deck: # Will NOT work
 cards: List[PlayingCard] = make_french_deck()

不要這樣做！這引入了Python中最常見的反模式之一：使用可變的默認參數(shù) 。

問題在于， Deck 的所有實例都將使用相同的list對象作為 cards 屬性的默認值。這意味著，如果一張牌從一副牌中被移走，那么它也將從牌的所有其他實例中消失。實際上， dataclass 類也會阻止你這樣做，上面的代碼將引發(fā) ValueError 。

相反， dataclass 類使用稱為 default_factory 的東西來處理可變的默認值。要使用 default_factory （以及 dataclass 類的許多其他很酷的功能），你需要使用 field() 說明符：

from dataclasses import dataclass, field
from typing import List
@dataclass
class Deck:
 cards: List[PlayingCard] = field(default_factory=make_french_deck)

default_factory 的參數(shù)可以是任何可調(diào)參數(shù)的零參數(shù)。現(xiàn)在很容易就可以創(chuàng)建一副完整的撲克牌：

>>> Deck()
Deck(cards=[PlayingCard(rank='2', suit='♣'), PlayingCard(rank='3', suit='♣'), ...
   PlayingCard(rank='K', suit='♠'), PlayingCard(rank='A', suit='♠')])

field() 說明符用于單獨自定義 dataclass 類的每個字段。后面你還會看到其他一些示例。下面有一些 field() 支持的參數(shù)，可以供你作為參考：

default : 字段的默認值
default_factory : 該函數(shù)返回字段的初始值
init : 是否在 __init__() 方法中使用字段（默認為True。）
repr : 是否在對象的 repr 中使用字段（默認為True。）
compare : 是否在比較時包含這個字段（默認為True。）
hash : 在計算 hash() 時是否包含該字段（默認值是使用與比較相同的值）
metadata : 包含有關(guān)該字段的信息的映射
在上邊的 Position 示例中，你了解了如何通過編寫 lat：float = 0.0 來添加簡單的默認值。但是，如果你還想自定義字段，例如將其隱藏在repr中，則需要使用默認參數(shù)： lat：float = field(default = 0.0，repr = False) 。

你不能同時指定 default 和 default_factory 。參數(shù) metadata 不被 dataclass 類本身使用，但是你(或第三方包)可以將信息附加到字段中。例如，在 Position 示例中，你可以指定緯度和經(jīng)度應(yīng)該用度數(shù)表示。

from dataclasses import dataclass, field

@dataclass
class Position:
 name: str
 lon: float = field(default=0.0, metadata={'unit': 'degrees'})
 lat: float = field(default=0.0, metadata={'unit': 'degrees'})

可以使用 fields() 函數(shù)檢索 metadata (以及關(guān)于字段的其他信息，注意 field 是復(fù)數(shù))。

>>> from dataclasses import fields
>>> fields(Position)
(Field(name='name',type=<class 'str'>,...,metadata={}),
 Field(name='lon',type=<class 'float'>,...,metadata={'unit': 'degrees'}),
 Field(name='lat',type=<class 'float'>,...,metadata={'unit': 'degrees'}))
>>> lat_unit = fields(Position)[2].metadata['unit']
>>> lat_unit
'degrees'

3.2 更好的表示方式

回想一下，我們可以使用下邊的代碼創(chuàng)造出一副紙牌：

>>> Deck()
Deck(cards=[PlayingCard(rank='2', suit='♣'), PlayingCard(rank='3', suit='♣'), ...
   PlayingCard(rank='K', suit='♠'), PlayingCard(rank='A', suit='♠')])

盡管 Deck 的這種表示形式是顯式的、可讀的，但它也非常冗長。（在上面的輸出中，我已經(jīng)刪除了52張牌中的48張。如果在80列顯示器上，只打印完整的 Deck 就占用22行?。?/p>

讓我們來一個更簡潔的表示。通常，Python對象有兩種不同的字符串表示形式：

repr(obj) 由 obj.__repr__() 定義，并且應(yīng)該返回對開發(fā)人員友好的 obj 表示。如果可能，這應(yīng)該是可以重新創(chuàng)建 obj 的代碼。 dataclass 類就是這樣做的。

str(obj) 由 obj.__str__() 定義，并且應(yīng)該返回一個對用戶友好的 obj 表示。 dataclass 類不實現(xiàn) __str__() 方法，因此Python將返回到 __repr__() 方法。
讓我們實現(xiàn)一個對用戶友好的 PlayCard 表示：

from dataclasses import dataclass
@dataclass
class PlayingCard:
 rank: str
 suit: str
 def __str__(self):
  return f'{self.suit}{self.rank}'

現(xiàn)在看起來好多了，但是還和以前一樣冗長：

>>> ace_of_spades = PlayingCard('A', '♠')
>>> ace_of_spades
PlayingCard(rank='A', suit='♠')
>>> print(ace_of_spades)
♠A
>>> print(Deck())
Deck(cards=[PlayingCard(rank='2', suit='♣'), PlayingCard(rank='3', suit='♣'), ...
   PlayingCard(rank='K', suit='♠'), PlayingCard(rank='A', suit='♠')])

為了表示你可以添加你自己的 __repr__() 方法。同樣，我們也違反了它應(yīng)該返回能夠重新創(chuàng)建對象的代碼的原則。畢竟，實用性勝過簡潔。以下代碼添加了更簡潔的 Deck 表示：

from dataclasses import dataclass, field
from typing import List

@dataclass
class Deck:
 cards: List[PlayingCard] = field(default_factory=make_french_deck)

 def __repr__(self):
  cards = ', '.join(f'{c!s}' for c in self.cards)
  return f'{self.__class__.__name__}({cards})'

請注意這里的 {c!s} 格式字符串中的 !s 說明符。這意味著我們要顯式地使用每個 PlayingCard 的 str() 表示。用新的 __repr__() ， Deck 的表示更容易看懂:

>>> Deck()
Deck(♣2, ♣3, ♣4, ♣5, ♣6, ♣7, ♣8, ♣9, ♣10, ♣J, ♣Q, ♣K, ♣A,
  ♢2, ♢3, ♢4, ♢5, ♢6, ♢7, ♢8, ♢9, ♢10, ♢J, ♢Q, ♢K, ♢A,
  ♡2, ♡3, ♡4, ♡5, ♡6, ♡7, ♡8, ♡9, ♡10, ♡J, ♡Q, ♡K, ♡A,
  ♠2, ♠3, ♠4, ♠5, ♠6, ♠7, ♠8, ♠9, ♠10, ♠J, ♠Q, ♠K, ♠A)

3.3 比較 Cards

在許多紙牌游戲中，紙牌是相互比較的。例如，在一個典型的取牌游戲中，最高的牌取牌。目前實現(xiàn)的那樣， PlayingCard 類不支持這種比較，如下：

>>> queen_of_hearts = PlayingCard('Q', '♡')
>>> ace_of_spades = PlayingCard('A', '♠')
>>> ace_of_spades > queen_of_hearts
TypeError: '>' not supported between instances of 'Card' and 'Card'

然而，這(似乎)很容易糾正：

from dataclasses import dataclass
@dataclass(order=True)
class PlayingCard:
 rank: str
 suit: str
 def __str__(self):
  return f'{self.suit}{self.rank}'

@dataclass 裝飾器有兩種形式。到目前為止，你已經(jīng)看到了指定 @dataclass 的簡單形式，沒有使用任何括號和參數(shù)。但是，你也可以像上邊一樣，在括號中為 @dataclass() 裝飾器提供參數(shù)。支持的參數(shù)如下：

init: 是否增加 __init__() 方法， (默認是True)
repr: 是否增加 __repr__() 方法， (默認是True)
eq: 是否增加 __eq__() 方法， (默認是True)
order: 是否增加 ordering 方法， (默認是False)
unsafe_hash: 是否強制添加 __hash__() 方法, (默認是False )
frozen: 如果為 True ，則分配給字段會引發(fā)異常。(默認是False )
有關(guān)每個參數(shù)的詳細信息，請參閱PEP。設(shè)置 order = True 后，就可以比較 PlayingCard 對象了：

>>> queen_of_hearts = PlayingCard('Q', '♡')
>>> ace_of_spades = PlayingCard('A', '♠')
>>> ace_of_spades > queen_of_hearts
False

那么，這兩張牌是如何比較的呢？這里還沒有說明應(yīng)該如何進行排序，就有了結(jié)果？由于某些原因，Python似乎認為 Queen 應(yīng)該大于 Ace 。事實證明， dataclass 類比較對象時就好像它們是字段的元組一樣。換句話說，之所以 Queen 比 Ace 大，是因為在字母表中， Q 出現(xiàn) A 的后面。

>>> ('A', '♠') > ('Q', '♡')
False

這對我們來說并不適用。相反，我們需要定義某種使用 RANKS 和 SUITS 順序的排序索引。類似下面：

>>> RANKS = '2 3 4 5 6 7 8 9 10 J Q K A'.split()
>>> SUITS = '♣ ♢ ♡ ♠'.split()
>>> card = PlayingCard('Q', '♡')
>>> RANKS.index(card.rank) * len(SUITS) + SUITS.index(card.suit)
42

要讓 PlayingCard 使用此排序索引進行比較，我們需要在類中添加一個 sort_index 字段。但是，此字段應(yīng)自動從其他字段 rank 和 suit 計算。這正是特殊方法 __post_init__() 的用途。它允許在調(diào)用 __init__() 方法后進行特殊處理：

from dataclasses import dataclass, field

RANKS = '2 3 4 5 6 7 8 9 10 J Q K A'.split()
SUITS = '♣ ♢ ♡ ♠'.split()

@dataclass(order=True)
class PlayingCard:
 sort_index: int = field(init=False, repr=False)
 rank: str
 suit: str

 def __post_init__(self):
  self.sort_index = (RANKS.index(self.rank) * len(SUITS)
       + SUITS.index(self.suit))

 def __str__(self):
  return f'{self.suit}{self.rank}'

注意： sort_index 作為類的第一個字段添加。這樣，才能首先使用 sort_index 進行比較，并且只有在還有其他字段的情況時才能生效。使用 field() ，還必須指定 sort_index 不應(yīng)作為參數(shù)包含在 __init__() 方法中(因為它是根據(jù) rank 和 suit 字段計算的)。為避免讓使用者對此實現(xiàn)細節(jié)感到困惑，從類的 repr 中刪除 sort_index 可能也是個好主意。

>>> queen_of_hearts = PlayingCard('Q', '♡')
>>> ace_of_spades = PlayingCard('A', '♠')
>>> ace_of_spades > queen_of_hearts
True

現(xiàn)在你可以輕松地創(chuàng)建一個排序的牌組了：

>>> Deck(sorted(make_french_deck()))
Deck(♣2, ♢2, ♡2, ♠2, ♣3, ♢3, ♡3, ♠3, ♣4, ♢4, ♡4, ♠4, ♣5,
  ♢5, ♡5, ♠5, ♣6, ♢6, ♡6, ♠6, ♣7, ♢7, ♡7, ♠7, ♣8, ♢8,
  ♡8, ♠8, ♣9, ♢9, ♡9, ♠9, ♣10, ♢10, ♡10, ♠10, ♣J, ♢J, ♡J,
  ♠J, ♣Q, ♢Q, ♡Q, ♠Q, ♣K, ♢K, ♡K, ♠K, ♣A, ♢A, ♡A, ♠A)

或者，如果你不關(guān)心排序，下面介紹了如何隨機抽取10張牌：

>>> from random import sample
>>> Deck(sample(make_french_deck(), k=10))
Deck(♢2, ♡A, ♢10, ♣2, ♢3, ♠3, ♢A, ♠8, ♠9, ♠2)

當(dāng)然，此處你不需要配置 order = True 。

4. 不可變的 dataclass

前面看到的 namedtuple 的定義特性之一是：它是不可變的。也就是說，它的字段的值可能永遠不會改變。對于許多類型的 dataclass ，這是一個好主意!要使 dataclass 不可變，請在創(chuàng)建時設(shè)置 frozen = True 。比如，下面是你前面看到的 Position 類的不可變版本：

from dataclasses import dataclass
@dataclass(frozen=True)
class Position:
 name: str
 lon: float = 0.0
 lat: float = 0.0

在 frozen=True 的 dataclass 中，不能在創(chuàng)建后為字段賦值。

>>> pos = Position('Oslo', 10.8, 59.9)
>>> pos.name
'Oslo'
>>> pos.name = 'Stockholm'
dataclasses.FrozenInstanceError: cannot assign to field 'name'

但是要注意，如果你的數(shù)據(jù)類包含可變字段，這些字段可能仍然會更改。這適用于Python中的所有嵌套數(shù)據(jù)結(jié)構(gòu)。

from dataclasses import dataclass
from typing import List

@dataclass(frozen=True)
class ImmutableCard:
 rank: str
 suit: str

@dataclass(frozen=True)
class ImmutableDeck:
 cards: List[PlayingCard]

盡管 ImmutableCard 和 ImmutableDeck 都是不可變的，但是包含 Card 的列表并不是不可變的。因此你仍然可以換牌。

>>> queen_of_hearts = ImmutableCard('Q', '♡')
>>> ace_of_spades = ImmutableCard('A', '♠')
>>> deck = ImmutableDeck([queen_of_hearts, ace_of_spades])
>>> deck
ImmutableDeck(cards=[ImmutableCard(rank='Q', suit='♡'), ImmutableCard(rank='A', suit='♠')])
>>> deck.cards[0] = ImmutableCard('7', '♢')
>>> deck
ImmutableDeck(cards=[ImmutableCard(rank='7', suit='♢'), ImmutableCard(rank='A', suit='♠')])

要避免這種情況，請確保不可變 dataclass 類的所有字段都使用不可變類型(但請記住，在運行時不強制執(zhí)行類型)。應(yīng)該使用元組而不是列表來實現(xiàn)ImmutableDeck。

5. 繼承

你可以非常自由地子類化 dataclass 類。例如，我們將使用 country 字段繼承 Position 示例并使用它來記錄國家名稱：

from dataclasses import dataclass
@dataclass
class Position:
 name: str
 lon: float
 lat: float
@dataclass
class Capital(Position):
 country: str

在這個簡單的例子中，一切都沒有問題：

>>> Capital('Oslo', 10.8, 59.9, 'Norway')
Capital(name='Oslo', lon=10.8, lat=59.9, country='Norway')

Capital 類的 country 字段被添加在 Position 類的三個原始字段（ name , lon , lat ）后邊。如果基類中的任何字段具有默認值，事情會變得復(fù)雜一些：

from dataclasses import dataclass
@dataclass
class Position:
 name: str
 lon: float = 0.0
 lat: float = 0.0
@dataclass
class Capital(Position):
 country: str # Does NOT work

上邊這段代碼將立即崩潰，并報一個 TypeError ： "non-default argument ‘country' follows default argument." 問題是：我們的新字段： country 沒有默認值，而 lon 和 lat 字段有默認值。 dataclass 類將嘗試編寫一個像下面一樣的 __init__() 方法：

def __init__(name: str, lon: float = 0.0, lat: float = 0.0, country: str):
 ...

然而，這不是可行的。如果參數(shù)具有默認值，則后邊的所有參數(shù)也必須具有默認值。換句話說，如果基類中的字段具有默認值，那么子類中添加的所有新字段也必須具有默認值。

另一件需要注意的是字段在子類中的排序方式。從基類開始，字段按照首次定義的順序排序。如果在子類中重新定義字段，則其順序不會更改。例如，如果你按如下方式定義 Position 和 Capital ：

from dataclasses import dataclass
@dataclass
class Position:
 name: str
 lon: float = 0.0
 lat: float = 0.0

@dataclass
class Capital(Position):
 country: str = 'Unknown'
 lat: float = 40.0

Capital 中字段的順序仍然是 name lon lat country 。但是， lat 的默認值為40.0。

>>> Capital('Madrid', country='Spain')
Capital(name='Madrid', lon=0.0, lat=40.0, country='Spain')

6. 優(yōu)化 dataclass

我將用幾個關(guān)于 Slot 的內(nèi)容來結(jié)束本教程。 Slot 可用于更快地創(chuàng)建類并使用更少的內(nèi)存。 dataclass 類沒有明確的語法來處理 Slot ，但創(chuàng)建 Slot 的常規(guī)方法也適用于 dataclass 類。（他們真的只是普通的類?。?/p>

from dataclasses import dataclass
@dataclass
class SimplePosition:
 name: str
 lon: float
 lat: float
@dataclass
class SlotPosition:
 __slots__ = ['name', 'lon', 'lat']
 name: str
 lon: float
 lat: float

本質(zhì)上， Slot 是用 __slots__ 在類中定義，并列出了變量。對于不在 __slots__ 的變量或?qū)傩裕瑢⒉粫欢x。此外， Slot 類可能沒有默認值。

添加這些限制的好處是可以進行某些優(yōu)化。例如， Slot 類占用的內(nèi)存更少，這個可以使用 Pympler 進行測試：

>>> from pympler import asizeof
>>> simple = SimplePosition('London', -0.1, 51.5)
>>> slot = SlotPosition('Madrid', -3.7, 40.4)
>>> asizeof.asizesof(simple, slot)
(440, 248)

同樣， Slot 類通常處理起來更快。下面的示例中，使用標(biāo)準(zhǔn)庫中的 timeit 測試了 slots data class 類和常規(guī) data class 類上的屬性訪問速度。

>>> from timeit import timeit
>>> timeit('slot.name', setup="slot=SlotPosition('Oslo', 10.8, 59.9)", globals=globals())
0.05882283499886398
>>> timeit('simple.name', setup="simple=SimplePosition('Oslo', 10.8, 59.9)", globals=globals())
0.09207444800267695

在這個特定的例子中， Slot 類的速度提高了約35％。

7. 總結(jié)及進一步閱讀

data class 類是 Python 3.7 的新特性之一。使用 DataClass 類，你不必編寫樣板代碼來為對象獲得適當(dāng)?shù)某跏蓟⒈硎竞捅容^。

你已經(jīng)了解了如何定義自己的 data class 類，以及：