翻譯源 來自：https://docs.python.org/3/library/functions.html 

abs(x)

返回一個數的絕對值。引數可以是一個整數或一個浮點數。若引數是複數，返回複數的模

all(iterable)

若 可迭代物件中所有元素為真（或可迭代物件為空），則返回True。等價於：

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

any(iterable)

若  可迭代物件中任意元素為真，則返回True。如果可迭代物件為空，返回False。等價於：

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

ascii(object)

如repr(),返回一個包含物件的可打印表示的字串，但會用\x,\u,or \U轉義pepr()返回的字串中的非ascii字元。生成一個類似於Python 2 中repr()返回的字串。

bin(x)

將整數轉換為以“0b”為字首的二進位制字串。結果是一個有效的Python表示式。若 x 不是一個int型物件，它必須定義了一個__index__()方法去返回整數。

一些例子：

>>>

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

字首“0b”需要或不需要，則可以使用以下任一方法。

>>>

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

class bool([x])

返回一個布林值，True或False。x用標準的真值測試程式來轉換。如果x為false或空，它返回False，否則返回True。bool類是int的一個子類。它不能被子類化。它擁有唯一兩個例項True和False

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

返回一個新的位元組陣列。bytearray類是一個範圍在0 <= x < 256之間的可變整數序列。它有可變序列大多數常規方法。

可選引數source可以用幾種不同方式來初始化陣列：

若 它是一個字串，必須給出編碼（可選的，錯誤）引數；bytearray()用str.encode()把字串轉換成位元組。

若 它是一個整數，陣列將具有該大小，並用空位元組初始化。

若  它是一個遵循buffer介面的物件，物件的只讀buffer將被用來初始化位元組陣列

若 它是一個可迭代物件，它必須是一個範圍在0 <= x < 256中的整數可迭代物件，被用做陣列的初始內容。

如果沒有引數，它建立一個大小為0的陣列。

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

返回一個新的位元組物件。一個數值在0 <= x < 256之間的不可變整數序列。bytes是byte array的不可變版本。它有相同的非修改性方法和相同的索引與切片操作。

因此，建構函式引數與bytearray()相同

Bytes物件也可以用字面值建立，詳情見String and Bytes literals

callable(object)

若 物件可呼叫，返回True，否則返回False。若，返回True，依然可能呼叫失敗，若返回False，呼叫絕不會成功。

注意類是可呼叫的（呼叫一個類返回一個例項），如果類有__call__()方法，例項可呼叫

chr(i)

返回整數i對應的Unicode字元字串。比如chr(97)返回字串‘a’，chr(8364)返回字串'€'。它是ord()的逆操作。

引數的有效範圍在0到1114111（0x10FFFF 16進位制）之間。若，超出異常，將丟擲ValuaError異常

@classmethod

講一個方法轉換為類方法

類方法接受類作為隱式的第一引數，就像例項方法接受例項作為隱式的第一個引數。宣告一個類方法，用如下慣例

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

@classmethod形式是一個裝飾器函式。它既可以在類上呼叫（如C.f()）也可以在例項上呼叫（如C().f()）。

除了例項的類，例項本身被忽略。如果一個類方法在子類上呼叫，那麼子類物件被傳遞為隱式的第一個引數。

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

將source編譯成程式碼物件，或者AST（Abstract Syntax Tree，抽象語法樹）物件。程式碼物件可以由exec()或eval()執行。源可以是普通字串，位元組字串或AST物件。有關如何使用AST物件的資訊，請參閱ast模組文件。

filename引數是要從中讀取程式碼的檔名；如果它不是從檔案中讀取的話，需要傳入一些可識別的內容（通常使用'string'）

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

可選引數flags和dont_inherit控制哪些未來版本的語句會應用於源編譯。如果兩者都不存在（或兩者都為零），則使用在呼叫compile()的程式碼中生效的未來語句來編譯程式碼。如果給出了flags引數且沒有給出dont_inherit引數（或者為0），除了本該使用的future語句之外，由flags引數指明的future語句也會影響編譯。如果dont_inherit是非0整數，flags引數被忽略（呼叫compile周圍的有效的future語句被忽略）。

future語句由bit位指明，這些bit可以做或運算，以指明多個語句。可以在__future__模組中，_Feature例項的compiler_flag屬性找到指明功能的bit位。

引數optimize指定編譯器的優化級別；預設值-1選擇由-O選項給出的直譯器的優化級別。顯式級別為0（無優化； __debug__為真），1（宣告被刪除，__debug__為假 ）或2（docstrings也被刪除）。

