內(nèi)置函數(shù)

Python 解釋器內(nèi)置了很多函數(shù)和類型，您可以在任何時候使用它們。以下按字母表順序列出它們。

		內(nèi)置函數(shù)
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

abs(x)

返回一個數(shù)的絕對值。實參可以是整數(shù)或浮點數(shù)。如果實參是一個復(fù)數(shù)，返回它的模。

all(iterable)

如果 iterable 的所有元素為真（或迭代器為空），返回 True 。等價于:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any(iterable)

如果 iterable 的任一元素為真則返回 True。 如果迭代器為空，返回 False。 等價于:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object)

與 repr() 類似，返回一個包含對象的可打印表示形式的字符串，但是使用 \x、\u 和 \U 對 repr() 返回的字符串中非 ASCII 編碼的字符進(jìn)行轉(zhuǎn)義。 生成的字符串和 Python 2 的 repr() 返回的結(jié)果相似。

bin(x)

將一個整數(shù)轉(zhuǎn)變?yōu)橐粋€前綴為“0b”的二進(jìn)制字符串。結(jié)果是一個合法的 Python 表達(dá)式。如果 x 不是 Python 的 int 對象，那它需要定義 __index__() 方法返回一個整數(shù)。一些例子：

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

如果不一定需要前綴“0b”，還可以使用如下的方法。

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

另見 format() 獲取更多信息。

class bool([x])

返回一個布爾值，True 或者 False。 x 使用標(biāo)準(zhǔn)的 真值測試過程 來轉(zhuǎn)換。 如果 x 是假值或者被省略，返回 False；其他情況返回 True。 bool 類是 int 的子類（參見 數(shù)字類型 --- int, float, complex ）。其他類不能繼承自它。它只有 False 和 True 兩個實例（參見 布爾值 ）。

在 3.7 版更改: x 現(xiàn)在只能作為位置參數(shù)。

breakpoint(*args, **kws)

此函數(shù)會在調(diào)用時將你陷入調(diào)試器中。具體來說，它調(diào)用 sys.breakpointhook() ，直接傳遞 args 和 kws 。默認(rèn)情況下， sys.breakpointhook() 調(diào)用 pdb.set_trace() 且沒有參數(shù)。在這種情況下，它純粹是一個便利函數(shù)，因此您不必顯式導(dǎo)入 pdb 且鍵入盡可能少的代碼即可進(jìn)入調(diào)試器。但是， sys.breakpointhook() 可以設(shè)置為其他一些函數(shù)并被 breakpoint() 自動調(diào)用，以允許進(jìn)入你想用的調(diào)試器。

3.7 新版功能.

class bytearray([source[, encoding[, errors]]])

返回一個新的 bytes 數(shù)組。 bytearray 類是一個可變序列，包含范圍為 0 <= x < 256 的整數(shù)。它有可變序列大部分常見的方法，見 可變序列類型 的描述；同時有 bytes 類型的大部分方法，參見 bytes 和 bytearray 操作。

可選形參 source 可以用不同的方式來初始化數(shù)組：

• 如果是一個 string，您必須提供 encoding 參數(shù)（errors 參數(shù)仍是可選的）；bytearray() 會使用 str.encode() 方法來將 string 轉(zhuǎn)變成 bytes。

• 如果是一個 integer，會初始化大小為該數(shù)字的數(shù)組，并使用 null 字節(jié)填充。

• 如果是一個符合 buffer 接口的對象，該對象的只讀 buffer 會用來初始化字節(jié)數(shù)組。

• 如果是一個 iterable 可迭代對象，它的元素的范圍必須是 0 <= x < 256 的整數(shù)，它會被用作數(shù)組的初始內(nèi)容。

如果沒有實參，則創(chuàng)建大小為 0 的數(shù)組。

另見 二進(jìn)制序列類型 --- bytes, bytearray, memoryview 和 bytearray 對象。

class bytes([source[, encoding[, errors]]])

返回一個新的“bytes”對象， 是一個不可變序列，包含范圍為 0 <= x < 256 的整數(shù)。bytes 是 bytearray 的不可變版本 - 它有其中不改變序列的方法和相同的索引、切片操作。

因此，構(gòu)造函數(shù)的實參和 bytearray() 相同。

字節(jié)對象還可以用字面值創(chuàng)建，參見 字符串和字節(jié)串字面值。

另見 二進(jìn)制序列類型 --- bytes, bytearray, memoryview，bytes 對象 和 bytes 和 bytearray 操作。

callable(object)

如果參數(shù) object 是可調(diào)用的就返回 True，否則返回 False。 如果返回 True，調(diào)用仍可能失敗，但如果返回 False，則調(diào)用 object 將肯定不會成功。 請注意類是可調(diào)用的（調(diào)用類將返回一個新的實例）；如果實例所屬的類有 __call__() 則它就是可調(diào)用的。

3.2 新版功能: 這個函數(shù)一開始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。

chr(i)

返回 Unicode 碼位為整數(shù) i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。這是 ord() 的逆函數(shù)。

實參的合法范圍是 0 到 1,114,111（16 進(jìn)制表示是 0x10FFFF）。如果 i 超過這個范圍，會觸發(fā) ValueError 異常。

@classmethod

把一個方法封裝成類方法。

一個類方法把類自己作為第一個實參，就像一個實例方法把實例自己作為第一個實參。請用以下習(xí)慣來聲明類方法:

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

@classmethod 這樣的形式稱為函數(shù)的 decorator -- 詳情參閱 函數(shù)定義。

類方法的調(diào)用可以在類上進(jìn)行 (例如 C.f()) 也可以在實例上進(jìn)行 (例如 C().f())。 其所屬類以外的類實例會被忽略。 如果類方法在其所屬類的派生類上調(diào)用，則該派生類對象會被作為隱含的第一個參數(shù)被傳入。

類方法與 C++ 或 Java 中的靜態(tài)方法不同。 如果你需要后者，請參閱 staticmethod()。

想了解更多有關(guān)類方法的信息，請參閱 標(biāo)準(zhǔn)類型層級結(jié)構(gòu) 。

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

將 source 編譯成代碼或 AST 對象。代碼對象可以被 exec() 或 eval() 執(zhí)行。source 可以是常規(guī)的字符串、字節(jié)字符串，或者 AST 對象。參見 ast 模塊的文檔了解如何使用 AST 對象。

filename 實參需要是代碼讀取的文件名；如果代碼不需要從文件中讀取，可以傳入一些可辨識的值（經(jīng)常會使用 '<string>'）。

mode 實參指定了編譯代碼必須用的模式。如果 source 是語句序列，可以是 'exec'；如果是單一表達(dá)式，可以是 'eval'；如果是單個交互式語句，可以是 'single'。（在最后一種情況下，如果表達(dá)式執(zhí)行結(jié)果不是 None 將會被打印出來。）

可選參數(shù) flags 和 dont_inherit 控制在編譯 source 時要用到哪個 future 語句。 如果兩者都未提供（或都為零）則會使用調(diào)用 compile() 的代碼中有效的 future 語句來編譯代碼。 如果給出了 flags 參數(shù)但沒有 dont_inherit (或是為零) 則 flags 參數(shù)所指定的 以及那些無論如何都有效的 future 語句會被使用。 如果 dont_inherit 為一個非零整數(shù)，則只使用 flags 參數(shù) -- 在調(diào)用外圍有效的 future 語句將被忽略。

