正文共：30429 字

預(yù)計(jì)閱讀時(shí)間：76分鐘

原文鏈接:https://realpython.com/python-type-checking/

作者:Geir Arne Hjelle

譯者：陳祥安

在本指南中，你將了解Python類型檢查。傳統(tǒng)上，Python解釋器以靈活但隱式的方式處理類型。Python的最新版本允許你指定可由不同工具使用的顯式類型提示，以幫助您更有效地開發(fā)代碼。

通過本教程，你將學(xué)到以下內(nèi)容：

類型注解和提示(Type annotations and type hints)

代碼里添加靜態(tài)類型

靜態(tài)類型檢查

運(yùn)行時(shí)強(qiáng)制類型一致

這是一個(gè)全面的指南，將涵蓋很多領(lǐng)域。如果您只是想快速了解一下類型提示在Python中是如何工作的，并查看類型檢查是否包括在您的代碼中，那么您不需要閱讀全部內(nèi)容。Hello Types和正反兩部分將讓您大致了解類型檢查是如何工作的，并介紹它在什么時(shí)候有用。

Type Systems

所有的編程語言都包括某種類型的系統(tǒng)，該系統(tǒng)將它可以處理的對象類別以及如何處理這些類別形式化。例如，類型系統(tǒng)可以定義一個(gè)數(shù)字類型，其中42是數(shù)字類型對象的一個(gè)例子。

動態(tài)類型

Python是一種動態(tài)類型語言。這意味著Python解釋器僅在代碼運(yùn)行時(shí)進(jìn)行類型檢查，并且允許變量的類型在其生命周期內(nèi)進(jìn)行更改。以下示例演示了Python具有動態(tài)類型：

>>> if False:... 1 + "two" # This line never runs, so no TypeError is raised... else:... 1 + 2...3>>> 1 + "two" # Now this is type checked, and a TypeError is raisedTypeError: unsupported operand type(s) for +: 'int' and 'str'

在上面例子中，if從未運(yùn)行過，因此它未被類型檢查過。else部分，當(dāng)計(jì)算1 +“2”時(shí)，因?yàn)轭愋筒灰恢滤?#xff0c;會產(chǎn)生一個(gè)類型錯(cuò)誤。

如果改變一個(gè)變量的值的類型

>>> thing = "Hello">>> type(thing)>>> thing = 28.1>>> type(thing)

type()返回對象的類型。這些示例確認(rèn)允許更改事物的類型，并且Python在更改時(shí)正確地推斷出類型。

靜態(tài)類型

與動態(tài)類型相反的是靜態(tài)類型。在不運(yùn)行程序的情況下執(zhí)行靜態(tài)類型檢查。在大多數(shù)靜態(tài)類型語言中，編譯是在程序時(shí)完成的。例如C和Java，

對于靜態(tài)類型，通常不允許變量改變類型，盡管可能存在將變量轉(zhuǎn)換為不同類型的機(jī)制。

讓我們看一個(gè)靜態(tài)類型語言的快速示例。請考慮以下Java代碼段：

String thing;thing = "Hello";

第一行聲明thing的類型是String，所以后面的賦值也必須指定字符串類型，如果你給thing=2就會出錯(cuò)，但是python就不會出錯(cuò)。

雖然，Python始終是一種動態(tài)類型語言。但是，PEP 484引入了類型提示，這使得還可以對Python代碼進(jìn)行靜態(tài)類型檢查。

與大多數(shù)其他靜態(tài)類型語言中的工作方式不同，類型提示本身不會導(dǎo)致Python強(qiáng)制執(zhí)行類型。顧名思義，鍵入提示只是建議類型。

鴨子類型

在談?wù)揚(yáng)ython時(shí)經(jīng)常使用的另一個(gè)術(shù)語是鴨子打字。這個(gè)綽號來自短語“如果它像鴨子一樣行走，它像鴨子一樣嘎嘎叫，那它一定是鴨子”(或其任何變化)。

鴨子類型是一個(gè)與動態(tài)類型相關(guān)的概念，其中對象的類型或類不如它定義的方法重要。使用鴨子類型根本不需要檢查類型，而是檢查給定方法或?qū)傩允欠翊嬖凇?/p>

下面一個(gè)例子, 你可在python所有的對象中使用?len()?的魔法函數(shù)__len__()?方法:

>>> class TheHobbit:... def __len__(self):... return 95022...>>> the_hobbit = TheHobbit()>>> len(the_hobbit)95022

實(shí)際len()方法就是下面的這種方法實(shí)現(xiàn)的:

def len(obj):return obj.__len__()

由此發(fā)現(xiàn)，對象也可以像str，list，dict那樣使用len方法，只不過需要重新寫__len__魔法函數(shù)即可。

Hello Types

在本節(jié)中，您將看到如何向函數(shù)添加類型提示。下面的函數(shù)通過添加適當(dāng)?shù)拇髮懽帜负脱b飾線將文本字符串轉(zhuǎn)換為標(biāo)題：

def headline(text, align=True):if align:return f"{text.title()}\n{'-' * len(text)}"else:return f" {text.title()} ".center(50, "o")

默認(rèn)情況下，函數(shù)返回與下劃線對齊的左側(cè)標(biāo)題。通過將align標(biāo)志設(shè)置為False，您還可以選擇使用o圍繞字符串:

>>> print(headline("python type checking"))Python Type Checking-------------------->>> print(headline("python type checking", align=False))oooooooooooooo Python Type Checking oooooooooooooo

是時(shí)候給我們第一個(gè)類型提示了！要向函數(shù)中添加關(guān)于類型的信息，只需如下注釋其參數(shù)和返回值：

def headline(text: str, align: bool = True) -> str:...

text: str 意思是text值類型是str， 類似的, 可選參數(shù) align 指定其類型為bool并給定默認(rèn)值True. 最后, -> str 表示函數(shù)headline() 返回值類型為str。

在代碼風(fēng)格方面，PEP 8建議如下：:

對冒號使用常規(guī)規(guī)則，即冒號前沒有空格，冒號后面有一個(gè)空格：text：str。

將參數(shù)注釋與默認(rèn)值組合時(shí)，在=符號周圍使用空格：align：bool = True。

def??headline(...) - > str，使用空格圍繞。

>>> print(headline("python type checking", align="left"))Python Type Checking--------------------

但是如果傳入的參數(shù)類型不是指定的參數(shù)類型，程序不會出現(xiàn)錯(cuò)誤，此時(shí)可以使用類型檢查模塊通過提示內(nèi)容確定是否類型輸入正確，如mypy。

你可以通過?pip安裝:

$ pip install mypy

將以下代碼放在名為headlines.py的文件中:

#headlines.pydef?headline(text:?str,?align:?bool?=?True)?->?str:if?align:return?f"{text.title()}\n{'-'?*?len(text)}"else:return?f"?{text.title()}?".center(50,?"o")print(headline("python?type?checking"))print(headline("use?mypy",?align="center"))

然后通過mypy運(yùn)行上面的文件:

$mypy headlines.pyheadlines.py:10: error: Argument "align" to "headline" has incompatibletype "str"; expected "bool"

根據(jù)類型提示，Mypy能夠告訴我們我們在第10行使用了錯(cuò)誤的類型

這樣說明一個(gè)問題參數(shù)名align不是很好確定參數(shù)是bool類型，我們將代碼改成下面這樣，換一個(gè)識別度高的參數(shù)名centered。

