python術語對照表

術語對照表

- >>>

交互式終端中默認的 Python 提示符。每每會顯示於能以交互方式在解釋器裏執行的樣例代碼以前。

- ...

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

- 2to3

一個將 Python 2.x 代碼轉換爲 Python 3.x 代碼的工具，可以處理大部分經過解析源碼並遍歷解析樹可檢測到的不兼容問題。

2to3 包含在標準庫中，模塊名爲 lib2to3；並提供一個獨立入口點 Tools/scripts/2to3。參見 2to3 - 自動將 Python 2 代碼轉爲 Python 3 代碼。

- abstract base class -- 抽象基類

抽象基類簡稱 ABC，是對 duck-typing 的補充，它提供了一種定義接口的新方式，相比之下其餘技巧例如 hasattr() 顯得過於笨拙或有微妙錯誤（例如使用 魔術方法）。ABC 引入了虛擬子類，這種類並不是繼承自其餘類，但卻仍能被 isinstance() 和 issubclass() 所承認；詳見 abc 模塊文檔。Python 自帶許多內置的 ABC 用於實現數據結構（在 collections.abc 模塊中）、數字（在 numbers 模塊中）、流（在 io 模塊中）、導入查找器和加載器（在 importlib.abc 模塊中）。你可使用 abc 模塊來建立本身的 ABC。

- annotation -- 標註

關聯到某個變量、類屬性、函數形參或返回值的標籤，被約定做爲 type hint 來使用。

局部變量的標註在運行時不可訪問，但全局變量、類屬性和函數的標註會分別存放模塊、類和函數的 __annotations__ 特殊屬性中。

參見 variable annotation、function annotation、PEP 484 和 PEP 526，對此功能均有介紹。

- argument -- 參數

在調用函數時傳給 function （或 method ）的值。參數分爲兩種：

• 關鍵字參數: 在函數調用中前面帶有標識符（例如 name=）或者做爲包含在前面帶有 ** 的字典裏的值傳入。舉例來講，3 和 5 在如下對 complex() 的調用中均屬於關鍵字參數:

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

• 位置參數: 不屬於關鍵字參數的參數。位置參數可出現於參數列表的開頭以及/或者做爲前面帶有 * 的 iterable 裏的元素被傳入。舉例來講，3 和 5 在如下調用中均屬於位置參數:

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

參數會被賦值給函數體中對應的局部變量。有關賦值規則參見 調用 一節。根據語法，任何表達式均可用來表示一個參數；最終算出的值會被賦給對應的局部變量。

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

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

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

- asynchronous generator -- 異步生成器

返回值爲 asynchronous generator iterator 的函數。它與使用 async def 定義的協程函數很類似，不一樣之處在於它包含 yield 表達式以產生一系列可在 async for 循環中使用的值。

此術語一般是指異步生成器函數，但在某些狀況下則多是指 異步生成器迭代器。若是須要清楚表達具體含義，請使用全稱以免歧義。

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

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

asynchronous generator 函數所建立的對象。

此對象屬於 asynchronous iterator，當使用 __anext__() 方法調用時會返回一個可等待對象來執行異步生成器函數的代碼直到下一個 yield 表達式。

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

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

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

- asynchronous iterator -- 異步迭代器

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

- attribute -- 屬性

關聯到一個對象的值，可使用點號表達式經過其名稱來引用。例如，若是一個對象 o 具備一個屬性 a，就能夠用 o.a 來引用它。

- awaitable -- 可等待對象

能在 await 表達式中使用的對象。能夠是 coroutine 或是具備 __await__() 方法的對象。參見 PEP 492。

- BDFL

「終身仁慈獨裁者」的英文縮寫，即 Guido van Rossum，Python 的創造者。

- binary file -- 二進制文件

file object 可以讀寫 字節類對象。二進制文件的例子包括以二進制模式（'rb', 'wb' or 'rb+'）打開的文件、sys.stdin.buffer、sys.stdout.buffer 以及 io.BytesIO 和 gzip.GzipFile 的實例。

另請參見 text file 瞭解可以讀寫 str 對象的文件對象。

- bytes-like object -- 字節類對象

支持 緩衝協議 而且能導出 C-contiguous 緩衝的對象。這包括全部 bytes、bytearray 和 array.array 對象，以及許多普通 memoryview 對象。字節類對象可在多種二進制數據操做中使用；這些操做包括壓縮、保存爲二進制文件以及經過套接字發送等。

