目錄(?)[-]

absx

alliterable

anyiterable

basestring

binx

boolx

callableobject

chri

classmethodfunction

cmpx y

compilesource filename mode flags dont_inherit

complexreal imag

delattrobject name

dictarg

dirobject

divmoda b

enumeratesequence start0

evalexpression globals locals

execfilefilename globals locals

filefilename mode bufsize

filterfunction iterable

floatx

formatvalue format_spec

frozensetiterable

getattrobject name default

globals

hasattrobject name

hashobject

helpobject

hexx

idobject

inputprompt

intx radix

isinstanceobject classinfo

issubclassclass classinfo

itero sentinel

lens

listiterable

locals

longx radix

mapfunction iterable

maxiterable args key

miniterable args key

nextiterator default

object

octx

openfilename mode bufsize

ordc

powx y z

printobject sep endn filesysstdout

propertyfget fset fdel doc

rangestart stop step

raw_inputprompt

reducefunction iterable initializer

reloadmodule

reprobject

reversedseq

roundx n

setiterable

setattrobject name value

slicestart stop step

sortediterable cmp key reverse

staticmethodfunction

strobject

sumiterable start

supertype object-or-type

tupleiterable

typeobject

typename bases dict

unichri

unicodeobject encoding errors

varsobject

xrangestart stop step

zipiterable

__import__name globals locals fromlist level

Python提供了許多內(nèi)建函數(shù)。下面按函數(shù)名字母順序一一列出并作介紹。

abs(x)

返回一個數(shù)的絕對值。參數(shù)可以是一個普通整數(shù)、長整數(shù)或浮點數(shù)。如果參數(shù)是復(fù)數(shù)， 則它的值被返回。如：若a=x+yi, 則abs(a)=sqrt(x^2+y^2)。

all(iterable)

如果可編歷對象中的所有元素都是真值，則返回True。相當(dāng)于：
def all(iterable):
??? for element in iterable:
??????? if not element:
??????????? return False
??? return True
該函數(shù)是2.5版本中新增的。

any(iterable)

只要可編歷對象中有一個元素為真值，就返回True。等價于：
def any(iterable):
??? for element in iterable:
??????? if element:
??????????? return True
??? return False
該函數(shù)是2.5版本中新增的。

basestring()

（注：basestring是一個可調(diào)用對象。）basestring是str與unicode的父類，它是一個抽象類，不能直接被調(diào)用或?qū)嵗?#xff0c; 但可以用它來測試一個對象是否是str或unicode的實例: isinstance(obj, basestring)，等效于isinstance(obj, (str, unicode))。
該函數(shù)是2.3版本中新增的。

bin(x)

將一個整數(shù)轉(zhuǎn)換成二進(jìn)制字符串。結(jié)果是一個合法的Python表達(dá)式。如果參數(shù)x不是一個整數(shù)對象（int object），它必須定義__index__()方法，并返回一個整數(shù)。
該函數(shù)是2.6版本中新增的。

bool([x])

使用標(biāo)準(zhǔn)真值測試過程(standard truth testing procedure)將一個值轉(zhuǎn)換成布爾型。如果參數(shù)x省略或為假值（如：0, 空字符串，None），返回False；否則總是返回True。bool也是類型，它是int類型的子類。但不能從bool類型派生子類。它只有兩個實 例：True和False。
該函數(shù)是2.21版本中新增的。
在2.3版本中有所改變：如果沒有參數(shù)傳入，函數(shù)返回False。

callable(object)

如果參數(shù)object是可調(diào)用的，返回True，否則返回False。即使函數(shù)返回True，調(diào)用該對象仍然有可能會失敗；但是如果返回 False，則調(diào)用對象肯定失敗。注意：類都是可調(diào)用的（通過調(diào)用類返回一個新實例）。定義了__call__()方法的實例都是可調(diào)用的。

chr(i)

將assii碼為i的整數(shù)轉(zhuǎn)換成只包含一個字符的字符串。例如：chr(97)返回字符串’a’。參數(shù)i必須在0—255范圍內(nèi)，否則會觸發(fā)ValueError異常。與之對應(yīng)的一個函數(shù)是ord(c)，它將字符轉(zhuǎn)換成整數(shù)。也可以參考一下unichr()。

classmethod(function)

該函數(shù)返回一個類方法。
類方法顯式的接收第一個參數(shù)作為類類型，就如實例方法接收第一個參數(shù)作為對當(dāng)前實例的引用。可以使用下面的語法定義一個類方法：
class C:
??? @classmethod
def f(cls, arg1, arg2, ...): ...