Future 語句使用比特位來指定，多個語句可以通過按位或來指定。具體特性的比特位可以通過 __future__ 模塊中的 _Feature 類的實例的 compiler_flag 屬性來獲得。

optimize 實參指定編譯器的優(yōu)化級別；默認(rèn)值 -1 選擇與解釋器的 -O 選項相同的優(yōu)化級別。顯式級別為 0 （沒有優(yōu)化；__debug__ 為真）、1 （斷言被刪除， __debug__ 為假）或 2 （文檔字符串也被刪除）。

如果編譯的源碼不合法，此函數(shù)會觸發(fā) SyntaxError 異常；如果源碼包含 null 字節(jié)，則會觸發(fā) ValueError 異常。

如果您想分析 Python 代碼的 AST 表示，請參閱 ast.parse()。

注解

在 'single' 或 'eval' 模式編譯多行代碼字符串時，輸入必須以至少一個換行符結(jié)尾。 這使 code 模塊更容易檢測語句的完整性。

警告

在將足夠大或者足夠復(fù)雜的字符串編譯成 AST 對象時，Python 解釋器有可以因為 Python AST 編譯器的棧深度限制而崩潰。

在 3.2 版更改: 允許使用 Windows 和 Mac 的換行符。在 'exec' 模式不再需要以換行符結(jié)尾。增加了 optimize 形參。

在 3.5 版更改: 之前 source 中包含 null 字節(jié)的話會觸發(fā) TypeError 異常。

class complex([real[, imag]])

返回值為 real + imag*1j 的復(fù)數(shù)，或?qū)⒆址驍?shù)字轉(zhuǎn)換為復(fù)數(shù)。如果第一個形參是字符串，則它被解釋為一個復(fù)數(shù)，并且函數(shù)調(diào)用時必須沒有第二個形參。第二個形參不能是字符串。每個實參都可以是任意的數(shù)值類型（包括復(fù)數(shù)）。如果省略了 imag，則默認(rèn)值為零，構(gòu)造函數(shù)會像 int 和 float 一樣進(jìn)行數(shù)值轉(zhuǎn)換。如果兩個實參都省略，則返回 0j。

注解

當(dāng)從字符串轉(zhuǎn)換時，字符串在 + 或 - 的周圍必須不能有空格。例如 complex('1+2j') 是合法的，但 complex('1 + 2j') 會觸發(fā) ValueError 異常。

數(shù)字類型 --- int, float, complex 描述了復(fù)數(shù)類型。

在 3.6 版更改: 您可以使用下劃線將代碼文字中的數(shù)字進(jìn)行分組。

delattr(object, name)

setattr() 相關(guān)的函數(shù)。實參是一個對象和一個字符串。該字符串必須是對象的某個屬性。如果對象允許，該函數(shù)將刪除指定的屬性。例如 delattr(x, 'foobar') 等價于 del x.foobar 。

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

創(chuàng)建一個新的字典。dict 對象是一個字典類。參見 dict 和 映射類型 --- dict 了解這個類。

其他容器類型，請參見內(nèi)置的 list、set 和 tuple 類，以及 collections 模塊。

dir([object])

如果沒有實參，則返回當(dāng)前本地作用域中的名稱列表。如果有實參，它會嘗試返回該對象的有效屬性列表。

如果對象有一個名為 __dir__() 的方法，那么該方法將被調(diào)用，并且必須返回一個屬性列表。這允許實現(xiàn)自定義 __getattr__() 或 __getattribute__() 函數(shù)的對象能夠自定義 dir() 來報告它們的屬性。

如果對象不提供 __dir__()，這個函數(shù)會嘗試從對象已定義的 __dict__ 屬性和類型對象收集信息。結(jié)果列表并不總是完整的，如果對象有自定義 __getattr__()，那結(jié)果可能不準(zhǔn)確。

默認(rèn)的 dir() 機(jī)制對不同類型的對象行為不同，它會試圖返回最相關(guān)而不是最全的信息：

• 如果對象是模塊對象，則列表包含模塊的屬性名稱。

• 如果對象是類型或類對象，則列表包含它們的屬性名稱，并且遞歸查找所有基類的屬性。

• 否則，列表包含對象的屬性名稱，它的類屬性名稱，并且遞歸查找它的類的所有基類的屬性。

返回的列表按字母表排序。例如：

>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

注解

因為 dir() 主要是為了便于在交互式時使用，所以它會試圖返回人們感興趣的名字集合，而不是試圖保證結(jié)果的嚴(yán)格性或一致性，它具體的行為也可能在不同版本之間改變。例如，當(dāng)實參是一個類時，metaclass 的屬性不包含在結(jié)果列表中。

divmod(a, b)

