術(shù)語對照表?

>>>?

交互式終端中默認(rèn)的 Python 提示符。往往會顯示于能以交互方式在解釋器里執(zhí)行的樣例代碼之前。

...?

具有以下含義：

• 交互式終端中輸入特殊代碼行時默認(rèn)的 Python 提示符，包括：縮進(jìn)的代碼塊，成對的分隔符之內(nèi)（圓括號、方括號、花括號或三重引號），或是指定一個裝飾器之后。

• Ellipsis 內(nèi)置常量。

2to3?

把 Python 2.x 代碼轉(zhuǎn)換為 Python 3.x 代碼的工具，通過解析源碼，遍歷解析樹，處理絕大多數(shù)檢測到的不兼容問題。

2to3 包含在標(biāo)準(zhǔn)庫中，模塊名為 lib2to3；提供了獨(dú)立入口點(diǎn) Tools/scripts/2to3。詳見 2to3 - 自動將 Python 2 代碼轉(zhuǎn)為 Python 3 代碼。

abstract base class -- 抽象基類?

抽象基類簡稱 ABC，是對 duck-typing 的補(bǔ)充，它提供了一種定義接口的新方式，相比之下其他技巧例如 hasattr() 顯得過于笨拙或有微妙錯誤（例如使用 魔術(shù)方法）。ABC 引入了虛擬子類，這種類并非繼承自其他類，但卻仍能被 isinstance() 和 issubclass() 所認(rèn)可；詳見 abc 模塊文檔。Python 自帶許多內(nèi)置的 ABC 用于實(shí)現(xiàn)數(shù)據(jù)結(jié)構(gòu)（在 collections.abc 模塊中）、數(shù)字（在 numbers 模塊中）、流（在 io 模塊中）、導(dǎo)入查找器和加載器（在 importlib.abc 模塊中）。你可以使用 abc 模塊來創(chuàng)建自己的 ABC。

annotation -- 標(biāo)注?

關(guān)聯(lián)到某個變量、類屬性、函數(shù)形參或返回值的標(biāo)簽，被約定作為 type hint 來使用。

局部變量的標(biāo)注在運(yùn)行時不可訪問，但全局變量、類屬性和函數(shù)的標(biāo)注會分別存放模塊、類和函數(shù)的 __annotations__ 特殊屬性中。

參見 variable annotation, function annotation, PEP 484 和 PEP 526，對此功能均有介紹。 另請參見 對象注解屬性的最佳實(shí)踐 了解使用標(biāo)注的最佳實(shí)踐。

argument -- 參數(shù)?

在調(diào)用函數(shù)時傳給 function （或 method ）的值。參數(shù)分為兩種：

• 關(guān)鍵字參數(shù): 在函數(shù)調(diào)用中前面帶有標(biāo)識符（例如 name=）或者作為包含在前面帶有 ** 的字典里的值傳入。舉例來說，3 和 5 在以下對 complex() 的調(diào)用中均屬于關(guān)鍵字參數(shù):

  complex(real=3, imag=5)
  complex(**{'real': 3, 'imag': 5})
  

• 位置參數(shù): 不屬于關(guān)鍵字參數(shù)的參數(shù)。位置參數(shù)可出現(xiàn)于參數(shù)列表的開頭以及/或者作為前面帶有 * 的 iterable 里的元素被傳入。舉例來說，3 和 5 在以下調(diào)用中均屬于位置參數(shù):

  complex(3, 5)
  complex(*(3, 5))
  

參數(shù)會被賦值給函數(shù)體中對應(yīng)的局部變量。有關(guān)賦值規(guī)則參見 調(diào)用 一節(jié)。根據(jù)語法，任何表達(dá)式都可用來表示一個參數(shù)；最終算出的值會被賦給對應(yīng)的局部變量。

另參見 parameter 術(shù)語表條目，常見問題中 參數(shù)與形參的區(qū)別 以及 PEP 362。

asynchronous context manager -- 異步上下文管理器?

此種對象通過定義 __aenter__() 和 __aexit__() 方法來對 async with 語句中的環(huán)境進(jìn)行控制。由 PEP 492 引入。

asynchronous generator -- 異步生成器?

返回值為 asynchronous generator iterator 的函數(shù)。它與使用 async def 定義的協(xié)程函數(shù)很相似，不同之處在于它包含 yield 表達(dá)式以產(chǎn)生一系列可在 async for 循環(huán)中使用的值。

此術(shù)語通常是指異步生成器函數(shù)，但在某些情況下則可能是指 異步生成器迭代器。如果需要清楚表達(dá)具體含義，請使用全稱以避免歧義。

一個異步生成器函數(shù)可能包含 await 表達(dá)式或者 async for 以及 async with 語句。

asynchronous generator iterator -- 異步生成器迭代器?

asynchronous generator 函數(shù)所創(chuàng)建的對象。

此對象屬于 asynchronous iterator，當(dāng)使用 __anext__() 方法調(diào)用時會返回一個可等待對象來執(zhí)行異步生成器函數(shù)的代碼直到下一個 yield 表達(dá)式。

每個 yield 會臨時暫停處理，記住當(dāng)前位置執(zhí)行狀態(tài) (包括局部變量和掛起的 try 語句)。當(dāng)該 異步生成器迭代器 與其他 __anext__() 返回的可等待對象有效恢復(fù)時，它會從離開位置繼續(xù)執(zhí)行。參見 PEP 492 和 PEP 525。

asynchronous iterable -- 異步可迭代對象?

可在 async for 語句中被使用的對象。必須通過它的 __aiter__() 方法返回一個 asynchronous iterator。由 PEP 492 引入。

asynchronous iterator -- 異步迭代器?

實(shí)現(xiàn)了 __aiter__() 和 __anext__() 方法的對象。__anext__ 必須返回一個 awaitable 對象。async for 會處理異步迭代器的 __anext__() 方法所返回的可等待對象，直到其引發(fā)一個 StopAsyncIteration 異常。由 PEP 492 引入。

attribute -- 屬性?

關(guān)聯(lián)到一個對象的值，可以使用點(diǎn)號表達(dá)式通過其名稱來引用。例如，如果一個對象 o 具有一個屬性 a，就可以用 o.a 來引用它。

awaitable -- 可等待對象?

能在 await 表達(dá)式中使用的對象?？梢允?coroutine 或是具有 __await__() 方法的對象。參見 PEP 492。

BDFL?

“終身仁慈獨(dú)裁者”的英文縮寫，即 Guido van Rossum，Python 的創(chuàng)造者。

binary file -- 二進(jìn)制文件?

file object 能夠讀寫 字節(jié)類對象。二進(jìn)制文件的例子包括以二進(jìn)制模式（'rb', 'wb' or 'rb+'）打開的文件、sys.stdin.buffer、sys.stdout.buffer 以及 io.BytesIO 和 gzip.GzipFile 的實(shí)例。

