python 常用的內置函數

2.內置函數

Python解釋器有許多內置的功能和類型，始終可用。他們按字母順序列在這里。

		內置功能
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

返回數字的絕對值。參數可以是整數或浮點數。如果參數是復數，則返回其大小。

all（可迭代）
返回True如果的所有元素迭代是真實的（或者如果可迭代為空）。相當於：

高清 全（迭代器）：
    為 元素 的 迭代：
        如果 沒有 元素：
            返回 假
    返回 真
any（可迭代）
True如果iterable的任何元素都為true ，則返回。如果iterable為空，則返回False。相當於：

DEF  任何（迭代器）：
    為 元素 的 迭代：
        如果 元素：
            返回 真正的
    回報 假
ascii（對象）
如repr()，由返回的字符串中返回一個包含對象的可打印表示一個字符串，但逃避非ASCII字符 repr()使用\x，\u或\U逃逸。這將生成一個類似於repr()Python 2 中返回的字符串。

bin（x ）
將整數轉換為以“0b”為前綴的二進制字符串。結果是一個有效的Python表達式。如果x不是Python int對象，則必須定義一個__index__()返回整數的方法。一些例子：

>>>
>>> bin （3 ）
'0b11' 
>>> bin （- 10 ）
'-0b1010'
如果希望前綴“0b”，您可以使用以下任一方式。

>>>
>>> format （14 ， '#b' ）， format （14 ， 'b' ）
（'0b1110'，'1110'）
>>> f ' {14：#b} ' ， f ' {14：' 
（'0b1110'，'1110'）
另請參閱format()更多信息。

class bool（[ x ] ）
返回一個布爾值，即其中之一True或False。 x使用標准真實測試程序進行轉換。如果x為假或省略，則返回False; 否則返回True。的 bool類是的子類int（參見數值類型-整數，浮點，復合）。它不能進一步子類化。它唯一的實例是False和 True（參見布爾值）。

class bytearray（[ source [，encoding [，errors ] ] ] ）
返回一個新的字節數組。的bytearray類是整數的范圍為0 <= X一個可變的序列<256它具有最的可變序列，在所描述的常規方法的可變序列類型，以及大多數方法，該bytes類型已見字節和ByteArray操作。

可選的源參數可用於以幾種不同的方式初始化數組：

如果是字符串，還必須給出編碼（和可選的 錯誤）參數; bytearray()然后使用字符串轉換為字節str.encode()。
如果它是整數，則數組將具有該大小，並且將以空字節初始化。
如果是符合緩沖區接口的對象，則將使用對象的只讀緩沖區來初始化字節數組。
如果它是一個可迭代的，它必須是范圍內的整數的迭代 ，它們被用作數組的初始內容。0 <= x < 256
沒有參數，將創建一個大小為0的數組。

另請參見二進制序列類型 - 字節，bytearray，memoryview和Bytearray對象。

class bytes（[ source [，encoding [，errors ] ] ] ）
返回一個新的“bytes”對象，這是一個不可變的整數序列。 是一個不可變的版本 - 它具有相同的非突變方法和相同的索引和切片行為。0 <= x < 256bytesbytearray

因此，構造函數參數被解釋為bytearray()。

也可以使用文字創建字節對象，請參閱字符串和字節文字。

另請參見二進制序列類型 - 字節，bytearray，memoryview，Bytes對象和Bytes和Bytearray操作。

callable（對象）
True如果對象參數出現可調用 False則返回，否則返回。如果這返回true，那么調用失敗仍然是可能的，但如果它為false，則調用對象將永遠不會成功。注意類可調用（調用一個類返回一個新的實例）; 如果他們的類有一個__call__()方法，則可以調用實例。

版本3.2中的新功能：此功能在Python 3.0中首先被刪除，然后被帶回到Python 3.2中。

chr（i ）
返回表示Unicode代碼點為整數i的字符的字符串。例如，chr(97)返回字符串'a'，同時 chr(8364)返回字符串'€'。這是倒數ord()。

參數的有效范圍為0到1,114,111（在16位為0x10FFFF）。 ValueError如果我超出該范圍，將會被提高。

classmethod（功能）
返回函數的類方法。

類方法接收類作為隱式第一個參數，就像實例方法接收到實例一樣。要聲明一個類的方法，使用這個成語：

類 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 ）
將源編譯成代碼或AST對象。代碼對象可以由exec()或執行eval()。 源可以是普通字符串，字節字符串或AST對象。ast有關如何使用AST對象的信息，請參閱模塊文檔。

該文件名參數應該給從代碼讀取的文件; 如果沒有從文件讀取（'<string>'通常使用），則傳遞一些可識別的值。

該模式參數指定什么樣的代碼必須進行編譯; 它可以是 'exec'，如果源包含的語句序列的，'eval'如果它由一個單一的表達的，或者'single'如果它由單個交互式聲明的（在后一種情況下，計算結果為比其他東西表達式語句None將被打印）。

可選參數flags和dont_inherit控制哪些未來語句（見PEP 236）影響源的編譯。如果兩者都不存在（或兩者均為零），則代碼將被編譯，並在正在調用的代碼中生效compile()。如果指定了 flags參數，並且 dont_inherit不是（或為零），那么除了將要使用的那些之外，還會使用 flags參數指定的將來的語句。如果 dont_inherit是一個非零整數，那么這個 flags參數就是它 - 將會忽略在編譯調用期間生效的將來的語句。

將來的語句由比特來指定，這些比特可以按位OR或一起指定多個語句。指定給定功能所需的位域可以作為模塊中實例的compiler_flag屬性找到。_Feature__future__

參數optimize指定編譯器的優化級別; 默認值-1選擇由-O選項給出的解釋器的優化級別。顯式級別為0（不優化; __debug__為真），1（斷言被刪除，__debug__為假）或2（文檔字符串也被刪除）。

SyntaxError如果編譯的源無效，並且ValueError源包含空字節，則此函數將引發。

如果您想將Python代碼解析成其AST表示，請參閱 ast.parse()。