@classmethod是一個函數(shù)修飾符----可以在Function definitions中查詢更多關(guān)于函數(shù)定義描述的信息。

可以通過類（如：C.f()）或?qū)嵗?#xff08;如：C().f()）調(diào)用類方法。如果在派生類中調(diào)用父類的類方法，派生類對象（derived class object） 將作為第一個參數(shù)被傳入類方法。
Python類方法與C++或Java中的靜態(tài)方法有區(qū)別。可以查詢本章中對staticmethod的介紹來了解這些知識。
更多關(guān)于類方法的信息，可以參考：The standard type hierarchy.
該函數(shù)是2.2版本中新增的。
在2.4版本中作了修改：添加了對函數(shù)裝飾語法的支持。

cmp(x, y)

比較兩個對象并根據(jù)比較結(jié)果返回一個整數(shù)。如果x < y， 返回一個負(fù)數(shù)，如果 x > y返回一個正數(shù)，如果x == y返回0。

compile(source, filename, mode[, flags[, dont_inherit]])

將源代碼編譯成代碼對象(code object)或AST對象。可以通過exec語句來執(zhí)行代碼對象，或通過eval()來求值。參數(shù)source可以是字符串或AST對象。更多關(guān)于AST對象的信息，可以參考ast模塊文檔。

參數(shù)mode指定了代碼編譯的模式。它可以是：
??? “exec”：代碼段
“eval”: 單個表達(dá)式
“single”: 單條交互式語句
可選參數(shù) flags和dot_inherit控制 影響代碼編譯的將來語句。兩個參數(shù)的默認(rèn)值都是0，

complex([real[, imag]])

創(chuàng)建一個值為 real + imag * j 的復(fù)數(shù)，或?qū)⒁粋€字符串或數(shù)字轉(zhuǎn)換為一個復(fù)數(shù)。如果第一個參數(shù)是字符串，它將被作為復(fù)數(shù)解析，同時不能提供第二個參數(shù)。第二個參數(shù)不能是字符串。每個參數(shù) 可以是任何的數(shù)字類型（包括復(fù)數(shù)類型）。參數(shù)imag的默認(rèn)值為0。如果兩個參數(shù)都省略，返回0j。

delattr(object, name)

參數(shù)是一個對象和字符串。字符串必須是對象屬性的名稱。函數(shù)刪除對象的屬性。如：delattr(x, “foobar”)，相當(dāng)于語句：del x.foobar。
與delattr對應(yīng)的函數(shù)是setattr，用于設(shè)置對象的屬性。

dict([arg])

創(chuàng)建一個字典對象。可選的參數(shù)arg用于初始化字典項。
字典類型在Mapping Types — dict章中進(jìn)行介紹。關(guān)于其他的容器，可以參考list, set,tuple，collections模塊。

dir([object])

如果省略參數(shù)，函數(shù)返回局部區(qū)域內(nèi)的變量列表。如果參數(shù)沒有省略，函數(shù)嘗試將該參數(shù)對象的所有合法屬性名稱保存到列表中并返回該列表。
如果對象定義了__dir__()方法，那么該方法將被調(diào)用，并返回屬性列表。允許對象通過實現(xiàn)__getattr__()和__getattribute__()方法來自定義dir()返回對象的屬性。
如果對象沒有定義__dir__()，dir()嘗試從對象的__dict__屬性（如果定義了__dict__）和對象所屬類型中獲取信息。dir()返回的結(jié)果不必是完整的，如果對象定義了__getattr__()方法，那么結(jié)果可能不準(zhǔn)確。
默認(rèn)的dir()實現(xiàn)針對不同類型的對象可能有不同的行為，它嘗試去獲取更多相關(guān)的信息，而不是全部的信息：
如果對象是模塊對象(module object)，結(jié)果列表包含所有模塊中定義的屬性的名稱。
如果對象是類型或類對象，結(jié)果列表包含該類型所有的屬性名稱，包括從父類繼承的。
否則，結(jié)果列表包含對象的所有屬性名稱、對象所屬類型的屬性名稱，以及父類的所有屬性名稱。
結(jié)果列表根據(jù)屬性的名稱字母順序保存。
>>> import struct
>>> dir()?? # doctest: +SKIP
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)?? # doctest: +NORMALIZE_WHITESPACE
['Struct', '__builtins__', '__doc__', '__file__', '__name__',
?'__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
?'unpack', 'unpack_from']
>>> class Foo(object):
...???? def __dir__(self):
...???????? return ["kan", "ga", "roo"]
...
>>> f = Foo()
>>> dir(f)
['ga', 'kan', 'roo']