某些操做須要可變的二進制數據。這種對象在文檔中常被稱爲「可讀寫字節類對象」。可變緩衝對象的例子包括 bytearray 以及 bytearray 的 memoryview。其餘操做要求二進制數據存放於不可變對象 ("只讀字節類對象")；這種對象的例子包括 bytes 以及 bytes 對象的 memoryview。

- bytecode -- 字節碼

Python 源代碼會被編譯爲字節碼，即 CPython 解釋器中表示 Python 程序的內部代碼。字節碼還會緩存在 .pyc 文件中，這樣第二次執行同一文件時速度更快（能夠免去將源碼從新編譯爲字節碼）。這種 "中間語言" 運行在根據字節碼執行相應機器碼的 virtual machine 之上。請注意不一樣 Python 虛擬機上的字節碼不必定通用，也不必定能在不一樣 Python 版本上兼容。

字節碼指令列表能夠在 dis 模塊 的文檔中查看。

- class -- 類

用來建立用戶定義對象的模板。類定義一般包含對該類的實例進行操做的方法定義。

- class variable -- 類變量

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

- coercion -- 強制類型轉換

在包含兩個相同類型參數的操做中，一種類型的實例隱式地轉換爲另外一種類型。例如，int(3.15) 是將原浮點數轉換爲整型數 3，但在 3+4.5 中，參數的類型不一致（一個是 int, 一個是 float），二者必須轉換爲相同類型才能相加，不然將引起 TypeError。若是沒有強制類型轉換機制，程序員必須將全部可兼容參數歸一化爲相同類型，例如要寫成 float(3)+4.5 而不是 3+4.5。

- complex number -- 複數

對普通實數系統的擴展，其中全部數字都被表示爲一個實部和一個虛部的和。虛數是虛數單位（-1 的平方根）的實倍數，一般在數學中寫爲 i，在工程學中寫爲 j。Python 內置了對複數的支持，採用工程學標記方式；虛部帶有一個 j 後綴，例如 3+1j。若是須要 math 模塊內對象的對應複數版本，請使用 cmath，複數的使用是一個比較高級的數學特性。若是你感受沒有必要，忽略它們也幾乎不會有任何問題。

- context manager -- 上下文管理器

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

- context variable -- 上下文變量

一種根據其所屬的上下文能夠具備不一樣的值的變量。 這相似於在線程局部存儲中每一個執行線程能夠具備不一樣的變量值。 不過，對於上下文變量來講，一個執行線程中可能會有多個上下文，而上下文變量的主要用途是對併發異步任務中變量進行追蹤。 參見 contextvars。

- contiguous -- 連續

一個緩衝若是是 C 連續 或 Fortran 連續 就會被認爲是連續的。零維緩衝是 C 和 Fortran 連續的。在一維數組中，全部條目必須在內存中彼此相鄰地排列，採用從零開始的遞增索引順序。在多維 C-連續數組中，當按內存地址排列時用最後一個索引訪問條目時速度最快。可是在 Fortran 連續數組中則是用第一個索引最快。

- coroutine -- 協程

協程是子例程的更通常形式。子例程能夠在某一點進入並在另外一點退出。協程則能夠在許多不一樣的點上進入、退出和恢復。它們可經過 async def 語句來實現。參見 PEP 492。

- coroutine function -- 協程函數

返回一個 coroutine 對象的函數。協程函數可經過 async def 語句來定義，並可能包含 await、async for 和 async with 關鍵字。這些特性是由 PEP 492 引入的。

- CPython

Python 編程語言的規範實現，在 python.org 上發佈。"CPython" 一詞用於在必要時將此實現與其餘實現例如 Jython 或 IronPython 相區別。

- decorator -- 裝飾器

返回值爲另外一個函數的函數，一般使用 @wrapper 語法形式來進行函數變換。 裝飾器的常見例子包括 classmethod() 和 staticmethod()。

裝飾器語法只是一種語法糖，如下兩個函數定義在語義上徹底等價:

```python
def f(...): ... f = staticmethod(f) @staticmethod def f(...): ...
```

同的樣概念也適用於類，但一般較少這樣使用。有關裝飾器的詳情可參見 函數定義 和 類定義 的文檔。

- descriptor -- 描述器

任何定義了 __get__(), __set__() 或 __delete__() 方法的對象。當一個類屬性爲描述器時，它的特殊綁定行爲就會在屬性查找時被觸發。一般狀況下，使用 a.b 來獲取、設置或刪除一個屬性時會在 a 的類字典中查找名稱爲 b 的對象，但若是 b 是一個描述器，則會調用對應的描述器方法。理解描述器的概念是更深層次理解 Python 的關鍵，由於這是許多重要特性的基礎，包括函數、方法、屬性、類方法、靜態方法以及對超類的引用等等。