注意 當使用'single'或 'eval'模式中的多行代碼編譯字符串時，輸入必須由至少一個換行符終止。這是為了便於檢測code模塊中不完整和完整的語句。
版本3.2更改：允許使用Windows和Mac換行符。此外，輸入'exec'模式也不必再以換行符結尾。添加了優化參數。

在版本3.5中更改：以前，TypeError在源中遇到空字節時引發。

class complex（[ real [，imag ] ] ）
返回復數與價值真正 + IMAG * 1J或者一個字符串或數字轉換為復數。如果第一個參數是一個字符串，它將被解釋為一個復數，該函數必須在沒有第二個參數的情況下被調用。第二個參數永遠不能是一個字符串。每個參數可以是任何數字類型（包括復數）。如果IMAG被省略，默認為零，並且構造用作數字轉換等 int和float。如果兩個參數都被省略，則返回 0j。

注意 從字符串轉換時，字符串不能包含中央+或-運算符周圍的空格。例如， complex('1+2j')不錯，但是提高了 。complex('1 + 2j')ValueError
復數類型在數值類型 - int，float，complex中描述。

在版本3.6中更改：允許使用代碼字面值分組帶下划線的數字。

delattr（對象，名稱）
這是一個親戚setattr()。參數是一個對象和一個字符串。字符串必須是對象屬性之一的名稱。該函數會刪除該命名屬性，只要該對象允許。例如，相當於。delattr(x, 'foobar')del x.foobar

班dict（** kwarg ）
類dict（映射，** kwarg ）
class dict（iterable，** kwarg ）
創建一個新的字典。該dict對象是字典類。查看dict和映射類型 - dict關於此類的文檔。

對於其他容器看到內置list，set以及 tuple類，還有collections模塊。

dir（[ object ] ）
沒有參數，返回當前本地作用域中的名稱列表。使用參數，嘗試返回該對象的有效屬性列表。

如果對象具有一個名為的__dir__()方法，則將調用此方法，並返回屬性列表。這允許實現自定義__getattr__()或__getattribute__()函數的對象自 定義dir()報告其屬性的方式 。

如果對象不提供__dir__()，該函數將盡力從對象的__dict__屬性（如果已定義）和其類型對象收集信息。生成的列表不一定是完整的，並且當對象具有自定義時可能不准確__getattr__()。

默認dir()機制與不同類型的對象的行為不同，因為它嘗試生成最相關但不完整的信息：

如果對象是模塊對象，則該列表包含模塊屬性的名稱。
如果對象是類型或類對象，則列表包含其屬性的名稱，並遞歸地顯示其基礎的屬性。
否則，列表包含對象的屬性名稱，其類的屬性的名稱，以及遞歸類的基類的屬性。
結果列表按字母順序排列。例如：

>>>
>>> import  struct 
>>> dir （）   ＃顯示模塊命名空間中的名稱
['__builtins__'，'__name__'，'struct'] 
>>> dir （struct ）   ＃顯示struct模塊中的名稱
['Struct ”， '__all__'， '__builtins__'， '__cached__'， '__doc__'， '__file__'，
'__initializing__'， '__loader__'， '__name__'， '__PACKAGE__'，
'_clearcache'， 'calcsize'， '錯誤'， 'pack'，'pack_into'，
'unpack'，'unpack_from'] 
>>> class  Shape ：
...    def  __dir__ （self ）：
...         return  [ 'area' ， 'spacing' ， 'location' ] 
>>> s  =  Shape （）
>>> dir （s ）
['area'，'location'，'streets']
注意 因為dir()主要是為了方便在交互式提示中使用，所以嘗試提供一組有趣的名稱，而不是嘗試提供嚴格或一致定義的名稱集，並且其詳細行為可能會在版本中更改。例如，當參數是一個類時，metaclass屬性不在結果列表中。
divmod（a，b ）
以兩個（非復數）數字作為參數，並返回一個由他們的商和余數組成的數字，當使用整數除法時。使用混合的操作數類型，二進制算術運算符的規則適用。對於整數，結果與。對於浮點數，結果是，其中q通常可能比其小1。在任何情況下，是非常接近的一個，如果不為零，它具有相同的符號為b，和。(a // b, a % b)(q, a % b)math.floor(a / b)q * b + a % ba % b0 <= abs(a % b) < abs(b)

enumerate（iterable，start = 0 ）
返回枚舉對象。iterable必須是序列， 迭代器或支持迭代的其他對象。__next__()返回的迭代器的方法 enumerate()返回一個包含count（從起始，默認為0）的元組和從迭代迭代獲得的值。

>>>
>>> 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，'秋天'），（4，'冬天'）]
相當於：

DEF  枚舉（序列， 開始= 0 ）：
    ñ  =  開始
    為 ELEM  在 序列：
        收率 Ñ ， ELEM 
        Ñ  + =  1
eval（expression，globals = None，locals = None ）
參數是一個字符串和可選的全局變量和當地人。如果提供， 全局變量必須是字典。如果提供，本地人可以是任何映射對象。

該表達參數分析，並作為一個Python表達式來使用（從技術上來說，一個條件列表）全局和當地人 的字典作為全局和局部名字空間。如果全局詞典存在且缺少“__builtins__”，則 在解析表達式之前，將當前全局變量復制到全局變量中。這意味着表達式通常具有對標准模塊的完全訪問權限，並且傳播受限制的環境。如果省略本地字典，則默認為全局變量builtins 字典。如果省略了兩個字典，表達式將在eval()被調用的環境中執行。返回值是評估表達式的結果。語法錯誤報告為異常。例：

>>>
>>> x  =  1 
>>> eval （'x + 1' ）
2
此函數也可用於執行任意代碼對象（如由compile()）創建的代碼對象。在這種情況下，傳遞代碼對象而不是字符串。如果代碼對象已經被編譯'exec'為 模式參數，那么eval()返回值將是None。

提示：該exec() 函數支持語句的動態執行。the globals()和locals()函數分別返回當前的全局和本地字典，這可能有助於傳遞eval()或使用exec()。