divmod(a, b)

接收兩個數(shù)字（復(fù)數(shù)除外）作為參數(shù)，返回一對值：商，余數(shù)。對于不同類型的操作數(shù)，按二進(jìn)制算術(shù)運(yùn)算法則進(jìn)行計算。對于普通整數(shù)與長整數(shù)，結(jié)果為： (a / b, a % b)。對于浮點數(shù)，結(jié)果為：(q, a % b)，其中q = math.floor(a / b)，如果q < 1，q = 1。無論如何，q * b + a % b總是非常接近于a，如果a不能整除b，那么：0 <= abs(a % b) < abs(b)。
在2.3版本中作了修改：不贊成使用復(fù)數(shù)作為參數(shù)。

enumerate(sequence[, start=0])

返回一個enumerate對象。參數(shù)sequence必須是一個序列類型，iterator,或者其他支持編歷的對象。通過調(diào)用 enumerate()返回的iterator，它的next()方法返回一個包含 計數(shù)（由參數(shù)start開始，默認(rèn)值為0）和對應(yīng)值 的元組。可以使用Enumerate()來獲取一個帶索引的序列：(0, seq[0]), (1, seq[1]), (2, seq[2]),...
例如：
>>> for i, season in enumerate(['spring', 'Summer', 'Fall', 'Winter']):
...???? print i, season
0 Spring
1 Summer
2 Fall
3 Winter
該函數(shù)是2.3版本中新增的。
在2.6版本中，增加了start 參數(shù)。

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

參數(shù)expression是一個字符串，可選的globals參數(shù)必須是一個字典，可選的locals必須是一個映射對象（mapping object）。
Expression參數(shù)作為一個Python表達(dá)式而被解析并求值(evaluate)，它使用globals與locals字典作為全局和本地變量。 globals參數(shù)的默認(rèn)值為當(dāng)前的全局變量。locals參數(shù)默認(rèn)為globals。 如果兩個參數(shù)都省略，那么eval()會在 當(dāng)前上下文 中執(zhí)行。執(zhí)行過程中的異常都會被認(rèn)為是語法錯誤異常。下面是使用eval的例子:
X = 1
Print eval(‘x + 1’)
expression參數(shù)也可以是一個代碼對象（通過compile()創(chuàng)建），如果代碼對象使用’exec’模式進(jìn)行編譯（如：eval(compile(‘3 + 4’, ‘<string>’, “exec”)），eval()函數(shù)將返回None。
提示：exec（）支持動態(tài)語句執(zhí)行，使用execfile()來執(zhí)行文件中的語句。Globals(), locals()分別返回全局變量和局部變量的字典，它們可以在調(diào)用eval, execfile時作為參數(shù)傳入。

execfile(filename[, globals[, locals]])

這個函數(shù)與exec語句很像，但是它接收一個文件路徑作為參數(shù)，并執(zhí)行文件中的內(nèi)容。它與import語句不同：它沒有使用模塊管理—它只是無條件的讀取文件內(nèi)容并執(zhí)行，而沒有創(chuàng)建一個新的模塊。
Execfile()的globals參數(shù)與locals參數(shù)的含義和eval()一樣，但函數(shù)的返回值為None。

file(filename[, mode[, bufsize]])

file類型的構(gòu)造函數(shù)，它的參數(shù)與open()方法的參數(shù)的含義一致。open()方法將在下面介紹。
當(dāng)要打開一個文件時，通常使用open()來代替file()。file()更適合在類型測試的時候來使用（如：isinstance(f, fle)）。
該函數(shù)是在此2.2版本中新增的。

filter(function, iterable)

分別對可編歷對象中的元素應(yīng)用函數(shù)，將結(jié)果為True的元素組成新的列表并返回（不改變原有列表。）。 iterable參數(shù)可以是一個序列、一個支持編歷的容器對象、也可以是一個iterator對象。如果參數(shù)是字符串類型或者tuple類型，那么返回的 結(jié)果也是原來的類型；否則它總是返回一個列表(list)類型。如果function為None，則恒等函數(shù)（identity function）被作為篩選函數(shù)（過濾掉非真值元素）
函數(shù)等效為：
function不為None: [item for item in iterable if function(item)]
Function為None: [item for item in iterable if item]

float([x])

將一個字符串或數(shù)字轉(zhuǎn)換為浮點數(shù)。如果參數(shù)是字符串，它可能包含符號或小數(shù)點，字符串參數(shù)也可以是”+nan”,”-nan” 或”+inf”,”-info”；否則，參數(shù)必須是普通整數(shù)或長整數(shù)，或一個浮點數(shù)。浮點數(shù)將直接被返回。如果沒有提供參數(shù)，函數(shù)返回0.0。
注意：
如果參數(shù)是字符串，函數(shù)可能會返回NaN( Not a Number)，Infinity（無窮大），這依賴于低層的C語言庫。Float可能接收”nan”來表示一個非數(shù)字，inf和-inf來表示一個正無 窮和負(fù)無窮。對于nan，”+”, “-“符號將被忽略。Float通過使用”nan”, “inf”, “-inf”來表示NaN, 正無窮，負(fù)無窮。

format(value[, format_spec])

按指定格式表示一個值。對格式的解析依賴于值參數(shù)。有一套標(biāo)準(zhǔn)的格式語法用于大部分Python內(nèi)置類型。
注意：
Format(value, format_spec)僅僅調(diào)用value.__format__(format_spec)。
該函數(shù)是2.6版本中新增的。

frozenset([iterable])

Return a frozenset object, optionally with elements taken from iterable. The frozenset type is described in Set Types — set, frozenset.
For other containers see the built in dict, list, and tuple classes, and the collections module.
New in version 2.4.

getattr(object, name[, default])

獲取對象指定屬性的值。參數(shù)name必須是一個字符串，如果name為對象中某個屬性的名字，該屬性的值將被返回。例如：getattr(x, “foobar”)等效于x.foobar。如果屬性名字不存在，參數(shù)default將被返回。如果函數(shù)名不存在且沒有提供default參數(shù)，將觸發(fā) AttributeError異常。

globals()

返回當(dāng)前模塊的全局變量字典。(如果在方法或函數(shù)中調(diào)用globals()，返回的是定義該方法或函數(shù)的模塊的全局變量字典，而不是調(diào)用該函數(shù)或方法的所在的模塊（的全局變量字典))