#headlines.pydef?headline(text:?str,?centered:?bool?=?False):if?not?centered:return?f"{text.title()}\n{'-'?*?len(text)}"else:return?f"?{text.title()}?".center(50,?"o")print(headline("python?type?checking"))print(headline("use?mypy",?centered=True))

再次運(yùn)行文件發(fā)現(xiàn)沒有錯(cuò)誤提示，ok。

$ mypy headlines.py

$

然后就可以打印結(jié)果了

$python headlines.pyPython Type Checking--------------------oooooooooooooooooooo Use Mypy oooooooooooooooooooo

第一個(gè)標(biāo)題與左側(cè)對齊，而第二個(gè)標(biāo)題居中。

Pros and Cons

類型提示的增加方便了IDE的代碼提示功能，我們看到下面text使用.即可得到str使用的一些方法和熟悉。

類型提示可幫助您構(gòu)建和維護(hù)更清晰的體系結(jié)構(gòu)。編寫類型提示的行為迫使您考慮程序中的類型。雖然Python的動態(tài)特性是其重要資產(chǎn)之一，但是有意識地依賴于鴨子類型，重載方法或多種返回類型是一件好事。

需要注意的是，類型提示會在啟動時(shí)帶來輕微的損失。如果您需要使用類型模塊，那么導(dǎo)入時(shí)間可能很長，尤其是在簡短的腳本中。

那么，您應(yīng)該在自己的代碼中使用靜態(tài)類型檢查嗎？這不是一個(gè)全有或全無的問題。幸運(yùn)的是，Python支持漸進(jìn)式輸入的概念。這意味著您可以逐漸在代碼中引入類型。沒有類型提示的代碼將被靜態(tài)類型檢查器忽略。因此，您可以開始向關(guān)鍵組件添加類型，只要它能為您增加價(jià)值，就可以繼續(xù)。

關(guān)于是否向項(xiàng)目添加類型的一些經(jīng)驗(yàn)法則：

如果您剛開始學(xué)習(xí)Python，可以安全地等待類型提示，直到您有更多經(jīng)驗(yàn)。

類型提示在短暫拋出腳本中增加的價(jià)值很小。

在其他人使用的庫中，尤其是在PyPI上發(fā)布的庫中，類型提示會增加很多價(jià)值。使用庫的其他代碼需要這些類型提示才能正確地進(jìn)行類型檢查。

在較大的項(xiàng)目中，類型提示可以幫助您理解類型是如何在代碼中流動的，強(qiáng)烈建議您這樣做。在與他人合作的項(xiàng)目中更是如此。

Bernat Gabor在他的文章《Python中類型提示的狀態(tài)》中建議，只要值得編寫單元測試，就應(yīng)該使用類型提示。實(shí)際上，類型提示在代碼中扮演著類似于測試的角色:它們幫助開發(fā)人員編寫更好的代碼。

注解

Python 3.0中引入了注釋，最初沒有任何特定用途。它們只是將任意表達(dá)式與函數(shù)參數(shù)和返回值相關(guān)聯(lián)的一種方法。

多年以后，PEP 484根據(jù)Jukka Lehtosalo博士項(xiàng)目Mypy所做的工作，定義了如何向Python代碼添加類型提示。添加類型提示的主要方法是使用注釋。隨著類型檢查變得越來越普遍，這也意味著注釋應(yīng)該主要保留給類型提示。

接下來的章節(jié)將解釋注釋如何在類型提示的上下文中工作。

函數(shù)注解

之前我們也提到過函數(shù)的注解例子向下面這樣:

def func(arg: arg_type, optarg: arg_type = default) -> return_type:...

對于參數(shù)，語法是參數(shù):注釋，而返回類型使用- >注釋進(jìn)行注釋。請注意，注釋必須是有效的Python表達(dá)式。

以下簡單示例向計(jì)算圓周長的函數(shù)添加注釋::

import mathdef circumference(radius: float) -> float:return 2 * math.pi * radius

通調(diào)用circumference對象的__annotations__魔法函數(shù)可以輸出函數(shù)的注解信息。

>>> circumference(1.23)7.728317927830891>>> circumference.__annotations__{'radius': , 'return': }

有時(shí)您可能會對Mypy如何解釋您的類型提示感到困惑。對于這些情況，有一些特殊的Mypy表達(dá)式:reveal type()和reveal local()。您可以在運(yùn)行Mypy之前將這些添加到您的代碼中，Mypy將報(bào)告它所推斷的類型。例如，將以下代碼保存為reveal.py。

#reveal.pyimport?mathreveal_type(math.pi)radius?=1circumference?=2?*?math.pi?*?radiusreveal_locals()

然后通過mypy運(yùn)行上面代碼

$mypy reveal.pyreveal.py:4: error: Revealed type is 'builtins.float'reveal.py:8: error: Revealed local types are:reveal.py:8: error: circumference: builtins.floatreveal.py:8: error: radius: builtins.int

即使沒有任何注釋，Mypy也正確地推斷了內(nèi)置數(shù)學(xué)的類型。以及我們的局部變量半徑和周長。

注意:以上代碼需要通過mypy運(yùn)行，如果用python運(yùn)行會報(bào)錯(cuò)，另外mypy?版本不低于?0.610

變量注解

有時(shí)類型檢查器也需要幫助來確定變量的類型。變量注釋在PEP 526中定義，并在Python 3.6中引入。語法與函數(shù)參數(shù)注釋相同：

pi: float = 3.142def circumference(radius: float) -> float:return 2 * pi * radius

pi被聲明為float類型。

注意:?靜態(tài)類型檢查器能夠很好地確定3.142是一個(gè)浮點(diǎn)數(shù)，因此在本例中不需要pi的注釋。隨著您對Python類型系統(tǒng)的了解越來越多，您將看到更多有關(guān)變量注釋的示例。.

變量注釋存儲在模塊級__annotations__字典中：:

>>> circumference(1)6.284>>> __annotations__{'pi': }

即使只是定義變量沒有給賦值，也可以通過__annotations__獲取其類型。雖然在python中沒有賦值的變量直接輸出是錯(cuò)誤的。

>>> nothing: str>>> nothingNameError: name 'nothing' is not defined>>> __annotations__{'nothing': }

類型注解

如上所述，注釋是在Python 3中引入的，并且它們沒有被反向移植到Python 2.這意味著如果您正在編寫需要支持舊版Python的代碼，則無法使用注釋。

要向函數(shù)添加類型注釋，您可以執(zhí)行以下操作：

import mathdef circumference(radius):# type: (float) -> floatreturn 2 * math.pi * radius

類型注釋只是注釋，所以它們可以用在任何版本的Python中。

類型注釋由類型檢查器直接處理，所以不存在__annotations__字典對象中:

>>> circumference.__annotations__{}

類型注釋必須以type: 字面量開頭，并與函數(shù)定義位于同一行或下一行。如果您想用幾個(gè)參數(shù)來注釋一個(gè)函數(shù)，您可以用逗號分隔每個(gè)類型:

def headline(text, width=80, fill_char="-"):# type: (str, int, str) -> strreturn f" {text.title()} ".center(width, fill_char)print(headline("type comments work", width=40))

您還可以使用自己的注釋在單獨(dú)的行上編寫每個(gè)參數(shù):

#headlines.pydefheadline(text,???????????#?type:?strwidth=80,???????#?type:?intfill_char="-",??#?type:?str):??????????????????#?type:?(...)?->?strreturn?f"?{text.title()}?".center(width,?fill_char)print(headline("type?comments?work",?width=40))