它將兩個（非復(fù)數(shù)）數(shù)字作為實參，并在執(zhí)行整數(shù)除法時返回一對商和余數(shù)。對于混合操作數(shù)類型，適用雙目算術(shù)運算符的規(guī)則。對于整數(shù)，結(jié)果和 (a // b, a % b) 一致。對于浮點數(shù)，結(jié)果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能會比 1 小。在任何情況下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符號和 b 一樣，并且 0 <= abs(a % b) < abs(b) 。

enumerate(iterable, start=0)

返回一個枚舉對象。iterable 必須是一個序列，或 iterator，或其他支持迭代的對象。 enumerate() 返回的迭代器的 __next__() 方法返回一個元組，里面包含一個計數(shù)值（從 start 開始，默認(rèn)為 0）和通過迭代 iterable 獲得的值。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

等價于:

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

eval(expression[, globals[, locals]])

實參是一個字符串，以及可選的 globals 和 locals。globals 實參必須是一個字典。locals 可以是任何映射對象。

expression 參數(shù)會作為一個 Python 表達(dá)式（從技術(shù)上說是一個條件列表）被解析并求值，使用 globals 和 locals 字典作為全局和局部命名空間。 如果 globals 字典存在且不包含以 __builtins__ 為鍵的值，則會在解析 expression 之前插入以此為鍵的對內(nèi)置模塊 builtins 的字典的引用。 這意味著 expression 通常具有對標(biāo)準(zhǔn) builtins 模塊的完全訪問權(quán)限且受限的環(huán)境會被傳播。 如果省略 locals 字典則其默認(rèn)值為 globals 字典。 如果兩個字典同時省略，表達(dá)式會在 eval() 被調(diào)用的環(huán)境中執(zhí)行。 返回值為表達(dá)式求值的結(jié)果。 語法錯誤將作為異常被報告。 例如:

>>> x = 1
>>> eval('x+1')
2

這個函數(shù)也可以用來執(zhí)行任何代碼對象（如 compile() 創(chuàng)建的）。這種情況下，參數(shù)是代碼對象，而不是字符串。如果編譯該對象時的 mode 實參是 'exec' 那么 eval() 返回值為 None 。

提示： exec() 函數(shù)支持動態(tài)執(zhí)行語句。 globals() 和 locals() 函數(shù)各自返回當(dāng)前的全局和本地字典，因此您可以將它們傳遞給 eval() 或 exec() 來使用。

另外可以參閱 ast.literal_eval()，該函數(shù)可以安全執(zhí)行僅包含文字的表達(dá)式字符串。

exec(object[, globals[, locals]])

這個函數(shù)支持動態(tài)執(zhí)行 Python 代碼。object 必須是字符串或者代碼對象。如果是字符串，那么該字符串將被解析為一系列 Python 語句并執(zhí)行（除非發(fā)生語法錯誤）。1 如果是代碼對象，它將被直接執(zhí)行。在任何情況下，被執(zhí)行的代碼都需要和文件輸入一樣是有效的（見參考手冊中關(guān)于文件輸入的章節(jié)）。請注意即使在傳遞給 exec() 函數(shù)的代碼的上下文中，return 和 yield 語句也不能在函數(shù)定義之外使用。該函數(shù)返回值是 None 。

無論哪種情況，如果省略了可選參數(shù)，代碼將在當(dāng)前范圍內(nèi)執(zhí)行。如果提供了 globals 參數(shù)，就必須是字典類型，而且會被用作全局和本地變量。如果同時提供了 globals 和 locals 參數(shù)，它們分別被用作全局和本地變量。如果提供了 locals 參數(shù)，則它可以是任何映射型的對象。請記住在模塊層級，全局和本地變量是相同的字典。如果 exec 有兩個不同的 globals 和 locals 對象，代碼就像嵌入在類定義中一樣執(zhí)行。

如果 globals 字典不包含 __builtins__ 鍵值，則將為該鍵插入對內(nèi)建 builtins 模塊字典的引用。因此，在將執(zhí)行的代碼傳遞給 exec() 之前，可以通過將自己的 __builtins__ 字典插入到 globals 中來控制可以使用哪些內(nèi)置代碼。

注解

內(nèi)置 globals() 和 locals() 函數(shù)各自返回當(dāng)前的全局和本地字典，因此可以將它們傳遞給 exec() 的第二個和第三個實參。

注解

默認(rèn)情況下，locals 的行為如下面 locals() 函數(shù)描述的一樣：不要試圖改變默認(rèn)的 locals 字典。如果您想在 exec() 函數(shù)返回時知道代碼對 locals 的變動，請明確地傳遞 locals 字典。

filter(function, iterable)

用 iterable 中函數(shù) function 返回真的那些元素，構(gòu)建一個新的迭代器。iterable 可以是一個序列，一個支持迭代的容器，或一個迭代器。如果 function 是 None ，則會假設(shè)它是一個身份函數(shù)，即 iterable 中所有返回假的元素會被移除。

請注意， filter(function, iterable) 相當(dāng)于一個生成器表達(dá)式，當(dāng) function 不是 None 的時候為 (item for item in iterable if function(item))；function 是 None 的時候為 (item for item in iterable if item) 。

請參閱 itertools.filterfalse() 了解，只有 function 返回 false 時才選取 iterable 中元素的補(bǔ)充函數(shù)。

class float([x])

返回從數(shù)字或字符串 x 生成的浮點數(shù)。

如果實參是字符串，則它必須是包含十進(jìn)制數(shù)字的字符串，字符串前面可以有符號，之前也可以有空格?？蛇x的符號有 '+' 和 '-' ； '+' 對創(chuàng)建的值沒有影響。實參也可以是 NaN（非數(shù)字）、正負(fù)無窮大的字符串。確切地說，除去首尾的空格后，輸入必須遵循以下語法：

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

這里， floatnumber 是 Python 浮點數(shù)的字符串形式，詳見 浮點數(shù)字面值。字母大小寫都可以，例如，“inf”、“Inf”、“INFINITY”、“iNfINity” 都可以表示正無窮大。

另一方面，如果實參是整數(shù)或浮點數(shù)，則返回具有相同值（在 Python 浮點精度范圍內(nèi)）的浮點數(shù)。如果實參在 Python 浮點精度范圍外，則會觸發(fā) OverflowError。

對于一般的 Python 對象 x ， float(x) 指派給 x.__float__() 。

如果沒有實參，則返回 0.0 。

示例:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

數(shù)字類型 --- int, float, complex 描述了浮點類型。

在 3.6 版更改: 您可以使用下劃線將代碼文字中的數(shù)字進(jìn)行分組。

在 3.7 版更改: x 現(xiàn)在只能作為位置參數(shù)。

format(value[, format_spec])

將 value 轉(zhuǎn)換為 format_spec 控制的“格式化”表示。format_spec 的解釋取決于 value 實參的類型，但是大多數(shù)內(nèi)置類型使用標(biāo)準(zhǔn)格式化語法：格式規(guī)格迷你語言。

默認(rèn)的 format_spec 是一個空字符串，它通常給出與調(diào)用 str(value) 相同的結(jié)果。

調(diào)用 format(value, format_spec) 會轉(zhuǎn)換成 type(value).__format__(value, format_spec) ，所以實例字典中的 __format__() 方法將不會調(diào)用。如果方法搜索回退到 object 類但 format_spec 不為空，或者如果 format_spec 或返回值不是字符串，則會觸發(fā) TypeError 異常。

在 3.4 版更改: 當(dāng) format_spec 不是空字符串時， object().__format__(format_spec) 會觸發(fā) TypeError。

class frozenset([iterable])

返回一個新的 frozenset 對象，它包含可選參數(shù) iterable 中的元素。 frozenset 是一個內(nèi)置的類。有關(guān)此類的文檔，請參閱 frozenset 和 集合類型 --- set, frozenset。

請參閱內(nèi)建的 set、list、tuple 和 dict 類，以及 collections 模塊來了解其它的容器。

getattr(object, name[, default])

返回對象命名屬性的值。name 必須是字符串。如果該字符串是對象的屬性之一，則返回該屬性的值。例如， getattr(x, 'foobar') 等同于 x.foobar。如果指定的屬性不存在，且提供了 default 值，則返回它，否則觸發(fā) AttributeError。

globals()

返回表示當(dāng)前全局符號表的字典。這總是當(dāng)前模塊的字典（在函數(shù)或方法中，不是調(diào)用它的模塊，而是定義它的模塊）。

hasattr(object, name)

該實參是一個對象和一個字符串。如果字符串是對象的屬性之一的名稱，則返回 True，否則返回 False。（此功能是通過調(diào)用 getattr(object, name) 看是否有 AttributeError 異常來實現(xiàn)的。）

hash(object)

返回該對象的哈希值（如果它有的話）。哈希值是整數(shù)。它們在字典查找元素時用來快速比較字典的鍵。相同大小的數(shù)字變量有相同的哈希值（即使它們類型不同，如 1 和 1.0）。

注解

如果對象實現(xiàn)了自己的 __hash__() 方法，請注意，hash() 根據(jù)機(jī)器的字長來截斷返回值。另請參閱 __hash__()。

help([object])

啟動內(nèi)置的幫助系統(tǒng)（此函數(shù)主要在交互式中使用）。如果沒有實參，解釋器控制臺里會啟動交互式幫助系統(tǒng)。如果實參是一個字符串，則在模塊、函數(shù)、類、方法、關(guān)鍵字或文檔主題中搜索該字符串，并在控制臺上打印幫助信息。如果實參是其他任意對象，則會生成該對象的幫助頁。

請注意如果在函數(shù)的形參列表中出現(xiàn)了斜杠 (/)，則它在發(fā)起調(diào)用 help() 的時候意味著斜杠之前的均為僅限位置形參。 更多相關(guān)信息，請參閱 有關(guān)僅限位置形參的 FAQ 條目。

該函數(shù)通過 site 模塊加入到內(nèi)置命名空間。

在 3.4 版更改: pydoc 和 inspect 的變更使得可調(diào)用對象的簽名信息更加全面和一致。

hex(x)

將整數(shù)轉(zhuǎn)換為以“0x”為前綴的小寫十六進(jìn)制字符串。如果 x 不是 Python int 對象，則必須定義返回整數(shù)的 __index__() 方法。一些例子：

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

如果要將整數(shù)轉(zhuǎn)換為大寫或小寫的十六進(jìn)制字符串，并可選擇有無“0x”前綴，則可以使用如下方法：

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

另見 format() 獲取更多信息。

另請參閱 int() 將十六進(jìn)制字符串轉(zhuǎn)換為以 16 為基數(shù)的整數(shù)。

注解

如果要獲取浮點數(shù)的十六進(jìn)制字符串形式，請使用 float.hex() 方法。

id(object)

返回對象的“標(biāo)識值”。該值是一個整數(shù)，在此對象的生命周期中保證是唯一且恒定的。兩個生命期不重疊的對象可能具有相同的 id() 值。

CPython implementation detail: This is the address of the object in memory.

input([prompt])

如果存在 prompt 實參，則將其寫入標(biāo)準(zhǔn)輸出，末尾不帶換行符。接下來，該函數(shù)從輸入中讀取一行，將其轉(zhuǎn)換為字符串（除了末尾的換行符）并返回。當(dāng)讀取到 EOF 時，則觸發(fā) EOFError。例如:

>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

如果加載了 readline 模塊，input() 將使用它來提供復(fù)雜的行編輯和歷史記錄功能。

class int([x])

class int(x, base=10)

返回一個使用數(shù)字或字符串 x 生成的整數(shù)對象，或者沒有實參的時候返回 0 。如果 x 定義了 __int__()，int(x) 返回 x.__int__() 。如果 x 定義了 __trunc__()，它返回 x.__trunc__() 。對于浮點數(shù)，它向零舍入。

如果 x 不是數(shù)字，或者有 base 參數(shù)，x 必須是字符串、bytes、表示進(jìn)制為 base 的 整數(shù)字面值 的 bytearray 實例。該文字前可以有 + 或 - （中間不能有空格），前后可以有空格。一個進(jìn)制為 n 的數(shù)字包含 0 到 n-1 的數(shù)，其中 a 到 z （或 A 到 Z ）表示 10 到 35。默認(rèn)的 base 為 10 ，允許的進(jìn)制有 0、2-36。2、8、16 進(jìn)制的數(shù)字可以在代碼中用 0b/0B 、 0o/0O 、 0x/0X 前綴來表示。進(jìn)制為 0 將安照代碼的字面量來精確解釋，最后的結(jié)果會是 2、8、10、16 進(jìn)制中的一個。所以 int('010', 0) 是非法的，但 int('010') 和 int('010', 8) 是合法的。

整數(shù)類型定義請參閱 數(shù)字類型 --- int, float, complex 。

在 3.4 版更改: 如果 base 不是 int 的實例，但 base 對象有 base.__index__ 方法，則會調(diào)用該方法來獲取進(jìn)制數(shù)。以前的版本使用 base.__int__ 而不是 base.__index__。

在 3.6 版更改: 您可以使用下劃線將代碼文字中的數(shù)字進(jìn)行分組。

在 3.7 版更改: x 現(xiàn)在只能作為位置參數(shù)。

isinstance(object, classinfo)

如果參數(shù) object 是參數(shù) classinfo 的實例或者是其 (直接、間接或 虛擬) 子類則返回 True。 如果 object 不是給定類型的對象，函數(shù)將總是返回 False。 如果 classinfo 是類型對象元組（或由其他此類元組遞歸組成的元組），那么如果 object 是其中任何一個類型的實例就返回 True。 如果 classinfo 既不是類型，也不是類型元組或類型元組的元組，則將引發(fā) TypeError 異常。

issubclass(class, classinfo)

如果 class 是 classinfo 的 (直接、間接或 虛擬) 子類則返回 True。 類會被視作其自身的子類。 classinfo 也以是類對象的元組，在此情況下 classinfo 中的每個條目都將被檢查。 在任何其他情況下，都將引發(fā) TypeError 異常。

iter(object[, sentinel])

返回一個 iterator 對象。根據(jù)是否存在第二個實參，第一個實參的解釋是非常不同的。如果沒有第二個實參，object 必須是支持迭代協(xié)議（有 __iter__() 方法）的集合對象，或必須支持序列協(xié)議（有 __getitem__() 方法，且數(shù)字參數(shù)從 0 開始）。如果它不支持這些協(xié)議，會觸發(fā) TypeError。如果有第二個實參 sentinel，那么 object 必須是可調(diào)用的對象。這種情況下生成的迭代器，每次迭代調(diào)用它的 __next__() 方法時都會不帶實參地調(diào)用 object；如果返回的結(jié)果是 sentinel 則觸發(fā) StopIteration，否則返回調(diào)用結(jié)果。

另請參閱 迭代器類型。

適合 iter() 的第二種形式的應(yīng)用之一是構(gòu)建塊讀取器。 例如，從二進(jìn)制數(shù)據(jù)庫文件中讀取固定寬度的塊，直至到達(dá)文件的末尾:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(s)

返回對象的長度（元素個數(shù)）。實參可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

class list([iterable])

雖然被稱為函數(shù)，list 實際上是一種可變序列類型，詳情請參閱 列表 和 序列類型 --- list, tuple, range。

locals()

更新并返回表示當(dāng)前本地符號表的字典。 在函數(shù)代碼塊但不是類代碼塊中調(diào)用 locals() 時將返回自由變量。 請注意在模塊層級上，locals() 和 globals() 是同一個字典。

注解

不要更改此字典的內(nèi)容；更改不會影響解釋器使用的局部變量或自由變量的值。

map(function, iterable, ...)

返回一個將 function 應(yīng)用于 iterable 中每一項并輸出其結(jié)果的迭代器。 如果傳入了額外的 iterable 參數(shù)，function 必須接受相同個數(shù)的實參并被應(yīng)用于從所有可迭代對象中并行獲取的項。 當(dāng)有多個可迭代對象時，最短的可迭代對象耗盡則整個迭代就將結(jié)束。 對于函數(shù)的輸入已經(jīng)是參數(shù)元組的情況，請參閱 itertools.starmap()。

max(iterable, *[, key, default])

max(arg1, arg2, *args[, key])

返回可迭代對象中最大的元素，或者返回兩個及以上實參中最大的。

如果只提供了一個位置參數(shù)，它必須是非空 iterable，返回可迭代對象中最大的元素；如果提供了兩個及以上的位置參數(shù)，則返回最大的位置參數(shù)。

有兩個可選只能用關(guān)鍵字的實參。key 實參指定排序函數(shù)用的參數(shù)，如傳給 list.sort() 的。default 實參是當(dāng)可迭代對象為空時返回的值。如果可迭代對象為空，并且沒有給 default ，則會觸發(fā) ValueError。

如果有多個最大元素，則此函數(shù)將返回第一個找到的。這和其他穩(wěn)定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

3.4 新版功能: keyword-only 實參 default 。

class memoryview(obj)

返回由給定實參創(chuàng)建的“內(nèi)存視圖”對象。有關(guān)詳細(xì)信息，請參閱 內(nèi)存視圖。

min(iterable, *[, key, default])

min(arg1, arg2, *args[, key])

返回可迭代對象中最小的元素，或者返回兩個及以上實參中最小的。

如果只提供了一個位置參數(shù)，它必須是 iterable，返回可迭代對象中最小的元素；如果提供了兩個及以上的位置參數(shù)，則返回最小的位置參數(shù)。

有兩個可選只能用關(guān)鍵字的實參。key 實參指定排序函數(shù)用的參數(shù)，如傳給 list.sort() 的。default 實參是當(dāng)可迭代對象為空時返回的值。如果可迭代對象為空，并且沒有給 default ，則會觸發(fā) ValueError。

如果有多個最小元素，則此函數(shù)將返回第一個找到的。這和其他穩(wěn)定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

3.4 新版功能: keyword-only 實參 default 。

next(iterator[, default])

通過調(diào)用 iterator 的 __next__() 方法獲取下一個元素。如果迭代器耗盡，則返回給定的 default，如果沒有默認(rèn)值則觸發(fā) StopIteration。

class object

返回一個沒有特征的新對象。object 是所有類的基類。它具有所有 Python 類實例的通用方法。這個函數(shù)不接受任何實參。

注解

由于 object 沒有 __dict__，因此無法將任意屬性賦給 object 的實例。

oct(x)

將一個整數(shù)轉(zhuǎn)變?yōu)橐粋€前綴為“0o”的八進(jìn)制字符串。結(jié)果是一個合法的 Python 表達(dá)式。如果 x 不是 Python 的 int 對象，那它需要定義 __index__() 方法返回一個整數(shù)。一些例子：

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