有關描述符的方法的詳情可參看 實現描述器。

- dictionary -- 字典

一個關聯數組，其中的任意鍵都映射到相應的值。鍵能夠是任何具備 __hash__() 和 __eq__() 方法的對象。在 Perl 語言中稱爲 hash。

- dictionary view -- 字典視圖

從 dict.keys(), dict.values() 和 dict.items() 返回的對象被稱爲字典視圖。它們提供了字典條目的一個動態視圖，這意味着當字典改變時，視圖也會相應改變。要將字典視圖強制轉換爲真正的列表，可以使用 list(dictview)。參見 字典視圖對象。

- docstring -- 文檔字符串

做爲類、函數或模塊以內的第一個表達式出現的字符串字面值。它在代碼執行時會被忽略，但會被解釋器識別並放入所在類、函數或模塊的 __doc__ 屬性中。因爲它可用於代碼內省，所以是對象存放文檔的規範位置。

- duck-typing -- 鴨子類型

指一種編程風格，它並不依靠查找對象類型來肯定其是否具備正確的接口，而是直接調用或使用其方法或屬性（「看起來像鴨子，叫起來也像鴨子，那麼確定就是鴨子。」）因爲強調接口而非特定類型，設計良好的代碼可經過容許多態替代來提高靈活性。鴨子類型避免使用 type() 或 isinstance() 檢測。(但要注意鴨子類型可使用 抽象基類 做爲補充。) 而每每會採用 hasattr() 檢測或是 EAFP 編程。

- EAFP

「求原諒比求許可更容易」的英文縮寫。這種 Python 經常使用代碼編寫風格會假定所需的鍵或屬性存在，並在假定錯誤時捕獲異常。這種簡潔快速風格的特色就是大量運用 try 和 except 語句。於其相對的則是所謂 LBYL 風格，常見於 C 等許多其餘語言。

- expression -- 表達式

能夠求出某個值的語法單元。 換句話說，一個表達式就是表達元素例如字面值、名稱、屬性訪問、運算符或函數調用的彙總，它們最終都會返回一個值。 與許多其餘語言不一樣，並不是全部語言構件都是表達式。 還存在不能被用做表達式的 statement，例如 while。 賦值也是屬於語句而非表達式。

- extension module -- 擴展模塊

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

- f-string -- f-字符串

帶有 'f' 或 'F' 前綴的字符串字面值一般被稱爲「f-字符串」即 格式化字符串字面值 的簡寫。參見 PEP 498。

- file object -- 文件對象

對外提供面向文件 API 以使用下層資源的對象（帶有 read() 或 write() 這樣的方法）。根據其建立方式的不一樣，文件對象能夠處理對真實磁盤文件，對其餘類型存儲，或是對通信設備的訪問（例如標準輸入/輸出、內存緩衝區、套接字、管道等等）。文件對象也被稱爲 文件類對象 或 流。

實際上共有三種類別的文件對象: 原始 二進制文件, 緩衝 二進制文件 以及 文本文件。它們的接口定義均在 io模塊中。建立文件對象的規範方式是使用 open() 函數。

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

file object 的同義詞。

- finder -- 查找器

一種會嘗試查找被導入模塊的 loader 的對象。

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

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

floor division -- 向下取整除法

向下舍入到最接近的整數的數學除法。向下取整除法的運算符是 // 。例如，表達式 11 // 4 的計算結果是 2，而與之相反的是浮點數的真正除法返回 2.75 。注意 (-11) // 4 會返回 -3 由於這是 -2.75 向下 舍入獲得的結果。見 PEP 238 。

function -- 函數

能夠向調用者返回某個值的一組語句。還能夠向其傳入零個或多個 參數 並在函數體執行中被使用。另見 parameter, method 和 函數定義 等節。

function annotation -- 函數標註

即針對函數形參或返回值的 annotation 。

函數標註一般用於 類型提示：例如如下函數預期接受兩個 int 參數並預期返回一個 int 值:

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

函數標註語法的詳解見 函數定義 一節。

請參看 variable annotation 和 PEP 484 對此功能的描述。

__future__

一種僞模塊，可被程序員用來啓用與當前解釋器不兼容的新語言特性。

經過導入 __future__ 模塊並對其中的變量求值，你能夠查看新特性什麼時候首次加入語言以及什麼時候成爲默認:

>>>

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

garbage collection -- 垃圾回收