查看ast.literal_eval()一個可以安全地使用只包含文字的表達式來計算字符串的函數。

exec（object [，globals [，locals ] ] ）
此函數支持Python代碼的動態執行。對象必須是字符串或代碼對象。如果它是一個字符串，則將該字符串解析為一組Python語句，然后執行該語句（除非發生語法錯誤）。[1]如果它是一個代碼對象，它只是被執行。在所有情況下，執行的代碼預期作為文件輸入有效（參見“參考手冊”中的“文件輸入”一節）。要知道， return和yield語句可能不是函數定義之外，甚至代碼傳遞給上下文中使用 exec()的功能。返回值為None。

在所有情況下，如果可選部分被省略，代碼將在當前范圍內執行。如果僅提供全局變量，則它必須是字典，將用於全局變量和局部變量。如果全局和 當地人給出，它們分別用於全局和局部變量。如果提供，本地人可以是任何映射對象。記住，在模塊級別，全局變量和本地化是相同的字典。如果exec將兩個單獨的對象作為全局變量和局部變量執行，則代碼將被執行，就好像嵌入在類定義中一樣。

如果全局變量字典不包含該鍵的值， 則會在該鍵下插入__builtins__對內置模塊的字典的引用 builtins。這樣，您可以通過將自己的__builtins__字典插入到全局變量中，然后再傳遞給執行的代碼，來控制哪些內置函數可用 exec()。

注意 內置函數globals()並分別locals()返回當前的全局和本地字典，這可能有助於作為第二和第三個參數傳遞exec()。
注意 默認的本地人的作用如locals()下面的功能所述：不要嘗試修改默認的本地字典。如果您需要在函數返回后查看本地代碼的效果，請傳遞一個顯式的本地字典。exec()
filter（函數，可迭代）
從可迭代的元素構造一個迭代器，該函數 返回true。 可迭代可以是序列，支持迭代的容器或迭代器。如果函數是None，則假定身份函數，即除以 false的所有可迭代元素。

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

請參閱itertools.filterfalse()為哪個函數返回false 可以返回iterable的元素的互補函數。

class float（[ x ] ）
返回從數字或字符串x構造的浮點數。

如果參數是一個字符串，它應該包含一個十進制數，可選地帶有一個符號，並且可以嵌入到空格中。可選標志可以是'+'或'-'; 一個'+'標志對產生的價值沒有影響。參數也可以是表示NaN（不是數字）或正或負無窮大的字符串。更准確地說，在刪除前導和尾隨空白字符之后，輸入必須符合以下語法：

sign           :: =“+”| “ - ”
 infinity       :: =“Infinity”| “inf”
 nan            :: =“nan”
 numeric_value :: =   floatnumber| infinity| numeric_string :: = [ ]nan
signnumeric_value
這floatnumber是浮點文字中描述的Python浮點文字的形式。情況並不重要，因此，例如，“inf”，“Inf”，“INFINITY”和“iNfINity”都是正無窮大的可接受拼寫。

否則，如果參數是整數或浮點數，則返回具有相同值的浮點數（在Python的浮點精度內）。如果參數超出了Python float的范圍，OverflowError則會引發一個參數。

對於一般的Python對象x，float(x)委托 x.__float__()。

如果沒有給出參數，0.0則返回。

例子：

>>>
>>> float （'+ 1E6' ）
1.23 
>>> float （'-12345 \ n ' ）- 
12345.0 
>>> float （'1e-003' ）
0.001 
>>> float （'+ 1E6' ）
1000000.0 
>> > float （'-Infinity' ）- 
inf
浮點類型在數值類型 - int，float，complex中描述。

在版本3.6中更改：允許使用代碼字面值分組帶下划線的數字。

format（value [，format_spec ] ）
將值轉換為由format_spec控制的“格式化”表示 。format_spec的解釋將取決於值參數的類型，但是還有一種標准的格式化語法，由大多數內置類型使用：格式規范Mini-Language。

默認format_spec是一個空字符串通常作為給調用同樣的效果str(value)。

在搜索該值的方法時，調用轉換為 繞過實例字典。一 ，如果該方法搜索到達引發異常 和format_spec非空，或者這兩個 format_spec或返回值是不是字符串。format(value, format_spec)type(value).__format__(value, format_spec)__format__()TypeErrorobject

在版本3.4中更改： 如果format_spec不是空字符串，則object().__format__(format_spec)引發。TypeError

類frozenset（[ iterable ] ）
返回一個新frozenset對象，可選擇從iterable取得的元素 。 frozenset是一個內置的類。查看frozenset和 設置類型 - 設置，frozenset以獲取有關此類的文檔。

對於其他容器看到內置的set，list， tuple，和dict類，還有collections 模塊。

getattr（object，name [，default ] ）
返回對象的命名屬性的值。 name必須是一個字符串。如果字符串是對象屬性之一的名稱，則該屬性的值為該值。例如，相當於 。如果命名屬性不存在，則返回默認值，否則生成。getattr(x, 'foobar')x.foobarAttributeError

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

hasattr（對象，名稱）
參數是一個對象和一個字符串。結果是True如果字符串是對象屬性之一的名稱，False否則。（這是通過調用和看到它是否引起的來實現的。）getattr(object, name)AttributeError

hash（對象）
返回對象的哈希值（如果有的話）。哈希值是整數。它們用於在字典查找期間快速比較字典鍵。比較均等的數值具有相同的散列值（即使它們是不同類型，如1和1.0的情況）。
注意 對於具有自定義__hash__()方法的對象，請注意，hash() 根據主機的位寬度截斷返回值。看__hash__()詳情。
help（[ object ] ）
調用內置的幫助系統。（此功能用於交互式使用。）如果沒有給出參數，交互式幫助系統將在解釋器控制台上啟動。如果參數是字符串，則將字符串作為模塊，函數，類，方法，關鍵字或文檔主題的名稱進行查找，並在控制台上打印一個幫助頁面。如果參數是任何其他類型的對象，則生成對象上的幫助頁面。