hasattr(object, name)

判斷對象是否存在指定名字的屬性。（hasattr通過調(diào)用getattr(object, name)，根據(jù)是否拋出異常來判斷屬性名是否存在）

hash(object)

返回對象的哈希值。哈希值是整數(shù)。它被應(yīng)用于字典的鍵，在查找的時候進(jìn)行快速比較。數(shù)值對象的哈希值與值相同（即使他們有不同的類型，如：
Hash(1.0) == 1.0 #True
hash(1.0) == hash(1) #True）

help([object])

調(diào)用系統(tǒng)幫助。（該函數(shù)可以與系統(tǒng)進(jìn)行交互）。如果沒有提供參數(shù)，交互式幫助系統(tǒng)幫助將在解析器控制臺上啟動。如果參數(shù)是一個字符串，它將作為模 塊、函數(shù)、類型、方法、關(guān)鍵字或文件主題的名稱查詢，并將相關(guān)幫助信息顯示到控制臺上；如果參數(shù)是其他類型的對象，對象的幫助信息將創(chuàng)建(并顯示在控制臺 上)。
該函數(shù)通過site模塊被添加到內(nèi)建命名域內(nèi)。
該函數(shù)是在2.2版本中新增的。

hex(x)

獲取一個整數(shù)的十六進(jìn)制字符串表示。結(jié)果是一個合法的Python表達(dá)式。
2.4版本之前只返回一個無符號字面值。

id(object)

返回對象的標(biāo)識符（identity）。標(biāo)識符是一個整數(shù)（或長整數(shù)），在對象生命周期內(nèi)保證唯一且不會改變。不重疊作用域內(nèi)的兩個對象可能會有一樣的標(biāo)識符。（當(dāng)前實現(xiàn)中，標(biāo)識符返回對象在內(nèi)存中的地址。）

input([prompt])

相當(dāng)于eval(raw_input(prompt))
警告：
該函數(shù)無法保證用戶輸入的內(nèi)容是合法的，它期望一個合法的Python表達(dá)式作為輸入，如果輸入有語法錯誤，將觸發(fā)SyntaxError。在求值期間出現(xiàn)的其他錯誤也會觸發(fā)相應(yīng)的異常。（另一方面，在寫一些快速腳本作為高級應(yīng)用時，這個函數(shù)非常有用。）
如果已經(jīng)加載了readline模塊，input()函數(shù)將使用該模塊提供復(fù)雜的行編輯和記載功能。
應(yīng)當(dāng)考慮使用raw_input()函數(shù)來獲取用戶的一般性輸入。

int([x[, radix]])