釋放再也不被使用的內存空間的過程。Python 是經過引用計數和一個可以檢測和打破循環引用的循環垃圾回收器來執行垃圾回收的。可使用 gc 模塊來控制垃圾回收器。

generator -- 生成器

返回一個 generator iterator 的函數。它看起來很像普通函數，不一樣點在於其包含 yield 表達式以便產生一系列值供給 for-循環使用或是經過 next() 函數逐一獲取。

一般是指生成器函數，但在某些狀況下也多是指 生成器迭代器。若是須要清楚表達具體含義，請使用全稱以免歧義。

generator iterator -- 生成器迭代器

generator 函數所建立的對象。

每一個 yield 會臨時暫停處理，記住當前位置執行狀態（包括局部變量和掛起的 try 語句）。當該 生成器迭代器恢復時，它會從離開位置繼續執行（這與每次調用都重新開始的普通函數差異很大）。

generator expression -- 生成器表達式

返回一個迭代器的表達式。 它看起來很像普通表達式後面帶有定義了一個循環變量、範圍的 for 子句，以及一個可選的 if 子句。 如下複合表達式會爲外層函數生成一系列值:

>>>

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

generic function -- 泛型函數

爲不一樣的類型實現相同操做的多個函數所組成的函數。在調用時會由調度算法來肯定應該使用哪一個實現。

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

GIL

參見 global interpreter lock。

global interpreter lock -- 全局解釋器鎖

CPython 解釋器所採用的一種機制，它確保同一時刻只有一個線程在執行 Python bytecode。此機制經過設置對象模型（包括 dict 等重要內置類型）針對併發訪問的隱式安全簡化了 CPython 實現。給整個解釋器加鎖使得解釋器多線程運行更方便，其代價則是犧牲了在多處理器上的並行性。

不過，某些標準庫或第三方庫的擴展模塊被設計爲在執行計算密集型任務如壓縮或哈希時釋放 GIL。此外，在執行 I/O 操做時也老是會釋放 GIL。

建立一個（以更精細粒度來鎖定共享數據的）「自由線程」解釋器的努力從未得到成功，由於這會犧牲在普通單處理器狀況下的性能。據信克服這種性能問題的措施將致使實現變得更復雜，從而更難以維護。

hash-based pyc -- 基於哈希的 pyc

使用對應源文件的哈希值而非最後修改時間來肯定其有效性的字節碼緩存文件。 參見 已緩存字節碼的失效。

hashable -- 可哈希

一個對象的哈希值若是在其生命週期內毫不改變，就被稱爲 可哈希 （它須要具備 __hash__() 方法），並能夠同其餘對象進行比較（它須要具備 __eq__() 方法）。可哈希對象必須具備相同的哈希值比較結果纔會相同。

可哈希性使得對象可以做爲字典鍵或集合成員使用，由於這些數據結構要在內部使用哈希值。

大多數 Python 中的不可變內置對象都是可哈希的；可變容器（例如列表或字典）都不可哈希；不可變容器（例如元組和 frozenset）僅當它們的元素均爲可哈希時纔是可哈希的。 用戶定義類的實例對象默認是可哈希的。 它們在比較時必定不相同（除非是與本身比較），它們的哈希值的生成是基於它們的 id()。

IDLE

Python 的 IDE，「集成開發與學習環境」的英文縮寫。是 Python 標準發行版附帶的基本編程器和解釋器環境。

immutable -- 不可變

具備固定值的對象。不可變對象包括數字、字符串和元組。這樣的對象不能被改變。若是必須存儲一個不一樣的值，則必須建立新的對象。它們在須要常量哈希值的地方起着重要做用，例如做爲字典中的鍵。

import path -- 導入路徑

由多個位置（或 路徑條目）組成的列表，會被模塊的 path based finder 用來查找導入目標。在導入時，此位置列表一般來自 sys.path，但對次級包來講也可能來自上級包的 __path__ 屬性。

importing -- 導入

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

importer -- 導入器

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

interactive -- 交互

Python 帶有一個交互式解釋器，即你能夠在解釋器提示符後輸入語句和表達式，當即執行並查看其結果。只需不帶參數地啓動 python 命令（也能夠在你的計算機開始菜單中選擇相應菜單項）。在測試新想法或檢驗模塊和包的時候用這種方式會很是方便（請記得使用 help(x)）。

interpreted -- 解釋型

Python 一是種解釋型語言，與之相對的是編譯型語言，雖然二者的區別因爲字節碼編譯器的存在而會有所模糊。這意味着源文件能夠直接運行而沒必要顯式地建立可執行文件再運行。解釋型語言一般具備比編譯型語言更短的開發/調試周期，可是其程序每每運行得更慢。參見 interactive。