通過Python和Mypy運(yùn)行示例：

$python headlines.py---------- Type Comments Work ----------$mypy headline.py$

如果傳入一個(gè)字符串width="full"，再次運(yùn)行mypy會出現(xiàn)一下錯(cuò)誤。

$mypy headline.pyheadline.py:10: error: Argument "width" to "headline" has incompatibletype "str"; expected "int"

您還可以向變量添加類型注釋。這與您向參數(shù)添加類型注釋的方式類似:

pi?=?3.142??#?type:?float

上面的例子可以檢測出pi是float類型。

So, Type Annotations or Type Comments?

所以向自己的代碼添加類型提示時(shí)，應(yīng)該使用注釋還是類型注釋？簡而言之:盡可能使用注釋，必要時(shí)使用類型注釋。

注釋提供了更清晰的語法，使類型信息更接近您的代碼。它們也是官方推薦的寫入類型提示的方式，并將在未來進(jìn)一步開發(fā)和適當(dāng)維護(hù)。

類型注釋更詳細(xì)，可能與代碼中的其他類型注釋沖突，如linter指令。但是，它們可以用在不支持注釋的代碼庫中。

還有一個(gè)隱藏選項(xiàng)3:存根文件。稍后，當(dāng)我們討論向第三方庫添加類型時(shí)，您將了解這些。

存根文件可以在任何版本的Python中使用，代價(jià)是必須維護(hù)第二組文件。通常，如果無法更改原始源代碼，則只需使用存根文件。

Playing With Python Types, Part 1

到目前為止，您只在類型提示中使用了str，float和bool等基本類型。但是Python類型系統(tǒng)非常強(qiáng)大，它可以支持多種更復(fù)雜的類型。

在本節(jié)中，您將了解有關(guān)此類型系統(tǒng)的更多信息，同時(shí)實(shí)現(xiàn)簡單的紙牌游戲。您將看到如何指定：

序列和映射的類型，如元組，列表和字典

鍵入別名，使代碼更容易閱讀

該函數(shù)和方法不返回任何內(nèi)容

可以是任何類型的對象

在簡要介紹了一些類型理論之后，您將看到更多用Python指定類型的方法。您可以在這里找到代碼示例：https://github.com/realpython/materials/tree/master/python-type-checking

Example: A Deck of Cards

以下示例顯示了一副常規(guī)紙牌的實(shí)現(xiàn):

#game.pyimport?randomSUITS?=?"???????".split()RANKS?=?"2?3?4?5?6?7?8?9?10?J?Q?K?A".split()def?create_deck(shuffle=False):"""Create?a?new?deck?of?52?cards"""deck?=?[(s,?r)?for?r?in?RANKS?for?s?in?SUITS]if?shuffle:random.shuffle(deck)return?deckdef?deal_hands(deck):"""Deal?the?cards?in?the?deck?into?four?hands"""return?(deck[0::4],?deck[1::4],?deck[2::4],?deck[3::4])def?play():"""Play?a?4-player?card?game"""deck?=?create_deck(shuffle=True)names?=?"P1?P2?P3?P4".split()hands?=?{n:?h?for?n,?h?in?zip(names,?deal_hands(deck))}for?name,?cards?in?hands.items():card_str?=?"?".join(f"{s}{r}"?for?(s,?r)?in?cards)print(f"{name}:?{card_str}")if?__name__?==?"__main__":play()

每張卡片都表示為套裝和等級的字符串元組。卡組表示為卡片列表。create_deck()創(chuàng)建一個(gè)由52張撲克牌組成的常規(guī)套牌，并可選擇隨機(jī)播放這些牌。deal_hands()將牌組交給四名玩家。

最后，play()扮演游戲。截至目前，它只是通過構(gòu)建一個(gè)洗牌套牌并向每個(gè)玩家發(fā)牌來準(zhǔn)備紙牌游戲。以下是典型輸出：

$python game.pyP4: ?9 ?9 ?2 ?7 ?7 ?A ?6 ?K ?5 ?6 ?3 ?3 ?QP1: ?A ?2 ?10 ?J ?10 ?4 ?5 ?Q ?5 ?6 ?A ?5 ?4P2: ?2 ?7 ?8 ?K ?3 ?3 ?K ?J ?A ?7 ?6 ?10 ?KP3: ?2 ?8 ?8 ?J ?Q ?9 ?J ?4 ?8 ?10 ?9 ?4 ?Q

下面讓我一步一步對上面的代碼進(jìn)行拓展。

Sequences and Mappings

讓我們?yōu)槲覀兊募埮朴螒蛱砑宇愋吞崾尽Q句話說，讓我們注釋函數(shù)create_deck()，deal_hands()和play()。第一個(gè)挑戰(zhàn)是你需要注釋復(fù)合類型，例如用于表示卡片組的列表和用于表示卡片本身的元組。

對于像str、float和bool這樣的簡單類型，添加類型提示就像使用類型本身一樣簡單:

>>> name: str = "Guido">>> pi: float = 3.142>>> centered: bool = False

對于復(fù)合類型，可以執(zhí)行相同的操作:

>>> names: list = ["Guido", "Jukka", "Ivan"]>>> version: tuple = (3, 7, 1)>>> options: dict = {"centered": False, "capitalize": True}

上面的注釋還是不完善，比如names我們只是知道這是list類型，但是我們不知道list里面的元素?cái)?shù)據(jù)類型

typing模塊為我們提供了更精準(zhǔn)的定義:

>>> from typing import Dict, List, Tuple>>> names: List[str] = ["Guido", "Jukka", "Ivan"]>>> version: Tuple[int, int, int] = (3, 7, 1)>>> options: Dict[str, bool] = {"centered": False, "capitalize": True}

需要注意的是，這些類型中的每一個(gè)都以大寫字母開頭，并且它們都使用方括號來定義項(xiàng)的類型:

names是一個(gè)str類型的list數(shù)組。

version是一個(gè)含有3個(gè)int類型的元組

options?是一個(gè)字典鍵名類型str，簡直類型bool

typing?還包括其他的很多類型比如?Counter,?Deque,?FrozenSet,?NamedTuple, 和?Set.此外，該模塊還包括其他的類型，你將在后面的部分中看到.

讓我們回到撲克游戲. 因?yàn)榭ㄆ怯?個(gè)str組成的元組定義的. 所以你可以寫作Tuple[str, str],所以函數(shù)create_deck()返回值的類型就是?List[Tuple[str, str]].

def?create_deck(shuffle:?bool?=?False)?->?List[Tuple[str,?str]]:"""Create?a?new?deck?of?52?cards"""deck?=?[(s,?r)?for?r?in?RANKS?for?s?in?SUITS]if?shuffle:random.shuffle(deck)return?deck

除了返回值之外，您還將bool類型添加到可選的shuffle參數(shù)中。

注意:?元組和列表的聲明是有區(qū)別的

元組是不可變序列，通常由固定數(shù)量的可能不同類型的元素組成。例如，我們將卡片表示為套裝和等級的元組。通常，您為n元組編寫元組[t_1，t_2，...，t_n]。

列表是可變序列，通常由未知數(shù)量的相同類型的元素組成，例如卡片列表。無論列表中有多少元素，注釋中只有一種類型：List [t]。