將一個字符串或數(shù)值轉(zhuǎn)換為一個普通整數(shù)。如果參數(shù)是字符串，那么它可能包含符號和小數(shù)點。參數(shù)radix表示轉(zhuǎn)換的基數(shù)（默認(rèn)為10進(jìn)制），它可以 是[2,36]范圍內(nèi)的值，或者0。如果為0，系統(tǒng)將根據(jù)字符串的內(nèi)容來解析。如果提供了參數(shù)radix，但參數(shù)x并不是一個字符串，將拋出 TypeError異常；否則，參數(shù)x必須是數(shù)值（普通整數(shù)，長整數(shù)，浮點數(shù)）。通過舍去小數(shù)來轉(zhuǎn)換浮點數(shù)。如果結(jié)果超出了普通整數(shù)的表示范圍，一個長整 數(shù)被返回。如果沒有提供參數(shù)，函數(shù)返回0。
關(guān)于整數(shù)類型，可以參考：Numeric Types — int, float, long, complex.

isinstance(object, classinfo)

如果對象是類型的實例，或該類型派生類的實例，則返回True；如果參數(shù)classinfo是類型對象(type object)同時參數(shù)object是類對象或派生類的對象，也返回True。(譯者注：如：isinstance(A, type(A)))。如果參數(shù)object不是類實例或不是給定類型的實例，函數(shù)將返回False。
如果參數(shù)classinfo不是一個類，類型或 關(guān)于類、類型的元組（譯者注：如：(ClassA, ClassB)），或其他相關(guān)元組，將觸發(fā)TypeError異常。
在2.2版本中添加了對 類型信息元組 的支持。

issubclass(class, classinfo)

如果參數(shù)class是參數(shù)classinfo的子類，返回True。一個類被認(rèn)為是它自己的子類（譯者注：issubclass(ClassA, ClassA)返回True）。參數(shù)classinfo可以是多個類對象(class object)的元組，在這種情況下，元組中的每個類都會被檢查。

iter(o[, sentinel])

返回一個iterator對象。該函數(shù)對于第一個參數(shù)的解析依賴于第二個參數(shù)。如果沒有提供第二個參數(shù)，參數(shù)o必須是一個集合對象，支持編歷功能 （__iter__()方法）或支持序列功能(__getitem__()方法，參數(shù)為整數(shù)，從0開始)，如果不支持這兩種功能，將觸發(fā) TypeError異常。如果提供了第二個參數(shù)，參數(shù)o必須是一個可調(diào)用對象。在這種情況下創(chuàng)建一個iterator對象，每次調(diào)用iterator的 next()方法來無參數(shù)的調(diào)用o，如果返回值等于參數(shù)sentinel，觸發(fā)StopIteration異常，否則將返回該值。
該函數(shù)是2.2版本中新增的。

len(s)

返回對象的長度。參數(shù)可以是序列類型（字符串、元組或列表）或映射類型（如字典）。

list([iterable])

list的構(gòu)造函數(shù)。參數(shù)iterable是可選的，它可以是序列，支持編譯的容器對象，或iterator對象。該函數(shù)創(chuàng)建一個 元素值，順序與 參數(shù)iterable一致的列表。如果參數(shù)iterable是一個列表，將創(chuàng)建該列表的一個拷貝并返回，就像語句iterable[:]。例 如：list(‘a(chǎn)bc‘)返回[‘a(chǎn)’, ‘b’, ‘c’]，list((1, 2, 3))返回[1, 2, 3]。如果沒有提供參數(shù)，返回一個空的列表:[]。

locals()

更新并返回一個表示當(dāng)前局部變量的字典。
警告：
不要修改locals()返回的字典中的內(nèi)容；改變可能不會影響解析器對局部變量的使用。
在函數(shù)體內(nèi)調(diào)用locals（），返回的是自由變量(Free variables)。修改自由變量不會影響解析器對變量的使用。不能在類區(qū)域內(nèi)返回自由變量。

long([x[, radix]])

將字符串或數(shù)字轉(zhuǎn)換為長整數(shù)。如果參數(shù)是字符串，那么它可能包含符號。參數(shù)radix的意義與int()函數(shù)中的一樣，只有在參數(shù)x是字符串的情況 下，才給出。否則x必須是普通整數(shù)、長整數(shù)或浮點數(shù)，如果是長整數(shù)，其值將直接被返回。通過舍去小數(shù)來將浮點數(shù)轉(zhuǎn)換成長整型。如果沒有提供參數(shù)，函數(shù)返回 0L。

map(function, iterable, ...)

