內置函數
Python解釋器內置了許多功能和類型,總是可用的。他們是按字母順序列在這里。

abs(x)
返回一個數的絕對值。參數可能是整數或浮點數。如果參數是一個復數,返回它的大小。

all(iterable)
返回 True
如果所有的元素iterable真(或者如果iterable為空)。等價于:
defall(iterable):forelementiniterable:ifnotelement:returnFalsereturnTrue

any(iterable)
返回 True
如果任何元素的iterable是正確的。如果iterable為空,返回 False
。等價于:
defany(iterable):forelementiniterable:ifelement:returnTruereturnFalse

ascii(對象)
作為 repr()
返回一個字符串,包含一個可打印的表示一個對象,但是逃避返回的字符串中的非ascii字符 repr()
使用 \x
, \u
或 \U
逃跑了。這生成一個字符串返回的相似 repr()
在Python中2。

bin(x)
將一個整數轉換成一個二進制字符串。結果是一個有效的Python表達式。如果x是Python int
對象,它必須定義一個 index()
方法返回一個整數。

類 bool([x])
返回一個布爾值,即之一 True
或 False
。x是使用標準的轉換 真理的檢驗程序。如果x是虛假或省略,這個回報 False
;否則它返回 True
。的 bool
類的一個子類 int
(見 數值類型,int、浮點數、復雜)。它不能再進一步。它唯一的實例 False
和 True
(見 布爾值).

類 bytearray
([源[,編碼[,錯誤]]])
返回一個新的數組的字節數。的 bytearray
類是一個可變的序列的整數范圍0 < = x < 256。它具有可變序列的最常見的方法,描述了 可變序列類型,以及大多數的方法 bytes
類型,看 字節和中Bytearray操作.
可選的源參數可以用來初始化數組在幾個不同的方式:
如果它是一個字符串,你還必須給編碼(和可選地,錯誤)參數; bytearray()
然后將字符串轉換成字節使用 str.encode()
.
如果它是一個整數,該數組將與空字節大小和將被初始化。
如果它是一個對象符合緩沖界面,一個只讀緩沖區將被用來初始化對象的字節數組。
如果它是一個iterable,它必須是一個整數的iterable范圍 0 <= x < 256
,這是作為數組的初始內容。

沒有一個論點,創建了一個數組大小為0。
另請參閱 二進制序列類型——字節中bytearray,memoryview和 中Bytearray對象.

類 bytes([源[,編碼[,錯誤]]])
返回一個新的“字節”對象,這是一個不可變的序列的整數范圍 0 <= x < 256
. bytes
不可變的版本嗎 bytearray
接觸非變異——它有相同的刺突的方法和相同的索引和切片的行為。
因此,構造函數參數解釋為 bytearray()
.
字節對象也可以創建文字,明白了 文本字符串和字節.
另請參閱 二進制序列類型——字節中bytearray,memoryview, 字節, 字節和中Bytearray操作.

callable(對象)
返回 True
如果對象參數出現可調用的, False
如果不是。如果返回true,它仍然是有可能的,調用失敗,但是如果它是假的,調用對象永遠不會成功。注意,類是可調用(調用一個類返回一個新實例);如果他們的類有一個可調用的實例call()
方法。
在新的3.2版本:這個函數首先移除在Python 3.0,然后帶回在Python 3.2。

chr(我)
返回的字符串代表一個字符的Unicode代碼點整我。例如, chr(97)
返回的字符串 'a'
,而 chr(8364)
返回的字符串 '€'
。這是的倒數 ord()
.
參數的有效范圍從0到1114111年(0 x10ffff基地16)。 ValueError
如果我不在這個范圍將提高。

classmethod(函數)
函數返回一個類方法。
一個類方法接收類隱式的第一個參數,就像一個實例方法接收實例。聲明一個類方法,使用這個成語:
classC:@classmethoddeff(cls,arg1,arg2,...):...

的 @classmethod
表單是一個函數 裝飾——看到函數定義的描述 函數定義獲取詳細信息。
它可以被稱為類(如 C.f()
(比如)或在一個實例 C().f()
)。除了它的類實例被忽略。如果一個類派生類的方法被調用時,派生類對象作為隱含第一個參數傳遞。
類方法是不同的比c++或Java靜態方法。如果你想要這些,明白了 staticmethod()
在這一節中。
關于類方法的更多信息,請參考文檔標準類型層次結構 標準的類型層次結構.

compile(源、文件名模式,旗幟= 0,dont_inherit = False,優化= 1)
編譯成一個源代碼或AST對象。對象可以執行的代碼 exec()
或 eval()
。來源可以是一個普通的字符串,一個字節的字符串,或一個AST對象。指的是 ast
模塊的文檔信息如何使用AST對象。
文件名參數應該給文件的代碼閱讀,通過一些可識別的值如果不是從文件讀('<string>'
是常用的)。
模式參數指定什么樣的代碼必須被編譯,就可以 'exec'
如果源由一系列的語句, 'eval'
如果它包含一個表達式,或 'single'
如果它包括一個交互式的聲明(在后一種情況下,表達式語句,評估以外的東西 None
將打印)。
未來的可選參數標志和dont_inherit控制語句(見PEP 236)影響源的編譯。如果不存在(或為零)的代碼編譯與未來的語句中實際上調用的代碼 compile()
。如果旗幟參數是dont_inherit并不是(或為零),那么未來語句指定的標志使用參數除了那些將使用。如果dont_inherit是一個非零的整數,那么旗幟的論點是,未來在調用編譯語句實際上被忽略。
未來語句指定比特可按位或共同指定多個語句。所需的設置指定給定的特性可以發現 compiler_flag
屬性 _Feature
實例的 future
模塊。
參數優化指定編譯器的優化級別;默認值的 -1
選擇的翻譯的優化級別 -O
選項。明確的水平 0
(沒有優化; debug
是正確的), 1
(斷言移除, debug
是假的)或 2
(刪除文檔字符串)。
這個函數了 SyntaxError
如果編譯源無效 ValueError
如果源包含空字節。
如果你想Python代碼解析成AST表示,看到的 ast.parse()
.
請注意
當編譯一個字符串與多行代碼 'single'
或 'eval'
模式下,輸入必須終止由至少一個換行符。這是為了方便檢測不完整的和完整的語句 code
模塊。