如果要將整數(shù)轉(zhuǎn)換為八進(jìn)制字符串，并可選擇有無“0o”前綴，則可以使用如下方法：

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

另見 format() 獲取更多信息。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

打開 file 并返回對應(yīng)的 file object。如果該文件不能打開，則觸發(fā) OSError。

file 是一個 path-like object，表示將要打開的文件的路徑（絕對路徑或者當(dāng)前工作目錄的相對路徑），也可以是要被封裝的整數(shù)類型文件描述符。（如果是文件描述符，它會隨著返回的 I/O 對象關(guān)閉而關(guān)閉，除非 closefd 被設(shè)為 False 。）

mode 是一個可選字符串，用于指定打開文件的模式。默認(rèn)值是 'r' ，這意味著它以文本模式打開并讀取。其他常見模式有：寫入 'w' （截斷已經(jīng)存在的文件）；排它性創(chuàng)建 'x' ；追加寫 'a' （在 一些 Unix 系統(tǒng)上，無論當(dāng)前的文件指針在什么位置，所有 寫入都會追加到文件末尾）。在文本模式，如果 encoding 沒有指定，則根據(jù)平臺來決定使用的編碼：使用 locale.getpreferredencoding(False) 來獲取本地編碼。（要讀取和寫入原始字節(jié)，請使用二進(jìn)制模式并不要指定 encoding。）可用的模式有：