在許多情況下，你的函數(shù)會期望某種順序，并不關(guān)心它是列表還是元組。在這些情況下，您應(yīng)該使用typing.Sequence在注釋函數(shù)參數(shù)時(shí)：

from typing import List, Sequencedef square(elems: Sequence[float]) -> List[float]:return [x**2 for x in elems]

使用?Sequence?是一個(gè)典型的鴨子類型的例子. 也就意味著可以使用len()?和?.__getitem__()等方法。

類型別名

使用嵌套類型(如卡片組)時(shí)，類型提示可能會變得非常麻煩。你可能需要仔細(xì)看List [Tuple [str，str]]，才能確定它與我們的一副牌是否相符.

現(xiàn)在考慮如何注釋deal_hands():

def?deal_hands(deck:?List[Tuple[str,?str]])?->?Tuple[List[Tuple[str,?str]],List[Tuple[str,?str]],List[Tuple[str,?str]],List[Tuple[str,?str]],]:"""Deal?the?cards?in?the?deck?into?four?hands"""return?(deck[0::4],?deck[1::4],?deck[2::4],?deck[3::4])

這也太麻煩了!

不怕，我們還可以使用起別名的方式把注解的類型賦值給一個(gè)新的變量，方便在后面使用，就像下面這樣:

from typing import List, TupleCard = Tuple[str, str]Deck = List[Card]

現(xiàn)在我們就可以使用別名對之前的代碼進(jìn)行注解了:

def deal_hands(deck: Deck) -> Tuple[Deck, Deck, Deck, Deck]:"""Deal?the?cards?in?the?deck?into?four?hands"""return?(deck[0::4],?deck[1::4],?deck[2::4],?deck[3::4])

類型別名讓我們的代碼變的簡潔了不少，我們可以打印變量看里面具體的值:

>>> from typing import List, Tuple>>> Card = Tuple[str, str]>>> Deck = List[Card]>>> Decktyping.List[typing.Tuple[str, str]]

當(dāng)輸出Deck的時(shí)候可以看到其最終的類型.

函數(shù)無返回值

對于沒有返回值的函數(shù)，我們可以指定None:

#play.pydef?play(player_name:?str)?->?None:print(f"{player_name}?plays")ret_val?=?play("Filip")

通過mypy檢測上面代碼

$mypy play.pyplay.py:6: error: "play" does not return a value

作為一個(gè)更奇特的情況，請注意您還可以注釋從未期望正常返回的函數(shù)。這是使用NoReturn完成的:

from typing import NoReturndef black_hole() -> NoReturn:raise Exception("There is no going back ...")

因?yàn)閎lack_hole( )總是引發(fā)異常，所以它永遠(yuǎn)不會正確返回。

Example: Play Some Cards

讓我們回到我們的紙牌游戲示例。在游戲的第二個(gè)版本中，我們像以前一樣向每個(gè)玩家發(fā)放一張牌。然后選擇一個(gè)開始玩家并且玩家輪流玩他們的牌。雖然游戲中沒有任何規(guī)則，所以玩家只會玩隨機(jī)牌:

#game.pyimport?randomfrom?typing?import?List,?TupleSUITS?=?"???????".split()RANKS?=?"2?3?4?5?6?7?8?9?10?J?Q?K?A".split()Card?=?Tuple[str,?str]Deck?=?List[Card]def?create_deck(shuffle:?bool?=?False)?->?Deck:"""Create?a?new?deck?of?52?cards"""deck?=?[(s,?r)?for?r?in?RANKS?for?s?in?SUITS]if?shuffle:random.shuffle(deck)return?deckdef?deal_hands(deck:?Deck)?->?Tuple[Deck,?Deck,?Deck,?Deck]:"""Deal?the?cards?in?the?deck?into?four?hands"""return?(deck[0::4],?deck[1::4],?deck[2::4],?deck[3::4])def?choose(items):"""Choose?and?return?a?random?item"""return?random.choice(items)def?player_order(names,?start=None):"""Rotate?player?order?so?that?start?goes?first"""if?start?is?None:start?=?choose(names)start_idx?=?names.index(start)return?names[start_idx:]?+?names[:start_idx]def?play()?->?None:"""Play?a?4-player?card?game"""deck?=?create_deck(shuffle=True)names?=?"P1?P2?P3?P4".split()hands?=?{n:?h?for?n,?h?in?zip(names,?deal_hands(deck))}start_player?=?choose(names)turn_order?=?player_order(names,?start=start_player)#?Randomly?play?cards?from?each?player's?hand?until?emptywhile?hands[start_player]:for?name?in?turn_order:card?=?choose(hands[name])hands[name].remove(card)print(f"{name}:?{card[0]?+?card[1]:<3}??",?end="")print()if?__name__?==?"__main__":play()

請注意，除了更改play()之外，我們還添加了兩個(gè)需要類型提示的新函數(shù)：choose()和player_order()。在討論我們?nèi)绾蜗蛩鼈兲砑宇愋吞崾局?#xff0c;以下是運(yùn)行游戲的示例輸出：

$python game.pyP3: ?10 P4: ?4 P1: ?8 P2: ?QP3: ?8 P4: ?6 P1: ?5 P2: ?KP3: ?9 P4: ?J P1: ?A P2: ?AP3: ?Q P4: ?3 P1: ?7 P2: ?AP3: ?4 P4: ?6 P1: ?2 P2: ?KP3: ?K P4: ?7 P1: ?7 P2: ?2P3: ?10 P4: ?4 P1: ?5 P2: ?3P3: ?Q P4: ?K P1: ?J P2: ?9P3: ?2 P4: ?4 P1: ?9 P2: ?10P3: ?A P4: ?5 P1: ?J P2: ?QP3: ?8 P4: ?7 P1: ?3 P2: ?JP3: ?3 P4: ?10 P1: ?9 P2: ?2P3: ?6 P4: ?6 P1: ?5 P2: ?8

在該示例中，隨機(jī)選擇玩家P3作為起始玩家。反過來，每個(gè)玩家都會玩一張牌：先是P3，然后是P4，然后是P1，最后是P2。只要手中有任何左手，玩家就會持續(xù)打牌。

The?Any?Type

choose()適用于名稱列表和卡片列表(以及任何其他序列)。為此添加類型提示的一種方法是：

import randomfrom typing import Any, Sequencedef choose(items: Sequence[Any]) -> Any:return random.choice(items)

這或多或少意味著它：items是一個(gè)可以包含任何類型的項(xiàng)目的序列，而choose()將返回任何類型的這樣的項(xiàng)目。不是很嚴(yán)謹(jǐn)，此時(shí)請考慮以下示例：

#choose.pyimport?randomfrom?typing?import?Any,?Sequencedef?choose(items:?Sequence[Any])?->?Any:return?random.choice(items)names?=?["Guido",?"Jukka",?"Ivan"]reveal_type(names)name?=?choose(names)reveal_type(name)

雖然Mypy會正確推斷名稱是字符串列表，但由于使用了任意類型，在調(diào)用choose ( )后，該信息會丟失:

$mypy choose.pychoose.py:10: error: Revealed type is 'builtins.list[builtins.str*]'choose.py:13: error: Revealed type is 'Any'

由此可以得知，如果使用了Any使用mypy的時(shí)候?qū)⒉蝗菀讬z測。

Playing With Python Types, Part 2

import randomfrom typing import Any, Sequencedef choose(items: Sequence[Any]) -> Any:return random.choice(items)