如果源包含空位元組，則此函式引發SyntaxError（如果編譯的源無效）和ValueError

如果要將Python程式碼解析為其AST表示形式，請參閱ast.parse()。

注意

當以'single'或者'eval'模式編譯多行程式碼字串的時候，輸入至少以一個新行結尾。這主要是便於code模組檢測語句是否結束。

class complex([real[, imag]])

返回值形式為real + imag * 1j的複數，或將字串或數字轉換為複數。如果第一個引數是個字串，它將被解釋成複數，同時函式不能有第二個引數。第二個引數不能是字串。每個引數必須是數值型別（包括複數）。如果省略imag，則預設為零，建構函式會像int和float一樣進行轉換。如果省略這兩個引數，則返回0j。

注意

當從字串轉化成複數的時候，字串中+或者-兩邊不能有空白。例如，complex('1+2j')是可行的，但complex('1 + 2j')會丟擲ValueError異常。

delattr(object, name)

這個函式和setattr()有關。引數是一個物件和一個字串。字串必須是物件的某個屬性的名字。只要物件允許，這個函式刪除該名字對應的屬性。例如，delattr(x, 'foobar')等同於del x.foobar。

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

建立一個新字典。dict物件是字典類。

dir([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。不管怎樣，q * b + a % b非常接近於a，如果a % b非0，它和b符號相同且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)

引數是字串和可選的全域性變數和區域性變數。如果有全域性變數，globals必須是個字典。如果有區域性變數，locals可以是任何對映型別物件。

expression引數被當作Python表示式來解析並演算（技術上來說，是個條件列表），使用globals和locals字典作為全域性和區域性的名稱空間。如果globals字典存在，且缺少‘__builtins__’，在expression被解析之前，當前的全域性變數被拷貝進globals。這意味著expression通常具有對標準builtins的完全訪問許可權，並且傳播受限環境。如果locals字典被忽略，預設是globals字典。如果兩個字典都省略，則在呼叫eval()的環境中執行表示式。返回值是被演算的表示式的結果。語法錯誤報告成異常。例子：

>>>

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

此函式也可用於執行任意程式碼物件（例如由compile()建立的程式碼物件）。在這種情況下，傳遞程式碼物件而不是字串。如果程式碼物件已使用'exec'作為mode引數編譯，則eval()的返回值將為None 。

提示：exec()函式支援語句的動態執行。globals()和locals()函式分別返回當前的全域性和區域性字典，可以用於傳遞給eval或exec()。

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

這個函式支援動態執行Python程式碼。object必須是一個字串或程式碼物件。如果它是一個字串，該字串被解析為一套Python語句，然後執行（除非語法錯誤發生）。[1]如果它是一個程式碼物件，只是簡單地執行它。在所有情況下，執行的程式碼應該可以作為有效的檔案輸入（參見“參考手冊”中的“檔案輸入”部分）。請注意，即使在傳遞給exec()函式的程式碼上下文中，函式定義外面的return和yield 語句可能不被執行。返回值為None。

在所有情況下，如果省略可選部分，則程式碼在當前作用域中執行。如果只提供globals，它必須是一個字典，它將用於全域性變數和區域性變數。如果提供globals和locals，它們分別用於全域性變數和區域性變數。如果存在，locals可以是任意的對映型別物件。記住在模組級別，全域性和區域性字典是同一個字典。如果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)

See itertools.filterfalse() for the complementary function that returns elements of iterable for which function returns false.

class float([x])

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

如果引數是一個字串，它應該包含一個十進位制數，可選地前面有一個符號，並且可選地嵌入在空格中。可選的sign可以是'+'或'–'； '+'符號對生成的值沒有影響。引數還可以是表示NaN（非數字）或正或負無窮大的字串。更確切地說，輸入必須符合以下語法，前導和尾隨空白字元被刪除：

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。

例子：

>>>

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

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

format(value[, format_spec])

將value轉化成“格式化”的表現形式，格式由format_spec控制。對format_spec的解釋依賴於value引數的型別，大多數內建型別有標準的格式化語法：Format Specification Mini-Language。

預設的format_spec是一個空字串，通常給出與呼叫str（value）相同的效果。

對格式（值， format_spec）的呼叫將被轉換為type（value）.__ format __（value， t4> format_spec）其在搜尋值的__format__()方法時繞過例項字典。如果方法搜尋到達object並且format_spec不為空，或者如果format_spec，則會引發TypeError t7>或返回值不是字串。

class frozenset([iterable])