interpreter shutdown -- 解釋器關閉

當被要求關閉時，Python 解釋器將進入一個特殊運行階段並逐步釋放全部已分配資源，例如模塊和各類關鍵內部結構等。它還會屢次調用 垃圾回收器。這會觸發用戶定義析構器或弱引用回調中的代碼執行。在關閉階段執行的代碼可能會遇到各類異常，由於其所依賴的資源已再也不有效（常見的例子有庫模塊或警告機制等）。

解釋器須要關閉的主要緣由有 __main__ 模塊或所運行的腳本已完成執行。

iterable -- 可迭代對象

可以逐一返回其成員項的對象。可迭代對象的例子包括全部序列類型（例如 list、str 和 tuple）以及某些非序列類型例如 dict、文件對象 以及定義了 __iter__() 方法或是實現了 Sequence 語義的 __getitem__() 方法的任意自定義類對象。

可迭代對象被可用於 for 循環以及許多其餘須要一個序列的地方（zip()、map() ...）。當一個可迭代對象做爲參數傳給內置函數 iter() 時，它會返回該對象的迭代器。這種迭代器適用於對值集合的一次性遍歷。在使用可迭代對象時，你一般不須要調用 iter() 或者本身處理迭代器對象。for 語句會爲你自動處理那些操做，建立一個臨時的未命名變量用來在循環期間保存迭代器。參見 iterator、sequence 以及 generator。

iterator -- 迭代器

用來表示一連串數據流的對象。重複調用迭代器的 __next__() 方法（或將其傳給內置函數 next()）將逐個返回流中的項。當沒有數據可用時則將引起 StopIteration 異常。到這時迭代器對象中的數據項已耗盡，繼續調用其 __next__() 方法只會再次引起 StopIteration 異常。迭代器必須具備 __iter__() 方法用來返回該迭代器對象自身，所以迭代器一定也是可迭代對象，可被用於其餘可迭代對象適用的大部分場合。一個顯著的例外是那些會屢次重複訪問迭代項的代碼。容器對象（例如 list）在你每次向其傳入 iter() 函數或是在 for 循環中使用它時都會產生一個新的迭代器。若是在此狀況下你嘗試用迭代器則會返回在以前迭代過程當中被耗盡的同一迭代器對象，使其看起來就像是一個空容器。

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

key function -- 鍵函數

鍵函數或稱整理函數，是可以返回用於排序或排位的值的可調用對象。例如，locale.strxfrm() 可用於生成一個符合特定區域排序約定的排序鍵。

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

要建立一個鍵函數有多種方式。例如，str.lower() 方法能夠用做忽略大小寫排序的鍵函數。另外，鍵函數也可經過 lambda 表達式來建立，例如 lambda r: (r[0], r[2])。還有 operator 模塊提供了三個鍵函數構造器：attrgetter()、itemgetter() 和 methodcaller()。請查看 如何排序 一節以獲取建立和使用鍵函數的示例。

keyword argument -- 關鍵字參數

參見 argument。

lambda

由一個單獨 expression 構成的匿名內聯函數，表達式會在調用時被求值。建立 lambda 函數的句法爲 lambda[parameters]: expression

LBYL

「先查看後跳躍」的英文縮寫。這種代碼編寫風格會在進行調用或查找以前顯式地檢查前提條件。此風格與 EAFP 方式恰成對比，其特色是大量使用 if 語句。

在多線程環境中，LBYL 方式會致使「查看」和「跳躍」之間發生條件競爭風險。例如，如下代碼 if key inmapping: return mapping[key] 可能因爲在檢查操做以後其餘線程從 mapping 中移除了 key 而出錯。這種問題可經過加鎖或使用 EAFP 方式來解決。

list -- 列表

Python 內置的一種 sequence。雖然名爲列表，但更相似於其餘語言中的數組而非連接列表，由於訪問元素的時間複雜度爲 O(1)。

list comprehension -- 列表推導式

處理一個序列中的全部或部分元素並返回結果列表的一種緊湊寫法。result = ['{:#04x}'.format(x) for xin range(256) if x % 2 == 0] 將生成一個 0 到 255 範圍內的十六進制偶數對應字符串（0x..）的列表。其中 if 子句是可選的，若是省略則 range(256) 中的全部元素都會被處理。

loader -- 加載器

負責加載模塊的對象。它必須定義名爲 load_module() 的方法。加載器一般由一個 finder 返回。詳情參見 PEP 302，對於 abstract base class 可參見 importlib.abc.Loader。

magic method -- 魔術方法

