[雪峯磁針石博客]python3標準庫-中文版2:內置函數

		內置功能
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	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()
delattr()	hash()	memoryview()	set()

abs(x)

返回絕對值。 參數能夠是整數或浮點數。 若是參數是複數，則返回其大小。

all(iterable)

若是iterable中全部的元素都爲True，或iterable爲空（empty），返回True。至關於以下: 若是迭代器的全部元素均爲真（或迭代器爲空），則返回True 。 至關於：

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

any(iterable)

若是iterable裏任何一個元素爲True，返回 True。若是iterable爲空（empty）,返回 False。至關於以下:

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

ascii(object)

相似repr()，用 \x，\u 或者\U 進行對非 ASCII 字符轉義，相似repr() 在 Python 2 中返回的字符串。

bin(x)

將整數轉換爲二進制字符串。結果是有效的Python表達式。若是 x 不是 Python int類型的對象，須要定義返回是整數的__index__() 方法。

#!python
>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

去掉0b

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

bool([x])

返回布爾值，True 或 False。將會使用真值測標準(truth testing procedure)對x 進行轉換。若是 x 的值爲 false 或被省略，這將返回 False;不然返回 True。bool 類(bool )是 int 的子類。它不能有子類。其惟一的實例是 False 和 True。

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

返回新的字節數組。bytearray 類整數的可變序列，範圍爲0 < = x < 256。它包含了可變序列大部分的經常使用方法，參見Mutable Sequence Types, ，同時也包含了bytes 類型的大部分方法，參見Bytes and Bytearray Operations。

可選的source參數能夠用幾種不一樣的方式初始化數組：

• 字符串 string，應該直接在參數中指定編碼類型，例如：utf-8(以及可選參數 errors)；bytearray() 將使用 str.encode()按照編碼轉化字符串爲字節序列。
• 整數，則該數組將具備該大小並將用空字節進行初始化。
• 符合緩衝區接口的對象，則將使用該對象的只讀緩衝區來初始化字節數組。
• 迭代類型iterable，其整數元素的取值範圍是0 <= x < 256，通常用做數組的初始內容。

沒有參數，就會建立一個大小爲0的數組。

參見 Binary Sequence Types — bytes, bytearray, memoryview和Bytearray Objects.

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

返回新的字節對象，在 0<= x < 256之間的不可變的整數序列。 bytes 是 bytearray 的不可變版本 – 它具備一樣的非改變性的方法和一樣的索引和切片操做

所以，構造函數參數的解釋與bytearray()相同。

字節對象也能夠用字面值建立，參見字符串和字節字面值。

參考資料: Binary Sequence Types — bytes, bytearray, memoryview, Bytes Objects, 和Bytes and Bytearray Operations.

callable(object)

若是該 object是可調用的，返回 True ,不然返回 False 。若是返回True，調用仍有可能失敗；可是若是返回False，對object的調用老是失敗。請注意，類是可調用的（調用類將返回實例）。若是實例的類有__call__()方法，則它是可調用；不然是不可調用的。

在 3.2版本的更新:這個函數第一次在 Python 3.0 中被移除，在Python 3.2.中被從新啓用

chr(i)

返回Unicode碼。例如，chr(97)返回字符串'a'，而chr(8364)返回字符串'€'。它是ord()的逆操做。

參數的有效範圍是從0到1,114,111（基於16的0x10FFFF）。若是i超出該範圍，則會引起ValueError。

classmethod(function)

將函數轉換爲類方法。

類方法將類做爲隱式第一個參數接收，就像實例方法接收實例同樣。要聲明一個類方法，使用這個習慣用法：

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

@classmethod形式是一個函數裝飾器 —— 查看函數定義中關於函數定義的詳細說明。

它既能夠在類上調用（如C.f()）也能夠在實例上調用（如C().f()）。該實例被忽略，除了它的類。若是一個類方法在子類上調用，那麼子類對象被傳遞爲隱式的第一個參數。

類方法與C ++或Java靜態方法不一樣。若是你須要靜態方法，參見本節中的staticmethod()。

關於類方法更多的信息，參考標註類型的層級中的標準類型層級的文檔。

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

將source編譯成代碼或AST對象。代碼對象能夠由exec()或eval()執行。source能夠是普通字符串，字節字符串或AST對象。有關如何使用AST對象的信息，請參閱ast模塊文檔。

filename參數是要從中讀取代碼的文件名；若是它不是從文件中讀取的話，須要傳入一些可識別的內容（一般使用'string'）

mode 參數指定必須編譯模式；若是source由語句序列組成，則它能夠是'exec'；若是它是單個語句，則可使用'eval'；若是它由單個交互式語句組成，則可使用'single'。（在最後一種狀況下，非None語句將會被打印出來）

可選參數flags和dont_inherit控制哪些將來版本的語句（見 PEP 236）會應用於源編譯。若是二者都不存在（或二者均爲零），則代碼將與正在調用compile()的代碼中的那些未來的語句一塊兒編譯。若是給出flags參數而且dont_inherit不是（或爲零），那麼除了使用flags參數指定的將來語句那些將被使用的東西。若是dont_inherit是一個非零整數，那麼flags參數就是它 - 圍繞編譯調用生效的將來語句將被忽略。

未來的語句由能夠按位或運算來指定多個語句的位指定。指定給定特徵所需的位域能夠在__future__模塊中的_Feature實例上的compiler_flag屬性中找到。