另請參見 text file 了解能夠讀寫 str 對象的文件對象。

borrowed reference -- 借入引用?

在 Python 的 C API 中，借入引用是指一種對象引用。 它不會修改對象引用計數(shù)。 如果對象被銷毀則它會成為一個無目標(biāo)指針。 例如，垃圾回收器可以移除對象的最后一個 strong reference 來銷毀它。

推薦在 borrowed reference 上調(diào)用 Py_INCREF() 以將其原地轉(zhuǎn)換為 strong reference，除非是當(dāng)該對象無法在借入引用的最后一次使用之前被銷毀。 Py_NewRef() 函數(shù)可以被用來創(chuàng)建一個新的 strong reference。

bytes-like object -- 字節(jié)類對象?

支持 緩沖協(xié)議 并且能導(dǎo)出 C-contiguous 緩沖的對象。這包括所有 bytes、bytearray 和 array.array 對象，以及許多普通 memoryview 對象。字節(jié)類對象可在多種二進(jìn)制數(shù)據(jù)操作中使用；這些操作包括壓縮、保存為二進(jìn)制文件以及通過套接字發(fā)送等。

某些操作需要可變的二進(jìn)制數(shù)據(jù)。這種對象在文檔中常被稱為“可讀寫字節(jié)類對象”?？勺兙彌_對象的例子包括 bytearray 以及 bytearray 的 memoryview。其他操作要求二進(jìn)制數(shù)據(jù)存放于不可變對象 ("只讀字節(jié)類對象")；這種對象的例子包括 bytes 以及 bytes 對象的 memoryview。

bytecode -- 字節(jié)碼?

Python 源代碼會被編譯為字節(jié)碼，即 CPython 解釋器中表示 Python 程序的內(nèi)部代碼。字節(jié)碼還會緩存在 .pyc 文件中，這樣第二次執(zhí)行同一文件時速度更快（可以免去將源碼重新編譯為字節(jié)碼）。這種 "中間語言" 運(yùn)行在根據(jù)字節(jié)碼執(zhí)行相應(yīng)機(jī)器碼的 virtual machine 之上。請注意不同 Python 虛擬機(jī)上的字節(jié)碼不一定通用，也不一定能在不同 Python 版本上兼容。

字節(jié)碼指令列表可以在 dis 模塊 的文檔中查看。

callback -- 回調(diào)?

一個作為參數(shù)被傳入以用以在未來的某個時刻被調(diào)用的子例程函數(shù)。

class -- 類?

用來創(chuàng)建用戶定義對象的模板。類定義通常包含對該類的實(shí)例進(jìn)行操作的方法定義。

class variable -- 類變量?

在類中定義的變量，并且僅限在類的層級上修改 (而不是在類的實(shí)例中修改)。

complex number -- 復(fù)數(shù)?

對普通實(shí)數(shù)系統(tǒng)的擴(kuò)展，其中所有數(shù)字都被表示為一個實(shí)部和一個虛部的和。虛數(shù)是虛數(shù)單位（-1 的平方根）的實(shí)倍數(shù)，通常在數(shù)學(xué)中寫為 i，在工程學(xué)中寫為 j。Python 內(nèi)置了對復(fù)數(shù)的支持，采用工程學(xué)標(biāo)記方式；虛部帶有一個 j 后綴，例如 3+1j。如果需要 math 模塊內(nèi)對象的對應(yīng)復(fù)數(shù)版本，請使用 cmath，復(fù)數(shù)的使用是一個比較高級的數(shù)學(xué)特性。如果你感覺沒有必要，忽略它們也幾乎不會有任何問題。

context manager -- 上下文管理器?

在 with 語句中使用，通過定義 __enter__() 和 __exit__() 方法來控制環(huán)境狀態(tài)的對象。參見 PEP 343。

context variable -- 上下文變量?

一種根據(jù)其所屬的上下文可以具有不同的值的變量。 這類似于在線程局部存儲中每個執(zhí)行線程可以具有不同的變量值。 不過，對于上下文變量來說，一個執(zhí)行線程中可能會有多個上下文，而上下文變量的主要用途是對并發(fā)異步任務(wù)中變量進(jìn)行追蹤。 參見 contextvars。

contiguous -- 連續(xù)?

一個緩沖如果是 C 連續(xù) 或 Fortran 連續(xù) 就會被認(rèn)為是連續(xù)的。零維緩沖是 C 和 Fortran 連續(xù)的。在一維數(shù)組中，所有條目必須在內(nèi)存中彼此相鄰地排列，采用從零開始的遞增索引順序。在多維 C-連續(xù)數(shù)組中，當(dāng)按內(nèi)存地址排列時用最后一個索引訪問條目時速度最快。但是在 Fortran 連續(xù)數(shù)組中則是用第一個索引最快。

coroutine -- 協(xié)程?

協(xié)程是子例程的更一般形式。 子例程可以在某一點(diǎn)進(jìn)入并在另一點(diǎn)退出。 協(xié)程則可以在許多不同的點(diǎn)上進(jìn)入、退出和恢復(fù)。 它們可通過 async def 語句來實(shí)現(xiàn)。 參見 PEP 492。

coroutine function -- 協(xié)程函數(shù)?

返回一個 coroutine 對象的函數(shù)。協(xié)程函數(shù)可通過 async def 語句來定義，并可能包含 await、async for 和 async with 關(guān)鍵字。這些特性是由 PEP 492 引入的。

CPython?

Python 編程語言的規(guī)范實(shí)現(xiàn)，在 python.org 上發(fā)布。"CPython" 一詞用于在必要時將此實(shí)現(xiàn)與其他實(shí)現(xiàn)例如 Jython 或 IronPython 相區(qū)別。

decorator -- 裝飾器?

返回值為另一個函數(shù)的函數(shù)，通常使用 @wrapper 語法形式來進(jìn)行函數(shù)變換。 裝飾器的常見例子包括 classmethod() 和 staticmethod()。

裝飾器語法只是一種語法糖，以下兩個函數(shù)定義在語義上完全等價:

def f(arg):
    ...
f = staticmethod(f)

@staticmethod
def f(arg):
    ...

同樣的概念也適用于類，但通常較少這樣使用。有關(guān)裝飾器的詳情可參見 函數(shù)定義 和 類定義 的文檔。

descriptor -- 描述器?

任何定義了 __get__(), __set__() 或 __delete__() 方法的對象。當(dāng)一個類屬性為描述器時，它的特殊綁定行為就會在屬性查找時被觸發(fā)。通常情況下，使用 a.b 來獲取、設(shè)置或刪除一個屬性時會在 a 的類字典中查找名稱為 b 的對象，但如果 b 是一個描述器，則會調(diào)用對應(yīng)的描述器方法。理解描述器的概念是更深層次理解 Python 的關(guān)鍵，因?yàn)檫@是許多重要特性的基礎(chǔ)，包括函數(shù)、方法、屬性、類方法、靜態(tài)方法以及對超類的引用等等。