special method 的非正式同義詞 。

mapping -- 映射

一種支持任意鍵查找並實現了 Mapping 或 MutableMapping 抽象基類 中所規定方法的容器對象。 此類對象的例子包括 dict, collections.defaultdict, collections.OrderedDict 以及 collections.Counter。

meta path finder -- 元路徑查找器

sys.meta_path 的搜索所返回的 finder。元路徑查找器與 path entry finders 存在關聯但並不相同。

請查看 importlib.abc.MetaPathFinder 瞭解元路徑查找器所實現的方法。

metaclass -- 元類

一種用於建立類的類。類定義包含類名、類字典和基類列表。元類負責接受上述三個參數並建立相應的類。大部分面向對象的編程語言都會提供一個默認實現。Python 的特別之處在於能夠建立自定義元類。大部分用戶永遠不須要這個工具，但當須要出現時，元類可提供強大而優雅的解決方案。它們已被用於記錄屬性訪問日誌、添加線程安全性、跟蹤對象建立、實現單例，以及其餘許多任務。

更多詳情參見 元類。

method -- 方法

在類內部定義的函數。若是做爲該類的實例的一個屬性來調用，方法將會獲取實例對象做爲其第一個 argument (一般命名爲 self)。參見 function 和 nested scope。

method resolution order -- 方法解析順序

方法解析順序就是在查找成員時搜索所有基類所用的前後順序。請查看 Python 2.3 方法解析順序 瞭解自 2.3 版起 Python 解析器所用相關算法的詳情。

module -- 模塊

此對象是 Python 代碼的一種組織單位。各模塊具備獨立的命名空間，可包含任意 Python 對象。模塊可經過 importing 操做被加載到 Python 中。

另見 package。

module spec -- 模塊規格

一個命名空間，其中包含用於加載模塊的相關導入信息。是 importlib.machinery.ModuleSpec 的實例。

MRO

參見 method resolution order。

mutable -- 可變

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

named tuple -- 具名元組

任何相似元組的類，其中的可索引元素也能使用名稱屬性來訪問。（例如，time.localtime() 會返回一個相似元組的對象，其中的 year 既能夠經過索引訪問如 t[0] 也能夠經過名稱屬性訪問如 t.tm_year）。

具名元組能夠是一個內置類型例如 time.struct_time，也能夠經過正規的類定義來建立。一個完備的具名元組還能夠經過工廠函數 collections.namedtuple() 來建立。後面這種方式會自動提供一些額外特性，例如 Employee(name='jones', title='programmer') 這樣的自包含文檔表示形式。

namespace -- 命名空間

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

namespace package -- 命名空間包

PEP 420 所引入的一種僅被用做子包的容器的 package，命名空間包能夠沒有實體表示物，其描述方式與 regular package 不一樣，由於它們沒有 __init__.py 文件。

另可參見 module。

nested scope -- 嵌套做用域

在一個定義範圍內引用變量的能力。例如，在另外一函數以內定義的函數能夠引用前者的變量。請注意嵌套做用域默認只對引用有效而對賦值無效。局部變量的讀寫都受限於最內層做用域。相似的，全局變量的讀寫則做用於全局命名空間。經過 nonlocal 關鍵字可容許寫入外層做用域。

new-style class -- 新式類

對於目前已被應於全部類對象的類形式的舊稱謂。在早先的 Python 版本中，只有新式類可以使用 Python 新增的更靈活特性，例如 __slots__、描述符、特徵屬性、__getattribute__()、類方法和靜態方法等。

object -- 對象

任何具備狀態（屬性或值）以及預約義行爲（方法）的數據。object 也是任何 new-style class 的最頂層基類名。

package -- 包

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

另參見 regular package 和 namespace package。

parameter -- 形參

function （或方法）定義中的命名實體，它指定函數能夠接受的一個 argument （或在某些狀況下，多個實參）。有五種形參：

• positional-or-keyword：位置或關鍵字，指定一個能夠做爲 位置參數 傳入也能夠做爲 關鍵字參數 傳入的實參。這是默認的形參類型，例以下面的 foo 和 bar:

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

• positional-only：僅限位置，指定一個只能按位置傳入的參數。Python 中沒有定義僅限位置形參的語法。可是一些內置函數有僅限位置形參（好比 abs()）。

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

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

• var-positional：可變位置，指定能夠提供由一個任意數量的位置參數構成的序列（附加在其餘形參已接受的位置參數以後）。這種形參可經過在形參名稱前加綴 * 來定義，例以下面的 args:

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