使用Any的問題在于您不必要地丟失類型信息。您知道如果將一個(gè)字符串列表傳遞給choose()，它將返回一個(gè)字符串。

類型變量

類型變量是一個(gè)特殊變量，可以采用任何類型，具體取決于具體情況。

讓我們創(chuàng)建一個(gè)有效封裝choose()行為的類型變量：

#choose.pyimport?randomfrom?typing?import?Sequence,?TypeVarChoosable?=?TypeVar("Chooseable")def?choose(items:?Sequence[Choosable])?->?Choosable:return?random.choice(items)names?=?["Guido",?"Jukka",?"Ivan"]reveal_type(names)name?=?choose(names)reveal_type(name)

類型變量必須使用類型模塊中的TypeVar定義。使用時(shí)，類型變量的范圍覆蓋所有可能的類型，并獲取最特定的類型。在這個(gè)例子中，name現(xiàn)在是一個(gè)str

$mypy choose.pychoose.py:12: error: Revealed type is 'builtins.list[builtins.str*]'choose.py:15: error: Revealed type is 'builtins.str*'

考慮一些其他例子:

#choose_examples.pyfrom?choose?import?choosereveal_type(choose(["Guido",?"Jukka",?"Ivan"]))reveal_type(choose([1,?2,?3]))reveal_type(choose([True,?42,?3.14]))reveal_type(choose(["Python",?3,?7])

前兩個(gè)例子應(yīng)該有類型str和int，但是后兩個(gè)呢？單個(gè)列表項(xiàng)有不同的類型，在這種情況下，可選擇類型變量會盡最大努力適應(yīng):

$mypy choose_examples.pychoose_examples.py:5: error: Revealed type is 'builtins.str*'choose_examples.py:6: error: Revealed type is 'builtins.int*'choose_examples.py:7: error: Revealed type is 'builtins.float*'choose_examples.py:8: error: Revealed type is 'builtins.object*'

正如您已經(jīng)看到的那樣bool是int的子類型，它也是float的子類型。所以在第三個(gè)例子中，choose()的返回值保證可以被認(rèn)為是浮點(diǎn)數(shù)。在最后一個(gè)例子中，str和int之間沒有子類型關(guān)系，因此關(guān)于返回值可以說最好的是它是一個(gè)對象。

請注意，這些示例都沒有引發(fā)類型錯(cuò)誤。有沒有辦法告訴類型檢查器，選擇( )應(yīng)該同時(shí)接受字符串和數(shù)字，但不能同時(shí)接受兩者？

您可以通過列出可接受的類型來約束類型變量:

#choose.pyimport?randomfrom?typing?import?Sequence,?TypeVarChoosable?=?TypeVar("Choosable",?str,?float)def?choose(items:?Sequence[Choosable])?->?Choosable:return?random.choice(items)reveal_type(choose(["Guido",?"Jukka",?"Ivan"]))reveal_type(choose([1,?2,?3]))reveal_type(choose([True, 42, 3.14]))reveal_type(choose(["Python",?3,?7]))

現(xiàn)在Choosable只能是str或float，而Mypy會注意到最后一個(gè)例子是一個(gè)錯(cuò)誤：

$mypy choose.pychoose.py:11: error: Revealed type is 'builtins.str*'choose.py:12: error: Revealed type is 'builtins.float*'choose.py:13: error: Revealed type is 'builtins.float*'choose.py:14: error: Revealed type is 'builtins.object*'choose.py:14: error: Value of type variable "Choosable" of "choose"cannot be "object"

還要注意，在第二個(gè)例子中，即使輸入列表只包含int對象，該類型也被認(rèn)為是float類型的。這是因?yàn)镃hoosable僅限于str和float，int是float的一個(gè)子類型。

在我們的紙牌游戲中，我們想限制choose()只能用str和Card類型:

Choosable = TypeVar("Choosable", str, Card)def choose(items: Sequence[Choosable]) -> Choosable:...

我們簡要地提到Sequence表示列表和元組。正如我們所指出的，一個(gè)Sequence可以被認(rèn)為是一個(gè)duck類型，因?yàn)樗梢允菍?shí)現(xiàn)了.__ len __()和.__ getitem __()的任何對象。

鴨子類型和協(xié)議

回想一下引言中的以下例子::

def len(obj):

return obj.__len__()

len()方法可以返回任何實(shí)現(xiàn)__len__魔法函數(shù)的對象的長度，那我們?nèi)绾卧趌en()里添加類型提示，尤其是參數(shù)obj的類型表示呢？

答案隱藏在學(xué)術(shù)術(shù)語structural subtyping背后。structural subtyping的一種方法是根據(jù)它們是normal的還是structural的:

在normal系統(tǒng)中，類型之間的比較基于名稱和聲明。Python類型系統(tǒng)大多是名義上的，因?yàn)樗鼈兊淖宇愋完P(guān)系，可以用int來代替float。

在structural系統(tǒng)中，類型之間的比較基于結(jié)構(gòu)。您可以定義一個(gè)結(jié)構(gòu)類型“大小”，它包括定義的所有實(shí)例。__len_ _ _()，無論其標(biāo)稱類型如何.

目前正在通過PEP 544為Python帶來一個(gè)成熟的結(jié)構(gòu)類型系統(tǒng)，該系統(tǒng)旨在添加一個(gè)稱為協(xié)議的概念。盡管大多數(shù)PEP 544已經(jīng)在Mypy中實(shí)現(xiàn)了。

協(xié)議指定了一個(gè)或多個(gè)實(shí)現(xiàn)的方法。例如，所有類定義。_ _ len _ _ _()完成typing.Sized協(xié)議。因此，我們可以將len()注釋如下:

from typing import Sizeddef len(obj: Sized) -> int:return obj.__len__()

除此之外，在Typing中還包括以下模塊?Container,?Iterable,?Awaitable, 還有?ContextManager.

你也可以聲明自定的協(xié)議，?通過導(dǎo)入typing_extensions模塊中的Protocol協(xié)議對象，然后寫一個(gè)繼承該方法的子類，像下面這樣:

from typing_extensions import Protocolclass Sized(Protocol):def __len__(self) -> int: ...def len(obj: Sized) -> int:return obj.__len__()

到寫本文為止，需要通過pip安裝上面使用的第三方模塊

pip install typing-extensions.

Optional 類型

在python中有一種公共模式，就是設(shè)置參數(shù)的默認(rèn)值None，這樣做通常是為了避免可變默認(rèn)值的問題，或者讓一個(gè)標(biāo)記值標(biāo)記特殊行為。

在上面 的card 例子中, 函數(shù)?player_order()?使用?None?作為參數(shù)start的默認(rèn)值,表示還沒有指定玩家:

def?player_order(names,?start=None):"""Rotate?player?order?so?that?start?goes?first"""if?start?is?None:start?=?choose(names)start_idx?=?names.index(start)return?names[start_idx:]?+?names[:start_idx]

這給類型提示帶來的挑戰(zhàn)是，通常start應(yīng)該是一個(gè)字符串。但是，它也可能采用特殊的非字符串值“None”。

為解決上面的問題，這里可以使用Optional類型:

from typing import Sequence, Optionaldef player_order(names: Sequence[str], start: Optional[str] = None) -> Sequence[str]:...

等價(jià)于Union類型的?Union[None, str]，意思是這個(gè)參數(shù)的值類型為str，默認(rèn)的話可以是