有關(guān)描述器的方法的更多信息，請參閱 實(shí)現(xiàn)描述器 或 描述器使用指南。

dictionary -- 字典?

一個關(guān)聯(lián)數(shù)組，其中的任意鍵都映射到相應(yīng)的值。鍵可以是任何具有 __hash__() 和 __eq__() 方法的對象。在 Perl 語言中稱為 hash。

dictionary comprehension -- 字典推導(dǎo)式?

處理一個可迭代對象中的所有或部分元素并返回結(jié)果字典的一種緊湊寫法。 results = {n: n ** 2 for n in range(10)} 將生成一個由鍵 n 到值 n ** 2 的映射構(gòu)成的字典。 參見 列表、集合與字典的顯示。

dictionary view -- 字典視圖?

從 dict.keys(), dict.values() 和 dict.items() 返回的對象被稱為字典視圖。它們提供了字典條目的一個動態(tài)視圖，這意味著當(dāng)字典改變時，視圖也會相應(yīng)改變。要將字典視圖強(qiáng)制轉(zhuǎn)換為真正的列表，可使用 list(dictview)。參見 字典視圖對象。

docstring -- 文檔字符串?

作為類、函數(shù)或模塊之內(nèi)的第一個表達(dá)式出現(xiàn)的字符串字面值。它在代碼執(zhí)行時會被忽略，但會被解釋器識別并放入所在類、函數(shù)或模塊的 __doc__ 屬性中。由于它可用于代碼內(nèi)省，因此是對象存放文檔的規(guī)范位置。

duck-typing -- 鴨子類型?

指一種編程風(fēng)格，它并不依靠查找對象類型來確定其是否具有正確的接口，而是直接調(diào)用或使用其方法或?qū)傩裕ā翱雌饋硐聒喿?，叫起來也像鴨子，那么肯定就是鴨子?！保┯捎趶?qiáng)調(diào)接口而非特定類型，設(shè)計良好的代碼可通過允許多態(tài)替代來提升靈活性。鴨子類型避免使用 type() 或 isinstance() 檢測。(但要注意鴨子類型可以使用 抽象基類 作為補(bǔ)充。) 而往往會采用 hasattr() 檢測或是 EAFP 編程。

EAFP?

“求原諒比求許可更容易”的英文縮寫。這種 Python 常用代碼編寫風(fēng)格會假定所需的鍵或?qū)傩源嬖冢⒃诩俣ㄥe誤時捕獲異常。這種簡潔快速風(fēng)格的特點(diǎn)就是大量運(yùn)用 try 和 except 語句。于其相對的則是所謂 LBYL 風(fēng)格，常見于 C 等許多其他語言。

expression -- 表達(dá)式?

可以求出某個值的語法單元。 換句話說，一個表達(dá)式就是表達(dá)元素例如字面值、名稱、屬性訪問、運(yùn)算符或函數(shù)調(diào)用的匯總，它們最終都會返回一個值。 與許多其他語言不同，并非所有語言構(gòu)件都是表達(dá)式。 還存在不能被用作表達(dá)式的 statement，例如 while。 賦值也是屬于語句而非表達(dá)式。

extension module -- 擴(kuò)展模塊?

以 C 或 C++ 編寫的模塊，使用 Python 的 C API 來與語言核心以及用戶代碼進(jìn)行交互。

f-string -- f-字符串?

帶有 'f' 或 'F' 前綴的字符串字面值通常被稱為“f-字符串”即 格式化字符串字面值 的簡寫。參見 PEP 498。

file object -- 文件對象?

對外提供面向文件 API 以使用下層資源的對象（帶有 read() 或 write() 這樣的方法）。根據(jù)其創(chuàng)建方式的不同，文件對象可以處理對真實(shí)磁盤文件，對其他類型存儲，或是對通訊設(shè)備的訪問（例如標(biāo)準(zhǔn)輸入/輸出、內(nèi)存緩沖區(qū)、套接字、管道等等）。文件對象也被稱為 文件類對象 或 流。

實(shí)際上共有三種類別的文件對象: 原始 二進(jìn)制文件, 緩沖 二進(jìn)制文件 以及 文本文件。它們的接口定義均在 io 模塊中。創(chuàng)建文件對象的規(guī)范方式是使用 open() 函數(shù)。

file-like object -- 文件類對象?

file object 的同義詞。

filesystem encoding and error handler -- 文件系統(tǒng)編碼格式與錯誤處理句柄?

Python 用來從操作系統(tǒng)解碼字節(jié)串和向操作系統(tǒng)編碼 Unicode 的編碼格式與錯誤處理句柄。

文件系統(tǒng)編碼格式必須保證能成功解碼長度在 128 以下的所有字節(jié)串。 如果文件系統(tǒng)編碼格式無法提供此保證，則 API 函數(shù)可能會引發(fā) UnicodeError。

sys.getfilesystemencoding() 和 sys.getfilesystemencodeerrors() 函數(shù)可被用來獲取文件系統(tǒng)編碼格式與錯誤處理句柄。

filesystem encoding and error handler 是在 Python 啟動時通過 PyConfig_Read() 函數(shù)來配置的：請參閱 PyConfig 的 filesystem_encoding 和 filesystem_errors 等成員。

另請參見 locale encoding。

finder -- 查找器?

一種會嘗試查找被導(dǎo)入模塊的 loader 的對象。

從 Python 3.3 起存在兩種類型的查找器: 元路徑查找器 配合 sys.meta_path 使用，以及 path entry finders 配合 sys.path_hooks 使用。

更多詳情可參見 PEP 302, PEP 420 和 PEP 451。

floor division -- 向下取整除法?

向下舍入到最接近的整數(shù)的數(shù)學(xué)除法。向下取整除法的運(yùn)算符是 // 。例如，表達(dá)式 11 // 4 的計算結(jié)果是 2 ，而與之相反的是浮點(diǎn)數(shù)的真正除法返回 2.75 。注意 (-11) // 4 會返回 -3 因?yàn)檫@是 -2.75 向下 舍入得到的結(jié)果。見 PEP 238 。

function -- 函數(shù)?

可以向調(diào)用者返回某個值的一組語句。還可以向其傳入零個或多個 參數(shù) 并在函數(shù)體執(zhí)行中被使用。另見 parameter, method 和 函數(shù)定義 等節(jié)。

function annotation -- 函數(shù)標(biāo)注?

即針對函數(shù)形參或返回值的 annotation 。

函數(shù)標(biāo)注通常用于 類型提示：例如以下函數(shù)預(yù)期接受兩個 int 參數(shù)并預(yù)期返回一個 int 值:

def sum_two_numbers(a: int, b: int) -> int:
   return a + b

函數(shù)標(biāo)注語法的詳解見 函數(shù)定義 一節(jié)。

參見 variable annotation 和 PEP 484，其中描述了此功能。 另請參閱 對象注解屬性的最佳實(shí)踐 以了解使用標(biāo)的最佳實(shí)踐。

__future__?

future 語句, from __future__ import <feature> 指示編譯器使用將在未來的 Python 發(fā)布版中成為標(biāo)準(zhǔn)的語法和語義來編譯當(dāng)前模塊。 __future__ 模塊文檔記錄了可能 的 feature 取值。 通過導(dǎo)入此模塊并對其變量求值，你可以看到每項新特性在何時被首次加入到該語言中以及它將（或已）在何時成為默認(rèn):

>>>

>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

garbage collection -- 垃圾回收?

釋放不再被使用的內(nèi)存空間的過程。Python 是通過引用計數(shù)和一個能夠檢測和打破循環(huán)引用的循環(huán)垃圾回收器來執(zhí)行垃圾回收的?？梢允褂?gc 模塊來控制垃圾回收器。

generator -- 生成器?

返回一個 generator iterator 的函數(shù)。它看起來很像普通函數(shù)，不同點(diǎn)在于其包含 yield 表達(dá)式以便產(chǎn)生一系列值供給 for-循環(huán)使用或是通過 next() 函數(shù)逐一獲取。

通常是指生成器函數(shù)，但在某些情況下也可能是指 生成器迭代器。如果需要清楚表達(dá)具體含義，請使用全稱以避免歧義。

generator iterator -- 生成器迭代器?

generator 函數(shù)所創(chuàng)建的對象。

每個 yield 會臨時暫停處理，記住當(dāng)前位置執(zhí)行狀態(tài)（包括局部變量和掛起的 try 語句）。當(dāng)該 生成器迭代器 恢復(fù)時，它會從離開位置繼續(xù)執(zhí)行（這與每次調(diào)用都從新開始的普通函數(shù)差別很大）。

generator expression -- 生成器表達(dá)式?

返回一個迭代器的表達(dá)式。 它看起來很像普通表達(dá)式后面帶有定義了一個循環(huán)變量、范圍的 for 子句，以及一個可選的 if 子句。 以下復(fù)合表達(dá)式會為外層函數(shù)生成一系列值:

>>>

>>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
285

generic function -- 泛型函數(shù)?

為不同的類型實(shí)現(xiàn)相同操作的多個函數(shù)所組成的函數(shù)。在調(diào)用時會由調(diào)度算法來確定應(yīng)該使用哪個實(shí)現(xiàn)。

另請參見 single dispatch 術(shù)語表條目、functools.singledispatch() 裝飾器以及 PEP 443。

generic type -- 泛型類型?

A type that can be parameterized; typically a container class such as list or dict. Used for type hints and annotations.

For more details, see generic alias types, PEP 483, PEP 484, PEP 585, and the typing module.

GIL?

參見 global interpreter lock。

global interpreter lock -- 全局解釋器鎖?

CPython 解釋器所采用的一種機(jī)制，它確保同一時刻只有一個線程在執(zhí)行 Python bytecode。此機(jī)制通過設(shè)置對象模型（包括 dict 等重要內(nèi)置類型）針對并發(fā)訪問的隱式安全簡化了 CPython 實(shí)現(xiàn)。給整個解釋器加鎖使得解釋器多線程運(yùn)行更方便，其代價則是犧牲了在多處理器上的并行性。

不過，某些標(biāo)準(zhǔn)庫或第三方庫的擴(kuò)展模塊被設(shè)計為在執(zhí)行計算密集型任務(wù)如壓縮或哈希時釋放 GIL。此外，在執(zhí)行 I/O 操作時也總是會釋放 GIL。

創(chuàng)建一個（以更精細(xì)粒度來鎖定共享數(shù)據(jù)的）“自由線程”解釋器的努力從未獲得成功，因?yàn)檫@會犧牲在普通單處理器情況下的性能。據(jù)信克服這種性能問題的措施將導(dǎo)致實(shí)現(xiàn)變得更復(fù)雜，從而更難以維護(hù)。

hash-based pyc -- 基于哈希的 pyc?

使用對應(yīng)源文件的哈希值而非最后修改時間來確定其有效性的字節(jié)碼緩存文件。 參見 已緩存字節(jié)碼的失效。

hashable -- 可哈希?

一個對象的哈希值如果在其生命周期內(nèi)絕不改變，就被稱為 可哈希 （它需要具有 __hash__() 方法），并可以同其他對象進(jìn)行比較（它需要具有 __eq__() 方法）?？晒ο蟊仨毦哂邢嗤墓Ｖ当容^結(jié)果才會相同。

可哈希性使得對象能夠作為字典鍵或集合成員使用，因?yàn)檫@些數(shù)據(jù)結(jié)構(gòu)要在內(nèi)部使用哈希值。

大多數(shù) Python 中的不可變內(nèi)置對象都是可哈希的；可變?nèi)萜鳎ɡ缌斜砘蜃值洌┒疾豢晒＃徊豢勺內(nèi)萜鳎ɡ缭M和 frozenset）僅當(dāng)它們的元素均為可哈希時才是可哈希的。 用戶定義類的實(shí)例對象默認(rèn)是可哈希的。 它們在比較時一定不相同（除非是與自己比較），它們的哈希值的生成是基于它們的 id()。

IDLE?

Python 的 IDE，“集成開發(fā)與學(xué)習(xí)環(huán)境”的英文縮寫。是 Python 標(biāo)準(zhǔn)發(fā)行版附帶的基本編輯器和解釋器環(huán)境。

immutable -- 不可變對象?

具有固定值的對象。不可變對象包括數(shù)字、字符串和元組。這樣的對象不能被改變。如果必須存儲一個不同的值，則必須創(chuàng)建新的對象。它們在需要常量哈希值的地方起著重要作用，例如作為字典中的鍵。

import path -- 導(dǎo)入路徑?

由多個位置（或 路徑條目）組成的列表，會被模塊的 path based finder 用來查找導(dǎo)入目標(biāo)。在導(dǎo)入時，此位置列表通常來自 sys.path，但對次級包來說也可能來自上級包的 __path__ 屬性。

importing -- 導(dǎo)入?

令一個模塊中的 Python 代碼能為另一個模塊中的 Python 代碼所使用的過程。

importer -- 導(dǎo)入器?

查找并加載模塊的對象；此對象既屬于 finder 又屬于 loader。

interactive -- 交互?