3.2版本的變化:允許使用Windows和Mac換行。也投入 'exec'
模式沒有以換行符結束了。增加了優化參數。

3.5版本的變化:在此之前, TypeError
長大當空字節中遇到的來源。

類 complex([真正的[,圖像放大]])
返回一個與真實值+復數圖像放大* 1 j或字符串或數字轉換為復數。如果第一個參數是一個字符串,它將被視為復數和函數必須調用第二個參數。第二個參數不能是一個字符串。每個參數可以是任何數字類型(包括復雜)。如果省略圖像放大,它默認為零和構造函數作為一個數字轉換 int
和 float
。如果兩個參數省略,回報 0j
.
請注意
當轉換從一個字符串,字符串必須不包含空格在中央 +
或 -
操作符。例如, complex('1+2j')
是可以的,但 complex('1 + 2j')
提出了 ValueError
.

描述的復雜類型 數值類型,int、浮點數、復雜.
3.6版本的變化:分組代碼中位數與下劃線文字是被允許的。

delattr(對象,的名字)
這是一個相對的 setattr()
。的參數是一個對象和一個字符串。字符串必須是一個對象的屬性的名稱。該函數刪除指定的屬性,提供了對象允許它。例如, delattr(x, 'foobar')
相當于 del x.foobar
.

類 dict(** * kwarg)
類 dict
(映射,* * kwarg)
類 dict
(iterable,* * kwarg*)
創建一個新字典。的 dict
對象字典類。看到 dict
和 映射類型——dict類型關于這個類的文檔。
對于其他容器內置 list
, set
, tuple
類,以及 collections
模塊。

dir([對象])
沒有參數,返回當前局部范圍的名單。與論證,試圖返回有效的屬性的對象的列表。
如果對象有一個名為的方法 dir()
,這個方法將被稱為,必須返回屬性的列表。這樣就可以實現一個自定義的對象 getattr()
或 getattribute()
功能定制 dir()
報告它們的屬性。
如果對象沒有提供 dir()
,功能盡量從對象的收集信息 dict
屬性,如果定義,并從其類型對象。結果不一定是完整的列表,和對象有一個自定義時可能不準確 getattr()
.
默認的 dir()
機制不同的行為與不同類型的對象,因為它試圖產生最相關的,而不是完整的信息:
如果對象是一個模塊對象,列表包含模塊的屬性的名稱。
如果對象是一個類型或類對象,列表包含它的屬性的名稱和屬性的遞歸的基地。
否則,該列表包含該對象的屬性的名稱、類的屬性的名稱和屬性的遞歸的類的基類。

生成的列表按字母順序排序。例如:

importstruct>>> 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']>>> classShape:... def__dir_(self):... return['area','perimeter','location']>>> s=Shape()>>> dir(s)['area', 'location', 'perimeter']

請注意
因為 dir()
主要是提供方便使用交互式提示符,它試圖提供一組有趣的名字超過它試圖提供一個嚴格或定義一致的組名稱,并在發布其詳細的行為可能會改變。例如,元類屬性不是在結果列表參數是一個類。