參數optimize指定編譯器的優化級別； -1的默認值選擇由-O選項給出的解釋器的優化級別。顯式級別爲0（無優化； __debug__爲真），1（聲明被刪除，__debug__爲假 ）或2（docstrings也被刪除）。

若是編譯的源代碼無效，則此函數引起SyntaxError；若是源代碼包含空字節，則此函數引起ValueError。

若是要將Python代碼解析爲其AST表示形式，請參閱ast.parse()。

注意

在'single'或'eval'模式下編譯具備多行代碼的字符串時，輸入必須至少由一個換行符終止。這是爲了便於在code模塊中檢測不完整和完整的語句。

在版本3.2中更改：容許使用Windows和Mac換行符。在'exec'模式下輸入也沒必要以換行符結束。添加了optimize參數。

在版本3.5中更改：之前，在source中遇到空字節時引起TypeError。

class complex([real[, imag]])

返回值形式爲real + imag * 1j的複數，或將字符串或數字轉換爲複數。若是第一個參數是一個字符串，它將被解釋爲一個複數，而且該函數必須在沒有第二個參數的狀況下被調用。第二個參數不能是一個字符串。每一個參數能夠是任何數字類型（包括複數）。若是省略imag，則默認爲零，構造函數會像int和float同樣進行轉換。若是省略這兩個參數，則返回0j。

注意

從字符串轉換時，該字符串不得在中央+或-運算符周圍包含空格。For example, complex('1+2j') is fine, but complex('1 + 2j') raises ValueError.

複數類型在數字類型 - int，float，complex中描述。

delattr(object, name)

這是setattr()的相對值。參數是一個對象和一個字符串。該字符串必須是對象屬性之一的名稱。該函數刪除指定的屬性，只要該對象容許。For example, delattr(x, 'foobar') is equivalent to del x.foobar.

class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg)

建立一個新的字典。dict對象是字典類。有關此類的文檔，請參見dict和映射類型 - dict。

對於其餘容器，請參閱內置的列表，集合和元組類以及容器 。

dir([object])

不帶參數時, 在當前本地做用域中返回名稱列表。帶參數時, 嘗試返回參數object的有效屬性列表。

若是對象具備名爲__dir__()的方法，那麼將調用此方法，而且必須返回屬性列表。這容許實現自定義__getattr__()或__getattribute__()函數的對象自定義dir()報告其屬性的方式。

若是對象不提供__dir__()，則函數會盡可能從對象的__dict__屬性（若是已定義）和其類型對象中收集信息。結果列表不必定是完整的，而且當對象具備自定義__getattr__()時，可能不許確。

默認的dir()機制對於不一樣類型的對象具備不一樣的行爲，由於它嘗試生成最相關，而不是完整的信息：

    若是對象是模塊對象，列表包含模塊的屬性名。
    若是對象是一個類型或類對象，則該列表包含其屬性的名稱，並遞歸地顯示其基礎的屬性。
    不然，該列表包含對象的屬性名稱，其類屬性的名稱以及其類的基類的屬性的遞歸。

結果列表按字母順序排序。例如：
>>>

>>> 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()主要是方便在交互式環境中使用，它嘗試提供一組有用的名稱，而不是試圖提供完整或一致性的名稱集合，具體的行爲在不一樣的版本之間會有變化。例如，當參數是一個類時，元類屬性不在結果列表中。

divmod(a, b)

以兩個（非複數）數字做爲參數，並在使用整數除法時返回由它們的商和餘數組成的一對數字。使用混合操做數類型時，適用二元算術運算符的規則。對於整數，結果與（a // b， a ％ b）相同。對於浮點數，結果爲（q， a ％ b），其中q一般爲math.floor(a / b)，也有可能比這個結果小1。In any case q * b + a % b is very close to a, if a % b is non-zero it has the same sign as b, and 0 <= abs(a % b) < abs(b).

enumerate(iterable, start=0)

返回一個枚舉對象。iterable 必須是一個序列、一個迭代器，或者其它某種支持迭代的對象。enumerate()返回的迭代器的__next__()方法返回一個元組，該元組包含一個計數（從start開始，默認爲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=None, locals=None)

參數是一個字符串和可選的全局變量和局部變量。If provided, globals must be a dictionary. If provided, locals can be any mapping object.

使用globals和locals字典將表達式參數解析並計算爲Python表達式（技術上講是條件列表），並將其做爲全局和本地命名空間。若是globals字典存在而且缺乏'__builtins__'，則在解析表達式以前，將當前全局變量複製到全局變量中。這意味着expression一般具備對標準builtins的徹底訪問權限，而且傳播受限環境。若是省略locals詞典，則默認爲globals詞典。若是兩個字典都省略，則在調用eval()的環境中執行表達式。返回值是評估表達式的結果。語法錯誤被報告爲例外。例：
>>>

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

此函數也可用於執行任意代碼對象（例如由compile()建立的代碼對象）。在這種狀況下，傳遞一個代碼對象而不是一個字符串。若是代碼對象已使用'exec'做爲mode參數編譯，則eval()的返回值將爲None 。

提示：exec()函數支持語句的動態執行。globals()和locals()函數分別返回當前的全局和局部字典，能夠用於傳遞給eval或exec()。

請參見ast.literal_eval()這個函數，它能夠安全地計算只包含字面值表達式的字符串。

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