該功能由site模塊添加到內置命名空間中。

在版本3.4中更改：更改pydoc並inspect意味着報告的電話簽名現在更全面和一致。

hex（x ）
將整數轉換為以“0x”為前綴的小寫十六進制字符串。如果x不是Python int對象，則必須定義返回一個整數的__index __（）方法。一些例子：

>>>
>>> hex （255 ）
'0xff' 
>>> hex （- 42 ）
'-0x2a'
如果要將整數轉換為具有前綴或不帶前綴的大寫或十六進制字符串，可以使用以下兩種方式之一：

>>>
>>> ' ％＃x '  ％ 255 ， ' ％x '  ％ 255 ， ' ％X '  ％ 255 
（'0xff'，'ff'，'FF'）
>>> 格式（255 ， ' #x ' ）， 格式（255 ， 'x' ）， 格式（255 ， 'X' ）
（'0xff'，'ff'，'FF'）
>>> f ' {255：#x} ' ， f ' {255：x} ' ， f ' {255：X}' 
（'0xff'，'ff'，'FF'）
另請參閱format()更多信息。

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

注意 要獲取浮點數的十六進制字符串表示形式，請使用該 float.hex()方法。
id（對象）
返回一個對象的“身份”。這是一個整數，在整個生命周期中，該對象被保證是唯一的和不變的。具有不重疊壽命的兩個對象可能具有相同的id() 值。

CPython實現細節：這是內存中對象的地址。
input（[ prompt ] ）
如果提示參數存在，則將其寫入標准輸出，而不帶尾隨的換行符。該函數然后從輸入讀取一行，將其轉換為字符串（剝離尾隨的換行符），並返回。當讀取EOF時，EOFError被提出。例：

>>>
>>> s  =  input （' - >' ）  
- > Monty Python的飛馬場
>>> s   
“Monty Python's Flying Circus”
如果readline模塊被加載，那么input()將使用它來提供詳細的行編輯和歷史記錄功能。

類int（x = 0 ）
類int（x，base = 10 ）
返回從數字或字符串x構造的整數對象，0如果沒有給出參數，則返回 。如果x是數字，則返回 x.__int__()。對於浮點數，這將截斷為零。

如果X不是數字或如果基給出，則X必須是一個字符串， bytes或bytearray代表一個實例字面整數在基數基。可選地，文字可以在之前+或之間-（在之間沒有空格）並被空格包圍。甲基-正文字由數字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並且基礎對象具有 base.__index__方法，則調用該方法以獲取基數的整數。以前使用的版本 base.__int__代替base.__index__。

在版本3.6中更改：允許使用代碼字面值分組帶下划線的數字。

isinstance（object，classinfo ）
如果對象參數是classinfo 參數的實例，或者（直接，間接或虛擬）子類的實例，則返回true 。如果對象不是給定類型的對象，則該函數總是返回false。如果classinfo是類型對象（或遞歸地，其他此類元組）的元組，則如果對象是任何類型的實例，則返回true 。如果classinfo不是類型或元組的類型和元組，TypeError則會引發異常。

issubclass（class，classinfo ）
如果class是classinfo的子類（直接，間接或虛擬），則返回true 。一個類被認為是一個子類。classinfo可以是類對象的元組，在這種情況下，將會檢查classinfo中的每個條目。在任何其他情況下，都會出現異常。TypeError

iter（object [，sentinel ] ）
返回一個迭代器對象。根據第二個參數的存在，第一個參數被非常不同的解釋。沒有第二個參數，對象必須是支持迭代協議（該__iter__()方法）的集合對象，或者必須支持序列協議（__getitem__()以整數參數開頭的方法0）。如果它不支持這些協議之一， TypeError則被提出。如果給定了第二個參數sentinel，那么對象必須是可調用的對象。在這種情況下創建的迭代器將調用對象，每個對其__next__()方法的調用都不帶參數 ; 如果返回的值等於 sentinel，StopIteration 將被提升，否則將返回值。

另請參見迭代器類型。

第二種形式的一個有用的應用iter()是讀取文件的行，直到達到一定的行。以下示例讀取文件，直到該readline()方法返回一個空字符串：

與 開放（'mydata.txt' ） 作為 FP ：
    用於 線 在 ITER （FP 。readline的， '' ）：
        process_line （線）
len（s ）
返回一個對象的長度（項目數）。參數可以是序列（如字符串，字節，元組，列表或范圍）或集合（如字典，集合或凍結集合）。

類list（[ iterable ] ）
而不是一個函數，list實際上是一個可變序列類型，如列表和序列類型 - 列表，元組，范圍中所述。

locals（）
更新並返回表示當前本地符號表的字典。locals()當函數塊調用時，返回自由變量，而不在類塊中。

注意 本字典的內容不得修改; 更改可能不會影響解釋器使用的本地和自由變量的值。
map（函數，迭代，... ）
返回一個迭代器，它將函數應用於可迭代的每個項目，從而產生結果。如果傳遞額外的可迭代參數， 函數必須使用許多參數，並且並行地應用於所有迭代的項目。使用多個迭代，當最短的迭代耗盡時，迭代器停止。對於功能輸入已經排列成參數元組的情況，請參見itertools.starmap()。

max（iterable，* [，key，default ] ）
max（arg1，arg2，* args [，key ] ）
返回一個可迭代或最大的兩個或多個參數中的最大項。

如果提供了一個位置參數，它應該是一個可迭代的。返回iterable中最大的項目。如果提供了兩個或多個位置參數，則返回最大的位置參數。

有兩個可選的關鍵字參數。該關鍵參數指定一個參數的排序功能，類似於用於list.sort()。該 默認參數指定的對象返回如果提供的迭代是空的。如果iterable為空，並且未提供默認值， ValueError則會引發a。

如果多個項目是最大的，該函數將返回遇到的第一個。這與其他分類穩定性保留工具（例如和）一致 。sorted(iterable, key=keyfunc, reverse=True)[0]heapq.nlargest(1, iterable, key=keyfunc)