Python 帶有一個交互式解釋器，即你可以在解釋器提示符后輸入語句和表達(dá)式，立即執(zhí)行并查看其結(jié)果。只需不帶參數(shù)地啟動 python 命令（也可以在你的計算機(jī)開始菜單中選擇相應(yīng)菜單項）。在測試新想法或檢驗(yàn)?zāi)K和包的時候用這種方式會非常方便（請記得使用 help(x)）。

interpreted -- 解釋型?

Python 一是種解釋型語言，與之相對的是編譯型語言，雖然兩者的區(qū)別由于字節(jié)碼編譯器的存在而會有所模糊。這意味著源文件可以直接運(yùn)行而不必顯式地創(chuàng)建可執(zhí)行文件再運(yùn)行。解釋型語言通常具有比編譯型語言更短的開發(fā)/調(diào)試周期，但是其程序往往運(yùn)行得更慢。參見 interactive。

interpreter shutdown -- 解釋器關(guān)閉?

當(dāng)被要求關(guān)閉時，Python 解釋器將進(jìn)入一個特殊運(yùn)行階段并逐步釋放所有已分配資源，例如模塊和各種關(guān)鍵內(nèi)部結(jié)構(gòu)等。它還會多次調(diào)用 垃圾回收器。這會觸發(fā)用戶定義析構(gòu)器或弱引用回調(diào)中的代碼執(zhí)行。在關(guān)閉階段執(zhí)行的代碼可能會遇到各種異常，因?yàn)槠渌蕾嚨馁Y源已不再有效（常見的例子有庫模塊或警告機(jī)制等）。

解釋器需要關(guān)閉的主要原因有 __main__ 模塊或所運(yùn)行的腳本已完成執(zhí)行。

iterable -- 可迭代對象?

An object capable of returning its members one at a time. Examples of iterables include all sequence types (such as list, str, and tuple) and some non-sequence types like dict, file objects, and objects of any classes you define with an __iter__() method or with a __getitem__() method that implements sequence semantics.

可迭代對象被可用于 for 循環(huán)以及許多其他需要一個序列的地方（zip()、map() ...）。當(dāng)一個可迭代對象作為參數(shù)傳給內(nèi)置函數(shù) iter() 時，它會返回該對象的迭代器。這種迭代器適用于對值集合的一次性遍歷。在使用可迭代對象時，你通常不需要調(diào)用 iter() 或者自己處理迭代器對象。for 語句會為你自動處理那些操作，創(chuàng)建一個臨時的未命名變量用來在循環(huán)期間保存迭代器。參見 iterator、sequence 以及 generator。

iterator -- 迭代器?

用來表示一連串?dāng)?shù)據(jù)流的對象。重復(fù)調(diào)用迭代器的 __next__() 方法（或?qū)⑵鋫鹘o內(nèi)置函數(shù) next()）將逐個返回流中的項。當(dāng)沒有數(shù)據(jù)可用時則將引發(fā) StopIteration 異常。到這時迭代器對象中的數(shù)據(jù)項已耗盡，繼續(xù)調(diào)用其 __next__() 方法只會再次引發(fā) StopIteration 異常。迭代器必須具有 __iter__() 方法用來返回該迭代器對象自身，因此迭代器必定也是可迭代對象，可被用于其他可迭代對象適用的大部分場合。一個顯著的例外是那些會多次重復(fù)訪問迭代項的代碼。容器對象（例如 list）在你每次向其傳入 iter() 函數(shù)或是在 for 循環(huán)中使用它時都會產(chǎn)生一個新的迭代器。如果在此情況下你嘗試用迭代器則會返回在之前迭代過程中被耗盡的同一迭代器對象，使其看起來就像是一個空容器。

更多信息可查看 迭代器類型。

CPython implementation detail: CPython does not consistently apply the requirement that an iterator define __iter__().

key function -- 鍵函數(shù)?

鍵函數(shù)或稱整理函數(shù)，是能夠返回用于排序或排位的值的可調(diào)用對象。例如，locale.strxfrm() 可用于生成一個符合特定區(qū)域排序約定的排序鍵。

Python 中有許多工具都允許用鍵函數(shù)來控制元素的排位或分組方式。其中包括 min(), max(), sorted(), list.sort(), heapq.merge(), heapq.nsmallest(), heapq.nlargest() 以及 itertools.groupby()。

There are several ways to create a key function. For example. the str.lower() method can serve as a key function for case insensitive sorts. Alternatively, a key function can be built from a lambda expression such as lambda r: (r[0], r[2]). Also, operator.attrgetter(), operator.itemgetter(), and operator.methodcaller() are three key function constructors. See the Sorting HOW TO for examples of how to create and use key functions.

keyword argument -- 關(guān)鍵字參數(shù)?

參見 argument。

lambda?

由一個單獨(dú) expression 構(gòu)成的匿名內(nèi)聯(lián)函數(shù)，表達(dá)式會在調(diào)用時被求值。創(chuàng)建 lambda 函數(shù)的句法為 lambda [parameters]: expression

LBYL?

“先查看后跳躍”的英文縮寫。這種代碼編寫風(fēng)格會在進(jìn)行調(diào)用或查找之前顯式地檢查前提條件。此風(fēng)格與 EAFP 方式恰成對比，其特點(diǎn)是大量使用 if 語句。

在多線程環(huán)境中，LBYL 方式會導(dǎo)致“查看”和“跳躍”之間發(fā)生條件競爭風(fēng)險。例如，以下代碼 if key in mapping: return mapping[key] 可能由于在檢查操作之后其他線程從 mapping 中移除了 key 而出錯。這種問題可通過加鎖或使用 EAFP 方式來解決。

locale encoding -- 語言區(qū)域編碼格式?

On Unix, it is the encoding of the LC_CTYPE locale. It can be set with locale.setlocale(locale.LC_CTYPE, new_locale).

On Windows, it is the ANSI code page (ex: "cp1252").

On Android and VxWorks, Python uses "utf-8" as the locale encoding.

locale.getencoding() can be used to get the locale encoding.

See also the filesystem encoding and error handler.

list -- 列表?

Python 內(nèi)置的一種 sequence。雖然名為列表，但更類似于其他語言中的數(shù)組而非鏈接列表，因?yàn)樵L問元素的時間復(fù)雜度為 O(1)。

list comprehension -- 列表推導(dǎo)式?

處理一個序列中的所有或部分元素并返回結(jié)果列表的一種緊湊寫法。result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] 將生成一個 0 到 255 范圍內(nèi)的十六進(jìn)制偶數(shù)對應(yīng)字符串（0x..）的列表。其中 if 子句是可選的，如果省略則 range(256) 中的所有元素都會被處理。

loader -- 加載器?

負(fù)責(zé)加載模塊的對象。它必須定義名為 load_module() 的方法。加載器通常由一個 finder 返回。詳情參見 PEP 302，對于 abstract base class 可參見 importlib.abc.Loader。

magic method -- 魔術(shù)方法?