這個函數支持動態執行Python代碼。object必須是一個字符串或代碼對象。若是它是一個字符串，則將該字符串解析爲一組Python語句，而後執行該語句（除非發生語法錯誤）。[1]若是它是一個代碼對象，只是簡單地執行它。在全部狀況下，執行的代碼應該能夠做爲有效的文件輸入（參見「參考手冊」中的「文件輸入」部分）。請注意，即便在傳遞給exec()函數的代碼上下文中，函數定義外面的return和yield 語句可能不被執行。返回值爲None。

在全部狀況下，若是省略可選部件，則代碼將在當前範圍內執行。若是隻提供globals，它必須是一個字典，它將用於全局變量和局部變量。若是提供globals和locals，它們分別用於全局變量和局部變量。If provided, locals can be any mapping object. 請記住，在模塊級別，全局變量和本地變量是相同的字典。若是exec的globals和locals是獨立的兩個對象，代碼的執行就像它嵌入在類定義中同樣。

若是globals字典的__builtins__鍵沒有值，則會給這個賦予一個內置模塊builtins字典的引用。這樣，你能夠在將globals傳遞給exec()以前插入本身的__builtins__字典，來控制執行的代碼可訪問的builtins。

注

內置函數globals()和locals()分別返回當前全局和局部字典，它們能夠用作傳遞給exec()的第二和第三個參數。

注意

默認locals的做用與下面的函數locals()描述的同樣：不該該嘗試修改默認的locals詞典。若是在函數exec()返回後，須要在locals上查看代碼的效果，請傳遞一個明確的locals字典。

filter(function, iterable)

用iterable中傳入function後返回True的元素構造一個迭代器。iterable能夠是序列，支持迭代的容器或迭代器。若是function是None，使用特性函數，即爲False的iterable中的元素被移除。

注意filter(function, iterable) 若是函數不是 None等效於生成器表達式 (item for item in iterable if function(item)) 。若是函數是 None ，(item for item in iterable if item)

請參閱itertools.filterfalse()，該函數返回函數返回false的iterable元素。

float

• class float([x])

返回由數字或字符串x構造的浮點數。

若是參數是字符串，它應該爲十進制數字，可能以符號開頭，而且能夠嵌入空格。符號的sign能夠是'+'或'–'； '+'對生成的值沒有影響。該參數也能夠是表示NaN或正或負無窮大的字符串。更確切地說，在刪除先後空白字符後，輸入必須符合如下語法：

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

floatnumber是Python浮點字面值的形式。inf」，「Inf」，「INFINITY」和「iNfINity」對於正無窮大都是可接受的拼寫。

若是參數是整數或浮點數，則返回具備相同值（在Python的浮點精度內）的浮點數。若是參數在Python浮點數的範圍以外，則引起OverflowError。

對於通常的Python對象x，float(x)藉助給x .float()。

若是沒有給出參數，則返回0.0。

例子：

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

float類型在 [Numeric Types — int, float, complex](https://docs.python.org/3/library/stdtypes.html#typesnumeric)中描述。

在版本3.6中更改：容許使用下劃線對代碼進行分組。

format(value[, format_spec])

將值轉換爲「格式化」表示，由format_spec控制。format_spec的解釋將取決於值參數的類型，可是存在大多數內置類型使用的標準格式化語法：Format Specification Mini-Language

默認的format_spec是一個空字符串，一般給出與調用str（value）相同的效果。

將格式（值， format_spec）的調用轉換爲類型（值）.__格式__（值， t4> format_spec），它們在搜索值的__format__()方法時繞過實例字典。若是方法搜索到達object且format_spec不爲空，或者format_spec異常，則會引起TypeError t7>或返回值不是字符串。

Changed in version 3.4: object().__format__(format_spec) raises TypeError if format_spec is not an empty string.

class frozenset([iterable])

返回一個新的frozenset對象，可選地使用iterable中的元素。frozenset是一個內置類。有關此類的文檔，請參見frozenset和設置類型 - 集合，frozenset。

對於其餘容器，請參閱內置的set，list，tuple和dict類以及collections模塊。

getattr(object, name[, default])

返回對象的命名屬性的值。名稱必須是字符串。若是字符串是對象屬性之一的名稱，則結果是該屬性的值。例如，getattr(x, 'foobar')等同於x.foobar。若是這個名字的屬性不存在，若是提供default則返回它，不然引起AttributeError。

globals()

返回表示當前全局符號表的字典。這老是當前模塊的字典（在函數或方法內部，這是定義它的模塊，而不是調用它的模塊）。

hasattr(object, name)

參數是一個對象和一個字符串。若是字符串是對象的一個屬性，則返回True，不然返回False。（它的實現是經過調用getattr(object, name)並查看它是否引起一個AttributeError）。

hash(object)

返回該對象的哈希值（若是有的話）. 哈希值應該是一個整數。哈希值用於在查找字典時快速地比較字典的鍵。相等數值的哈希值相同（即便它們的類型不一樣，好比1和1.0）.

注意

對於具備自定義__hash__()方法的對象，請注意，hash()根據主機的位寬截斷返回值。有關詳細信息，請參見__hash__()。

help([object])

調用內置的幫助系統。（此功能用於交互式使用。）若是沒有提供參數，則交互式幫助系統將在解釋器控制檯上啓動。若是參數是一個字符串，那麼該字符串將被查找爲模塊，函數，類，方法，關鍵字或文檔主題的名稱，並在控制檯上打印幫助頁面。若是參數是任何其餘類型的對象，則會生成對象上的幫助頁面。

該函數加入內置函數的名字空間，函數收錄在site 模塊裏.

在版本3.4中更改：對pydoc和inspect的更改意味着可報告的已報告簽名如今更加全面和一致。

hex(x)

將整數轉換爲以「0x」爲前綴的小寫十六進制字符串,若是x不是Python int對象，它必須定義__index__()方法，返回整數。

#!python
>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

格式化

#!python
>>> '%#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')