請注意，使用Optional或Union時(shí)，必須注意變量是否在后面有操作。比如上面的例子通過判斷start是否為None。如果不判斷None的情況，在做靜態(tài)類型檢查的時(shí)候會發(fā)生錯(cuò)誤：

1 # player_order.py

2

3 from typing import Sequence, Optional

4

5 def player_order(

6 names: Sequence[str], start: Optional[str] = None

7 ) -> Sequence[str]:

8 start_idx = names.index(start)

9 return names[start_idx:] + names[:start_idx]

Mypy告訴你還沒有處理start為None的情況。

$mypy player_order.pyplayer_order.py:8: error: Argument 1 to "index" of "list" has incompatibletype "Optional[str]"; expected "str"

也可以使用以下操作，聲明參數(shù)start的類型。

def player_order(names: Sequence[str], start: str = None) -> Sequence[str]:...

如果你不想 Mypy 出現(xiàn)報(bào)錯(cuò)，你可以使用命令

--no-implicit-optional

Example: The Object(ive) of the Game

接下來我們會重寫上面的撲克牌游戲，讓它看起來更面向?qū)ο?#xff0c;以及適當(dāng)?shù)氖褂米⒔狻?/p>

將我們的紙牌游戲翻譯成以下幾個(gè)類，?Card,?Deck,?Player,?Game?，下面是代碼實(shí)現(xiàn)。

#game.pyimport?randomimport?sysclass?Card:SUITS?=?"???????".split()RANKS?=?"2?3?4?5?6?7?8?9?10?J?Q?K?A".split()def?__init__(self,?suit,?rank):self.suit?=?suitself.rank?=?rankdef?__repr__(self):return?f"{self.suit}{self.rank}"class?Deck:def?__init__(self,?cards):self.cards?=?cards@classmethoddef?create(cls,?shuffle=False):"""Create?a?new?deck?of?52?cards"""cards?=?[Card(s,?r)?for?r?in?Card.RANKS?for?s?in?Card.SUITS]if?shuffle:random.shuffle(cards)return?cls(cards)def?deal(self,?num_hands):"""Deal?the?cards?in?the?deck?into?a?number?of?hands"""cls?=?self.__class__return?tuple(cls(self.cards[i::num_hands])?for?i?in?range(num_hands))class?Player:def?__init__(self,?name,?hand):self.name?=?nameself.hand?=?handdef?play_card(self):"""Play?a?card?from?the?player's?hand"""card?=?random.choice(self.hand.cards)self.hand.cards.remove(card)print(f"{self.name}:?{card!r:<3}??",?end="")return?cardclass?Game:def?__init__(self,?*names):"""Set?up?the?deck?and?deal?cards?to?4?players"""deck?=?Deck.create(shuffle=True)self.names?=?(list(names)?+?"P1?P2?P3?P4".split())[:4]self.hands?=?{n:?Player(n,?h)?for?n,?h?in?zip(self.names,?deck.deal(4))}def?play(self):"""Play?a?card?game"""start_player?=?random.choice(self.names)turn_order?=?self.player_order(start=start_player)#?Play?cards?from?each?player's?hand?until?emptywhile?self.hands[start_player].hand.cards:for?name?in?turn_order:self.hands[name].play_card()print()def?player_order(self,?start=None):"""Rotate?player?order?so?that?start?goes?first"""if?start?is?None:start?=?random.choice(self.names)start_idx?=?self.names.index(start)return?self.names[start_idx:]?+?self.names[:start_idx]if?__name__?==?"__main__":#?Read?player?names?from?command?lineplayer_names?=?sys.argv[1:]game?=?Game(*player_names)game.play()

好了，下面讓我們添加注解

Type Hints for Methods

方法的類型提示與函數(shù)的類型提示非常相似。唯一的區(qū)別是self參數(shù)不需要注釋，因?yàn)樗且粋€(gè)類的實(shí)例。Card類的類型很容易添加:

class?Card:SUITS?=?"???????".split()RANKS?=?"2?3?4?5?6?7?8?9?10?J?Q?K?A".split()def?__init__(self,?suit:?str,?rank:?str)?->?None:self.suit?=?suitself.rank?=?rankdef?__repr__(self)?->?str:return?f"{self.suit}{self.rank}"

__init__()?的返回值總是為None

Class作為類型

類別和類型之間有對應(yīng)關(guān)系。例如，Card的所有實(shí)例一起形成Card類型。要使用類作為類型，只需使用類的名稱Card。

例如：Deck(牌組)本質(zhì)上由一組Card對象組成，你可以像下面這樣去聲明

class?Deck:def?__init__(self,?cards:?List[Card])?->?None:self.cards?=?cards

但是，當(dāng)您需要引用當(dāng)前定義的類時(shí)，這種方法就不那么有效了。例如，Deck.create() 類方法返回一個(gè)帶有Deck類型的對象。但是，您不能簡單地添加-> Deck，因?yàn)镈eck類還沒有完全定義。

這種情況下可以在注釋中使用字符串文字。就像下面使用"Deck",聲明了返回類型，然后加入docstring注釋進(jìn)一步說明方法。

class?Deck:@classmethoddef?create(cls,?shuffle:?bool?=?False)?->?"Deck":"""Create?a?new?deck?of?52?cards"""cards?=?[Card(s,?r)?for?r?in?Card.RANKS?for?s?in?Card.SUITS]if?shuffle:random.shuffle(cards)return?cls(cards)

Player類也可以直接使用?Deck作為類型聲明. 因?yàn)樵谇懊嫖覀円呀?jīng)定義它

class?Player:def?__init__(self,?name:?str,?hand:?Deck)?->?None:self.name?=?nameself.hand?=?hand

通常，注釋不會在運(yùn)行時(shí)使用。這為推遲對注釋的評估提供了動力。該提議不是將注釋評估為Python表達(dá)式并存儲其值，而是存儲注釋的字符串表示形式，并僅在需要時(shí)對其進(jìn)行評估。

這種功能計(jì)劃在Python 4.0中成為標(biāo)準(zhǔn)。但是，在Python 3.7及更高版本中，可以通過導(dǎo)入__future__屬性的annotations來實(shí)現(xiàn)：

from __future__ import annotationsclass Deck:@classmethoddef create(cls, shuffle: bool = False) -> Deck:...

使用?__future__之后就可以使用Deck對象替換字符串"Deck"了。

返回?self?或者?cls

如前所述，通常不應(yīng)該注釋self或cls參數(shù)。在一定程度上，這是不必要的，因?yàn)閟elf指向類的實(shí)例，所以它將具有類的類型。在Card示例中，self擁有隱式類型Card。此外，顯式地添加這種類型會很麻煩，因?yàn)檫€沒有定義該類。所以需要使用字符串“Card”聲明返回類型。

但是，有一種情況可能需要注釋self或cls。考慮如果你有一個(gè)其他類繼承的超類，并且有返回self或cls的方法會發(fā)生什么：

#dogs.pyfrom datetime import dateclass Animal:def __init__(self, name: str, birthday: date) -> None:self.name = nameself.birthday = birthday@classmethoddef newborn(cls, name: str) -> "Animal":return cls(name, date.today())def twin(self, name: str) -> "Animal":cls = self.__class__return cls(name, self.birthday)class Dog(Animal):def bark(self) -> None:print(f"{self.name} says woof!")fido = Dog.newborn("Fido")pluto = fido.twin("Pluto")fido.bark()pluto.bark()