special method 的非正式同義詞 。

mapping -- 映射?

A container object that supports arbitrary key lookups and implements the methods specified in the collections.abc.Mapping or collections.abc.MutableMapping abstract base classes. Examples include dict, collections.defaultdict, collections.OrderedDict and collections.Counter.

meta path finder -- 元路徑查找器?

sys.meta_path 的搜索所返回的 finder。元路徑查找器與 path entry finders 存在關(guān)聯(lián)但并不相同。

請查看 importlib.abc.MetaPathFinder 了解元路徑查找器所實(shí)現(xiàn)的方法。

metaclass -- 元類?

一種用于創(chuàng)建類的類。類定義包含類名、類字典和基類列表。元類負(fù)責(zé)接受上述三個參數(shù)并創(chuàng)建相應(yīng)的類。大部分面向?qū)ο蟮木幊陶Z言都會提供一個默認(rèn)實(shí)現(xiàn)。Python 的特別之處在于可以創(chuàng)建自定義元類。大部分用戶永遠(yuǎn)不需要這個工具，但當(dāng)需要出現(xiàn)時，元類可提供強(qiáng)大而優(yōu)雅的解決方案。它們已被用于記錄屬性訪問日志、添加線程安全性、跟蹤對象創(chuàng)建、實(shí)現(xiàn)單例，以及其他許多任務(wù)。

更多詳情參見 元類。

method -- 方法?

在類內(nèi)部定義的函數(shù)。如果作為該類的實(shí)例的一個屬性來調(diào)用，方法將會獲取實(shí)例對象作為其第一個 argument (通常命名為 self)。參見 function 和 nested scope。

method resolution order -- 方法解析順序?

方法解析順序就是在查找成員時搜索全部基類所用的先后順序。請查看 Python 2.3 方法解析順序 了解自 2.3 版起 Python 解析器所用相關(guān)算法的詳情。

module -- 模塊?

此對象是 Python 代碼的一種組織單位。各模塊具有獨(dú)立的命名空間，可包含任意 Python 對象。模塊可通過 importing 操作被加載到 Python 中。

另見 package。

module spec -- 模塊規(guī)格?

一個命名空間，其中包含用于加載模塊的相關(guān)導(dǎo)入信息。是 importlib.machinery.ModuleSpec 的實(shí)例。

MRO?

參見 method resolution order。

mutable -- 可變對象?

可變對象可以在其 id() 保持固定的情況下改變其取值。另請參見 immutable。

named tuple -- 具名元組?

術(shù)語“具名元組”可用于任何繼承自元組，并且其中的可索引元素還能使用名稱屬性來訪問的類型或類。 這樣的類型或類還可能擁有其他特性。

有些內(nèi)置類型屬于具名元組，包括 time.localtime() 和 os.stat() 的返回值。 另一個例子是 sys.float_info:

>>>

>>> sys.float_info[1]                   # indexed access
1024
>>> sys.float_info.max_exp              # named field access
1024
>>> isinstance(sys.float_info, tuple)   # kind of tuple
True

有些具名元組是內(nèi)置類型（例如上面的例子）。 此外，具名元組還可通過常規(guī)類定義從 tuple 繼承并定義名稱字段的方式來創(chuàng)建。 這樣的類可以手工編寫，或者使用工廠函數(shù) collections.namedtuple() 創(chuàng)建。 后一種方式還會添加一些手工編寫或內(nèi)置具名元組所沒有的額外方法。

namespace -- 命名空間?

命名空間是存放變量的場所。命名空間有局部、全局和內(nèi)置的，還有對象中的嵌套命名空間（在方法之內(nèi)）。命名空間通過防止命名沖突來支持模塊化。例如，函數(shù) builtins.open 與 os.open() 可通過各自的命名空間來區(qū)分。命名空間還通過明確哪個模塊實(shí)現(xiàn)那個函數(shù)來幫助提高可讀性和可維護(hù)性。例如，random.seed() 或 itertools.islice() 這種寫法明確了這些函數(shù)是由 random 與 itertools 模塊分別實(shí)現(xiàn)的。

namespace package -- 命名空間包?

PEP 420 所引入的一種僅被用作子包的容器的 package，命名空間包可以沒有實(shí)體表示物，其描述方式與 regular package 不同，因?yàn)樗鼈儧]有 __init__.py 文件。

另可參見 module。

nested scope -- 嵌套作用域?

在一個定義范圍內(nèi)引用變量的能力。例如，在另一函數(shù)之內(nèi)定義的函數(shù)可以引用前者的變量。請注意嵌套作用域默認(rèn)只對引用有效而對賦值無效。局部變量的讀寫都受限于最內(nèi)層作用域。類似的，全局變量的讀寫則作用于全局命名空間。通過 nonlocal 關(guān)鍵字可允許寫入外層作用域。

new-style class -- 新式類?

對于目前已被應(yīng)于所有類對象的類形式的舊稱謂。在早先的 Python 版本中，只有新式類能夠使用 Python 新增的更靈活特性，例如 __slots__、描述符、特征屬性、__getattribute__()、類方法和靜態(tài)方法等。

object -- 對象?

任何具有狀態(tài)（屬性或值）以及預(yù)定義行為（方法）的數(shù)據(jù)。object 也是任何 new-style class 的最頂層基類名。

package -- 包?

一種可包含子模塊或遞歸地包含子包的 Python module。從技術(shù)上說，包是帶有 __path__ 屬性的 Python 模塊。

另參見 regular package 和 namespace package。

parameter -- 形參?

function （或方法）定義中的命名實(shí)體，它指定函數(shù)可以接受的一個 argument （或在某些情況下，多個實(shí)參）。有五種形參：

• positional-or-keyword：位置或關(guān)鍵字，指定一個可以作為 位置參數(shù) 傳入也可以作為 關(guān)鍵字參數(shù) 傳入的實(shí)參。這是默認(rèn)的形參類型，例如下面的 foo 和 bar:

  def func(foo, bar=None): ...
  

• positional-only：僅限位置，指定一個只能通過位置傳入的參數(shù)。 僅限位置形參可通過在函數(shù)定義的形參列表中它們之后包含一個 / 字符來定義，例如下面的 posonly1 和 posonly2:

  def func(posonly1, posonly2, /, positional_or_keyword): ...
  

• keyword-only：僅限關(guān)鍵字，指定一個只能通過關(guān)鍵字傳入的參數(shù)。僅限關(guān)鍵字形參可通過在函數(shù)定義的形參列表中包含單個可變位置形參或者在多個可變位置形參之前放一個 * 來定義，例如下面的 kw_only1 和 kw_only2:

  def func(arg, *, kw_only1, kw_only2): ...
  