• var-keyword：可變關鍵字，指定能夠提供任意數量的關鍵字參數（附加在其餘形參已接受的關鍵字參數以後）。這種形參可經過在形參名稱前加綴 ** 來定義，例如上面的 kwargs。

形參能夠同時指定可選和必選參數，也能夠爲某些可選參數指定默認值。

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

path entry -- 路徑入口

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

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

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

請參看 importlib.abc.PathEntryFinder 以瞭解路徑入口查找器所實現的各個方法。

path entry hook -- 路徑入口鉤子

一種可調用對象，在知道如何查找特定 path entry 中的模塊的狀況下可以使用 sys.path_hook 列表返回一個 path entry finder。

path based finder -- 基於路徑的查找器

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

path-like object -- 路徑類對象

表明一個文件系統路徑的對象。類路徑對象能夠是一個表示路徑的 str 或者 bytes 對象，還能夠是一個實現了 os.PathLike 協議的對象。一個支持 os.PathLike 協議的對象可經過調用 os.fspath() 函數轉換爲 str 或者 bytes 類型的文件系統路徑；os.fsdecode() 和 os.fsencode() 可被分別用來確保得到 str 或 bytes 類型的結果。此對象是由 PEP 519 引入的。

PEP

「Python 加強提議」的英文縮寫。一個 PEP 就是一份設計文檔，用來向 Python 社區提供信息，或描述一個 Python 的新增特性及其進度或環境。PEP 應當提供精確的技術規格和所提議特性的原理說明。

PEP 應被做爲提出主要新特性建議、收集社區對特定問題反饋以及爲必須加入 Python 的設計決策編寫文檔的首選機制。PEP 的做者有責任在社區內部創建共識，並應將不一樣意見也記入文檔。

參見 PEP 1。

portion -- 部分

構成一個命名空間包的單個目錄內文件集合（也可能存放於一個 zip 文件內），具體定義見 PEP 420。

positional argument -- 位置參數

參見 argument。

provisional API -- 暫定 API

暫定 API 是指被有意排除在標準庫的向後兼容性保證以外的應用編程接口。雖然此類接口一般不會再有重大改變，但只要其被標記爲暫定，就可能在覈心開發者肯定有必要的狀況下進行向後不兼容的更改（甚至包括移除該接口）。此種更改並不會隨意進行 -- 僅在 API 被加入以前未考慮到的嚴重基礎性缺陷被發現時纔可能會這樣作。

即使是對暫定 API 來講，向後不兼容的更改也會被視爲「最後的解決方案」 —— 任何問題被確認時都會盡量先嚐試找到一種向後兼容的解決方案。

這種處理過程容許標準庫持續不斷地演進，不至於被有問題的長期性設計缺陷所困。詳情見 PEP 411。

provisional package -- 暫定包

參見 provisional API。

Python 3000

Python 3.x 發佈路線的暱稱（這個名字在版本 3 的發佈還遙遙無期的時候就已出現了）。有時也被縮寫爲「Py3k」。

Pythonic

指一個思路或一段代碼緊密遵循了 Python 語言最經常使用的風格和理念，而不是使用其餘語言中通用的概念來實現代碼。例如，Python 的經常使用風格是使用 for 語句循環來遍歷一個可迭代對象中的全部元素。許多其餘語言沒有這樣的結構，所以不熟悉 Python 的人有時會選擇使用一個數字計數器:

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

而相應的更簡潔更 Pythonic 的方法是這樣的:

for piece in food: print(piece) 

qualified name -- 限定名稱

一個以點號分隔的名稱，顯示從模塊的全局做用域到該模塊中定義的某個類、函數或方法的「路徑」，相關定義見 PEP 3155。對於最高層級的函數和類，限定名稱與對象名稱一致:

>>>

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

當被用於引用模塊時，完整限定名稱 意爲標示該模塊的以點號分隔的整個路徑，其中包含其全部的父包，例如 email.mime.text:

>>>

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

reference count -- 引用計數

對特定對象的引用的數量。當一個對象的引用計數降爲零時，所分配資源將被釋放。引用計數對 Python 代碼來講一般是不可見的，但它是 CPython 實現的一個關鍵元素。sys 模塊定義了一個 getrefcount() 函數，程序員可調用它來返回特定對象的引用計數。

regular package -- 正規包

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

另參見 namespace package。

__slots__

一種寫在類內部的聲明，經過預先聲明實例屬性等對象並移除實例字典來節省內存。雖然這種技巧很流行，但想要用好卻並不容易，最好是隻保留在少數狀況下采用，例如極耗內存的應用程序，而且其中包含大量實例。