在新版本3.4：在默認情況下只有關鍵字的說法。

memoryview（obj ）
返回從給定的參數創建的“內存視圖”對象。有關詳細信息，請參閱 內存視圖

min（iterable，* [，key，default ] ）
min（arg1，arg2，* args [，key ] ）
以可迭代或最小的兩個或多個參數返回最小的項。

如果提供了一個位置參數，它應該是一個可迭代的。返回iterable中最小的項。如果提供了兩個或多個位置參數，則返回最小的位置參數。

有兩個可選的關鍵字參數。該關鍵參數指定一個參數的排序功能，類似於用於list.sort()。該 默認參數指定的對象返回如果提供的迭代是空的。如果iterable為空，並且未提供默認值， ValueError則會引發a。

如果多個項目最小，該函數將返回遇到的第一個。這與其他分類穩定性保留工具（例如和）一致。sorted(iterable, key=keyfunc)[0]heapq.nsmallest(1, iterable, key=keyfunc)

在新版本3.4：在默認情況下只有關鍵字的說法。

next（iterator [，default ] ）
通過調用其 方法從迭代器獲取下一個項目__next__()。如果給定了默認值，則如果迭代器耗盡，則返回，否則將StopIteration被引發。

類object
返回一個新的無特征對象。 object是所有班級的基地。它具有Python類的所有實例通用的方法。此函數不接受任何參數。

注意 object沒有不有__dict__，所以你不能指定任意屬性的實例object類。
oct（x ）
將整數轉換為前綴為“0o”的八進制字符串。結果是一個有效的Python表達式。如果x不是Python int對象，則必須定義一個__index__()返回整數的方法。例如：

>>>
>>> oct （8 ）
'0o10' 
>>> oct （- 56 ）
'-0o70'
如果要使用前綴“0o”將整數轉換為八進制字符串，則可以使用以下任一方式。

>>>
>>> ' ％＃o '  ％ 10 ， ' ％o '  ％ 10 
（'0o12'，'12'）
>>> format （10 ， '#o​​' ）， format （10 ， 'o' ）
（'0o12 '，
'12 '）>>> f ' {10：#o} ' ， f ' {10：o} ' 
（'0o12'，'12'）
另請參閱format()更多信息。

open（文件，模式= 'R' ，緩沖= -1，編碼=無，誤差=無，換行符=無，closefd =真，開啟器=無）
打開文件並返回相應的文件對象。如果文件無法打開，則會生成一個文件OSError。

file是一個路徑樣的對象，給出要打開的文件的路徑名（絕對或相對於當前工作目錄）或要包裝的文件的整數文件描述符。（如果給出了一個文件描述符，則當返回的I / O對象關閉時關閉它，除非將closefd 設置為False。）

mode是一個可選字符串，指定文件打開的方式。它默認為'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本身完成的，因此是與平台無關的。
buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. When no buffering argument is given, the default buffering policy works as follows:

Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device’s “block size” and falling back on io.DEFAULT_BUFFER_SIZE. On many systems, the buffer will typically be 4096 or 8192 bytes long.
“Interactive” text files (files for which isatty() returns True) use line buffering. Other text files use the policy described above for binary files.
encoding是用於對文件進行解碼或編碼的編碼名稱。這只能在文本模式下使用。默認編碼是平台依賴（無論locale.getpreferredencoding()返回），但是可以使用Python支持的任何 文本編碼。有關codecs支持的編碼列表，請參閱模塊。

錯誤是一個可選的字符串，指定如何處理編碼和解碼錯誤 - 這不能在二進制模式下使用。可以使用各種標准錯誤處理程序（列在錯誤處理程序下），盡管已注冊的任何錯誤處理名稱 codecs.register_error()也是有效的。標准名稱包括：

'strict'ValueError如果存在編碼錯誤，則引發異常。默認值None具有相同的效果。
'ignore'忽略錯誤。請注意，忽略編碼錯誤可能導致數據丟失。
'replace'導致替換標記（例如'?'）插入有畸形數據的地方。
'surrogateescape'將代表任何不正確的字節作為Unicode私有使用區域中的代碼點，范圍從U + DC80到U + DCFF。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（默認），否則會引發錯誤。

通過傳遞一個可打開的開啟者，可以使用自定義的開啟者。然后通過使用（file，flags）調用opener獲取文件對象的底層文件描述符。開啟者必須返回一個打開的文件描述符（ 作為opener結果傳遞的功能類似於傳遞 ）。os.openNone

新創建的文件是不可繼承的。

以下示例使用函數的dir_fd參數 os.open()來打開相對於給定目錄的文件：

>>>
>>> import  os 
>>> dir_fd  =  os 。開放（'somedir' ， OS 。O_RDONLY ）
>>> 高清 開瓶器（路徑， 旗）：
...     返回 操作系統。開（路徑， 標志， dir_fd = dir_fd ）
... 
>>> 與 開放（'spamspam.txt' ， 'W' ， 首戰= 開瓶器） 作為 f ：
...     print （'這將被寫入somedir / spamspam.txt' ， file = f ）
... 
>>> os 。close （dir_fd ）  ＃不要泄漏文件描述符
函數返回的文件對象的類型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中更改：
該文件現在不可繼承。
自從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 ] ）
Return x to the power y; if z is present, return x to the power y, modulo z (computed more efficiently than pow(x, y) % z). The two-argument form pow(x, y) is equivalent to using the power operator: x**y.

The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, 10**2 returns 100, but 10**-2 returns 0.01. If the second argument is negative, the third argument must be omitted. If z is present, x and y must be of integer types, and y must be non-negative.

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
Print objects to the text stream file, separated by sep and followed by end. sep, end, file and flush, if present, must be given as keyword arguments.

所有非關鍵字參數都將轉換為字符串str()，並將其寫入流，以sep分隔，后跟結尾。無論九月 和年底必須是字符串; 它們也可以None，這意味着使用默認值。如果沒有給出對象，print()只會寫入 結束。