• var-positional：可變位置，指定可以提供由一個任意數(shù)量的位置參數(shù)構(gòu)成的序列（附加在其他形參已接受的位置參數(shù)之后）。這種形參可通過在形參名稱前加綴 * 來定義，例如下面的 args:

  def func(*args, **kwargs): ...
  

• var-keyword：可變關(guān)鍵字，指定可以提供任意數(shù)量的關(guān)鍵字參數(shù)（附加在其他形參已接受的關(guān)鍵字參數(shù)之后）。這種形參可通過在形參名稱前加綴 ** 來定義，例如上面的 kwargs。

形參可以同時指定可選和必選參數(shù)，也可以為某些可選參數(shù)指定默認(rèn)值。

另參見 argument 術(shù)語表條目、參數(shù)與形參的區(qū)別 中的常見問題、inspect.Parameter 類、函數(shù)定義 一節(jié)以及 PEP 362。

path entry -- 路徑入口?

import path 中的一個單獨(dú)位置，會被 path based finder 用來查找要導(dǎo)入的模塊。

path entry finder -- 路徑入口查找器?

任一可調(diào)用對象使用 sys.path_hooks (即 path entry hook) 返回的 finder，此種對象能通過 path entry 來定位模塊。

請參看 importlib.abc.PathEntryFinder 以了解路徑入口查找器所實(shí)現(xiàn)的各個方法。

path entry hook -- 路徑入口鉤子?

一種可調(diào)用對象，在知道如何查找特定 path entry 中的模塊的情況下能夠使用 sys.path_hook 列表返回一個 path entry finder。

path based finder -- 基于路徑的查找器?

默認(rèn)的一種 元路徑查找器，可在一個 import path 中查找模塊。

path-like object -- 路徑類對象?

代表一個文件系統(tǒng)路徑的對象。類路徑對象可以是一個表示路徑的 str 或者 bytes 對象，還可以是一個實(shí)現(xiàn)了 os.PathLike 協(xié)議的對象。一個支持 os.PathLike 協(xié)議的對象可通過調(diào)用 os.fspath() 函數(shù)轉(zhuǎn)換為 str 或者 bytes 類型的文件系統(tǒng)路徑；os.fsdecode() 和 os.fsencode() 可被分別用來確保獲得 str 或 bytes 類型的結(jié)果。此對象是由 PEP 519 引入的。

PEP?

“Python 增強(qiáng)提議”的英文縮寫。一個 PEP 就是一份設(shè)計文檔，用來向 Python 社區(qū)提供信息，或描述一個 Python 的新增特性及其進(jìn)度或環(huán)境。PEP 應(yīng)當(dāng)提供精確的技術(shù)規(guī)格和所提議特性的原理說明。

PEP 應(yīng)被作為提出主要新特性建議、收集社區(qū)對特定問題反饋以及為必須加入 Python 的設(shè)計決策編寫文檔的首選機(jī)制。PEP 的作者有責(zé)任在社區(qū)內(nèi)部建立共識，并應(yīng)將不同意見也記入文檔。

參見 PEP 1。

portion -- 部分?

構(gòu)成一個命名空間包的單個目錄內(nèi)文件集合（也可能存放于一個 zip 文件內(nèi)），具體定義見 PEP 420。

positional argument -- 位置參數(shù)?

參見 argument。

provisional API -- 暫定 API?

暫定 API 是指被有意排除在標(biāo)準(zhǔn)庫的向后兼容性保證之外的應(yīng)用編程接口。雖然此類接口通常不會再有重大改變，但只要其被標(biāo)記為暫定，就可能在核心開發(fā)者確定有必要的情況下進(jìn)行向后不兼容的更改（甚至包括移除該接口）。此種更改并不會隨意進(jìn)行 -- 僅在 API 被加入之前未考慮到的嚴(yán)重基礎(chǔ)性缺陷被發(fā)現(xiàn)時才可能會這樣做。

即便是對暫定 API 來說，向后不兼容的更改也會被視為“最后的解決方案” —— 任何問題被確認(rèn)時都會盡可能先嘗試找到一種向后兼容的解決方案。

這種處理過程允許標(biāo)準(zhǔn)庫持續(xù)不斷地演進(jìn)，不至于被有問題的長期性設(shè)計缺陷所困。詳情見 PEP 411。

provisional package -- 暫定包?

參見 provisional API。

Python 3000?

Python 3.x 發(fā)布路線的昵稱（這個名字在版本 3 的發(fā)布還遙遙無期的時候就已出現(xiàn)了）。有時也被縮寫為“Py3k”。

Pythonic?

指一個思路或一段代碼緊密遵循了 Python 語言最常用的風(fēng)格和理念，而不是使用其他語言中通用的概念來實(shí)現(xiàn)代碼。例如，Python 的常用風(fēng)格是使用 for 語句循環(huán)來遍歷一個可迭代對象中的所有元素。許多其他語言沒有這樣的結(jié)構(gòu)，因此不熟悉 Python 的人有時會選擇使用一個數(shù)字計數(shù)器:

for i in range(len(food)):
    print(food[i])

而相應(yīng)的更簡潔更 Pythonic 的方法是這樣的:

for piece in food:
    print(piece)

qualified name -- 限定名稱?

一個以點(diǎn)號分隔的名稱，顯示從模塊的全局作用域到該模塊中定義的某個類、函數(shù)或方法的“路徑”，相關(guān)定義見 PEP 3155。對于最高層級的函數(shù)和類，限定名稱與對象名稱一致:

>>>

>>> class C:
...     class D:
...         def meth(self):
...             pass
...
>>> C.__qualname__
'C'
>>> C.D.__qualname__
'C.D'
>>> C.D.meth.__qualname__
'C.D.meth'

當(dāng)被用于引用模塊時，完整限定名稱 意為標(biāo)示該模塊的以點(diǎn)號分隔的整個路徑，其中包含其所有的父包，例如 email.mime.text:

>>>

>>> import email.mime.text
>>> email.mime.text.__name__
'email.mime.text'

reference count -- 引用計數(shù)?

The number of references to an object. When the reference count of an object drops to zero, it is deallocated. Reference counting is generally not visible to Python code, but it is a key element of the CPython implementation. Programmers can call the sys.getrefcount() function to return the reference count for a particular object.

regular package -- 常規(guī)包?

傳統(tǒng)型的 package，例如包含有一個 __init__.py 文件的目錄。

另參見 namespace package。

__slots__?

一種寫在類內(nèi)部的聲明，通過預(yù)先聲明實(shí)例屬性等對象并移除實(shí)例字典來節(jié)省內(nèi)存。雖然這種技巧很流行，但想要用好卻并不容易，最好是只保留在少數(shù)情況下采用，例如極耗內(nèi)存的應(yīng)用程序，并且其中包含大量實(shí)例。

sequence -- 序列?