運(yùn)行上面的代碼，Mypy會拋出下面的錯(cuò)誤:

$mypy dogs.pydogs.py:24: error: "Animal" has no attribute "bark"dogs.py:25: error: "Animal" has no attribute "bark"

問題是，即使繼承的Dog.newborn()和Dog.twin()方法將返回一個(gè)Dog，注釋表明它們返回一個(gè)Animal。

在這種情況下，您需要更加小心以確保注釋正確。返回類型應(yīng)與self的類型或cls的實(shí)例類型匹配。這可以使用TypeVar來完成，這些變量會跟蹤實(shí)際傳遞給self和cls的內(nèi)容：

#dogs.pyfrom datetime import datefrom typing import Type, TypeVarTAnimal = TypeVar("TAnimal", bound="Animal")class Animal:def __init__(self, name: str, birthday: date) -> None:self.name = nameself.birthday = birthday@classmethoddef newborn(cls: Type[TAnimal], name: str) -> TAnimal:return cls(name, date.today())def twin(self: TAnimal, name: str) -> TAnimal:cls = self.__class__return cls(name, self.birthday)class Dog(Animal):def bark(self) -> None:print(f"{self.name} says woof!")fido = Dog.newborn("Fido")pluto = fido.twin("Pluto")fido.bark()pluto.bark()

在這個(gè)例子中有幾個(gè)需要注意的點(diǎn)：

類型變量TAnimal用于表示返回值可能是Animal的子類的實(shí)例。.

我們指定Animal是TAnimal的上限。指定綁定意味著TAnimal將是Animal子類之一。這可以正確限制所允許的類型。

typing.Type []是type()的類型。需要注意，是cls的類方法需要使用這種形式注解，而self就不用使用。

注解?*args?和?**kwargs

在面向?qū)ο蟮挠螒虬姹局?#xff0c;我們添加了在命令行上命名玩家的選項(xiàng)。這是通過在程序名稱后面列出玩家名稱來完成的：

$python game.py GeirArne Dan JoannaDan: ?A Joanna: ?9 P1: ?A GeirArne: ?2Dan: ?A Joanna: ?6 P1: ?4 GeirArne: ?8Dan: ?K Joanna: ?Q P1: ?K GeirArne: ?5Dan: ?2 Joanna: ?J P1: ?7 GeirArne: ?KDan: ?10 Joanna: ?3 P1: ?4 GeirArne: ?8Dan: ?6 Joanna: ?Q P1: ?Q GeirArne: ?JDan: ?2 Joanna: ?4 P1: ?8 GeirArne: ?7Dan: ?10 Joanna: ?3 P1: ?3 GeirArne: ?2Dan: ?K Joanna: ?5 P1: ?7 GeirArne: ?JDan: ?6 Joanna: ?9 P1: ?J GeirArne: ?10Dan: ?3 Joanna: ?5 P1: ?9 GeirArne: ?QDan: ?A Joanna: ?9 P1: ?10 GeirArne: ?8Dan: ?6 Joanna: ?5 P1: ?7 GeirArne: ?4

關(guān)于類型注釋:即使名稱是字符串元組，也應(yīng)該只注釋每個(gè)名稱的類型。換句話說，您應(yīng)該使用字符串而不是元組[字符串]，就像下面這個(gè)例子:

class Game:def?__init__(self,?*names:?str)?->?None:"""Set?up?the?deck?and?deal?cards?to?4?players"""deck?=?Deck.create(shuffle=True)self.names?=?(list(names)?+?"P1?P2?P3?P4".split())[:4]self.hands?=?{n:?Player(n,?h)?for?n,?h?in?zip(self.names,?deck.deal(4))}

類似地，如果有一個(gè)接受**kwargs的函數(shù)或方法，那么你應(yīng)該只注釋每個(gè)可能的關(guān)鍵字參數(shù)的類型。

Callables可調(diào)用類型

函數(shù)是Python中的一類對象。可以使用函數(shù)作為其他函數(shù)的參數(shù)。這意味著需要能夠添加表示函數(shù)的類型提示。

函數(shù)以及l(fā)ambdas、方法和類都由type的Callable對象表示。參數(shù)的類型和返回值通常也表示。例如，Callable[[A1, A2, A3]， Rt]表示一個(gè)函數(shù)，它有三個(gè)參數(shù)，分別具有A1、A2和A3類型。函數(shù)的返回類型是Rt。

在下面這個(gè)例子, 函數(shù)?do_twice()?傳入一個(gè)Callable類型的func參數(shù)，并指明傳入的函數(shù)的參數(shù)類型為str，返回值類型為str。比如傳入?yún)?shù)create_greeting.

#do_twice.pyfrom?typing?import?Callabledef?do_twice(func:?Callable[[str],?str],?argument:?str)?->?None:print(func(argument))print(func(argument))def?create_greeting(name:?str)?->?str:return?f"Hello?{name}"do_twice(create_greeting,?"Jekyll")

Example: Hearts

讓我們以紅心游戲的完整例子來結(jié)束。您可能已經(jīng)從其他計(jì)算機(jī)模擬中了解了這個(gè)游戲。下面是對規(guī)則的簡要回顧:

四名玩家每人玩13張牌。

持有?2的玩家開始第一輪，必須出?2。

如果可能的話，玩家輪流打牌，跟隨領(lǐng)頭的一套牌。

在第一套牌中打出最高牌的玩家贏了這個(gè)把戲，并在下一個(gè)回合中成為開始牌的玩家。

玩家不能用?，除非?已經(jīng)在之前的技巧中玩過。

玩完所有牌后，玩家如果拿到某些牌就會獲得積分：

?Q為13分

每個(gè)?1為分

一場比賽持續(xù)幾輪，直到得到100分以上。得分最少的玩家獲勝

具體游戲規(guī)則可以網(wǎng)上搜索一下.

在這個(gè)示例中，沒有多少新的類型概念是尚未見過的。因此，我們將不詳細(xì)討論這段代碼，而是將其作為帶注釋代碼的示例。

