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(*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 風格的換行符。