對參數(shù)iterable中的每個元素都應(yīng)用function函數(shù)，并將結(jié)果作為列表返回。 如果有多個iterable參數(shù)，那么function函數(shù)必須接收多個參數(shù)，這些iterable中相同索引處的元素將并行的作為function函數(shù) 的參數(shù)。如果一個iterable中元素的個數(shù)比其他少，那么將用None來擴(kuò)展該iterable使元素個數(shù)一致。如果有多個iterable且 function為None，map()將返回由元組組成的列表，每個元組包含所有iterable中對應(yīng)索引處值。參數(shù)iterable必須是一個序列 或任何可編歷對象，函數(shù)返回的往往是一個列表(list)。

max(iterable[, args...][, key])

如果只提供iterable參數(shù)，函數(shù)返回可編歷對象（如：字符串，元組或列表）中最大的非空元素。如果提供了多個參數(shù)，那么返回值最大的那個參數(shù)。
可選參數(shù)key是單參數(shù)的排序函數(shù)。如果提供key參數(shù)，必須是以命名參數(shù)的形式，如：max(a, b, c, key = fun)----我不清楚參數(shù)key有什么作用？
在2.5版本中修改：添加了可選的key參數(shù)。

min(iterable[, args...][, key])

如果只提供iterable參數(shù)，函數(shù)返回可編歷對象（如：字符串，元組或列表）中最小的非空元素。如果提供了多個參數(shù)，那么返回值最小的那個參數(shù)。
可選參數(shù)key是單參數(shù)的排序函數(shù)。如果提供key參數(shù)，必須是以命名參數(shù)的形式，如：max(a, b, c, key = fun)----我不清楚參數(shù)key有什么作用？

next(iterator[, default])

通過調(diào)用iterator的next()方法獲取下一個元素。當(dāng)iterator編歷完的時候，如果提供default參數(shù)，該default參數(shù)將被返回，否則觸發(fā)StopIteration異常。
該函數(shù)是2.6版本中新增的。

object()

獲取一個新的、無特性(featureless)對象。Object是所有類的基類。它提供的方法將在所有的類型實例中共享。
該函數(shù)是2.2版本中新增的。
2.3版本之后，該函數(shù)不接收任何參數(shù)。以前可以接收參數(shù)，但這些參數(shù)都被忽略。

oct(x)

將一個整數(shù)轉(zhuǎn)換為八進(jìn)制字符串。結(jié)果是一個合法的Python表達(dá)式。
在2.4版本之前，該函數(shù)只返回?zé)o符號的字面值。

open(filename[, mode[, bufsize]])

打開一個文件，返回一個file對象。如果文件無法打開，將觸發(fā)IOError 異常。應(yīng)該使用open()來代替直接使用file類型的構(gòu)造函數(shù)打開文件。
參數(shù)filename表示將要被打開的文件的路徑字符串；參數(shù)mode表示打開的模式，最常用的模式有：‘r’表示讀文本文件，’w’表示寫文本文 件，’a’表示在文件中追加文本內(nèi)容。Mode的默認(rèn)值是’r’。 在操作文本文件時，’/n’可能會被轉(zhuǎn)換為特定平臺相關(guān)的表示。
當(dāng)操作的是二進(jìn)制文件時，只要在模式值上添加’b’。這樣提高了程序的可移植性。（有些操作系統(tǒng)不區(qū)別文本文件和二進(jìn)制文件，這些文件都被當(dāng)作文檔(document)來處理，這時把模式設(shè)為二進(jìn)制模式就比較合適。）
可選參數(shù)bufsize定義了文件緩沖區(qū)大小。0表示不緩沖 (unbuffered)；1表示行緩沖(line buffered)；任何其他正數(shù)表示使用該大小的緩沖區(qū)；負(fù)數(shù)表示使用系統(tǒng)默認(rèn)緩沖區(qū)大小，對于tty設(shè)備它往往是行緩沖，而對于其他文件往往完全緩 沖。如果參數(shù)被省略，使用系統(tǒng)默認(rèn)值。

ord(c)

將字符（長度為1的字符串）轉(zhuǎn)換為整數(shù)。例如：ord(‘a(chǎn)’)返回整數(shù)97，ord(u’/u2020’)返回8224。

pow(x, y[, z])

返回x的y次方；如果提供了參數(shù)z，則返回x的y次方，并對z進(jìn)行取模操作（比pow(x, y) % z效率更高）。也可以使用x**y來代替pow(x, y)

print([object, ...][, sep=' '][, end='n'][, file=sys.stdout])