字符	含義
'r'	讀取（默認(rèn)）
'w'	寫入，并先截斷文件
'x'	排它性創(chuàng)建，如果文件已存在則失敗
'a'	寫入，如果文件存在則在末尾追加
'b'	二進(jìn)制模式
't'	文本模式（默認(rèn)）
'+'	更新磁盤文件（讀取并寫入）

默認(rèn)的模式是 'r' （打開并讀取文本，同 'rt' ）。對于二進(jìn)制寫入， 'w+b' 模式打開并把文件截斷成 0 字節(jié)； 'r+b' 則不會截斷。

正如在 概述 中提到的，Python區(qū)分二進(jìn)制和文本I/O。以二進(jìn)制模式打開的文件（包括 mode 參數(shù)中的 'b' ）返回的內(nèi)容為 bytes`對象，不進(jìn)行任何解碼。在文本模式下（默認(rèn)情況下，或者在 *mode* 參數(shù)中包含 `'t'` ）時，文件內(nèi)容返回為 str ，首先使用指定的 encoding （如果給定）或者使用平臺默認(rèn)的的字節(jié)編碼解碼。

此外還允許使用一個模式字符 'U'，該字符已不再具有任何效果，并被視為已棄用。 之前它會在文本模式中啟用 universal newlines，這在 Python 3.0 中成為默認(rèn)行為。 請參閱 newline 形參的文檔了解更多細(xì)節(jié)。

注解

Python不依賴于底層操作系統(tǒng)的文本文件概念;所有處理都由Python本身完成，因此與平臺無關(guān)。

buffering 是一個可選的整數(shù)，用于設(shè)置緩沖策略。傳遞0以切換緩沖關(guān)閉（僅允許在二進(jìn)制模式下），1選擇行緩沖（僅在文本模式下可用），并且>1的整數(shù)以指示固定大小的塊緩沖區(qū)的大小（以字節(jié)為單位）。如果沒有給出 buffering 參數(shù)，則默認(rèn)緩沖策略的工作方式如下:

• 二進(jìn)制文件以固定大小的塊進(jìn)行緩沖；使用啟發(fā)式方法選擇緩沖區(qū)的大小，嘗試確定底層設(shè)備的“塊大小”或使用 io.DEFAULT_BUFFER_SIZE。在許多系統(tǒng)上，緩沖區(qū)的長度通常為4096或8192字節(jié)。

• “交互式”文本文件（ isatty() 返回 True 的文件）使用行緩沖。其他文本文件使用上述策略用于二進(jìn)制文件。

encoding 是用于解碼或編碼文件的編碼的名稱。這應(yīng)該只在文本模式下使用。默認(rèn)編碼是依賴于平臺的（不 管 locale.getpreferredencoding() 返回何值），但可以使用任何Python支持的 text encoding 。有關(guān)支持的編碼列表，請參閱 codecs 模塊。

errors 是一個可選的字符串參數(shù)，用于指定如何處理編碼和解碼錯誤 - 這不能在二進(jìn)制模式下使用。可以使用各種標(biāo)準(zhǔn)錯誤處理程序（列在 錯誤處理方案 ），但是使用 codecs.register_error() 注冊的任何錯誤處理名稱也是有效的。標(biāo)準(zhǔn)名稱包括:

• 如果存在編碼錯誤，'strict' 會引發(fā) ValueError 異常。 默認(rèn)值 None 具有相同的效果。

• 'ignore' 忽略錯誤。請注意，忽略編碼錯誤可能會導(dǎo)致數(shù)據(jù)丟失。

• 'replace' 會將替換標(biāo)記（例如 '?' ）插入有錯誤數(shù)據(jù)的地方。

• 'surrogateescape' 將表示任何不正確的字節(jié)作為Unicode專用區(qū)中的代碼點，范圍從U+DC80到U+DCFF。當(dāng)在寫入數(shù)據(jù)時使用 surrogateescape 錯誤處理程序時，這些私有代碼點將被轉(zhuǎn)回到相同的字節(jié)中。這對于處理未知編碼的文件很有用。

• 只有在寫入文件時才支持 'xmlcharrefreplace'。編碼不支持的字符將替換為相應(yīng)的XML字符引用 &#nnn;。

• 'backslashreplace' 用Python的反向轉(zhuǎn)義序列替換格式錯誤的數(shù)據(jù)。

• 'namereplace' （也只在編寫時支持）用 \N{...} 轉(zhuǎn)義序列替換不支持的字符。

newline 控制 universal newlines 模式如何生效（它僅適用于文本模式）。它可以是 None，''，'\n'，'\r' 和 '\r\n'。它的工作原理:

• 從流中讀取輸入時，如果 newline 為 None，則啟用通用換行模式。輸入中的行可以以 '\n'，'\r' 或 '\r\n' 結(jié)尾，這些行被翻譯成 '\n' 在返回呼叫者之前。如果它是 ''，則啟用通用換行模式，但行結(jié)尾將返回給調(diào)用者未翻譯。如果它具有任何其他合法值，則輸入行僅由給定字符串終止，并且行結(jié)尾將返回給未調(diào)用的調(diào)用者。

• 將輸出寫入流時，如果 newline 為 None，則寫入的任何 '\n' 字符都將轉(zhuǎn)換為系統(tǒng)默認(rèn)行分隔符 os.linesep。如果 newline 是 '' 或 '\n'，則不進(jìn)行翻譯。如果 newline 是任何其他合法值，則寫入的任何 '\n' 字符將被轉(zhuǎn)換為給定的字符串。

如果 closefd 是 False 并且給出了文件描述符而不是文件名，那么當(dāng)文件關(guān)閉時，底層文件描述符將保持打開狀態(tài)。如果給出文件名則 closefd 必須為 True （默認(rèn)值），否則將引發(fā)錯誤。

可以通過傳遞可調(diào)用的 opener 來使用自定義開啟器。然后通過使用參數(shù)（ file，flags ）調(diào)用 opener 獲得文件對象的基礎(chǔ)文件描述符。 opener 必須返回一個打開的文件描述符（使用 os.open as opener 時與傳遞 None 的效果相同）。

新創(chuàng)建的文件是 不可繼承的。

下面的示例使用 os.open() 函數(shù)的 dir_fd 的形參，從給定的目錄中用相對路徑打開文件:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

open() 函數(shù)所返回的 file object 類型取決于所用模式。 當(dāng)使用 open() 以文本模式 ('w', 'r', 'wt', 'rt' 等) 打開文件時，它將返回 io.TextIOBase (特別是 io.TextIOWrapper) 的一個子類。 當(dāng)使用緩沖以二進(jìn)制模式打開文件時，返回的類是 io.BufferedIOBase 的一個子類。 具體的類會有多種：在只讀的二進(jìn)制模式下，它將返回 io.BufferedReader；在寫入二進(jìn)制和追加二進(jìn)制模式下，它將返回 io.BufferedWriter，而在讀/寫模式下，它將返回 io.BufferedRandom。 當(dāng)禁用緩沖時，則會返回原始流，即 io.RawIOBase 的一個子類 io.FileIO。

另請參閱文件操作模塊，例如 fileinput、io （聲明了 open()）、os、os.path、tempfile 和 shutil。

在 3.3 版更改:

• 增加了 opener 形參。

• 增加了 'x' 模式。

• 過去觸發(fā)的 IOError，現(xiàn)在是 OSError 的別名。

• 如果文件已存在但使用了排它性創(chuàng)建模式（ 'x' ），現(xiàn)在會觸發(fā) FileExistsError。

在 3.4 版更改:

• 文件現(xiàn)在禁止繼承。

Deprecated since version 3.4, will be removed in version 3.9: 'U' 模式。

在 3.5 版更改:

• 如果系統(tǒng)調(diào)用被中斷，但信號處理程序沒有觸發(fā)異常，此函數(shù)現(xiàn)在會重試系統(tǒng)調(diào)用，而不是觸發(fā) InterruptedError 異常 (原因詳見 PEP 475)。

• 增加了 'namereplace' 錯誤處理接口。

在 3.6 版更改:

• 增加對實現(xiàn)了 os.PathLike 對象的支持。

• 在 Windows 上，打開一個控制臺緩沖區(qū)將返回 io.RawIOBase 的子類，而不是 io.FileIO。

ord(c)

對表示單個 Unicode 字符的字符串，返回代表它 Unicode 碼點的整數(shù)。例如 ord('a') 返回整數(shù) 97， ord('€') （歐元符號）返回 8364 。這是 chr() 的逆函數(shù)。

pow(x, y[, z])

返回 x 的 y 次冪；如果 z 存在，則對 z 取余（比直接 pow(x, y) % z 計算更高效）。兩個參數(shù)形式的 pow(x, y) 等價于冪運算符： x**y。

參數(shù)必須為數(shù)值類型。 對于混用的操作數(shù)類型，則適用二元算術(shù)運算符的類型強(qiáng)制轉(zhuǎn)換規(guī)則。 對于 int 操作數(shù)，結(jié)果具有與操作數(shù)相同的類型（轉(zhuǎn)換后），除非第二個參數(shù)為負(fù)值；在這種情況下，所有參數(shù)將被轉(zhuǎn)換為浮點數(shù)并輸出浮點數(shù)結(jié)果。 例如，10**2 返回 100，但 10**-2 返回 0.01。 如果第二個參數(shù)為負(fù)值，則第三個參數(shù)必須省略。 如果存在 z，則 x 和 y 必須為整數(shù)類型，且 y 必須為非負(fù)數(shù)。

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

將 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在，它們必須以關(guān)鍵字參數(shù)的形式給出。

所有非關(guān)鍵字參數(shù)都會被轉(zhuǎn)換為字符串，就像是執(zhí)行了 str() 一樣，并會被寫入到流，以 sep 且在末尾加上 end。 sep 和 end 都必須為字符串；它們也可以為 None，這意味著使用默認(rèn)值。 如果沒有給出 objects，則 print() 將只寫入 end。

file 參數(shù)必須是一個具有 write(string) 方法的對象；如果參數(shù)不存在或為 None，則將使用 sys.stdout。 由于要打印的參數(shù)會被轉(zhuǎn)換為文本字符串，因此 print() 不能用于二進(jìn)制模式的文件對象。 對于這些對象，應(yīng)改用 file.write(...)。

輸出是否被緩存通常決定于 file，但如果 flush 關(guān)鍵字參數(shù)為真值，流會被強(qiáng)制刷新。

在 3.3 版更改: 增加了 flush 關(guān)鍵字參數(shù)。

class property(fget=None, fset=None, fdel=None, doc=None)

返回 property 屬性。

fget 是獲取屬性值的函數(shù)。 fset 是用于設(shè)置屬性值的函數(shù)。 fdel 是用于刪除屬性值的函數(shù)。并且 doc 為屬性對象創(chuàng)建文檔字符串。

一個典型的用法是定義一個托管屬性 x:

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

如果 c 是 C 的實例，c.x 將調(diào)用getter，c.x = value 將調(diào)用setter， del c.x 將調(diào)用deleter。

如果給出，doc 將成為該 property 屬性的文檔字符串。 否則該 property 將拷貝 fget 的文檔字符串（如果存在）。 這令使用 property() 作為 decorator 來創(chuàng)建只讀的特征屬性可以很容易地實現(xiàn):

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

以上 @property 裝飾器會將 voltage() 方法轉(zhuǎn)化為一個具有相同名稱的只讀屬性的 "getter"，并將 voltage 的文檔字符串設(shè)置為 "Get the current voltage."

特征屬性對象具有 getter, setter 以及 deleter 方法，它們可用作裝飾器來創(chuàng)建該特征屬性的副本，并將相應(yīng)的訪問函數(shù)設(shè)為所裝飾的函數(shù)。 這最好是用一個例子來解釋:

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

上述代碼與第一個例子完全等價。 注意一定要給附加函數(shù)與原始的特征屬性相同的名稱 (在本例中為 x。)

返回的特征屬性對象同樣具有與構(gòu)造器參數(shù)相對應(yīng)的屬性 fget, fset 和 fdel。

在 3.5 版更改: 特征屬性對象的文檔字符串現(xiàn)在是可寫的。

class range(stop)

class range(start, stop[, step])

雖然被稱為函數(shù)，但 range 實際上是一個不可變的序列類型，參見在 range 對象 與 序列類型 --- list, tuple, range 中的文檔說明。

repr(object)

返回包含一個對象的可打印表示形式的字符串。 對于許多類型來說，該函數(shù)會嘗試返回的字符串將會與該對象被傳遞給 eval() 時所生成的對象具有相同的值，在其他情況下表示形式會是一個括在尖括號中的字符串，其中包含對象類型的名稱與通常包括對象名稱和地址的附加信息。 類可以通過定義 __repr__() 方法來控制此函數(shù)為它的實例所返回的內(nèi)容。

reversed(seq)

返回一個反向的 iterator。 seq 必須是一個具有 __reversed__() 方法的對象或者是支持該序列協(xié)議（具有從 0 開始的整數(shù)類型參數(shù)的 __len__() 方法和 __getitem__() 方法）。

round(number[, ndigits])

返回 number 舍入到小數(shù)點后 ndigits 位精度的值。 如果 ndigits 被省略或為 None，則返回最接近輸入值的整數(shù)。

對于支持 round() 的內(nèi)置類型，值會被舍入到最接近的 10 的負(fù) ndigits 次冪的倍數(shù)；如果與兩個倍數(shù)的距離相等，則選擇偶數(shù) (因此，round(0.5) 和 round(-0.5) 均為 0 而 round(1.5) 為 2)。 任何整數(shù)值都可作為有效的 ndigits (正數(shù)、零或負(fù)數(shù))。 如果 ndigits 被省略或為 None 則返回值將為整數(shù)。 否則返回值與 number 的類型相同。

對于一般的 Python 對象 number, round 將委托給 number.__round__。

注解

對浮點數(shù)執(zhí)行 round() 的行為可能會令人驚訝：例如，round(2.675, 2) 將給出 2.67 而不是期望的 2.68。 這不算是程序錯誤：這一結(jié)果是由于大多數(shù)十進(jìn)制小數(shù)實際上都不能以浮點數(shù)精確地表示。 請參閱 浮點算術(shù)：爭議和限制 了解更多信息。

class set([iterable])

返回一個新的 set 對象，可以選擇帶有從 iterable 獲取的元素。 set 是一個內(nèi)置類型。 請查看 set 和 集合類型 --- set, frozenset 獲取關(guān)于這個類的文檔。

有關(guān)其他容器請參看內(nèi)置的 frozenset, list, tuple 和 dict 類，以及 collections 模塊。

setattr(object, name, value)

此函數(shù)與 getattr() 兩相對應(yīng)。 其參數(shù)為一個對象、一個字符串和一個任意值。 字符串指定一個現(xiàn)有屬性或者新增屬性。 函數(shù)會將值賦給該屬性，只要對象允許這種操作。 例如，setattr(x, 'foobar', 123) 等價于 x.foobar = 123。

class slice(stop)

class slice(start, stop[, step])

返回一個表示由 range(start, stop, step) 所指定索引集的 slice 對象。 其中 start 和 step 參數(shù)默認(rèn)為 None。 切片對象具有僅會返回對應(yīng)參數(shù)值（或其默認(rèn)值）的只讀數(shù)據(jù)屬性 start, stop 和 step。 它們沒有其他的顯式功能；不過它們會被 NumPy 以及其他第三方擴(kuò)展所使用。 切片對象也會在使用擴(kuò)展索引語法時被生成。 例如: a[start:stop:step] 或 a[start:stop, i]。 請參閱 itertools.islice() 了解返回迭代器的一種替代版本。

sorted(iterable, *, key=None, reverse=False)

根據(jù) iterable 中的項返回一個新的已排序列表。

具有兩個可選參數(shù)，它們都必須指定為關(guān)鍵字參數(shù)。

key 指定帶有單個參數(shù)的函數(shù)，用于從 iterable 的每個元素中提取用于比較的鍵 (例如 key=str.lower)。 默認(rèn)值為 None (直接比較元素)。

reverse 為一個布爾值。 如果設(shè)為 True，則每個列表元素將按反向順序比較進(jìn)行排序。

使用 functools.cmp_to_key() 可將老式的 cmp 函數(shù)轉(zhuǎn)換為 key 函數(shù)。

內(nèi)置的 sorted() 確保是穩(wěn)定的。 如果一個排序確保不會改變比較結(jié)果相等的元素的相對順序就稱其為穩(wěn)定的 --- 這有利于進(jìn)行多重排序（例如先按部門、再按薪級排序）。

有關(guān)排序示例和簡要排序教程，請參閱 排序指南 。

@staticmethod

將方法轉(zhuǎn)換為靜態(tài)方法。

靜態(tài)方法不會接收隱式的第一個參數(shù)。要聲明一個靜態(tài)方法，請使用此語法

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

@staticmethod 這樣的形式稱為函數(shù)的 decorator -- 詳情參閱 函數(shù)定義。

靜態(tài)方法的調(diào)用可以在類上進(jìn)行 (例如 C.f()) 也可以在實例上進(jìn)行 (例如 C().f())。

Python中的靜態(tài)方法與Java或C ++中的靜態(tài)方法類似。另請參閱 classmethod() ，用于創(chuàng)建備用類構(gòu)造函數(shù)的變體。

像所有裝飾器一樣，也可以像常規(guī)函數(shù)一樣調(diào)用 staticmethod ，并對其結(jié)果執(zhí)行某些操作。比如某些情況下需要從類主體引用函數(shù)并且您希望避免自動轉(zhuǎn)換為實例方法。對于這些情況，請使用此語法:

class C:
    builtin_open = staticmethod(open)

想了解更多有關(guān)靜態(tài)方法的信息，請參閱 標(biāo)準(zhǔn)類型層級結(jié)構(gòu) 。

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')

返回一個 str 版本的 object 。有關(guān)詳細(xì)信息，請參閱 str() 。

str 是內(nèi)置字符串 class 。更多關(guān)于字符串的信息查看 文本序列類型 --- str。

sum(iterable[, start])

從 start 開始自左向右對 iterable 中的項求和并返回總計值。 start 默認(rèn)為 0。 iterable 的項通常為數(shù)字，開始值則不允許為字符串。

對某些用例來說，存在 sum() 的更好替代。 拼接字符串序列的更好更快方式是調(diào)用 ''.join(sequence)。 要以擴(kuò)展精度對浮點值求和，請參閱 math.fsum()。 要拼接一系列可迭代對象，請考慮使用 itertools.chain()。

super([type[, object-or-type]])

返回一個代理對象，它會將方法調(diào)用委托給 type 指定的父類或兄弟類。 這對于訪問已在類中被重載的繼承方法很有用。 搜索順序與 getattr() 所使用的相同，只是 type 指定的類型本身會被跳過。

type 的 __mro__ 屬性列出了 getattr() 和 super() 所使用的方法解析順序。 該屬性是動態(tài)的，可以在繼承層級結(jié)構(gòu)更新的時候任意改變。

如果省略第二個參數(shù)，則返回的超類對象是未綁定的。 如果第二個參數(shù)為一個對象，則 isinstance(obj, type) 必須為真值。 如果第二個參數(shù)為一個類型，則 issubclass(type2, type) 必須為真值（這適用于類方法）。

super 有兩個典型用例。 在具有單繼承的類層級結(jié)構(gòu)中，super 可用來引用父類而不必顯式地指定它們的名稱，從而令代碼更易維護(hù)。 這種用法與其他編程語言中 super 的用法非常相似。

第二個用例是在動態(tài)執(zhí)行環(huán)境中支持協(xié)作多重繼承。 此用例為 Python 所獨有，在靜態(tài)編譯語言或僅支持單繼承的語言中是不存在的。 這使得實現(xiàn)“菱形圖”成為可能，在這時會有多個基類實現(xiàn)相同的方法。 好的設(shè)計強(qiáng)制要求這種方法在每個情況下具有相同的調(diào)用簽名（因為調(diào)用順序是在運行時確定的，也因為該順序要適應(yīng)類層級結(jié)構(gòu)的更改，還因為該順序可能包含在運行時之前未知的兄弟類）。

對于以上兩個用例，典型的超類調(diào)用看起來是這樣的:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

除了方法查找之外，super() 也可用于屬性查找。 一個可能的此種用例是在上級或同級類中調(diào)用 descriptor。

請注意 super() 是作為顯式加點屬性查找的綁定過程的一部分來實現(xiàn)的，例如 super().__getitem__(name)。 它做到這一點是通過實現(xiàn)自己的 __getattribute__() 方法，這樣就能以可預(yù)測的順序搜索類，并且支持協(xié)作多重繼承。 對應(yīng)地，super() 在像 super()[name] 這樣使用語句或操作符進(jìn)行隱式查找時則未被定義。

還要注意的是，除了零個參數(shù)的形式以外，super() 并不限于在方法內(nèi)部使用。 兩個參數(shù)的形式明確指定參數(shù)并進(jìn)行相應(yīng)的引用。 零個參數(shù)的形式僅適用于類定義內(nèi)部，因為編譯器需要填入必要的細(xì)節(jié)以正確地檢索到被定義的類，還需要讓普通方法訪問當(dāng)前實例。

對于有關(guān)如何使用 super() 來如何設(shè)計協(xié)作類的實用建議，請參閱 使用 super() 的指南。

class tuple([iterable])

雖然被稱為函數(shù)，但 tuple 實際上是一個不可變的序列類型，參見在 元組 與 序列類型 --- list, tuple, range 中的文檔說明。

class type(object)

class type(name, bases, dict)

傳入一個參數(shù)時，返回 object 的類型。 返回值是一個 type 對象，通常與 object.__class__ 所返回的對象相同。

推薦使用 isinstance() 內(nèi)置函數(shù)來檢測對象的類型，因為它會考慮子類的情況。

傳入三個參數(shù)時，返回一個新的 type 對象。 這在本質(zhì)上是 class 語句的一種動態(tài)形式。 name 字符串即類名并且會成為 __name__ 屬性；bases 元組列出基類并且會成為 __bases__ 屬性；而 dict 字典為包含類主體定義的命名空間并且會被復(fù)制到一個標(biāo)準(zhǔn)字典成為 __dict__ 屬性。 例如，下面兩條語句會創(chuàng)建相同的 type 對象:

>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))

另請參閱 類型對象。

在 3.6 版更改: type 的子類如果未重載 type.__new__，將不再能使用一個參數(shù)的形式來獲取對象的類型。

vars([object])

返回模塊、類、實例或任何其它具有 __dict__ 屬性的對象的 __dict__ 屬性。

模塊和實例這樣的對象具有可更新的 __dict__ 屬性；但是，其它對象的 __dict__ 屬性可能會設(shè)為限制寫入（例如，類會使用 types.MappingProxyType 來防止直接更新字典）。

不帶參數(shù)時，vars() 的行為類似 locals()。 請注意，locals 字典僅對于讀取起作用，因為對 locals 字典的更新會被忽略。

zip(*iterables)

創(chuàng)建一個聚合了來自每個可迭代對象中的元素的迭代器。

返回一個元組的迭代器，其中的第 i 個元組包含來自每個參數(shù)序列或可迭代對象的第 i 個元素。 當(dāng)所輸入可迭代對象中最短的一個被耗盡時，迭代器將停止迭代。 當(dāng)只有一個可迭代對象參數(shù)時，它將返回一個單元組的迭代器。 不帶參數(shù)時，它將返回一個空迭代器。 相當(dāng)于:

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

函數(shù)會保證可迭代對象按從左至右的順序被求值。 使得可以通過 zip(*[iter(s)]*n) 這樣的慣用形式將一系列數(shù)據(jù)聚類為長度為 n 的分組。 這將重復(fù) 同樣的 迭代器 n 次，以便每個輸出的元組具有第 n 次調(diào)用該迭代器的結(jié)果。 它的作用效果就是將輸入拆分為長度為 n 的數(shù)據(jù)塊。

當(dāng)你不用關(guān)心較長可迭代對象末尾不匹配的值時，則 zip() 只須使用長度不相等的輸入即可。 如果那些值很重要，則應(yīng)改用 itertools.zip_longest()。

zip() 與 * 運算符相結(jié)合可以用來拆解一個列表:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

__import__(name, globals=None, locals=None, fromlist=(), level=0)

注解

與 importlib.import_module() 不同，這是一個日常 Python 編程中不需要用到的高級函數(shù)。

此函數(shù)會由 import 語句發(fā)起調(diào)用。 它可以被替換 (通過導(dǎo)入 builtins 模塊并賦值給 builtins.__import__) 以便修改 import 語句的語義，但是 強(qiáng)烈 不建議這樣做，因為使用導(dǎo)入鉤子 (參見 PEP 302) 通常更容易實現(xiàn)同樣的目標(biāo)，并且不會導(dǎo)致代碼問題，因為許多代碼都會假定所用的是默認(rèn)實現(xiàn)。 同樣也不建議直接使用 __import__() 而應(yīng)該用 importlib.import_module()。

該函數(shù)會導(dǎo)入 name 模塊，有可能使用給定的 globals 和 locals 來確定如何在包的上下文中解讀名稱。 fromlist 給出了應(yīng)該從由 name 指定的模塊導(dǎo)入對象或子模塊的名稱。 標(biāo)準(zhǔn)實現(xiàn)完全不使用其 locals 參數(shù)，而僅使用 globals 參數(shù)來確定 import 語句的包上下文。

level 指定是使用絕對還是相對導(dǎo)入。 0 (默認(rèn)值) 意味著僅執(zhí)行絕對導(dǎo)入。 level 為正數(shù)值表示相對于模塊調(diào)用 __import__() 的目錄，將要搜索的父目錄層數(shù) (詳情參見 PEP 328)。

當(dāng) name 變量的形式為 package.module 時，通常將會返回最高層級的包（第一個點號之前的名稱），而 不是 以 name 命名的模塊。 但是，當(dāng)給出了非空的 fromlist 參數(shù)時，則將返回以 name 命名的模塊。

例如，語句 import spam 的結(jié)果將為與以下代碼作用相同的字節(jié)碼:

spam = __import__('spam', globals(), locals(), [], 0)

語句 import spam.ham 的結(jié)果將為以下調(diào)用:

spam = __import__('spam.ham', globals(), locals(), [], 0)

請注意在這里 __import__() 是如何返回頂層模塊的，因為這是通過 import 語句被綁定到特定名稱的對象。

另一方面，語句 from spam.ham import eggs, sausage as saus 的結(jié)果將為

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

在這里， spam.ham 模塊會由 __import__() 返回。 要導(dǎo)入的對象將從此對象中提取并賦值給它們對應(yīng)的名稱。

如果您只想按名稱導(dǎo)入模塊（可能在包中），請使用 importlib.import_module()

在 3.3 版更改: Negative values for level are no longer supported (which also changes the default value to 0).

備注

1

解析器只接受 Unix 風(fēng)格的行結(jié)束符。如果您從文件中讀取代碼，請確保用換行符轉(zhuǎn)換模式轉(zhuǎn)換 Windows 或 Mac 風(fēng)格的換行符。