的文件參數必須是與對象write(string)方法; 如果它不存在或None，sys.stdout將被使用。由於打印的參數被轉換為文本字符串，print()不能與二進制模式文件對象一起使用。對於這些，請file.write(...)改用。

輸出緩沖是否通常由文件確定，但如果 flush關鍵字參數為true，則強制刷新該流。

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

class property（fget = None，fset = None，fdel = None，doc = None ）
返回屬性屬性。

fget是獲取屬性值的函數。 fset是設置屬性值的函數。fdel是刪除屬性值的函數。而doc會為該屬性創建一個docstring。

典型的用法是定義托管屬性x：

 C 類：
    def  __init__ （self ）：
        self 。_x  =  無

    def  getx （self ）：
        return  self 。_X

    def  setx （self ， value ）：
        self 。_x  =  值

    def  delx （self ）：
        del  self 。_X

    x  =  property （getx ， setx ， delx ， “我是'x'屬性。” ）
如果c是C的一個實例，c.x將調用getter， 將調用setter和deleter。c.x = valuedel c.x

如果給定，doc將是屬性屬性的docstring。否則，該屬性將復制fget的docstring（如果存在）。這使得可以輕松地創建只讀屬性property()作為裝飾器：

類 鸚鵡：
    高清 __init__ （個體經營）：
        自我。_voltage  =  100000

    @property 
    def  voltage （self ）：
        “”“獲得當前電壓。”“” 
        返回 自我。_電壓
該@property裝飾變成的voltage()方法變成“吸”為只讀具有相同名稱的屬性，並將其設置的文檔字符串的 電壓為“獲取當前的電壓。”

屬性對象具有getter，setter和deleter可用作裝飾器的方法，用於創建屬性的副本，並將相應的訪問器函數設置為裝飾函數。這最好用一個例子來解釋：

 C 類：
    def  __init__ （self ）：
        self 。_x  =  無

    @property 
    def  x （self ）：
        “”“我是'x'屬性。”“” 
        return  self 。_X

    @x 。setter 
    def  x （self ， value ）：
        self 。_x  =  值

    @x 。刪除器
    高清 X （自）：
        德爾 自我。_X
這段代碼完全等同於第一個例子。請確保附加的功能與原始屬性相同（x在這種情況下）。

返回的屬性對象也有屬性fget，fset以及 fdel相對應的構造函數的參數。

版本3.5更改：屬性對象的文本字符串現在可寫。

range（停）
range（開始，停止[，步驟] ）
實際上不是一個函數，而是range一個不可變的序列類型，如范圍和序列類型 - 列表，元組，范圍中所述。

repr（對象）
返回一個包含對象的可打印表示的字符串。對於許多類型，此函數嘗試返回一個字符串，該字符串在傳遞時將產生具有相同值的對象eval()，否則表示形式是包含在尖括號中的字符串，其中包含對象類型的名稱以及附加信息通常包括對象的名稱和地址。一個類可以通過定義一個__repr__()方法來控制這個函數返回的實例。

reversed（seq ）
返回一個反向迭代器。 seq必須是一個具有__reversed__()方法或支持序列協議的對象（以整數參數開頭的 __len__()方法和__getitem__()方法0）。

round（number [，ndigits ] ）
在小數點后，返回數字四舍五入到ndigits精度。如果省略了ndigits，或者None返回最接近整數的輸入。

對於支持的內置類型round()，值將四舍五入到功率減去ndigits的10的最接近的倍數; 如果兩個倍數同樣接近，舍入朝向甚至選擇完成（因此，例如，這兩個round(0.5)和round(-0.5)是0，和round(1.5)是 2）。任何整數值對於ndigits（正，零或負）有效。返回值是一個整數，如果使用一個參數調用，否則與number類型相同。

對於一般的Python對象number，委托 。round(number, ndigits)number.__round__(ndigits)

注意 的行為round()為花車可奇怪的：例如， 給出而不是預期。這不是一個錯誤：這是一個事實，大多數小數部分不能完全像浮點表示的結果。有關詳細信息，請參閱浮點算術：問題和限制。round(2.675, 2)2.672.68
類set（[ iterable ] ）
返回一個新set對象，可選擇從iterable取得的元素 。 set是一個內置的類。查看set和 設置類型 - 設置，frozenset以獲取有關此類的文檔。

對於其他容器看到內置的frozenset，list， tuple，和dict類，還有collections 模塊。

setattr（對象，名稱，值）
這是對應的getattr()。參數是一個對象，一個字符串和一個任意值。字符串可以命名現有屬性或新屬性。該函數將賦值給該屬性，前提是該對象允許該屬性。例如，相當於 。setattr(x, 'foobar', 123)x.foobar = 123

班slice（停）
類slice（開始，停止[，步驟] ）
返回表示由其指定的索引集的切片對象 。在啟動和步參數默認為 。切片對象具有只讀數據屬性， 而這僅僅是返回參數值（或它們的默認值）。他們沒有其他明確的功能; 然而它們被數字Python和其他第三方擴展所使用。當使用擴展索引語法時，也會生成切片對象。例如：或。查看 返回迭代器的替代版本。range(start, stop, step)Nonestartstopstepa[start:stop:step]a[start:stop, i]itertools.islice()

sorted（iterable，*，key = None，reverse = False ）
從iterable中的項中返回一個新的排序列表。

有兩個可選參數必須指定為關鍵字參數。

key指定用於從每個列表元素中提取比較鍵的一個參數的函數：key=str.lower。默認值為None （直接比較元素）。

reverse是一個布爾值。如果設置為True，那么列表元素將被排序，就好像每個比較被顛倒一樣。

用functools.cmp_to_key()一個老式的轉換CMP功能的 關鍵功能。

內置sorted()功能保證穩定。如果它保證不改變比較相等的元素的相對順序，那么它是穩定的 - 這有助於在多個遍中排序（例如，按部門排序，然后按薪水等級排序）。

有關排序示例和簡要排序教程，請參閱排序如何。