返回一個新的frozenset物件，如果可選引數iterable存在，frozenset的元素來自於iterable。frozenset是個內建類。

getattr(object, name[, default])

返回object的屬性值。name必須是個字串。如果字串是物件某個屬性的名字，則返回該屬性的值。例如，getattr(x, 'foobar')等同於x.foobar。如果這個名字的屬性不存在，如果提供default則返回它，否則引發AttributeError。

globals()

返回表示當前全域性符號表的字典。它總是當前模組的字典（在函式或者方法中，它指定義的模組而不是呼叫的模組）。

hasattr(object, name)

引數是一個物件和一個字串。如果字串是物件的一個屬性，則返回True，否則返回False。（它的實現是通過呼叫getattr(object, name)並檢視它是否引發一個AttributeError）。

hash(object)

返回該物件的雜湊值（如果有的話）. 雜湊值應該是一個整數。雜湊值用於在查詢字典時快速地比較字典的鍵。相等數值的雜湊值相同（即使它們的型別不同，比如1和1.0）.

help([object])

呼叫內建的幫助系統。（這個函式主要用於互動式使用。）如果沒有引數，在直譯器的控制檯啟動互動式幫助系統。如果引數是個字串，該字串被當作模組名，函式名，類名，方法名，關鍵字或者文件主題而被查詢，在控制檯上列印幫助頁面。如果引數是其它某種物件，生成關於物件的幫助頁面。

該函式加入內建函式的名字空間，函式收錄在site 模組裡.

hex(x)

將整數轉換為以“0x”為字首的小寫十六進位制字串，例如：

>>>

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

如果x不是Python int物件，它必須定義一個__index__()方法，返回一個整數。

另請參見int()用於將十六進位制字串轉換為使用16為基數的整數。

注意

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

id(object)

返回物件的“標識”。這是一個整數，它保證在該物件的生命週期內是唯一的和恆定的。具有不重疊壽命的兩個物件可以具有相同的id()值。

CPython實現細節：這是記憶體中物件的地址。

input([prompt])

如果有prompt引數，則將它輸出到標準輸出且不帶換行。該函式然後從標準輸入讀取一行，將它轉換成一個字串（去掉一個末尾的換行符），然後返回它。當讀取到EOF時，會產生EOFError。例子：

>>>

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

如果readline模組已載入，則input()將使用它提供精細的行編輯和歷史記錄功能。

class int(x=0)

class int(x, base=10)

從數字或字串（x）構造並返回一個整數物件，如果沒有給出引數，則返回0。如果 x 是一個數字，返回 x.__int__()。對於浮點數，這將截斷到零。

如果x不是數字，或者如果給定base，則x必須是字串bytes bytearray例項代表基數base中的integer literal。字面量的前面可以有+或者-（中間不能有空格），周圍可以有空白。以n為基數的字面量包含數字0到n-1，用a到z（或者A到Z）來表示10到35。預設的base是10。允許的值為0和2-36。Base-2, -8, and -16 literals can be optionally prefixed with 0b/0B, 0o/0O, or 0x/0X, as with integer literals in code. base為0意味著完全解釋為程式碼字面值，使得實際基數為2,8,10或16，並且使得int（'010'， 0 ）是不合法的，而int('010')是以及int（'010'，8）。

isinstance(object, classinfo)

如果object是clsaainfo的一個例項（或者是classinfo的直接、間接或虛擬子類的例項），那麼則返回true。如果物件不是給定型別的物件，則函式始終返回false。如果classinfo是物件型別的元組（或遞迴地，其他這樣的元組），如果物件是任何型別的例項，則返回true。如果classinfo不是型別或型別組成的元祖和此類元組，則會引發TypeError異常。

issubclass(class, classinfo)

如果 class 是classinfo的子類(直接、 間接或 虛擬) 則返回 true 。一個類被認為是它自己的子類。classinfo可以是類物件的元組，這時classinfo中的每個類物件都會被檢查。在任何其他情況下，會引發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(s)

返回物件的長度（元素的個數）。引數可以是序列（如字串，位元組，元組，列表或者範圍）或者集合（如字典，集合或者固定集合）。

class list([iterable])

list不是一個函式，它實際上是一個可變的序列型別，其文件在Lists和序列型別 — list, tuple, range中。

locals()

更新和返回表示當前區域性符號表的字典。當locals()在函式程式碼塊中呼叫時會返回自由變數，但是在類程式碼塊中不會。

注意

不應該修改這個字典的內容；因為這些變化可能不會影響直譯器使用的區域性變數和自由變數。