要獲取浮點型的十六進制字符串表示形式，請使用float.hex()方法。

id(object)

返回一個對象的「身份」。這是一個整數，它保證在該對象的生命週期內是惟一的和恆定的。具備不重疊壽命的兩個對象能夠具備相同的id()值。

CPython實現細節：這是內存中對象的地址。

input

• input([prompt])

  可選參數prompt輸出到標準輸出(不帶結尾換行符)。函數從輸入中讀取一行，將其轉換爲字符串（剝離尾隨的換行符），而後返回該行。當讀取到EOF時，會產生EOFError。例：

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

若是readline模塊已加載，則input()將使用它提供精細的行編輯和歷史記錄功能。

int: class int(x=0) class int(x, base=10)

從數字或字符串x構造並返回整數對象，若是沒有給出參數，則返回0。若是 x定義了 [`__int__()`](https://docs.python.org/3/reference/datamodel.html#object.__int__ "object.__int__")

，返回x.int()。若是x定義了__trunc__() ，則返回x.trunc()。對於浮點數，將向0截斷。

若是x不是數字或指定了base，那麼x必須是字符串，字節或bytearray實例，它表示以base爲基數的整數文字。文字能夠在前面加上+或 -(二者之間沒有空格)並用空格包圍。 base-n文字由數字0到n-1組成，其中a到z（或A到Z）的值爲10到35.默認基數爲10.容許的值爲0和2-36。 base-2，-8和-16文字能夠有選擇地以0b / 0B，0o / 0O或0x / 0X做爲前綴，就像代碼中的整數文字同樣。基數0表示正確解釋爲代碼字面量，所以實際基數爲2,8,10或16，而且int('010', 0)不合法，而int（'010'）是，以及int（'010'，8）。

整數類型在數值類型 - int，float，complex中描述。

版本3.4中更改：若是base不是int的實例，而且基礎對象具備基礎.__ index__方法，則會調用該方法以獲取基礎的整數。之前的版本使用base .__ int__而不是base .__ index__。

在版本3.6中更改：容許使用下劃線對代碼進行分組。

isinstance(object, classinfo)

若是object是clsaainfo的一個實例（或者是classinfo的直接、間接或虛擬子類的實例），那麼則返回true。若是object不是給定類型的對象，則該函數始終返回false。若是classinfo是類型對象的元組（或者其餘這樣的元組），若是object是任何類型的實例，則返回true。若是classinfo不是類型或類型組成的元祖和此類元組，則會引起TypeError異常。

issubclass(class, classinfo)

若是 class 是classinfo的子類(直接、 間接或 虛擬) 則返回 true 。一個類被認爲是它本身的一個子類。classinfo may be a tuple of class objects, in which case every entry in classinfo will be checked. 在任何其餘狀況下，會引起TypeError異常。

iter(object[, sentinel])

返回一個迭代器對象。根據第二個參數的存在，第一個參數被解釋得很是不一樣。沒有第二個參數，object必須是一個支持迭代協議（__iter__()方法）的容器對象，或者它必須支持序列協議（從 0開始的整數參數的__getitem__() 方法）。若是它不支持這些協議任何一個，將引起TypeError。若是給出第二個參數sentinel，那麼object必須是一個可調用的對象。這種狀況下建立的迭代器將在每次調用時不帶參數調用object的__next__()方法；若是返回的值等於sentinel，將引起StopIteration，不然返回這個值。

另見迭代器類型。

iter()第二個參數的有用的一個場景是讀取文件的行直至到達某個特定的行。下面的示例讀取一個文件，直至readline()方法返回一個空字符串：

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

len

• len(s)

返回對象的長度(項目數量)。參數能夠是一個序列（如字符串，字節，元組，列表或range）或集合(如字典，集合或固定集合)。

list

• class list([iterable])

  list其實是一個可變的序列類型，其文檔在Lists and Sequence Types — list, tuple, range。

locals()

更新和返回表示當前局部符號表的字典。當locals()在函數代碼塊中調用時會返回自由變量，可是在類代碼塊中不會。

注意

不該該修改這個字典的內容；由於這些變化可能不會影響解釋器使用的局部變量和自由變量。

map(function, iterable, ...)

返回一個迭代器，對iterable的每一個項應用function，並yield結果。若是傳遞多個iterable參數，function必須接受這麼多參數，並應用到從iterables並行提取的項中。若是有多個iterable，迭代器在最短的iterable耗盡時中止。對於函數的輸入已經排列成參數元組的狀況，參見itertools.starmap()。

max

• max(iterable, *[, key, default])
• max(arg1, arg2, *args[, key])

返回最大值。

單個位置參數應該是可迭代的對象，返回迭代器中最大值。若是提供了兩個或多個位置參數，則返回最大的位置參數。

有兩個可選關鍵字參數。key參數指定相似於list.sort()。default爲iterable爲空則要返回的對象。若是迭代器爲空且未提供default，則會引起ValueError。

若是多個項爲最大值，則返回第一個。這與其餘排序穩定性保持工具一致，和sorted(iterable, key=keyfunc, reverse=True)[0]及heapq.nlargest(1, iterable, key=keyfunc)之類的相似。

版本3.4中的新功能： default關鍵字參數。

memoryview(obj)

返回從給定參數建立的「內存視圖」對象。請參閱Memory Views的詳細信息。

min

• min(iterable, *[, key, default])
• min(arg1, arg2, *args[, key])

返回最小值。

單個位置參數應該是可迭代的對象，返回迭代器中最小值。若是提供了兩個或多個位置參數，則返回最小的位置參數。

有兩個可選關鍵字參數。key參數指定相似於list.sort()。default爲iterable爲空則要返回的對象。若是迭代器爲空且未提供default，則會引起ValueError。

若是多個項爲最大值，則返回第一個。這與其餘排序穩定性保持工具一致，和sorted(iterable, key=keyfunc, reverse=True)[0]及heapq.nlargest(1, iterable, key=keyfunc)之類的相似。

版本3.4中的新功能： default關鍵字參數。

next(iterator[, default])

經過調用__next__()方法從迭代器中檢索下一個項目。若是給出default，則在迭代器耗盡時返回，不然引起StopIteration。

class object

返回一個新的無特徵的對象。object是全部類的基礎類.它包含全部Python類實例裏都會有的通用方法.該函數不接受任何的參數。

注意

object沒有有__dict__，因此你不能指定任何屬性給object類的實例。

oct(x)

將整數轉換爲八進制字符串。結果是一個有效的Python表達式。若是x不是Python int對象，則必須定義一個返回整數的__index__()方法。

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

打開 file 並返回一個相應的 文件對象.若是文件不能被打開, 拋出 OSError 異常.

參數 file 是一個字符串表示的文件名稱，或者一個數組表示的文件名稱。文件名稱能夠是相對當前目錄的路徑，也能夠是絕對路徑表示。（若是給出了一個文件描述器，則當關閉返回的I / O對象時除外，除非closefd設置爲False。

參數 mode 是指明打開文件的模式。默認值是'r'，表示使用文本的方式打開文件來讀取。其餘常見值爲'w'用於寫入（若是文件已經存在則截斷文件），'x'用於排他性建立，'a' （在某些 Unix系統上，意味着所有寫入追加到文件的末尾，而無論當前的查找位置）。在文本模式下，若是未指定encoding，則使用的編碼取決於平臺：locale.getpreferredencoding（False）以獲取當前語言環境編碼。（對於讀取和寫入原始字節，使用二進制模式，不指定編碼。可用的模式有：
字符	含義
'r'	打開閱讀（默認）
'w'	打開寫入，首先截斷文件
'x'	打開獨佔建立，若是文件已經存在則失敗
'a'	打開寫入，追加到文件末尾（若是存在）
'b'	二進制模式
't'	文本模式（默認）
'+'	打開磁盤文件進行更新（讀取和寫入）
'U'	通用換行符模式（已棄用）

默認模式爲'r'（打開閱讀文本，'rt'的同義詞）。對於二進制讀寫訪問，模式'w b'打開並將文件截斷爲0字節。'r b'打開文件而不截斷。

如概述中所述，Python區分二進制和文本I / O。以二進制模式打開的文件（包括模式參數中的'b'）將內容做爲字節對象，而不進行任何解碼。在文本模式（默認狀況下，或當't'包括在模式參數中）時，文件的內容將做爲str ，這些字節已經使用平臺相關編碼首先解碼，或者若是給出則使用指定的編碼。

注意

Python不依賴於底層操做系統的文本文件的概念；全部的處理都是由Python自己完成的，所以是平臺無關的。

參數 buffering是用於設置緩衝策略的可選整數。經過0以關閉緩衝（僅在二進制模式下容許），1選擇行緩衝（僅在文本模式下可用）和整數當未給出buffers參數時，默認緩衝策略工做以下：

    二進制文件以固定大小的塊緩衝；使用啓發式嘗試肯定底層器件的「塊大小」並回退到io.DEFAULT_BUFFER_SIZE來選擇緩衝區的大小。在許多系統上，緩衝區一般爲4096或8192字節長。
    「交互式」文本文件（isatty()返回True的文件）使用行緩衝。其餘文本文件使用上述策略用於二進制文件。

參數 encoding是用於解碼或編碼文件的編碼的名稱。這應該只在文本模式下使用。默認編碼是平臺相關的（不管locale.getpreferredencoding()返回），可是可使用Python支持的任何文本編碼。有關支持的編碼列表，請參閱編解碼器模塊。

參數 errors是一個可選字符串，指定如何處理編碼和解碼錯誤 - 這不能在二進制模式下使用。雖然使用codecs.register_error()註冊的任何錯誤處理名稱也有效，但仍提供了多種標準錯誤處理程序（在錯誤處理程序下列出）。標準名稱包括：

    'strict'引起ValueError例外，若是存在編碼錯誤。默認值None具備相同的效果。
    'ignore'忽略錯誤。請注意，忽略編碼錯誤可能會致使數據丟失。
    'replace'會致使替換標記（例如'？'）插入到存在格式錯誤的數據的位置。
    'surrogateescape'將表示任何不正確的字節，做爲從U DC80到U DCFF範圍內的Unicode私人使用區域中的代碼點。當寫入數據時使用surrogateescape錯誤處理程序時，這些專用代碼點將被轉回相同的字節。這對於處理未知編碼中的文件頗有用。
    僅當寫入文件時，才支持'xmlcharrefreplace'。編碼不支持的字符將替換爲相應的XML字符引用
    'backslashreplace'經過Python的反斜槓轉義序列替換格式錯誤的數據。
    'namereplace'（也僅在編寫時支持）用\ N {...}轉義序列替換不支持的字符。

參數 newline控制通用換行符模式的工做原理（僅適用於文本模式）。它能夠是None、''、'\n'、'\r'、'\r\n'。它的工做原理以下：

    從流讀取輸入時，若是newline爲None，則啓用通用換行符模式。輸入中的行能夠以'\n'，'\r'或'\r\n'結尾，它們在返回給調用者以前被轉換成'\n'。若是它是''，則啓用通用換行符模式，但行結尾將返回給調用者而不會轉換。若是它具備任何其它合法值，則輸入行僅由給定字符串終止，而且行結尾被返回給調用者而不會轉換。
    將輸出寫入流時，若是newline爲None，則寫入的任何'\n'字符都將轉換爲系統默認行分隔符os.linesep。若是newline是''或'\n'，則不會進行轉換。若是newline是任何其餘合法值，寫入的任何'\n'字符都將轉換爲給定字符串。

若是closefd是False而且給出了文件描述器而不是文件名，則當文件關閉時，基本文件描述器將保持打開。若是給定文件名，則closefd必須爲True（默認值），不然將產生錯誤。

經過傳遞可調用對象opener可使用自定義開啓器。而後經過調用opener（文件，標誌）獲取文件對象的基礎文件描述器。opener必須返回一個打開的文件描述器（傳遞os.open爲opener 結果相似的功能 None）。

新建立的文件爲non-inheritable。

如下示例使用os.open()函數的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()函數返回的file object的類型取決於模式。當open()用於以文本模式打開文件時（'w'，'r'，'wt'，'rt'等），它返回io.TextIOBase的子類（特別是io.TextIOWrapper）。當用緩衝區以二進制模式打開文件時，返回的類是io.BufferedIOBase的子類。確切的類有所不一樣：在讀取二進制模式下，它返回一個io.BufferedReader；在寫入二進制和附加二進制模式時，它返回一個io.BufferedWriter，而且在讀/寫模式下，它返回一個io.BufferedRandom。當禁用緩衝時，將返回原始流（io.RawIOBase，io.FileIO的子類）。

See also the file handling modules, such as, fileinput, io (where open() is declared), os, os.path, tempfile, and shutil.

在版本3.3中已更改：添加了開啓程序參數。添加了'x'模式。IOError曾經被提出，它如今是OSError的別名。FileExistsError is now raised if the file opened in exclusive creation mode ('x') already exists.

在版本3.4中更改：此文件如今是不可繼承的。

自版本3.4起棄用，將在版本4.0中刪除： 'U'模式。

Changed in version 3.5: If the system call is interrupted and the signal handler does not raise an exception, the function now retries the system call instead of raising an InterruptedError exception (see PEP 475 for the rationale).

在版本3.5中更改：添加了'namereplace'錯誤處理程序。

ord(c)

給定一個表示一個Unicode字符的字符串，返回一個表示該字符的Unicode代碼點的整數。For example, ord('a') returns the integer 97 and ord('€') (Euro sign) returns 8364. 這是chr()的逆操做。

pow

• pow(x, y[, z])

返回x的y次方; 若是提供z參數， 返回x 的y次方再除以z的餘數 (計算效率比pow(x, y) % z更高)。雙參數形式pow(x, y)等效於使用冪操做符號：x**y 。

參數必須有數字類型。對於混合操做數類型，適用於二元算術運算符的強制規則。對於int操做數，除非第二個參數爲負數，不然結果與操做數（強制後）的類型相同。在這種狀況下，全部參數都將轉換爲浮點數並傳遞浮點結果。例如，102返回 100，可是10-2返回0.01。若是第二個參數是負數，則必須省略第三個參數。若是存在z，則x和y必須是整數類型，而且y必須是非負的。

print

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

將objects打印到文本流file，以sep分隔，而後以end結尾。 必須將sep，end，file和flush(若是存在)做爲關鍵字參數給出。

全部非關鍵字參數都會像 str()同樣轉換爲字符串寫入流中，並由sep和end結尾進行分隔。 sep和end都必須是字符串; 它們也能夠是None，這意味着使用默認值。 若是沒有給出對象只寫結束。

file參數必須支持write(string); 若是它不存在或None，則將使用sys.stdout。 因爲打印的參數轉換爲文本字符串，print()不能用於二進制模式文件對象,請改用file.write（...）。

輸出是否緩衝一般由文件決定，但若是flush關鍵字參數爲true，則強制刷新流。

版本3.3中更改：添加了flush關鍵字參數。

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

返回一個property 屬性。

fget是獲取屬性值的函數。fset是用於設置屬性值的功能。fdel is a function for deleting an attribute value. 而doc爲該屬性建立一個文檔字符串。

典型的用法是定義一個託管屬性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將調用getter，c.x = value將調用setter，del c.x將調用deleter。

If given, doc will be the docstring of the property attribute. 不然，該屬性將複製fget的文檔字符串（若是存在）。這使得可使用property()做爲裝飾器輕鬆建立只讀屬性：

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

    [@property](https://my.oschina.net/property)
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

@property裝飾器將voltage()方法轉換爲具備相同名稱的只讀屬性的「getter」，並設置爲voltage的文檔字符串爲「Get the current voltage.」。

Property對象具備可用做裝飾器的getter、setter和deleter方法，用於建立property的副本，並將相應的訪問器函數設置爲裝飾的功能。這能夠用一個例子來解釋：

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

    [@property](https://my.oschina.net/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

此代碼與第一個示例徹底等效。請務必給予附加函數與原始屬性相同的名稱（在本例中爲x）。

返回的property對象還具備對應於構造函數參數的屬性fget、fset和fdel。

在3.5版本中已更改：屬性對象的docstrings如今是可寫的。

range(stop) range(start, stop[, step])

range其實是一個不可變的序列類型，如Ranges和Sequence Types — list, tuple, range中所記錄。

repr(object)

返回一個包含對象可打印表示的字符串。對於許多類型，此函數嘗試返回一個字符串，該字符串在傳遞給eval()時會產生一個具備相同值的對象，不然該表示是一個用尖括號括起來的字符串，其中包含名稱該對象的類型以及常常包括該對象的名稱和地址的附加信息。一個類能夠經過定義一個__repr__()方法來控制該函數爲其實例返回的內容。

reversed(seq)

返回一個反向iterator。seq必須是具備__reversed__()方法或支持序列協議（__len__()方法和__getitem__()方法，整數參數從0開始）。

round(number[, ndigits])

返回number舍入到小數點後ndigits位的浮點值。若是省略ndigits，將返回最接近輸入的整數。底層調用的是number.__round__(ndigits)。

對於支持round()的內建類型，值舍入到10的最接近的負ndigits次冪的倍數；若是離兩個倍數的距離相等，則舍入選擇偶數（所以，round(0.5)和round(-0.5)都是0，而round(1.5)是2）。若是使用一個參數調用返回值是一個整數，不然其類型與number相同。

注意

浮點數round()的行爲可能讓人驚訝，例如round(2.675, 2)給出的是2.67而不是指望的2.68。這不是一個錯誤：由於事實上大部分十進制小數不能用浮點數精確表示。更多信息，請參閱浮點數運算：問題和限制。

class set([iterable])

返回一個新的set對象，可選地使用iterable中的元素。set是一個內置類。有關此類的文檔，請參閱set和Set Types — set, frozenset。

對於其餘容器，請參閱內置的frozenset，list，tuple和dict類以及collections模塊。

setattr(object, name, value)

它與getattr()相對應。參數是一個對象、一個字符串和一個任意值。該字符串能夠命名現有的屬性或新的屬性。若是該對象容許，該函數將該值分配給該屬性。例如，setattr(x, 'foobar', 123)等同於x.foobar = 123。

class slice(stop) class slice(start, stop[, step])

返回表示由範圍（start， stop， step）指定的一組索引的slice對象 T2>。start和step參數默認爲None。Slice對象具備僅讀取參數值（或其默認值）的只讀數據屬性start，stop和step。他們沒有其餘明確的功能；然而，它們被Numerical Python和其餘第三方擴展使用。當使用擴展索引語法時，也會生成切片對象。例如：a[start:stop:step]或者a[start:stop, i]。請參見itertools.islice()中另一個返回迭代器的版本。

sorted

• sorted(iterable[, key][, reverse])

返回排好序的列表。

具備兩個必須指明爲關鍵字參數可選參數。

key爲帶有一個參數的函數，它用於從列表的每一個元素中提取比較的關鍵字，如key=str.lower。默認值是None(直接比較元素)。

reverse是布爾值。若是設置爲True，那麼列表中元素反過來排序。

functools.cmp_to_key()用於將老式的cmp函數轉換爲key函數。

參考：Sorting HOW TO.

staticmethod(function)

爲函數返回一個靜態方法。

靜態方法不會收到隱式的第一個參數。要聲明一個靜態方法，使用這個習慣用法：

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

@staticmethod形式是一個函數裝飾器 - 有關詳細信息，請參閱函數定義中的函數定義的描述。

它能夠在類上（如C.f()）或實例上（如C().f()）調用。該實例被忽略，除了它的類。

Python中的靜態方法相似於Java或C ++中的方法。另請參見classmethod()瞭解用於建立備用類構造函數的變體。

有關靜態方法的詳細信息，請參閱標準類型層次結構中標準類型層次結構的文檔。

str

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

返回object的str版本。參見str() str是內置字符串類。有關字符串的信息，請參閱 Text Sequence Type — str。

sum

• sum(iterable[, start])

從左到右總計start和可迭代的項目並返回總數。開始默認爲0。可迭代的項目一般是數字，而且起始值不容許爲字符串。

對於某些使用狀況有很好的替代sum()的方法。鏈接字符串序列的首選方法是經過調用''.join(sequence)。要以擴展精度添加浮點值，請參見 math.fsum()。要鏈接可迭代對象，請考慮使用itertools.chain()。

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

返回一個代理對象，它委託方法給父類或者type的同級類。這對於訪問類中被覆蓋的繼承方法頗有用。除了跳過type自己以外，搜索順序與getattr()所使用的順序相同。

type的__mro__屬性列出getattr()和super()使用的方法解析順序。該屬性是動態的，而且能夠在繼承層次結構更新時更改。

若是省略第二個參數，則返回的super對象是未綁定的。若是第二個參數是一個對象，則isinstance(obj, type)必須爲真。若是第二個參數是類型，則issubclass(type2, type)必須爲真（這對類方法頗有用）。

super有兩種典型的使用狀況。在具備單繼承的類層次結構中，可使用super來引用父類，而沒必要明確命名它們，從而使代碼更易於維護。這種使用很是相似於在其餘編程語言中super的使用。

第二種使用狀況是在動態執行環境中支持協同多繼承。這種使用狀況是Python獨有的，在靜態編譯語言或僅支持單繼承的語言中找不到。這使得能夠實現「菱形圖」，其中多個基類實現相同的方法。良好的設計指出此方法在每種狀況下具備相同的調用順序（由於調用的順序在運行時肯定，由於該順序適應類層次結構中的更改，而且由於該順序能夠包括在運行時以前未知的兄弟類）。

對於這兩種使用狀況，典型的超類調用看起來像這樣：

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

注意，super()只實現顯式點分屬性查找的綁定過程，例如super().__getitem__(name)。它經過實現本身的__getattribute__()方法來實現這一點，以便以支持協同多繼承須要的以可預測的順序搜索類。所以，super()沒有定義隱式的查找語句或操做，例如super()[name]。

還要注意，若是不是零個參數的形式，沒有限制super()在方法內部使用。若是兩個參數的形式指定準確的參數，就能進行正確的引用。零個參數的形式只在類定義中工做，由於編譯器填充必要的細節以正確檢索正在定義的類，原理相似訪問當前實例的普通方法。

有關如何使用super()設計協同類的實用建議，請參閱使用super()的指南。

tuple([iterable])

tuple其實是一個不可變的序列類型，而不是一個函數。Tuples和Sequence Types — list, tuple, range中有記錄。

class type(object) class type(name, bases, dict)

使用一個參數，返回對象的類型。返回值是一個類型對象，而且一般與object.__class__返回的對象相同。

建議使用isinstance()內置函數來測試對象的類型，由於它考慮了子類。

有三個參數，返回一個新的類型對象。這本質上是class語句的動態形式。The name string is the class name and becomes the __name__ attribute; the bases tuple itemizes the base classes and becomes the __bases__ attribute; and the dict dictionary is the namespace containing definitions for class body and is copied to a standard dictionary to become the __dict__ attribute. 例如，如下兩條語句建立相同的type對象：
>>>

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

另見Type Objects。

vars([object])

返回一個模塊、字典、類、實例或者其它任何一個具備__dict__屬性的對象的__dict__屬性。

模塊和實例這樣的對象的__dict__屬性能夠更新；可是其它對象可能對它們的__dict__屬性的寫操做具備限制（例如，類使用types.MappingProxyType來阻止對字典直接更新）。

若是不帶參數，vars()的行爲就像locals()。注意，locals字典只用於讀取，由於對locals字典的更新會被忽略。

zip(*iterables)

建立一個迭代器，聚合來自每一個迭代器的元素。

返回一個由元組構成的迭代器，其中第i個元組包含來自每一組參數序列或可迭代量的第i元素。當最短的輸入迭代耗盡時，迭代器中止。使用單個迭代參數，它將返回1元組的迭代器。沒有參數，它返回一個空的迭代器。至關於以下:

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)

可保證迭代的從左到右的評估順序。這使得使用zip(*[iter(s)]*n)將數據序列聚類爲n長度組成爲可能。這將重複相同的迭代器n次，以便每一個輸出元組都有n調用結果到迭代器。這具備將輸入劃分爲n長度塊的效果。

zip()當迭代器元素不一致時，循環中止在較短的迭代器元素，較長的迭代器元素會被捨棄。若是這些值很重要，請改用itertools.zip_longest()。

zip()結合*運算符可用於解壓縮列表：
>>>

>>> 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編程中不須要的高級函數。

經過 import 語句調用此函數。他可以被替代(經過導入builtins 模塊，賦值給 builtins.__import__)去改變 import 語句的語義, 可是強烈 不鼓勵，由於一般使用import鉤子 (見 PEP 302) 更容易達到相同的目標，並且不會對使用了默認import實現的代碼形成任何問題。直接使用__import__()也不鼓勵使用importlib.import_module()。

該函數導入模塊名稱，可能使用給定的globals和locals來肯定如何解釋包上下文中的名稱。fromlist給出了應從name給出的模塊導入的對象或子模塊的名稱。標準實現不使用其 locals 參數，僅僅使用 globals 肯定 導入 語句的包的上下文。

級別指定是使用絕對導入仍是相對導入。0（默認）意味着只執行絕對導入。level的正值表示相對於調用__import__()的模塊的目錄搜索的父目錄的數量（參見 PEP 328瞭解詳情）。

當name變量​​的形式爲package.module時，一般會返回頂級包（名稱直到第一個點），not < / t3>由名稱命名的模塊。可是，若是給出非空的fromlist參數，則返回由name命名的模塊。

例如，語句import spam致使字節碼相似於如下代碼：

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

語句import spam.ham致使此調用：

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

請注意，__import__()在此返回頂層模塊，由於這是經過import語句綁定到名稱的對象。

On the other hand, the statement from spam.ham import eggs, sausage as saus results in

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

這裏，spam.ham模塊從__import__()返回。從這個對象中，要導入的名稱被檢索並分配給它們各自的名稱。

若是你只是想要按名稱導入模塊 ，使用 importlib.import_module()。

在版本3.3中更改：再也不支持level的負值（它也將默認值更改成0）。

腳註 [1] 請注意，解析器只接受Unix風格的行結束約定。若是你從文件中讀取代碼，請確保要使用換行符轉換模式轉換 Windows 或者 Mac 風格的換行符。