打印對象到流文件(stream file)，通過sep參數(shù)分開，以end參數(shù)結(jié)束。參數(shù)sep, end, file必須以關(guān)鍵字參數(shù)的形式出現(xiàn)，如果提供的話。
所有非關(guān)鍵字參數(shù)都被轉(zhuǎn)換為字符串并寫入到流，通過sep分開，將end附加到末尾。參數(shù)sep和end都是字符串，也可以為None，這意味著使用默認(rèn)值。如果沒有對象，print()直接將end寫入。
File參數(shù)必須是一個包含write(string)方法的對象。如果沒有該方法或?qū)ο鬄镹one，使用默認(rèn)值sys.stdout
注意：在默認(rèn)情況下，print方法是不可使用的，因為它往往被認(rèn)為是print語句。為了使用print()方法同時并禁用print語句，要在模塊的開始處添加如下語句：
from __future__ import print_function
該函數(shù)是2.6版本中新增的。

property([fget[, fset[, fdel[, doc]]]])

...

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

這是一個通過的，用于創(chuàng)建包含連續(xù)算術(shù)值的列表（list）。它經(jīng)常被用于for循環(huán)。參數(shù)必須是普通整數(shù)。參數(shù) step的默認(rèn)值為1，參數(shù)start的默認(rèn)值為0。全參數(shù)調(diào)用該函數(shù)將返回一個普通整數(shù)列表[start, start + step, start + 2 * step, ...]。如果參數(shù)step為正數(shù)，列表中的最后一個元素將是最大值，為start + i * step，小于stop；如果step為負(fù)數(shù)，列表中最后一個元素將是最小值，為start – I * step，大于stop。參數(shù)step不能為0（否則將觸發(fā)ValueError異常）。
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

raw_input([prompt])

如果提供了prompt參數(shù)，它將被寫入到標(biāo)準(zhǔn)輸出（結(jié)尾沒有換行符），函數(shù)然后從輸入中讀一行數(shù)據(jù)，轉(zhuǎn)換成字符串（去除結(jié)尾的換行符）并返回。當(dāng)讀取EOF時，將觸發(fā)EOFError異常。下面是一個例子：
>>> s = raw_input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"

reduce(function, iterable[, initializer])

...

reload(module)

重新加載先前導(dǎo)入(imported)的模塊。參數(shù)是模塊對象，所以該模塊必須在之前成功的導(dǎo)入。Reload在這種情況下非常有用：程序在運(yùn)行過程中模塊源代碼發(fā)生改變，讓Python解析器擅自加載最新版本代碼。函數(shù)的返回值是模塊對象。
當(dāng)reload(module)執(zhí)行時：
Python模塊的代碼被重新編譯，模塊級(module-level)的代碼被重新執(zhí)行，定義新的對象信綁定到模塊字典，而擴(kuò)展模塊的初始化函數(shù)將不會被再次調(diào)用。
就如Python中其他對象一樣，原有模塊的一些對象只有在其引用計算為0的時候才會被回收。
模塊內(nèi)的名稱被更新，用于表明任何新的或改變的對象。
對原有對象的引用不會重新綁定引用到新的對象。

repr(object)

返回一個對象的字符串表示。有時可以使用這個函數(shù)來訪問操作。對于許多類型來說，repr()嘗試返回一個字符串，eval()方法可以使用該字符 串產(chǎn)生對象；否則用尖括號括起來的，包含類名稱和其他額外信息（如：對象名字，在內(nèi)存中的地址）的字符串被返回。類可以通過定義__repr__()方法 來控制它的對象的輸出。

reversed(seq)

返回一個逆序的iterator對象。參數(shù)seq必須是一個包含__reversed__()方法的對象或支持序列操作（__len__()和__getitem__()）
該函數(shù)是2.4版本中新增的。

round(x[, n])

對參數(shù)x的第n+1位小數(shù)進(jìn)行四舍五入，返回一個小數(shù)位數(shù)為n的浮點數(shù)。參數(shù)n的默認(rèn)值是0。結(jié)果是一個浮點數(shù)。如：round(0.5) 結(jié)果 為 1.0

set([iterable])

...

setattr(object, name, value)

該方法與getattr()相對應(yīng)。參數(shù)分別是一個對象、字符串和值。字符串可能是一個存在的屬性名或一個新的屬性名，該函數(shù)將值賦給對象的屬性。如：setattr(x, ‘fllbar’, 123)等價于x.foobar = 123。

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

...

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

...

staticmethod(function)

返回一個靜態(tài)方法。