map(function, iterable, ...)

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

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

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

返回可迭代的物件中的最大的元素，或者返回2個或多個引數中的最大的引數。

填入的位置引數應該是可迭代的（ iterable）物件.返回可迭代物件中最大的元素。如果有2個或更多的位置引數，返回最大位置引數。

有兩個可選的僅關鍵字引數。key引數指定類似於用於list.sort()的單引數排序函式。default引數指定如果提供的iterable為空則要返回的物件。如果迭代器為空並且未提供default，則會引發ValueError。

如果多個專案是最大的，則函式返回遇到的第一個專案。這與其他排序穩定性保留工具（例如sorted（iterable， key = keyfunc， reverse = True）[0] t3 >和heapq.nlargest（1， iterable， key = keyfunc）。

memoryview(obj)

返回給定引數的“記憶體檢視”。

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

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

返回可迭代的物件中的最小的元素，或者返回2個或多個引數中的最小的引數。

如果提供了一個位置引數，它應該是一個可迭代物件。返回可迭代物件中最小的元素。如果有2個或更多的位置引數，返回最小的位置引數。

有兩個可選的僅關鍵字引數。鍵引數指定類似於用於list.sort()的單引數排序函式。預設引數指定如果提供的iterable為空則要返回的物件。如果迭代器為空並且未提供default，則會引發ValueError。

如果多個專案是最小的，函式返回遇到的第一個。這與其他排序穩定性保留工具（例如sorted（iterable， key = keyfunc）[0]和heapq.nsmallest（1， iterable， key = keyfunc）。

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的子類。

ord(c)

給定一個表示一個Unicode字元的字串，返回一個表示該字元的Unicode程式碼點的整數。例如，ord('a')返回整數97和ord('€')（歐元符號）返回8364。這是chr()的逆操作。

pow(x, y[, z])

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

引數必須是數字型別的。由於運算元是混合型別的，二進位制計算的原因需要一些強制的規定。對於int運算元，結果具有與運算元相同的型別（強制後），除非第二個引數為負；在這種情況下，所有引數都轉換為float，並傳遞float結果。例如, 10**2 返回 100, 但 10**-2 返回0.01. 如果第二個引數為負數，那麼第三個引數必須省略。如果存在z，則x和y必須是整數型別，且y

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

將object列印到文字流file，由sep分隔，尾部接end。sep, end 和 file，如果提供這三個引數的話，必須以關鍵引數的形式。

All non-keyword arguments are converted to strings like str() does and written to the stream, separated by sep and followed by end.sep和結束必須是字串；它們也可以是None，這意味著使用預設值。如果沒有列印 物件, print() 只打印一個 結束符號 end.

檔案引數必須是具有write(string)方法的物件；如果不存在或None，將使用sys.stdout。由於列印的引數被轉換為文字字串，因此print()不能與二進位制模式檔案物件一起使用。對於這些，請改用file.write(...)。

儘管通常是由file 引數來決定輸出流是否快取，但是如果 flush 引數為ture，那麼輸出流將會被強制重新整理。

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

返回一個property 屬性。

fget是獲取屬性值的函式。fset是用於設定屬性值的功能。fdel是用於刪除屬性值的功能。並且doc為屬性建立一個docstring。

典型的用法是定義一個託管屬性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。

如果給出doc，它將是該屬性的文件字串。否則，該屬性將拷貝fget的文件字串（如果存在）。這使得可以使用property()作為裝飾器輕鬆建立只讀屬性：

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

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

range(stop)

range(start, stop[, step])

range實際上是Ranges和Sequence Types — list, tuple, range中描述的不可變序列型別，而不是函式。

repr(object)

返回某個物件可列印形式的字串。For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to eval(), otherwise the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object. 類可以通過定義__repr__()方法控制該函式對其例項的返回。

reversed(seq)

返回一個反向iterator。seq必須是一個具有__reversed__() 方法或支援序列協議的物件（整數引數從0開始的__len__()方法和__getitem__()方法）。

round(number[, ndigits])

返回一個浮點型 近似值，保留小數點後 ndigits 位。如果省略 ndigits,將返回最接近輸入的整數.代表number.__round__(ndigits)。

對於支援round()的內建型別，值被四捨五入為功率減去ndigits的最接近的倍數10；如果兩個倍數相等地接近，則對偶數選擇進行舍入（因此，例如，round(0.5)和round(-0.5)都是0和round(1.5)是2）。如果使用一個引數呼叫，返回值是一個整數，否則型別與number相同。