staticmethod（功能）
返回靜態方法的函數。

靜態方法不會收到隱式的第一個參數。要聲明靜態方法，請使用此成語：

類 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' ）
返回一個對象的str版本。看詳情。str()

str是內置的字符串類。有關字符串的一般信息，請參閱文本序列類型 - str。

sum（iterable [，start ] ）
資金開始和的項目迭代由左到右，並返回總。 開始默認為0。該迭代的項目通常是數字，起始值不允許是一個字符串。

對於一些用例，有很好的選擇sum()。連接字符串序列的首選方式是快速調用 ''.join(sequence)。要添加具有擴展精度的浮點值，請參見math.fsum()。要連接一系列迭代，請考慮使用 itertools.chain()。

super（[ type [，object-or-type ] ] ）
返回一個代理對象，將代理對象調用類型的父類或同級類。這對於訪問在類中被覆蓋的繼承方法很有用。搜索順序與使用的順序相同， getattr()但跳過類型本身。

在__mro__該屬性類型列出了兩種使用方法分辨率搜索順序getattr()和super()。屬性是動態的，每當更新繼承層次結構時，它都可以更改。

如果省略第二個參數，則返回的超級對象是未綁定的。如果第二個參數是一個對象，則必須為true。如果第二個參數是一個類型，則必須為true（這對於classmethods很有用）。isinstance(obj, type)issubclass(type2, type)

超級用戶有兩個典型用例。在具有單一繼承的類層次結構中，超級可以用於引用父類，而不必明確命名它們，從而使代碼更易於維護。這種使用與其他編程語言中的super的使用密切相關。

第二個用例是在動態執行環境中支持協作多重繼承。這種用例對於Python是獨一無二的，在靜態編譯語言或僅支持單一繼承的語言中找不到。這使得可以實現多個基類實現相同方法的“菱形圖”。良好的設計規定，這種方法在每種情況下具有相同的呼叫簽名（因為在運行時確定了調用順序，因為該順序適應類層次結構中的更改，並且因為該順序可以包括在運行時之前未知的兄弟類）。

對於這兩種用例，典型的超類調用如下所示：

class  C （B ）：
    def  method （self ， arg ）：
        super （）。方法（arg ）    ＃這樣做同樣的事情：
                               ＃super（C，self）.method（arg）
注意，super()作為明確的虛擬屬性查找的綁定過程的一部分實現，例如super().__getitem__(name)。它通過實現自己的__getattribute__()方法來以可預測的順序搜索類，從而支持協作多重繼承。因此，super()對於使用諸如此類的語句或運算符的隱式查找是未定義的super()[name]。

另請注意，除零參數形式外，super()不限於使用內部方法。兩個參數形式精確地指定參數，並進行適當的引用。零參數形式僅適用於類定義，因為編譯器填寫必要的詳細信息以正確檢索正在定義的類，以及訪問普通方法的當前實例。

關於如何設計合作課程的實際建議 super()，請參閱使用super（）的指南。

tuple（[ 可迭代] ）
而不是一個功能，tuple實際上是不可變的序列的類型，如記錄元組和序列類型-列表，元組，范圍。

類type（對象）
類type（名稱，基地，字典）
使用一個參數，返回一個對象的類型。返回值是一個類型對象，通常與返回的對象相同 object.__class__。

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

有三個參數，返回一個新的類型對象。這本質上是class聲明的動態形式。該名字符串類名，並成為__name__屬性; 所述鹼 元組逐條列出的基類和成為__bases__ 屬性; 而dict字典是包含類體定義的命名空間，並被復制到標准字典以成為 __dict__屬性。例如，以下兩個語句創建相同的type對象：

>>>
>>> class  X ：
...     a  =  1 
... 
>>> X  =  type （'X' ， （object ，）， dict （a = 1 ））
另請參見鍵入對象。

在版本3.6中更改：type不覆蓋的子類type.__new__可能不再使用單參數形式來獲取對象的類型。

vars（[ object ] ）
返回__dict__模塊，類，實例或具有__dict__屬性的任何其他對象的屬性。

模塊和實例等對象具有可更新__dict__ 屬性; 然而，其他對象可能對其__dict__屬性具有寫入限制 （例如，類使用a types.MappingProxyType來防止直接字典更新）。

沒有爭論，vars()就像locals()。請注意，本地字典僅對讀取有用，因為對本地字典的更新將被忽略。

zip（* iterables ）
做一個迭代器來聚合每個迭代的元素。

返回元組的迭代器，其中第i個元組包含來自每個參數序列或迭代的第i個元素。當最短輸入iterable耗盡時，迭代器停止。使用單個可迭代參數，它返回1元組的迭代器。沒有參數，它返回一個空的迭代器。相當於：

def  zip （* iterables ）：
    ＃zip（'ABCD'，'xy'） - > Ax by 
    sentinel  =  object （）
    iterators  =  [ iter （it ） for  it  in  iterables ] 
    while  iterators ：
        result  =  [] 
        for  it  in  迭代器：
            elem  =  next （it ， sentinel ）
            如果 elem  是 sentinel ：
                return 
            result 。附加（elem ）
        yield  tuple （result ）
確保迭代的從左到右的評估順序。這使得使用數字系列成為n個長度組的成語成為可能zip(*[iter(s)]*n)。這將重復相同的迭代器n次數，以便每個輸出元組具有n對迭代器的調用結果。這具有將輸入划分成n長度塊的效果。

zip()只有當您不關心較長的迭代中的尾隨，不匹配的值時，才應使用不等長的輸入。如果這些值很重要，請itertools.zip_longest()改用。

zip()結合*操作員可以用來解壓縮列表：