#hearts.pyfrom collections import Counterimport randomimport sysfrom typing import Any, Dict, List, Optional, Sequence, Tuple, Unionfrom typing import overloadclass Card:SUITS = "? ? ? ?".split()RANKS = "2 3 4 5 6 7 8 9 10 J Q K A".split()def __init__(self, suit: str, rank: str) -> None:self.suit = suitself.rank = rank@propertydef value(self) -> int:"""The value of a card is rank as a number"""return self.RANKS.index(self.rank)@propertydef points(self) -> int:"""Points this card is worth"""if self.suit == "?" and self.rank == "Q":return 13if self.suit == "?":return 1return 0def __eq__(self, other: Any) -> Any:return self.suit == other.suit and self.rank == other.rankdef __lt__(self, other: Any) -> Any:return self.value < other.valuedef __repr__(self) -> str:return f"{self.suit}{self.rank}"class Deck(Sequence[Card]):def __init__(self, cards: List[Card]) -> None:self.cards = cards@classmethoddef create(cls, shuffle: bool = False) -> "Deck":"""Create a new deck of 52 cards"""cards = [Card(s, r) for r in Card.RANKS for s in Card.SUITS]if shuffle:random.shuffle(cards)return cls(cards)def play(self, card: Card) -> None:"""Play one card by removing it from the deck"""self.cards.remove(card)def deal(self, num_hands: int) -> Tuple["Deck", ...]:"""Deal the cards in the deck into a number of hands"""return tuple(self[i::num_hands] for i in range(num_hands))def add_cards(self, cards: List[Card]) -> None:"""Add a list of cards to the deck"""self.cards += cardsdef __len__(self) -> int:return len(self.cards)@overloaddef __getitem__(self, key: int) -> Card: ...@overloaddef __getitem__(self, key: slice) -> "Deck": ...def __getitem__(self, key: Union[int, slice]) -> Union[Card, "Deck"]:if isinstance(key, int):return self.cards[key]elif isinstance(key, slice):cls = self.__class__return cls(self.cards[key])else:raise TypeError("Indices must be integers or slices")def __repr__(self) -> str:return " ".join(repr(c) for c in self.cards)class Player:def __init__(self, name: str, hand: Optional[Deck] = None) -> None:self.name = nameself.hand = Deck([]) if hand is None else handdef playable_cards(self, played: List[Card], hearts_broken: bool) -> Deck:"""List which cards in hand are playable this round"""if Card("?", "2") in self.hand:return Deck([Card("?", "2")])lead = played[0].suit if played else Noneplayable = Deck([c for c in self.hand if c.suit == lead]) or self.handif lead is None and not hearts_broken:playable = Deck([c for c in playable if c.suit != "?"])return playable or Deck(self.hand.cards)def non_winning_cards(self, played: List[Card], playable: Deck) -> Deck:"""List playable cards that are guaranteed to not win the trick"""if not played:return Deck([])lead = played[0].suitbest_card = max(c for c in played if c.suit == lead)return Deck([c for c in playable if c < best_card or c.suit != lead])def play_card(self, played: List[Card], hearts_broken: bool) -> Card:"""Play a card from a cpu player's hand"""playable = self.playable_cards(played, hearts_broken)non_winning = self.non_winning_cards(played, playable)# Strategyif non_winning:# Highest card not winning the trick, prefer pointscard = max(non_winning, key=lambda c: (c.points, c.value))elif len(played) < 3:# Lowest card maybe winning, avoid pointscard = min(playable, key=lambda c: (c.points, c.value))else:# Highest card guaranteed winning, avoid pointscard = max(playable, key=lambda c: (-c.points, c.value))self.hand.cards.remove(card)print(f"{self.name} -> {card}")return carddef has_card(self, card: Card) -> bool:return card in self.handdef __repr__(self) -> str:return f"{self.__class__.__name__}({self.name!r}, {self.hand})"class HumanPlayer(Player):def play_card(self, played: List[Card], hearts_broken: bool) -> Card:"""Play a card from a human player's hand"""playable = sorted(self.playable_cards(played, hearts_broken))p_str = " ".join(f"{n}: {c}" for n, c in enumerate(playable))np_str = " ".join(repr(c) for c in self.hand if c not in playable)print(f" {p_str} (Rest: {np_str})")while True:try:card_num = int(input(f" {self.name}, choose card: "))card = playable[card_num]except (ValueError, IndexError):passelse:breakself.hand.play(card)print(f"{self.name} => {card}")return cardclass HeartsGame:def __init__(self, *names: str) -> None:self.names = (list(names) + "P1 P2 P3 P4".split())[:4]self.players = [Player(n) for n in self.names[1:]]self.players.append(HumanPlayer(self.names[0]))def play(self) -> None:"""Play a game of Hearts until one player go bust"""score = Counter({n: 0 for n in self.names})while all(s < 100 for s in score.values()):print("\nStarting new round:")round_score = self.play_round()score.update(Counter(round_score))print("Scores:")for name, total_score in score.most_common(4):print(f"{name:<15} {round_score[name]:>3} {total_score:>3}")winners = [n for n in self.names if score[n] == min(score.values())]print(f"\n{' and '.join(winners)} won the game")def play_round(self) -> Dict[str, int]:"""Play a round of the Hearts card game"""deck = Deck.create(shuffle=True)for player, hand in zip(self.players, deck.deal(4)):player.hand.add_cards(hand.cards)start_player = next(p for p in self.players if p.has_card(Card("?", "2")))tricks = {p.name: Deck([]) for p in self.players}hearts = False# Play cards from each player's hand until emptywhile start_player.hand:played: List[Card] = []turn_order = self.player_order(start=start_player)for player in turn_order:card = player.play_card(played, hearts_broken=hearts)played.append(card)start_player = self.trick_winner(played, turn_order)tricks[start_player.name].add_cards(played)print(f"{start_player.name} wins the trick\n")hearts = hearts or any(c.suit == "?" for c in played)return self.count_points(tricks)def player_order(self, start: Optional[Player] = None) -> List[Player]:"""Rotate player order so that start goes first"""if start is None:start = random.choice(self.players)start_idx = self.players.index(start)return self.players[start_idx:] + self.players[:start_idx]@staticmethoddef trick_winner(trick: List[Card], players: List[Player]) -> Player:lead = trick[0].suitvalid = [(c.value, p) for c, p in zip(trick, players) if c.suit == lead]return max(valid)[1]@staticmethoddef count_points(tricks: Dict[str, Deck]) -> Dict[str, int]:return {n: sum(c.points for c in cards) for n, cards in tricks.items()}if __name__ == "__main__":# Read player names from the command lineplayer_names = sys.argv[1:]game = HeartsGame(*player_names)game.play()

對于上面的代碼有幾個(gè)注意點(diǎn):

對于難以使用Union或類型變量表達(dá)的類型關(guān)系比如魔法函數(shù)，可以使用@overload裝飾器。

子類對應(yīng)于子類型，因此可以在任何需要玩家的地方使用HumanPlayer。

當(dāng)子類從超類重新實(shí)現(xiàn)方法時(shí)，類型注釋必須匹配。有關(guān)示例，請參閱HumanPlayer.play_card()。

開始游戲時(shí)，你控制第一個(gè)玩家。輸入數(shù)字以選擇要玩的牌。下面是一個(gè)游戲的例子，突出顯示的線條顯示了玩家的選擇:

$python hearts.py GeirArne Aldren Joanna BradStarting new round:Brad -> ?20: ?5 1: ?Q 2: ?K (Rest: ?6 ?10 ?6 ?J ?3 ?9 ?10 ?7 ?K ?4)GeirArne, choose card: 2GeirArne => ?KAldren -> ?10Joanna -> ?9GeirArne wins the trick0: ?4 1: ?5 2: ?6 3: ?7 4: ?10 5: ?J 6: ?Q 7: ?K (Rest: ?10 ?6 ?3 ?9)GeirArne, choose card: 0GeirArne => ?4Aldren -> ?5Joanna -> ?3Brad -> ?2Aldren wins the trick...Joanna -> ?JBrad -> ?20: ?6 1: ?9 (Rest: )GeirArne, choose card: 1GeirArne => ?9Aldren -> ?AAldren wins the trickAldren -> ?AJoanna -> ?QBrad -> ?J0: ?6 (Rest: )GeirArne, choose card: 0GeirArne => ?6Aldren wins the trickScores:Brad 14 14Aldren 10 10GeirArne 1 1Joanna 1 1

當(dāng)前目前所有的typing方法的使用場景就結(jié)束了。覺得有用的朋友可以點(diǎn)個(gè)已看，或者轉(zhuǎn)發(fā)到朋友圈分享更更多好友。

總結(jié)

以上是生活随笔為你收集整理的python中函数type可以测试对象类型_python类型检测最终指南--Typing模块的使用的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。