注意

浮點數round()的行為可能讓人驚訝，例如round(2.675, 2)給出的是2.68 而不是期望的2.67。這不是一個錯誤：大部分十進位制小數不能用浮點數精確表示，它是因為這樣的一個事實的結果。更多資訊，請參閱Floating Point Arithmetic: Issues and Limitations。

class set([iterable])

返回一個新的set 物件，其元素可以從可選的iterable獲得。set是一個內建的類。

setattr(object, name, value)

它與getattr()相對應。引數是一個物件、一個字串和一個任意值。字串可以是一個已存在屬性的名字也可以是一個新屬性的名字。該函式將值賦值給屬性，只要物件允許。例如，setattr(x, 'foobar', 123)等同於x.foobar = 123。

class slice(stop)

class slice(start, stop[, step])

返回一個slice物件，表示由索引range(start, stop, step)指出的集合。start和step引數預設為None。切片物件具有隻讀屬性start、stop和step，它們僅僅返回引數的值（或者它們的預設值）。他們沒有其他明確的功能；但是它們被數字Python和其他第三方擴充套件使用。在使用擴充套件的索引語法時同樣會生成切片物件。例如：a[start:stop:step]或者a[start:stop, i]。請參見itertools.islice()中另外一個返回迭代器的版本。

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

依據iterable中的元素返回一個新的排好序的列表。

具有兩個可選引數，它們必須指明為關鍵字引數。

key指示一個帶有一個引數的函式，它用於從列表的每個元素中提取比較的關鍵字：key=str.lower。預設值是None（直接比較元素）。

reverse是一個布林值。如果設定為True，那麼列表中元素反過來比較來排序。

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

內建的sorted()函式保證是穩定的。如果保證不更改比較相等的元素的相對順序，則排序是穩定的 - 這有助於在多個通過中排序（例如，按部門排序，然後按工資級別排序）。

staticmethod(function)

返回function的一個靜態方法。

靜態方法不接受隱式的第一個引數（也就是例項名稱self）。要宣告靜態方法，請使用下面的習慣方式：

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

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

它可以在類上（如C.f()）或例項上（如C().f()）呼叫。除了它的型別，例項其他的內容都被忽略。

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

有關靜態方法的詳細資訊，請參閱標準型別層次結構中標準型別層次結構的文件。

class str(object='')

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

返回object的str版本。有關詳細資訊，請參見str()。

str是內建字串類。有關字串的一般資訊，請參閱文字序列型別 - str。

sum(iterable[, start])

將start以及iterable的元素從左向右相加並返回總和。start預設為0。iterable的元素通常是數字，start值不允許是一個字串。

對於某些使用情況，有很好的替代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的型別。返回值是一個型別物件，通常與object.__class__返回的物件相同。

建議使用isinstance()內建函式來測試物件的型別，因為它考慮了子類。

帶有三個引數時，返回一個新的型別物件。它本質上是class語句的動態形式。name string是類名，併成為__name__屬性； bases元組列出基類，併成為__bases__屬性；並且dict字典是包含類主體的定義的名稱空間，並且複製到標準字典以成為__dict__屬性。例如，下面的兩條語句建立完全相同的type物件：

>>>

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

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() 與 * 操作符一起可以用來 unzip 一個列表：

>>>

>>> 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鉤子  更容易達到相同的目標，而且不會對使用了預設import實現的程式碼造成任何問題。也不建議直接使用__import__()以支援importlib.import_module()。

該函式匯入模組名稱，可能使用給定的globals和locals來確定如何解釋包上下文中的名稱。fromlist給出了應從name給出的模組匯入的物件或子模組的名稱。標準實現不使用其 locals 引數，僅僅使用 globals 確定 匯入 語句的包的上下文。

level specifies whether to use absolute or relative imports. 0（預設值）表示僅執行絕對匯入。級別的正值表示相對於呼叫__import__()的模組的目錄進行搜尋的父目錄數

When the name variable is of the form package.module, normally, the top-level package (the name up till the first dot) is returned, not the module named by name. However, when a non-empty fromlist argument is given, the module named by name is returned.

例如，語句import spam導致位元組碼類似於以下程式碼：

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

語句import spam.ham導致此呼叫：

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

Note how __import__() returns the toplevel module here because this is the object that is bound to a name by the import statement.

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

Here, the spam.ham module is returned from __import__(). From this object, the names to import are retrieved and assigned to their respective names.

如果你只是想要按名稱匯入模組 ，使用 importlib.import_module()。