>>>
>>> X  =  [ 1 ， 2 ， 3 ] 
>>> Ŷ  =  [ 4 ， 5 ， 6 ] 
>>> 壓縮 =  拉鏈（X ， ÿ ）
>>> 列表（壓縮）
[（1，4），（ 2，5），（3，6）] 
>>> x2 ， y2  =  zip （* zip （x ， y ））
>>> x  ==  list （x2 ） 和 y  ==  list （y2 ）
True
__import__（name，globals = None，locals = None，fromlist =（），level = 0 ）
注意 這是一個在日常Python編程中不需要的高級功能importlib.import_module()。
該函數由import語句調用。它可以被替換（通過導入builtins模塊和分配給 builtins.__import__）來改變import語句的語義 ，但這樣做是非常不鼓勵的，因為通常使用導入鈎子更簡單（參見PEP 302）以達到相同的目標，並且不會導致使用默認導入實現的代碼問題。直接使用__import__()也不鼓勵importlib.import_module()。

該函數導入模塊名稱，潛在地使用給定的全局變量 和本地人來確定如何解釋包上下文中的名稱。在fromlist里給出了應該從給出的模塊導入的對象或子的名字命名。標准實現根本不使用其locals參數，並且僅使用其全局變量來確定import語句的包上下文。

level指定是使用絕對還是相對導入。0（默認值）表示僅執行絕對導入。級別的正值 表示要相對於模塊調用的目錄搜索的父目錄的數量__import__()（見PEP 328詳細信息）。

當名稱變量為形式時package.module，通常會返回頂級包（名稱直到第一個點），而不是名稱的模塊。但是，如果給出非空的fromlist參數，則返回名為name的模塊。

例如，該語句的字節碼類似於以下代碼：import spam

垃圾郵件 =  __import__ （'垃圾郵件' ， 全局（）， 當地人（）， []， 0 ）
該聲明導致此電話：import spam.ham

垃圾郵件 =  __import__ （'spam.ham' ， 全局（）， 當地人（）， []， 0 ）
注意__import__()在這里返回toplevel模塊，因為這是由import語句綁定到一個名稱的對象。

另一方面，聲明導致from spam.ham import eggs, sausage as saus

_temp  =  __import__ （'spam.ham' ， 全局（）， 當地人（）， [ '雞蛋' ， '香腸' ]， 0 ）
雞蛋 =  _temp 。雞蛋
saus  =  _temp 。香腸
在這里，spam.ham返回模塊__import__()。從該對象中，要導入的名稱被檢索並分配給它們各自的名稱。

如果您只想按名稱導入一個模塊（可能在一個包中），請使用importlib.import_module()。

版本3.3中更改：不再支持級別的負值（也將默認值更改為0）。

腳注

 ======================================================================

內置函數必會的幾個點

============================================================================

常用方法

#bytes 字節，bytes('xxx',encoding='utf-8')
#bytearray 字節數組
#print(chr(80)) #數字轉化成對應的字母或者是asllc馬    P
#print(ord('b'))  將ascall轉化成數字
#print(callable(123))#False 判斷是否可執行
#####################
#code='''def hellocut():return "name%S%D"'''
#print(compile(code,'<string>','exec'))#<code object <module> at 0x02B04338, file "<string>", line 1>將一個字符串編譯成可以執行的代碼

#li=[]
#print(dir(li))列出里面所有的功能
#print(divmod(10,3))#(3, 1) 獲得除數+余數
#print(eval('1+3'))#將字符串轉化成表達式  4
#print(eval('a+33',{'a':22}))#55  ,h后面可加表達式
#print(exec('for i in range(10):print(i)'))#執行py代碼

#循環可以迭代的對象，獲取每一個參數，函數（參數）
#ret=filter(lambda x:x>22,[11,22,33,55] ) #過濾，符合的獲取，不符合過濾
#print(exec('for i in ret:print(i)'))

#=====================

#map(函數，刻碟對的對象)
#ret=map(lambda x:x+100 if x%2==1 else x,[11,22,33,44]) #111,22,133,44
#for i in ret:
 #   print(i)
#===哈希=======================
'''dic={
    'sadfhashfiuoqyhwuiyqiruw':'213123'
}
print(hash('sadfhashfiuoqyhwud'))#326347203  將長數據轉化成一個哈希值 I便於查找，相當於key的優化
'''
#isinstance([11,22,33],list) 判斷某個對象市某是一個類創建的
#r=iter([11,22,33,44])創建一個可迭代的對象，取值取第一個，
#max min 取最大最小值
#oct 八進制
#print(pow(2,10))取米的次方
#ascii()，repr() 一樣
#print(round(3,23)) 四舍五入
#reversed()反轉
#==========================
'''li=[11,22,33,44]
li1=['23','as','vs']
r=zip(li,li1)
for i in r:    (11, '23')
    print(i)   (22, 'as')  (33, 'vs')
'''

#__import__   導入


'''delattr()  反射
getattr()
hasattr()
setattr()'''

 

常用小添 

abs絕對值
print(abs(123))
print(abs(-123))
all循環參數，如果每個元素為真，那么all的返回值為真
0  NONE 空值 都是假的
i=all([None,'',[],{},()])
print(i) #False
======
any 只有一個為真都為真
i=all([None,'',[],{},(),1])
print(i)#Trun
ascii(object)

 

random 隨機數，生成隨機驗證碼全字母

import random

temp=''
for x in range(4):
    i = random.randrange(65, 91)  # >=65,<=91
    c = chr(i)
    temp+=c
print(temp)

random生成驗證碼 數字加字母

import random

temp=''
for x in range(4):
    i = random.randrange(0,4)  #生成隨機驗證碼
    if i==3 or i==1:
        rad=random.randrange(0,10)
        temp=temp+str(rad)
    else:
        red=random.randrange(65,91)
        c1=chr(red)
        temp=temp+c1
print(temp)
===========================================

import random

temp=''
for x in range(4):
    i = random.randrange(0,4)  #生成隨機驗證碼
    if i==3 or i==1:#如果隨機數1或3，那么就再驗證碼中生成一個0-9的隨機數字，否則生成一個隨機字母
        rad=random.randrange(0,10)
        temp=temp+str(rad)
    else:
        red=random.randrange(65,91)
        c1=chr(red)
        temp=temp+c1
print(temp)