sequence -- 序列

一種 iterable，它支持經過 __getitem__() 特殊方法來使用整數索引進行高效的元素訪問，並定義了一個返回序列長度的 __len__() 方法。內置的序列類型有 list、str、tuple 和 bytes。注意雖然 dict 也支持 __getitem__() 和 __len__()，但它被認爲屬於映射而非序列，由於它查找時使用任意的 immutable 鍵而非整數。

collections.abc.Sequence 抽象基類定義了一個更豐富的接口，它超越了 __getitem__() 和 __len__()，添加了 count(), index(), __contains__() 和 __reversed__() 。 可使用 register() 顯式註冊實現此擴展接口的類型。

single dispatch -- 單分派

一種 generic function 分派形式，其實現是基於單個參數的類型來選擇的。

slice -- 切片

一般只包含了特定 sequence 的一部分的對象。切片是經過使用下標標記來建立的，在 [] 中給出幾個以冒號分隔的數字，例如 variable_name[1:3:5]。方括號（下標）標記在內部使用 slice 對象。

special method -- 特殊方法

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

statement -- 語句

語句是程序段（一個代碼「塊」）的組成單位。一條語句能夠是一個 expression 或某個帶有關鍵字的結構，例如 if、while 或 for。

struct sequence -- 結構序列

具備命名元素的元組。結構序列所暴露的接口相似於 named tuple，其元素既可經過索引也可做爲屬性來訪問。不過，它們沒有任何具名元組的方法，例如 _make() 或 _asdict()。結構序列的例子包括 sys.float_info以及 os.stat() 的返回值。

text encoding -- 文本編碼

用於將Unicode字符串編碼爲字節串的編碼器。

text file -- 文本文件

一種可以讀寫 str 對象的 file object。一般一個文本文件實際是訪問一個面向字節的數據流並自動處理 text encoding。文本文件的例子包括以文本模式（'r' 或 'w'）打開的文件、sys.stdin、sys.stdout 以及 io.StringIO 的實例。

另請參看 binary file 瞭解可以讀寫 字節類對象 的文件對象。

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

首尾各帶三個連續雙引號（"）或者單引號（'）的字符串。它們在功能上與首尾各用一個引號標註的字符串沒有什麼不一樣，可是有多種用處。它們容許你在字符串內包含未經轉義的單引號和雙引號，而且能夠跨越多行而無需使用鏈接符，在編寫文檔字符串時特別好用。

type -- 類型

類型決定一個 Python 對象屬於什麼種類；每一個對象都具備一種類型。要知道對象的類型，能夠訪問它的 __class__ 屬性，或是經過 type(obj) 來獲取。

type alias -- 類型別名

一個類型的同義詞，建立方式是把類型賦值給特定的標識符。

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

from typing import List, Tuple def remove_gray_shades( colors: List[Tuple[int, int, int]]) -> List[Tuple[int, int, int]]: pass 

能夠這樣提升可讀性:

from typing import List, Tuple Color = Tuple[int, int, int] def remove_gray_shades(colors: List[Color]) -> List[Color]: pass 

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

type hint -- 類型提示

annotation 爲變量、類屬性、函數的形參或返回值指定預期的類型。

類型提示屬於可選項，Python 不要求提供，但其可對靜態類型分析工具起做用，並可協助 IDE 實現代碼補全與重構。

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

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

universal newlines -- 通用換行

一種解讀文本流的方式，將如下全部符號都識別爲行結束標誌：Unix 的行結束約定 '\n'、Windows 的約定 '\r\n' 以及舊版 Macintosh 的約定 '\r'。參見 PEP 278 和 PEP 3116 和 bytes.splitlines() 瞭解更多用法說明。

variable annotation -- 變量標註

對變量或類屬性的 annotation。

在標註變量或類屬性時，還可選擇爲其賦值:

class C: field: 'annotation' 

變量標註一般被用做 類型提示：例如如下變量預期接受 int 類型的值:

count: int = 0 

變量標註語法的詳細解釋見 帶標註的賦值語句 一節。

請參看 function annotation、PEP 484 和 PEP 526，其中對此功能有詳細描述。

virtual environment -- 虛擬環境

一種採用協做式隔離的運行時環境，容許 Python 用戶和應用程序在安裝和升級 Python 分發包時不會干擾到同一系統上運行的其餘 Python 應用程序的行爲。

另參見 venv。

virtual machine -- 虛擬機

一臺徹底經過軟件定義的計算機。Python 虛擬機可執行字節碼編譯器所生成的 bytecode。

Zen of Python -- Python 之禪

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