divmod(一個,b)
取兩個(非復雜)的數字作為參數并返回一個數字組成的商和余數當使用整數的除法。與混合操作數類型,二進制算術運算符的規則適用。為整數,結果是一樣的 (a // b, a % b)
。浮點數結果 (q, a % b)
通常,問math.floor(a / b)
但可能小于1。在任何情況下 q * b + a % b
非常接近,如果 a % b
非零和b一樣的標志,然后呢 0 <= abs(a % b) < abs(b)
.

enumerate(iterable,= 0開始)
返回一個枚舉對象。iterable必須是一個序列,一個 迭代器或其他對象支持迭代。的 next()
返回的迭代器的方法 enumerate()
返回一個元組,其中包含一個計數(從開始默認為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')]

等價于:
defenumerate(sequence,start=0):n=startforeleminsequence:yieldn,elemn+=1

eval(表達式,全局變量=沒有當地人=沒有)
參數是一個字符串,可選的全局和當地人。如果提供,全局變量必須是一個字典。如果提供,當地人可以是任何對象的映射。
解析表達式參數和評估作為一個Python表達式(技術上來說,一個條件列表)使用全局和本地詞典作為全球和本地名稱空間。如果存在全局字典,缺乏“builtins”,當前全局變量復制到全局解析表達式。這意味著表達式通常有完全訪問的標準 builtins
模塊和限制環境傳播。如果省略當地人字典它默認為全局字典。如果字典都省略了,表達式是在環境中執行 eval()
被稱為。返回值是計算表達式的結果。語法錯誤報告為例外。例子:

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

這個函數也可以用來執行任意代碼(比如由對象 compile()
)。在這種情況下,傳遞一個代碼對象,而不是一個字符串。如果代碼對象編譯了 'exec'
作為模式的參數, eval()
的返回值 None
.
提示:支持動態執行語句 exec()
函數。的 globals()
和 locals()
函數返回當前全球和本地詞典,分別,這可能是有用的在使用的 eval()
或 exec()
.
看到 ast.literal_eval()
為一個函數,可以安全評估與表達式只包含字符串字面值。

exec(對象[,全局變量[,當地人]])
這個函數支持Python代碼的動態執行。對象必須是一個字符串或對象代碼。如果它是一個字符串,字符串解析為一套然后執行Python語句(除非出現語法錯誤)。[1]如果它是一個代碼的對象,它只是執行。在所有情況下,預計將是有效執行的代碼文件輸入(見參考手冊中的部分“輸入文件”)。請注意, return
和 yield
語句之外不得使用函數定義的上下文中甚至代碼傳遞到 exec()
函數。返回值是 None
.
在所有情況下,如果省略可選的部分,執行代碼在當前的范圍。如果全局變量,它必須是一個字典,將用于全球和本地變量。如果全局變量和當地人,他們用于全球和本地變量,分別。如果提供,當地人可以是任何對象的映射。記住,在模塊級別,全局和當地人是相同的字典。如果執行兩個獨立的對象作為全局變量和當地居民,將執行的代碼,就好像它是嵌入在一個類的定義。
如果全局字典不包含一個值的關鍵 builtins
,內置的詞典模塊 builtins
插入鑰匙。這樣你可以控制內置命令可以執行代碼插入自己的 builtins
字典到全局變量傳遞之前 exec()
.
請注意
內置的功能 globals()
和 locals()
返回當前全球和本地詞典,分別,這可能是有用的在第二和第三個參數使用 exec()
.

請注意
默認的當地人作為函數的描述 locals()
下圖:修改默認當地人字典不應該嘗試。通過顯式的當地人字典如果你需要看后的代碼對當地人的影響函數 exec()
的回報。

filter(函數,iterable)
從這些元素的iterable構造迭代器函數返回true。iterable可以是一個序列,一個容器支持迭代,迭代器。如果函數是 None
,恒等函數假設,即所有元素的iterable假被刪除。
請注意, filter(function, iterable)
相當于生成器表達式 (item for item in iterable if function(item))
如果函數不 None
和 (item for item in iterable if item)
如果函數是 None
.
看到 itertools.filterfalse()
iterable互補函數,它返回元素的函數返回false。

類 float([x])
返回一個浮點數由一個數字或字符串x。
如果參數是一個字符串,它應該包含一個十進制數,選擇之前簽署,有選擇地嵌入空格。可選的跡象 '+'
或 '-'
; '+'
對產生的價值沒有影響。參數也可以是一個字符串代表南(不是一個數字),或積極或消極的無窮。更準確地說,輸入后必須符合以下語法前導和尾隨空白字符刪除:
簽名::= " + " |“-”無窮::=“∞”|“正”南::= "南"numeric_value::=floatnumber
| infinity
| nan
numeric_string::=(sign
] numeric_value

在這里 floatnumber
Python浮點文字的形式,描述在嗎 浮點文字。情況并不明顯,所以,例如,“正”、“正”、“∞”和“∞”都是可接受的拼寫為正無窮。
否則,如果參數是一個整數或浮點數,浮點數和相同的值(在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

浮子式中描述 數值類型,int、浮點數、復雜.
3.6版本的變化:分組代碼中位數與下劃線文字是被允許的。

format(價值[,format_spec])
將一個值轉換為一個表示“格式化”,由format_spec控制。解釋format_spec取決于值的類型參數,然而有一個標準格式使用語法,最內置類型: 格式規范迷你語言.
默認format_spec是一個空字符串通常給調用相同的效果 str(value)
.
調用 format(value, format_spec)
是翻譯 type(value).format(value, format_spec)
它繞過了實例的字典當尋找價值的 format()
方法。一個 TypeError
如果搜索的方法達到異常 object
format_spec非空,或者如果format_spec或返回值不是字符串。
3.4版本的變化: object().format(format_spec)
提出了 TypeError
如果format_spec不是一個空字符串。

類 frozenset([iterable])
返回一個新的 frozenset
對象,可選元素取自iterable。 frozenset
是一個內置的類。看到 frozenset
和 類型——集合,frozenset關于這個類的文檔。
對于其他容器內置 set
, list
, tuple
, dict
類,以及 collections
模塊。

getattr(對象,的名字[,默認的])
返回指定屬性的值的對象。名稱必須是一個字符串。如果字符串是對象的一個屬性的名字,結果是,屬性的值。例如, getattr(x, 'foobar')
相當于 x.foobar
。如果指定的屬性不存在,返回默認如果提供,否則AttributeError
是提高。

globals()
返回一個代表當前全局符號表字典。這總是當前模塊的字典(在一個函數或方法,這是定義的模塊,不叫做的模塊)。

hasattr(對象,的名字)
的參數是一個對象和一個字符串。結果是 True
如果字符串是對象的一個屬性的名字, False
如果不是。(這是通過調用實現的 getattr(object, name)
看到它是否提出了一個 AttributeError
不信)。

hash(對象)
返回對象的散列值(如果它有一個)。散列值是整數。他們是用來快速比較在字典查找字典鍵。數值比較平等有相同的散列值(即使他們是不同類型的,1和1.0)一樣。

請注意
與自定義對象的 hash()
方法,注意, hash()
返回值截斷基于主機的位寬。看到 hash()
獲取詳細信息。

help([對象])
調用內置的幫助系統。(這個函數是用于交互式使用。)如果沒有參數,翻譯上的互動幫助系統啟動控制臺。如果參數是一個字符串,字符串查找模塊的名稱,函數,類,方法,關鍵字,或文檔的主題,一個幫助頁面打印在控制臺上。如果參數是任何其他類型的對象,生成一個對象上的幫助頁面。
這個函數添加到內置的名稱空間 site
模塊。
3.4版本的變化:更改 pydoc
和 inspect
意味著報道簽名可調用現在更全面和一致的。

hex(x)
把一個整數轉換成小寫的十六進制字符串前綴“0 x”,例如:

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

如果x是Python int
對象,它必須定義一個index()方法,它返回一個整數。
另請參閱 int()
將十六進制字符串轉換為一個整數使用16的基地。
請注意
獲得一個浮動的十六進制字符串表示,使用 float.hex()
方法。

id(對象)
返回一個對象的“身份”。這是一個整數保證獨特和常數這個對象在它的生命周期。兩個對象重疊壽命可能有相同的 id()
價值。
CPython的實現細節:這是在內存中對象的地址。

input([提示文字])

如果提示存在爭論,末尾寫到標準輸出沒有換行符。從輸入函數然后讀取一行,將其轉換為一個字符串(剝離后換行),并返回。當EOF閱讀, EOFError
是提高。例子:

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

如果 readline
模塊被加載 input()
將使用它來提供詳盡的行編輯和歷史特征。

類 int(x = 0)
類 int(x,基礎= 10)

返回一個整數對象由一個數字或字符串x,或者退貨 0
如果沒有參數。如果x是一個數字,回報 x.int()
。對于浮點數,這對截斷零。
如果x不是很多或者基地,那么x必須是一個字符串, bytes
,或 bytearray
實例代表一個 整數字面在基數基礎。可選地,可以之前的文字 +
或 -
(沒有之間的空間)和周圍的空白。base-n文字由數字0到n - 1, a
來 z(或 A來 Z10 - 35)值。默認的基礎是10。允許的值是0,轉動。以2為底,8,-16文字可以選擇前綴 0b/0B, 0o/0O,或 0x/0X在代碼中,與整數文字。基地0意味著代碼字面解釋一樣,所以實際的基礎是2,8,10或16,所以 int('010', 0)是不合法的,int('010')是,以及 int('010', 8).
描述的整數類型 數值類型,int、浮點數、復雜.
3.4版本的變化:如果基礎不是的一個實例 int
和基礎對象 base.index
方法,調用方法獲得一個整數的基地。使用以前的版本 base.int
而不是 base.index
.
3.6版本的變化:分組代碼中位數與下劃線文字是被允許的。

isinstance(對象,classinfo)
返回true,如果參數是對象的一個實例classinfo論點,或(直接、間接或 虛擬)子類。如果對象不是一個給定類型的對象,函數始終返回false。如果classinfo tuple類型的對象(或遞歸,其他元組),返回true,如果對象是任何類型的一個實例。如果classinfo不是一個類型或元組的類型和元組等 TypeError
例外。

issubclass(類,classinfo)
返回true,如果類(直接、間接或一個子類 虛擬classinfo)。一個類被認為是自身的一個子類。classinfo可能是一個類對象的元組,在這種情況下,每一個進入classinfo將檢查。在任何其他情況下, TypeError
例外。

iter(對象[,哨兵])
返回一個 迭代器對象。第一個參數是解釋不同的根據第二個參數的存在。沒有第二個參數,對象必須是一組對象支持迭代協議( iter()
方法),也必須支持的協議序列( getitem()
方法用整數參數開始 0
)。如果它不支持的協議, TypeError
是提高。哨兵,如果第二個參數,那么對象必須是一個可調用對象。在這種情況下,創建的迭代器將為每個調用不帶參數調用對象 next()
方法;如果返回的值等于哨兵, StopIteration
將提高,否則將返回值。
另請參閱 迭代器類型.
第二種的一個有用的應用程序 iter()
是讀取行一個文件直到到達一定行。下面的例子將讀取一個文件,直到 readline()
方法返回一個空字符串:
withopen('mydata.txt')asfp:forlineiniter(fp.readline,''):process_line(line)

len(年代)
返回對象的長度(項目)的數量。參數可以是一個序列(如一個字符串,字節,tuple,列表,或范圍)或一組(如字典、集,或冷凍集)。

類 list([iterable])
而不是一個函數, list
實際上是一個可變的序列類型,記錄在嗎 列表和 序列類型——列表、元組、范圍.

locals()
字典更新并返回一個表示當前本地符號表。自由變量返回 locals()
當它被稱為功能塊,但不是在課堂上。
請注意
這本字典的內容不應被修改;變化可能不會影響當地和自由變量的值所使用的翻譯。

map(函數,iterable,* ...*)

返回一個迭代器函數適用于每件iterable,產生結果。如果額外iterable參數傳遞,函數必須采取許多參數和應用于項目并行iterable。與多個iterable,迭代器停止當最短的iterable耗盡。情況下,函數已經安排輸入參數元組,明白了itertools.starmap().

max(iterable,* [的關鍵,默認的])
max
(__arg1、最長,** args[,關鍵*])
返回iterable或最大的項目中最大的兩個或兩個以上的參數。
如果提供了一個位置參數,它應該是一個 iterable。最大的項目返回iterable。如果提供兩個或兩個以上的位置參數,返回最大的位置參數。
有兩個可選keyword-only參數。關鍵參數指定一個參數排序函數用于 list.sort()
。默認參數指定一個對象返回,如果提供iterable是空的。如果iterable為空,???認不提供, ValueError
是提高。
如果多個項目最大,函數返回第一個。這是符合其他sort-stability保留等工具 sorted(iterable, key=keyfunc, reverse=True)[0]
和 heapq.nlargest(1, iterable, key=keyfunc)
.
在新的3.4版本:默認keyword-only論點。

memoryview(obj)
返回一個“內存視圖對象創建從給定的參數。看到 內存視圖為更多的信息。

min(iterable,* [的關鍵,默認的])
min(__arg1、最長,** args[,關鍵*])
返回最小項iterable或最小的兩個或兩個以上的參數。
如果提供了一個位置參數,它應該是一個 iterable。最小的項目返回iterable。如果提供兩個或兩個以上的位置參數,返回最小的位置參數。
有兩個可選keyword-only參數。關鍵參數指定一個參數排序函數用于 list.sort()
。默認參數指定一個對象返回,如果提供iterable是空的。如果iterable為空,???認不提供, ValueError
是提高。
如果多個項目是最小的,函數返回第一個。這是符合其他sort-stability保留等工具 sorted(iterable, key=keyfunc)[0]
和 heapq.nsmallest(1, iterable, key=keyfunc)
.
在新的3.4版本:默認keyword-only論點。

next(迭代器[,默認的])
檢索從迭代器通過調用它的下一個項目 next()
方法。如果違約,它返回迭代器是否耗盡,否則 StopIteration
是提高。

類 object

返回一個新的無特色的對象。 object
是所有類的一個基地。它的方法是常見的Python類的所有實例。這個函數不接受任何參數。
請注意
object
沒有一個 dict
,所以你不能指定任意屬性的一個實例 object
類。

oct(x)
整數轉換為八進制數的字符串。結果是一個有效的Python表達式。如果x是Python int
對象,它必須定義一個 index()
方法返回一個整數。

open(文件,模式= ' r ',緩沖= 1,編碼=沒有錯誤=沒有換行符= None,closefd = True,刀=沒有)
打開文件并返回一個對應的 文件對象。如果文件不能打開,一個 OSError
是提高。
文件是一個 就對象給路徑名(絕對或相對于當前工作目錄)的文件打開或整數包裝文件的文件描述符。(如果一個文件描述符,它關閉時返回的I / O對象是關閉,除非closefd將 False
.)
模式是一個可選的字符串,指定了模式的文件打開。它默認為 'r'
這意味著在文本模式打開閱讀。其他常見的值 'w'
寫作(刪除文件如果它已經存在), 'x'
為獨家創建和 'a'
為附加(在某些Unix系統,意味著所有寫附加到文件的末尾不管當前尋求位置)。在文本模式下,如果沒有指定編碼的編碼使用平臺的依賴: locale.getpreferredencoding(False)
被稱為當前語言環境編碼。(閱讀和寫作的原始字節使用二進制模式和編碼未指明的離開。)可用的模式是:

字符
意義

'r'

開放閱讀(默認)

'w'

開放的寫作,首先刪除文件

'x'

開放獨家創造,失敗如果文件已經存在

'a'

開放的寫作,附加的文件如果它存在

'b'

二進制模式

't'

文本模式(默認)

'+'

打開磁盤文件更新(閱讀和寫作)

'U'

普遍的換行模式(棄用)

默認的模式是 'r'
(打開閱讀文本,同義詞 'rt'
)。對于二進制讀寫訪問模式 'w+b'
打開,這樣就為0字節的文件。 'r+b'
打開文件沒有截斷。
正如前面提到的, 概述,Python區分二進制和文本I / O。打開的文件(包括以二進制模式 'b'
模式參數)返回的內容 bytes
對象沒有任何解碼。在文本模式(默認,或者當 't'
包含在模式參數),返回文件的內容是 str
,字節被首先使用平臺相關的編碼或解碼編碼如果使用指定的。
請注意
Python不依賴于底層操作系統概念的文本文件,所有的處理是通過Python本身,因此獨立于平臺的。

緩沖是一個可選的整型用于設置緩沖政策。通過0關閉緩沖(只允許在二進制模式),1選擇行緩沖(僅在文本模式下可用),和一個整數> 1表明固定大小的塊的大小的字節緩沖區。當沒有緩沖參數,默認緩沖策略工作如下:
二進制文件緩存在固定大小的塊,緩沖區的大小是選擇使用啟發式試圖確定底層設備的塊大小和回落 io.DEFAULT_BUFFER_SIZE
。在許多系統中,緩沖區通常是4096或8192字節。
“互動”的文本文件(文件 isatty()
返回 True
)使用行緩沖。其他文本文件為二進制文件使用上述政策。

編碼所使用的編碼解碼的名稱或編碼文件。這應該只用于文本模式。默認的編碼是依賴于平臺(不管 locale.getpreferredencoding()
返回),但任何 文本編碼可以使用Python支持。看到 codecs
模塊支持的編碼列表。
錯誤是一個可選的字符串指定編碼和解碼錯誤是如何處理這種不能用于二進制模式。各種標準的錯誤處理程序(以下列出 錯誤處理程序),盡管任何錯誤處理名稱已被注冊 codecs.register_error()
也是有效的。標準的名稱包括:
'strict'
提高一個 ValueError
如果有一個編碼錯誤異常。的默認值 None
有同樣的效果。
'ignore'
忽略錯誤。注意,忽略編碼錯誤可能導致數據丟失。
'replace'
導致替換標記(如 '?'
)插入哪里有畸形的數據。
'surrogateescape'
將代表任何錯誤的字節在Unicode代碼點私人使用面積從U + U + DCFF DC80。這些私人代碼點就會轉回時相同的字節 surrogateescape
錯誤處理程序寫入數據時使用。這是有用的在一個未知的編碼處理文件。
'xmlcharrefreplace'
只有當寫入一個文件的支持。不支持的字符編碼替換為適當的XML字符引用 &#nnn;
.
'backslashreplace'
通過Python的斜轉義序列替換畸形數據。
'namereplace'
(也寫作時僅支持)取代了不支持的字符 \N{...}
轉義序列。

換行符控制 普遍的換行工作模式(它只適用于文本模式)。它可以 None
, ''
, '\n'
, '\r'
, '\r\n'
。它的工作原理如下:
閱讀時的輸入流,如果換行符 None
,環球換行模式啟用。行輸入可以結束 '\n'
, '\r'
,或 '\r\n'
,這些都是翻譯成 '\n'
之前返回給調用者。如果它是 ''
通用換行模式啟用,但結局都是返回給調用者翻譯。如果有任何其他的法律價值觀,輸入行只是被給定字符串終止,和行結束返回給調用者未翻譯。
當編寫輸出流,如果換行符 None
,任何 '\n'
寫字符轉換到系統默認行分隔符, os.linesep
。如果換行符 ''
或 '\n'
,沒有翻譯。如果任何其他法律價值換行, '\n'
字符是給定字符串翻譯寫的。

如果closefd False
和一個文件描述符,而不是一個文件名,底層文件描述符將保持關閉打開的文件。如果一個文件名closefd必須給出 True
(默認),否則,它會拋出一個錯誤。
可以使用一個定制刀通過一個可調用的。底層文件描述符的文件對象然后通過調用刀(文件、旗幟)。開瓶器必須返回一個打開的文件描述符(傳遞 os.open
比賽結果在功能上類似于傳遞 None
).
新創建的文件 non-inheritable.
下面的例子使用了 dir_fd參數的 os.open()
函數打開一個文件相對于給定目錄:

importos>>> dir_fd=os.open('somedir',os.O_RDONLY)>>> defopener(path,flags):... returnos.open(path,flags,dir_fd=dir_fd)...>>> withopen('spamspam.txt','w',opener=opener)asf:... print('This will be written to somedir/spamspam.txt',file=f)...>>> os.close(dir_fd)# don't leak a file descriptor

的類型 文件對象返回的 open()
函數依賴于模式。當 open()
用來打開一個文件在一個文本模式('w'
, 'r'
, 'wt'
, 'rt'
等),它返回的一個子類 io.TextIOBase
(特別是 io.TextIOWrapper
)。當用于與緩沖以二進制方式打開一個文件,返回的類的一個子類 io.BufferedIOBase
。確切的階級不同:在讀取二進制模式下,它返回一個 io.BufferedReader
;在寫二進制和附加二進制模式,它返回一個 io.BufferedWriter
以讀/寫模式,它返回一個io.BufferedRandom
。禁用緩沖時,原始流的一個子類 io.RawIOBase
, io.FileIO
,返回。
參見文件處理模塊,如 fileinput
, io
( open()
聲明), os
, os.path
, tempfile
, shutil
.
3.3版本的變化:刀參數了。
的 'x'
模式是補充道。
IOError
用于提高,現在的別名 OSError
.
FileExistsError
現在在獨家提出如果文件打開嗎
創建模式('x'
)已經存在。

3.4版本的變化:文件現在non-inheritable。

棄用自3.4版本,4.0版本將被刪除:的 'U'
模式。

3.5版本的變化:如果系統調用中斷和信號處理器不引發一個異常,該函數現在重試的系統調用,而不是一個 InterruptedError
異常(見PEP 475基本原理)。
的 'namereplace'
添加錯誤處理程序。

3.6版本的變化:支持添加到接受對象實現 os.PathLike
.
在Windows上,打開一個控制臺緩沖可能返回的一個子類 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)
相當于使用權力操作符: xy
.
一定數值類型的參數。混合操作數類型,強迫二進制算術運算符規則適用。為 int
操作數,結果有相同的類型作為操作數(脅迫)除非第二個參數是消極的;在這種情況下,所有參數轉換為浮動,浮動的結果。例如, 102
返回 100
,但10**-2
返回 0.01
。如果第二個參數是負的,第三個參數必須省略???如果z,x和y必須是整數類型,和y必須是非負數。

print(對象,9 = ' ' = ' \ n '結束,文件= sys.stdout,沖洗= False*)
打印文本流文件對象,由9月,緊隨其后的是結束。9月,結束,文件,如果存在,必須作為關鍵字參數。
像所有non-keyword參數轉換為字符串 str()
和寫入到流,由9月,緊隨其后的是結束。9月和結束都必須是字符串;他們也可以 None
,這意味著使用默認值。如果沒有對象, print()
只會寫。
文件的參數必須是一個對象 write(string)
方法,如果它不存在或 None
, sys.stdout
就會被使用。因為印刷參數轉換為文本字符串, print()
不能用于二進制模式文件對象。對于這些,使用 file.write(...)
代替。
是否輸出緩沖通常是由文件,但是如果沖洗關鍵字參數是正確的,流強制刷新。
3.3版本的變化:添加刷新關鍵字參數。

類 property(fget = None,fset = None,fdel =沒有醫生=沒有)
返回一個財產屬性。
fget函數獲取一個屬性的值。fset設置一個屬性值是一個函數。fdel刪除一個屬性值是一個函數。和醫生創建文檔字符串屬性。
一個典型的用途是定義一個屬性管理 x
:
classC:def__init__(self):self._x=Nonedefgetx(self):returnself._xdefsetx(self,value):self._x=valuedefdelx(self):delself._xx=property(getx,setx,delx,"I'm the 'x' property.")

如果c是c的一個實例, c.x
將調用getter, c.x = value
將調用setter和 del c.x
刪除人。
如果,醫生將所以的財產屬性。否則,房地產將復制fget docstring(如果它存在的話)。這使得它可以創建只讀屬性很容易使用 property()
作為一個 裝飾:
classParrot:def__init__(self):self._voltage=100000@propertydefvoltage(self):"""Get the current voltage."""returnself._voltage

的 @property
修飾符將 voltage()
方法為“getter”為一個只讀屬性相同的名稱,它為電壓設置有“獲取當前電壓”。
屬性對象 getter
, setter
, deleter
方法使用修飾符創建一份財產與相應的訪問器功能設置為裝飾功能。這是用一個例子做了最好的解釋:
classC:def__init__(self):self._x=None@propertydefx(self):"""I'm the 'x' property."""returnself._x@x.setterdefx(self,value):self._x=value@x.deleterdefx(self):delself._x

這段代碼是完全等價的第一個例子。一定要給額外的函數名稱相同的原始屬性(x
在這種情況下)。
返回的屬性對象也有屬性 fget
, fset
, fdel
相應的構造函數參數。
3.5版本的變化:現在可寫屬性的文檔字符串對象。

range(停止)
range
(開始,停止[,一步])
而不是一個函數, range
實際上是一個不可變的序列類型,記錄在嗎 范圍和 序列類型——列表、元組、范圍.

repr(對象)
返回一個字符串包含一個可打印的代表一個對象。對于許多類型,這個函數使試圖返回一個字符串,將產生一個對象傳遞給時相同的值 eval()
,否則表示是用尖括號括起來的字符串,它包含的類型對象的名稱加上額外的信息通常包括對象的名稱和地址。一個類可以控制通過定義這個函數返回的實例 repr()
方法。

reversed(seq)
返回一個反向 迭代器。seq必須有一個對象 reversed()
方法或支持的協議序列( len()
方法和 getitem()
方法用整數參數開始 0
).

round(數量[,ndigits])
返回浮點值的數字四舍五入小數點后ndigits位數。如果省略ndigits或 None
,它返回最近的整數輸入。代表 number.round(ndigits)
.
內置類型支持 round()
、價值觀四舍五入為最接近的倍數10次方- ndigits;如果兩個同樣倍數接近,甚至舍入完成向的選擇(例如,兩個 round(0.5)
和 round(-0.5)
是 0
, round(1.5)
是 2
)。返回值是一個整數,如果調用了一個參數,否則相同類型的數量。
請注意
的行為 round()
花車可以令人驚訝:例如, round(2.675, 2)
給了 2.67
而不是預期的 2.68
。這不是一個錯誤:這是一個事實,大多數的結果小數分數不能完全表示為一個浮點數。看到 浮點運算:問題和局限性為更多的信息。

類 set([iterable])
返回一個新的 set
對象,可選元素取自iterable。 set
是一個內置的類。看到 set
和 類型——集合,frozenset關于這個類的文檔。
對于其他容器內置 frozenset
, list
, tuple
, dict
類,以及 collections
模塊。

setattr(對象,名字,價值)
這是相對應的 getattr()
。參數是一個對象,一個字符串和一個任意值。字符串可能現有的屬性或一個新屬性名稱。函數分配價值屬性,提供了對象允許它。例如, setattr(x, 'foobar', 123)
相當于 x.foobar = 123
.

類 slice(停止)
類 slice
(開始,停止[,一步])
返回一個 片對象代表指定的一系列指標 range(start, stop, step)
。參數默認的啟動和步驟 None
。片有只讀數據屬性的對象 start
, stop
和 step
這僅僅是返回的參數值(或違約)。他們沒有其他明確的功能,但是它們使用Numerical Python和其他第三方擴展。部分對象也使用時生成擴展索引的語法。例如: a[start:stop:step]
或 a[start:stop, i]
。看到 itertools.islice()
返回一個迭代器的另一個版本。

sorted(iterable[,][,反向))
返回一個新的iterable項目的有序列表。
有兩個可選參數必須指定為關鍵字參數。
鍵指定一個參數的函數,用于提取比較主要從每個列表元素: key=str.lower
。默認值是 None
(比較直接的元素)。
相反的是一個布爾值。如果設置為 True
,那么列表元素排序好像每個比較逆轉。
使用 functools.cmp_to_key()
一個老式的cmp函數轉換為一個關鍵功能。
內置的 sorted()
功能是保證穩定。排序是穩定的,如果保證不改變元素的相對順序比較平等——這有助于排序在多個傳遞(例如,由部門,然后由工資等級)。
用于排序的例子和一個簡短的排序教程,看看 排序如何.

staticmethod(函數)
函數返回一個靜態方法。
靜態方法不能得到一個隱式的第一個參數。要聲明一個靜態方法,使用這個成語:
classC:@staticmethoddeff(arg1,arg2,...):...

的 @staticmethod
表單是一個函數 裝飾——看到函數定義的描述 函數定義獲取詳細信息。
它可以被稱為類(如 C.f()
(比如)或在一個實例 C().f()
)。除了它的類實例被忽略。
靜態方法在Python中發現類似Java或c++。也看到 classmethod()
為創建有用的變體替代類構造函數。
有關靜態方法的更多信息,請參考文檔標準類型層次結構 標準的類型層次結構.

類 str(obj= ")
類 str
(對象= b”,編碼=“utf - 8”,錯誤=“嚴格的”)
返回一個 str
版本的對象。看到 str()
獲取詳細信息。
str
是內置的字符串 類。對于一般信息字符串,明白了 文本序列類型- str.

sum(iterable[,開始])
資金開始和iterable從左到右的物品并返回。開始違約 0
。iterable的項目通常是數字,開始值不能是一個字符串。
對于一些用例,有很好的替代品 sum()
。的首選,快速連接字符串序列的方法是通過調用 ''.join(sequence)
。添加和擴展精度浮點值,明白了 math.fsum()
。連接一系列iterable,考慮使用 itertools.chain()
.

super([類型[,對象或者類型]])
方法調用返回一個代理對象,代表父母或兄弟姐妹的類型。這是非常有用的用于訪問被覆蓋在一個類繼承的方法。使用的搜索順序是一樣的 getattr()
除了類型本身是跳過。
的 mro
屬性的類型列表使用的方法解析搜索順序 getattr()
和 super()
。屬性是動態的,可以改變,無論何時更新繼承層次結構。
如果省略第二個參數,返回超級對象是不受約束的。如果第二個參數是一個對象, isinstance(obj, type)
必須是真實的。如果第二個參數是一個類型, issubclass(type2, type)
必須是真實的(這是有用的類方法)。
有兩個超級的典型用例。與單繼承一個類層次結構,可以使用超級引用父類沒有明確命名它們,從而使代碼更易于維護。這個用密切的相似之處在其他編程語言中使用的。
第二個用例是支持合作動態執行環境中多重繼承。這個用例是獨一無二的,沒有找到Python和靜態編譯語言或語言只支持單繼承的。這使得它可以實現“鉆石圖”,多個基類實現相同的方法。好的設計要求,該方法具有相同的調用簽名在任何情況下(因為在運行時調用的順序決定,因為為了適應類層次結構的變化,因為這個順序可以包括兄弟姐妹類運行時)之前是未知的。
對于這兩個用例,一個典型的超類是這樣的:
classC(B):defmethod(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
實際上是一個不可變的序列類型,記錄在嗎 元組和 序列類型——列表、元組、范圍.

類 type(對象)
類 type(名稱、基地dict)
一個參數,返回一個對象的類型。返回值是一個對象類型和通常返回的對象一樣 object.class
.
的 isinstance()
內置函數建議測試一個對象的類型,因為它考慮了子類。
有三個參數,返回一個新的類型對象。這本質上是一個動態的形式 class
聲明。這個名字是類名,成為字符串 name
元組屬性;基地列舉了基類,變成了 bases
屬性;關鍵字詞典是包含類定義的名稱空間的身體和復制到成為一個標準的字典 dict
屬性。例如,以下兩個語句創建相同的 type
對象:

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

另請參閱 類型的對象.
3.6版本的變化:的子類 type
不覆蓋 type.new
可能不再使用一個參數形式來獲得一個對象的類型。

vars([對象])
返回 dict
屬性模塊、類實例,或任何其他對象 dict
屬性。
對象模塊和實例等可更新 dict
屬性;但是,其他對象可能會限制他們的寫 dict
屬性(例如,使用一個類 types.MappingProxyType
為了防止直接字典更新)。
沒有一個論點, vars()
就像 locals()
。注意,當地人字典只用于讀取以來更新當地人字典被忽略。

zip(** iterable)
做一個集合元素的迭代器從每個iterable。
返回一個迭代器的元組,其中的第i個tuple包含每個參數序列的第i個元素或iterable。輸入迭代器停止時最短iterable耗盡。用一個iterable論點,它返回一個迭代器1-tuples。不帶參數,它將返回一個空的迭代器。等價于:
defzip(iterables):# zip('ABCD', 'xy') --> Ax Bysentinel=object()iterators=[iter(it)foritiniterables]whileiterators:result=[]foritiniterators:elem=next(it,sentinel)ifelemissentinel:returnresult.append(elem)yieldtuple(result)

的評價從左到右順序iterable保證。這使可能的成語集群數據系列分為n-length組使用 zip([iter(s)]n)
。這種重復相同的迭代器 n
次,這樣每個輸出元組的結果 n
調用迭代器。這樣做的效果是將輸入分成n-length塊。
zip()
只能使用不平等的長度輸入當你不關心的,無與倫比的值不再iterable。如果這些值很重要,使用 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)andy==list(y2)True

import(名稱、全局變量=沒有當地人= None,fromlist =(),水平= 0)
請注意
這是一個先進的功能,不需要在每天的Python編程,不像 importlib.import_module()
.

這個函數被調用的 import
聲明。它可以(通過進口替代 builtins
模塊和分配 builtins.import
為了改變語義的 import
聲明,但不提倡這樣做,因為它通常是更簡單的使用進口掛鉤(見PEP 302)實現相同的目標,不會導致問題的代碼假定默認實現使用的進口。直接使用 import()
也不贊成嗎 importlib.import_module()
.
導入功能模塊名稱,可能使用給定的全局和當地人來決定如何解釋這個名字在包上下文。fromlist給的名字應該進口的對象或子模塊的名字。標準實現不使用它的當地人參數,并使用它的全局唯一確定的包上下文 import
聲明。
指定是否使用絕對或相對進口水平。 0
(默認)意味著只有執行絕對進口。積極的水平值顯示的數量相對于目錄的父目錄搜索模塊調用 import()
(見PEP 328的詳細信息)。
當表單的變量的名稱 package.module
,正常情況下,頂層包(這個名字到第一個點)返回,而不是模塊的名字命名。然而,當一個非空fromlist參數,返回模塊命名的名字。
例如,語句 import spam
結果在字節碼類似下面的代碼:
spam=import('spam',globals(),locals(),[],0)

該聲明 import spam.ham
這個調用的結果:
spam=import('spam.ham',globals(),locals(),[],0)

請注意 import()
返回頂層的模塊,因為這是由對象綁定到一個名稱 import
聲明。
另一方面,這一聲明 from spam.ham import eggs, sausage as saus
結果
_temp=import('spam.ham',globals(),locals(),['eggs','sausage'],0)eggs=_temp.eggssaus=_temp.sausage

在這里, spam.ham
模塊是回來 import()
。從這個對象中,導入名稱檢索并分配給各自的名字。
如果你只是想要導入一個模塊(可能在一個包)的名字,使用 importlib.import_module()
.
3.3版本的變化:負值為水平不再支持(也改變默認值為0)。

腳注

[1]
注意,解析器只接受線公約的unix形式結束。如果你正在閱讀的代碼文件,確保使用換行符轉換模式將Windows或蘋果樣式換行。