一種 iterable，它支持通過 __getitem__() 特殊方法來使用整數(shù)索引進(jìn)行高效的元素訪問，并定義了一個返回序列長度的 __len__() 方法。內(nèi)置的序列類型有 list、str、tuple 和 bytes。注意雖然 dict 也支持 __getitem__() 和 __len__()，但它被認(rèn)為屬于映射而非序列，因?yàn)樗檎視r使用任意的 immutable 鍵而非整數(shù)。

collections.abc.Sequence 抽象基類定義了一個更豐富的接口，它在 __getitem__() 和 __len__() 之外又添加了 count(), index(), __contains__() 和 __reversed__()。 實(shí)現(xiàn)此擴(kuò)展接口的類型可以使用 register() 來顯式地注冊。

set comprehension -- 集合推導(dǎo)式?

處理一個可迭代對象中的所有或部分元素并返回結(jié)果集合的一種緊湊寫法。 results = {c for c in 'abracadabra' if c not in 'abc'} 將生成字符串集合 {'r', 'd'}。 參見 列表、集合與字典的顯示。

single dispatch -- 單分派?

一種 generic function 分派形式，其實(shí)現(xiàn)是基于單個參數(shù)的類型來選擇的。

slice -- 切片?

通常只包含了特定 sequence 的一部分的對象。切片是通過使用下標(biāo)標(biāo)記來創(chuàng)建的，在 [] 中給出幾個以冒號分隔的數(shù)字，例如 variable_name[1:3:5]。方括號（下標(biāo)）標(biāo)記在內(nèi)部使用 slice 對象。

special method -- 特殊方法?

一種由 Python 隱式調(diào)用的方法，用來對某個類型執(zhí)行特定操作例如相加等等。這種方法的名稱的首尾都為雙下劃線。特殊方法的文檔參見 特殊方法名稱。

statement -- 語句?

語句是程序段（一個代碼“塊”）的組成單位。一條語句可以是一個 expression 或某個帶有關(guān)鍵字的結(jié)構(gòu)，例如 if、while 或 for。

strong reference -- 強(qiáng)引用?

在 Python 的 C API 中，強(qiáng)引用是對象引用的一種，當(dāng)它被創(chuàng)建時將會增加對象引用計數(shù)而當(dāng)它被刪除時則會減少對象引用計數(shù)。

Py_NewRef() 函數(shù)可被用于創(chuàng)建一個對象的強(qiáng)引用。 通常，必須在退出某個強(qiáng)引用的作用域時在該強(qiáng)引用上調(diào)用 Py_DECREF() 函數(shù)，以避免引用的泄漏。

另請參閱 borrowed reference。

text encoding -- 文本編碼?

A string in Python is a sequence of Unicode code points (in range U+0000--U+10FFFF). To store or transfer a string, it needs to be serialized as a sequence of bytes.

Serializing a string into a sequence of bytes is known as "encoding", and recreating the string from the sequence of bytes is known as "decoding".

There are a variety of different text serialization codecs, which are collectively referred to as "text encodings".

text file -- 文本文件?

一種能夠讀寫 str 對象的 file object。通常一個文本文件實(shí)際是訪問一個面向字節(jié)的數(shù)據(jù)流并自動處理 text encoding。文本文件的例子包括以文本模式（'r' 或 'w'）打開的文件、sys.stdin、sys.stdout 以及 io.StringIO 的實(shí)例。

另請參看 binary file 了解能夠讀寫 字節(jié)類對象 的文件對象。

triple-quoted string -- 三引號字符串?

首尾各帶三個連續(xù)雙引號（"）或者單引號（'）的字符串。它們在功能上與首尾各用一個引號標(biāo)注的字符串沒有什么不同，但是有多種用處。它們允許你在字符串內(nèi)包含未經(jīng)轉(zhuǎn)義的單引號和雙引號，并且可以跨越多行而無需使用連接符，在編寫文檔字符串時特別好用。

type -- 類型?

類型決定一個 Python 對象屬于什么種類；每個對象都具有一種類型。要知道對象的類型，可以訪問它的 __class__ 屬性，或是通過 type(obj) 來獲取。

type alias -- 類型別名?

一個類型的同義詞，創(chuàng)建方式是把類型賦值給特定的標(biāo)識符。

類型別名的作用是簡化 類型提示。例如:

def remove_gray_shades(
        colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
    pass

可以這樣提高可讀性:

Color = tuple[int, int, int]

def remove_gray_shades(colors: list[Color]) -> list[Color]:
    pass

參見 typing 和 PEP 484，其中有對此功能的詳細(xì)描述。

type hint -- 類型提示?

annotation 為變量、類屬性、函數(shù)的形參或返回值指定預(yù)期的類型。

類型提示屬于可選項，Python 不要求提供，但其可對靜態(tài)類型分析工具起作用，并可協(xié)助 IDE 實(shí)現(xiàn)代碼補(bǔ)全與重構(gòu)。

全局變量、類屬性和函數(shù)的類型提示可以使用 typing.get_type_hints() 來訪問，但局部變量則不可以。

參見 typing 和 PEP 484，其中有對此功能的詳細(xì)描述。

universal newlines -- 通用換行?

一種解讀文本流的方式，將以下所有符號都識別為行結(jié)束標(biāo)志：Unix 的行結(jié)束約定 '\n'、Windows 的約定 '\r\n' 以及舊版 Macintosh 的約定 '\r'。參見 PEP 278 和 PEP 3116 和 bytes.splitlines() 了解更多用法說明。

variable annotation -- 變量標(biāo)注?

對變量或類屬性的 annotation。

在標(biāo)注變量或類屬性時，還可選擇為其賦值:

class C:
    field: 'annotation'

變量標(biāo)注通常被用作 類型提示：例如以下變量預(yù)期接受 int 類型的值:

count: int = 0

變量標(biāo)注語法的詳細(xì)解釋見 帶標(biāo)注的賦值語句 一節(jié)。

參見 function annotation, PEP 484 和 PEP 526，其中描述了此功能。 另請參閱 對象注解屬性的最佳實(shí)踐 以了解使用標(biāo)注的最佳實(shí)踐。

virtual environment -- 虛擬環(huán)境?

一種采用協(xié)作式隔離的運(yùn)行時環(huán)境，允許 Python 用戶和應(yīng)用程序在安裝和升級 Python 分發(fā)包時不會干擾到同一系統(tǒng)上運(yùn)行的其他 Python 應(yīng)用程序的行為。

另參見 venv。

virtual machine -- 虛擬機(jī)?

一臺完全通過軟件定義的計算機(jī)。Python 虛擬機(jī)可執(zhí)行字節(jié)碼編譯器所生成的 bytecode。

Zen of Python -- Python 之禪?

列出 Python 設(shè)計的原則與哲學(xué)，有助于理解與使用這種語言。查看其具體內(nèi)容可在交互模式提示符中輸入 "import this"。