術語對照表?

>>>

交互式終端中默認的 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、 和 ，對此功能均有介紹。

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 術語表條目，常見問題中 參數與形參的區別 以及 。

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

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

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__() 返回的可等待對象有效恢復時，它會從離開位置繼續執行。參見 和 。

asynchronous iterable -- 異步可迭代對象

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

asynchronous iterator -- 異步迭代器

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

attribute -- 屬性

關聯到一個對象的值，可以使用點號表達式通過其名稱來引用。例如，如果一個對象 o 具有一個屬性 a，就可以用 o.a 來引用它。

awaitable -- 可等待對象

能在 await 表達式中使用的對象。可以是 coroutine 或是具有 __await__() 方法的對象。參見 。

BDFL

“終身仁慈獨裁者”的英文縮寫，即 ，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__() 方法來控制環境狀態的對象。參見 。

context variable -- 上下文變量

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

contiguous -- 連續

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

coroutine -- 協程

協程是子例程的更一般形式。 子例程可以在某一點進入并在另一點退出。 協程則可以在許多不同的點上進入、退出和恢復。 它們可通過 async def 語句來實現。 參見 。

coroutine function -- 協程函數

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

CPython

Python 編程語言的規范實現，在 上發布。"CPython" 一詞用于在必要時將此實現與其他實現例如 Jython 或 IronPython 相區別。

decorator -- 裝飾器

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

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

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-字符串”即 格式化字符串字面值 的簡寫。參見 。

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 使用。

更多詳情可參見 , 和 。

floor division -- 向下取整除法

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

function -- 函數

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

function annotation -- 函數標注

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

函數標注通常用于 類型提示：例如以下函數預期接受兩個 int 參數并預期返回一個 int 值:

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

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

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

__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() 裝飾器以及 。

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 in mapping: return mapping[key] 可能由于在檢查操作之后其他線程從 mapping 中移除了 key 而出錯。這種問題可通過加鎖或使用 EAFP 方式來解決。

list -- 列表

Python 內置的一種 sequence。雖然名為列表，但更類似于其他語言中的數組而非鏈接列表，因為訪問元素的時間復雜度為 O(1)。

list comprehension -- 列表推導式

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

loader -- 加載器

負責加載模塊的對象。它必須定義名為 load_module() 的方法。加載器通常由一個 finder 返回。詳情參見 ，對于 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 -- 方法解析順序

方法解析順序就是在查找成員時搜索全部基類所用的先后順序。請查看 了解自 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() 和 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

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

namespace -- 命名空間

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

namespace package -- 命名空間包

所引入的一種僅被用作子包的容器的 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 類、函數定義 一節以及 。

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

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

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

參見 。

portion -- 部分

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

positional argument -- 位置參數

參見 argument。

provisional API -- 暫定 API

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

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

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

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 -- 限定名稱

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

>>> 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。

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 和 ，其中有對此功能的詳細描述。

type hint -- 類型提示

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

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

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

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

universal newlines -- 通用換行

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

variable annotation -- 變量標注

對變量或類屬性的 annotation。

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

class C:
    field: 'annotation'

變量標注通常被用作 類型提示：例如以下變量預期接受 int 類型的值:

count: int = 0

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

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

virtual environment -- 虛擬環境

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

另參見 venv。

virtual machine -- 虛擬機

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

Zen of Python -- Python 之禪

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