靜態(tài)方法不顯式的接收第一個參數(shù)（作為類型）。使用下面的語法聲明一個靜態(tài)方法：
lass C:
??? @staticmethod
??? def f(arg1, arg2, ...): ...
可以在類中調(diào)用靜態(tài)方法（如：C.f()），，也可以在對象上調(diào)用（如：C().f()）。
Python中的靜態(tài)方法與java或C++中的靜態(tài)方法類似，更詳細(xì)的信息，可以參考：classmethod()
該函數(shù)是2.2版本中新增的。

str([object])?

獲取對象的字符串表示。對于字符串參數(shù)，函數(shù)直接返回。Repr()與str()之間的不同在于：str()返回的字符串可能不被eval()所接收求值，而僅僅返回一個可打印的字符串。如果沒有提供參數(shù)，空字符串將被返回。

sum(iterable[, start])

先計算可編歷對象中的元素之和，再與start相加。參數(shù)start的默認(rèn)值為0。可編歷對象的元素通過是數(shù)字，不能為字符串。通過調(diào) 用’’.join(sequence)可以快速正確的連接一個字符串序列。注意：sum(range(n), m)等價于：reduce(operator.add, range(n), m)。對高精度的浮點數(shù)進(jìn)行求和時，可以使用math.fsum().

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

返回一個可以通過委托方法調(diào)用父類型或兄弟類型的代理對象。在重寫方法中使用它來訪問父類中的虛方法，

tuple([iterable])

返回一個元組，它的元素值及元素的順序與iterable中的一致。參數(shù)iterable可以是一個序列，或者iterator對象。如果 iterable本身也是一個元組，它將被原封不支的返回。例如：tuple(‘a(chǎn)bc’)將返回(‘a(chǎn)’, ‘b’, ‘c’)，tuple([1, 2, 3])將返回(1, 2, 3)。如果沒有提供參數(shù)，函數(shù)返回一個空元組。

type(object)

返回對象的類型。返回值是類型對象(type object)，建議使用isinstance()來檢測對象的類型。含有三個參數(shù)的type()函數(shù)是type類的構(gòu)造函數(shù)，在下面詳細(xì)介紹。

type(name, bases, dict)

返回一個類對象。它本質(zhì)上是一個動態(tài)形式的類定義語句（可以動態(tài)的創(chuàng)建新類型）。參數(shù)name作為__name__的值，為新類型的名稱，參數(shù) bases是一個元組，表示新類型的父類，作為__bases__的值；參數(shù)dict是一個字典，表示類范圍成員的定義，作為__dict__的值。例 如：下面兩段語句創(chuàng)建同一類型對象：
>>> class X(object):
...???? a = 1
...
>>> X = type('X', (object,), dict(a=1))

unichr(i)

返回整數(shù)的unicode字符串。如：unichar(97)返回字符串 u’a’。

unicode([object[, encoding[, errors]]])

...

vars([object])

如果沒有提供參數(shù)，返回一個表示當(dāng)前局部變量表的字典。如果輸入一個模塊對象、類對象或類實例對象（或其他任何含有__dict__屬性的東西），返回一個表示該對象變量表的字典。

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

這個函數(shù)與range()非常像，但它返回一個xrange對象而不是列表。這是一個不透明的序列對象，可以產(chǎn)生像對應(yīng)列表一樣的值但不同時保存它們（在內(nèi)存里）。
Xrange相比于range的優(yōu)點在于：使用xrange占用的內(nèi)存更少。

zip([iterable, ...])

函數(shù)返回一個元組列表，其中第n個元組的元素由所有參數(shù)序列的第n個元素組成。返回列表的長度等于參數(shù)中長度最短的序列的長度。如果多個參數(shù)序列的長度一致，那么zip() 如果只有一個參數(shù)，那么返回的序列中，元素的長度為1。如果沒有提供參數(shù)，返回一個空列表。
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> zipped
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zipped)
>>> x == x2, y == y2
True
該函數(shù)是2.0版本中新增的。
在2.4版本之前，調(diào)用zip()時至少要提供一個參數(shù)，否則將觸發(fā)TypeError異常。

__import__(name[, globals[, locals[, fromlist[, level]]]])

這是一個高級函數(shù)，在平常編程中很少用到。
使用import語句加載模塊時會調(diào)用該函數(shù)。
很少直接使用__import__()函數(shù)，除非模塊的名稱在運(yùn)行時得到。

轉(zhuǎn)載于:https://www.cnblogs.com/xuexiaohun/p/6373284.html

總結(jié)

以上是生活随笔為你收集整理的python build-in function的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。