python3從零學習-4.2.2、內置函數

Python 解釋器內置了很多函數和類型，您可以在任何時候使用它們。以下按字母表順序列出它們。

abs(x)

返回一個數的絕對值。實參可以是整數或浮點數。如果實參是一個複數，返回它的模。

all(iterable)

如果 iterable 的所有元素為真（或迭代器為空），返回 True 。

等價於:

<code>def all(iterable):     
    for element in iterable:         
        if not element:             
          return False     
    return True/<code>

any(iterable)

如果 iterable 的任一元素為真則返回 True。 如果迭代器為空，返回 False。

等價於:

<code>def any(iterable):     
\t\tfor element in iterable:         
    \t\tif element:             
          \treturn True     
\t\treturn False/<code>

ascii(object)

就像函數 repr()，返回一個對象可打印的字符串，但是 repr() 返回的字符串中非 ASCII 編碼的字符，會使用 \\\\x、\\\\u 和 \\U 來轉義。生成的字符串和 Python 2 的 repr() 返回的結果相似。

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:b}'

('0b1110', '1110')

另見 format() 獲取更多信息。

class bool([x])返回一個布爾值，True 或者 False。 x 使用標準的 真值測試過程 來轉換。如果 x 是假的或者被省略，返回 False；其他情況返回 True。bool 類是 int 的子類（參見 數字類型 — int, float, complex）。其他類不能繼承自它。它只有 False 和 True 兩個實例（參見 布爾值）。

class bytearray([source[, encoding[, errors]]])返回一個新的 bytes 數組。 bytearray 類是一個可變序列，包含範圍為 0 <= x < 256 的整數。它有可變序列大部分常見的方法，見 可變序列類型 的描述；同時有 bytes 類型的大部分方法，參見 bytes 和 bytearray 操作。可選形參 source 可以用不同的方式來初始化數組：

• 如果是一個 string，您必須提供 encoding 參數（errors 參數仍是可選的）；bytearray() 會使用 str.encode() 方法來將 string 轉變成 bytes。
• 如果是一個 integer，會初始化大小為該數字的數組，並使用 null 字節填充。
• 如果是一個符合 buffer 接口的對象，該對象的只讀 buffer 會用來初始化字節數組。
• 如果是一個 iterable 可迭代對象，它的元素的範圍必須是 0 <= x < 256 的整數，它會被用作數組的初始內容。

如果沒有實參，則創建大小為 0 的數組。

另見 二進制序列類型 — bytes, bytearray, memoryview 和 bytearray 對象。

class bytes([source[, encoding[, errors]]])返回一個新的“bytes”對象， 是一個不可變序列，包含範圍為 0 <= x < 256 的整數。bytes 是 bytearray 的不可變版本 - 它有其中不改變序列的方法和相同的索引、切片操作。因此，構造函數的實參和 bytearray() 相同。字節對象還可以用字面值創建，參見 字符串和字節串字面值。另見 二進制序列類型 — bytes, bytearray, memoryview，bytes 對象 和 bytes 和 bytearray 操作。

callable(object)

Return True if the object argument appears callable, False if not. If this returns true, it is still possible that a call fails, but if it is false, calling object will never succeed. Note that classes are callable (calling a class returns a new instance); instances are callable if their class has a __call__() method.3.2 新版功能: 這個函數一開始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。

chr(i)

返回 Unicode 碼位為整數 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。這是 ord() 的逆函數。實參的合法範圍是 0 到 1,114,111（16 進製表示是 0x10FFFF）。如果 i 超過這個範圍，會觸發 ValueError 異常。

@classmethod

把一個方法封裝成類方法。一個類方法把類自己作為第一個實參，就像一個實例方法把實例自己作為第一個實參。請用以下習慣來聲明類方法:

<code>class C:     
  @classmethod     
\tdef f(cls, arg1, arg2, ...): 
        .../<code>

The @classmethod form is a function decorator – see the description of function definitions in 函數定義 for details.

It can be called either on the class (such as C.f()) or on an instance (such as C().f()). The instance is ignored except for its class. If a class method is called for a derived class, the derived class object is passed as the implied first argument.

Class methods are different than C++ or Java static methods. If you want those, see staticmethod() in this section.

For more information on class methods, consult the documentation on the standard type hierarchy in 標準類型層級結構.

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 控制在編譯 source 時要用到哪個 future 語句。 如果兩者都未提供（或都為零）則會使用調用 compile() 的代碼中有效的 future 語句來編譯代碼。 如果給出了 flags 參數但沒有 dont_inherit (或是為零) 則 flags 參數所指定的 以及那些無論如何都有效的 future 語句會被使用。 如果 dont_inherit 為一個非零整數，則只使用 flags 參數 – 在調用外圍有效的 future 語句將被忽略。Future 語句使用比特位來指定，多個語句可以通過按位或來指定。具體特性的比特位可以通過 __future__ 模塊中的 _Feature 類的實例的 compiler_flag 屬性來獲得。optimize 實參指定編譯器的優化級別；默認值 -1 選擇與解釋器的 -O 選項相同的優化級別。顯式級別為 0 （沒有優化；__debug__ 為真）、1 （斷言被刪除， __debug__ 為假）或 2 （文檔字符串也被刪除）。如果編譯的源碼不合法，此函數會觸發 SyntaxError 異常；如果源碼包含 null 字節，則會觸發 ValueError 異常。如果您想分析 Python 代碼的 AST 表示，請參閱 ast.parse()。

class complex([real[, imag]])

返回值為 real + imag*1j 的複數，或將字符串或數字轉換為複數。如果第一個形參是字符串，則它被解釋為一個複數，並且函數調用時必須沒有第二個形參。第二個形參不能是字符串。每個實參都可以是任意的數值類型（包括複數）。如果省略了 imag，則默認值為零，構造函數會像 int 和 float 一樣進行數值轉換。如果兩個實參都省略，則返回 0j。註解當從字符串轉換時，字符串在 + 或 - 的周圍必須不能有空格。例如 complex('1+2j') 是合法的，但 complex('1 + 2j') 會觸發 ValueError 異常。數字類型 — int, float, complex 描述了複數類型。在 3.6 版更改: 您可以使用下劃線將代碼文字中的數字進行分組。

delattr(object, name)

setattr() 相關的函數。實參是一個對象和一個字符串。該字符串必須是對象的某個屬性。如果對象允許，該函數將刪除指定的屬性。例如 delattr(x, 'foobar') 等價於 del x.foobar 。

class dict(**kwarg)class dict(mapping, **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() # 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']

>>>

... def __dir__(self):

... return ['area', 'perimeter', 'location']

>>> s = Shape()

>>> dir(s)

['area', 'location', 'perimeter']

註解

因為 dir() 主要是為了便於在交互式時使用，所以它會試圖返回人們感興趣的名字集合，而不是試圖保證結果的嚴格性或一致性，它具體的行為也可能在不同版本之間改變。例如，當實參是一個類時，metaclass 的屬性不包含在結果列表中。

divmod(a, b)它將兩個（非複數）數字作為實參，並在執行整數除法時返回一對商和餘數。對於混合操作數類型，適用雙目算術運算符的規則。對於整數，結果和 (a // b, a % b) 一致。對於浮點數，結果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能會比 1 小。在任何情況下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符號和 b 一樣，並且 0 <= abs(a % b) < abs(b) 。

enumerate(iterable, start=0)返回一個枚舉對象。iterable 必須是一個序列，或 iterator，或其他支持迭代的對象。 enumerate() 返回的迭代器的 __next__() 方法返回一個元組，裡面包含一個計數值（從 start 開始，默認為 0）和通過迭代 iterable 獲得的值。>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter'] >>> list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]>>> list(enumerate(seasons, start=1)) [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

等價於:

def enumerate(sequence, start=0):

n = start

for elem in sequence:

yield n, elem

n += 1

eval(expression, globals=None, locals=None)

實參是一個字符串，以及可選的 globals 和 locals。globals 實參必須是一個字典。locals 可以是任何映射對象。expression 參數會作為一個 Python 表達式（從技術上說是一個條件列表）被解析並求值，使用 globals 和 locals 字典作為全局和局部命名空間。 如果 globals 字典存在且不包含以 __builtins__ 為鍵的值，則會在解析 expression 之前插入以此為鍵的對內置模塊 builtins 的字典的引用。 這意味著 expression 通常具有對標準 builtins 模塊的完全訪問權限且受限的環境會被傳播。 如果省略 locals 字典則其默認值為 globals 字典。 如果兩個字典同時省略，表達式會在 eval() 被調用的環境中執行。 返回值為表達式求值的結果。 語法錯誤將作為異常被報告。 例如:

這個函數也可以用來執行任何代碼對象（如 compile() 創建的）。這種情況下，參數是代碼對象，而不是字符串。如果編譯該對象時的 mode 實參是 'exec' 那麼 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 參數，它們分別被用作全局和本地變量。如果提供了 locals 參數，則它可以是任何映射型的對象。請記住在模塊層級，全局和本地變量是相同的字典。如果 exec 有兩個不同的 globals 和 locals 對象，代碼就像嵌入在類定義中一樣執行。如果 globals 字典不包含 __builtins__ 鍵值，則將為該鍵插入對內建 builtins 模塊字典的引用。因此，在將執行的代碼傳遞給 exec() 之前，可以通過將自己的 __builtins__ 字典插入到 globals 中來控制可以使用哪些內置代碼。

filter(function, iterable)

用 iterable 中函數 function 返回真的那些元素，構建一個新的迭代器。iterable 可以是一個序列，一個支持迭代的容器，或一個迭代器。如果 function 是 None ，則會假設它是一個身份函數，即 iterable 中所有返回假的元素會被移除。請注意， filter(function, iterable) 相當於一個生成器表達式，當 function 不是 None 的時候為 (item for item in iterable if function(item))；function 是 None 的時候為 (item for item in iterable if item) 。請參閱 itertools.filterfalse() 瞭解，只有 function 返回 false 時才選取 iterable 中元素的補充函數。

class float([x])

返回從數字或字符串 x 生成的浮點數。如果實參是字符串，則它必須是包含十進制數字的字符串，字符串前面可以有符號，之前也可以有空格。可選的符號有 '+' 和 '-' ； '+' 對創建的值沒有影響。實參也可以是 NaN（非數字）、正負無窮大的字符串。確切地說，除去首尾的空格後，輸入必須遵循以下語法：

這裡， floatnumber 是 Python 浮點數的字符串形式，詳見 浮點數字面值。字母大小寫都可以，例如，“inf”、“Inf”、“INFINITY”、“iNfINity” 都可以表示正無窮大。

另一方面，如果實參是整數或浮點數，則返回具有相同值（在 Python 浮點精度範圍內）的浮點數。如果實參在 Python 浮點精度範圍外，則會觸發 OverflowError。

對於一般的 Python 對象 x ， float(x) 指派給 x.__float__() 。

如果沒有實參，則返回 0.0 。

示例:

>>>

>>> float('+1.23')

1.23

>>> float(' -12345\\n')

-12345.0

>>> float('1e-003')

0.001

>>> float('+1E6')

1000000.0

>>> float('-Infinity')

-inf

數字類型 — int, float, complex 描述了浮點類型。

在 3.6 版更改: 您可以使用下劃線將代碼文字中的數字進行分組。

format(value[, format_spec])

將 value 轉換為 format_spec 控制的“格式化”表示。format_spec 的解釋取決於 value 實參的類型，但是大多數內置類型使用標準格式化語法：格式規格迷你語言。默認的 format_spec 是一個空字符串，它通常和調用 str(value) 的結果相同。調用 format(value, format_spec) 會轉換成 type(value).__format__(value, format_spec) ，所以實例字典中的 __format__() 方法將不會調用。如果搜索到 object 有這個方法但 format_spec 不為空，format_spec 或返回值不是字符串，會觸發 TypeError 異常。在 3.4 版更改: 當 format_spec 不是空字符串時， object().__format__(format_spec) 會觸發 TypeError。

class frozenset([iterable])

返回一個新的 frozenset 對象，它包含可選參數 iterable 中的元素。 frozenset 是一個內置的類。有關此類的文檔，請參閱 frozenset 和 集合類型 — set, frozenset。請參閱內建的 set、list、tuple 和 dict 類，以及 collections 模塊來了解其它的容器。

getattr(object, name[, default])

返回對象命名屬性的值。name 必須是字符串。如果該字符串是對象的屬性之一，則返回該屬性的值。例如， 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__() 方法。一些例子：>>> hex(255) '0xff'>>> hex(-42) '-0x2a'

如果要將整數轉換為大寫或小寫的十六進制字符串，並可選擇有無“0x”前綴，則可以使用如下方法：

>>> '%#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')

另見 format() 獲取更多信息。

另請參閱 int() 將十六進制字符串轉換為以 16 為基數的整數。

註解

如果要獲取浮點數的十六進制字符串形式，請使用 float.hex() 方法。

id(object)返回對象的“標識值”。該值是一個整數，在此對象的生命週期中保證是唯一且恆定的。兩個生命期不重疊的對象可能具有相同的 id() 值。CPython implementation detail: This is the address of the object in memory.

input([prompt])如果存在 prompt 實參，則將其寫入標準輸出，末尾不帶換行符。接下來，該函數從輸入中讀取一行，將其轉換為字符串（除了末尾的換行符）並返回。當讀取到 EOF 時，則觸發 EOFError。例如:>>>>>> s = input('--> ') --> Monty Python's Flying Circus>>> s "Monty Python's Flying Circus"

如果加載了 readline 模塊，input() 將使用它來提供複雜的行編輯和歷史記錄功能。

class int(x=0)

class int(x, base=10)返回一個使用數字或字符串 x 生成的整數對象，或者沒有實參的時候返回 0 。如果 x 定義了 __int__()，int(x) 返回 x.__int__() 。如果 x 定義了 __trunc__()，它返回 x.__trunc__() 。對於浮點數，它向零舍入。如果 x 不是數字，或者有 base 參數，x 必須是字符串、bytes、表示進製為 base 的 整數字面值 的 bytearray 實例。該文字前可以有 + 或 - （中間不能有空格），前後可以有空格。一個進製為 n 的數字包含 0 到 n-1 的數，其中 a 到 z （或 A 到 Z ）表示 10 到 35。默認的 base 為 10 ，允許的進制有 0、2-36。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 對象有 base.__index__ 方法，則會調用該方法來獲取進制數。以前的版本使用 base.__int__ 而不是 base.__index__。在 3.6 版更改: 您可以使用下劃線將代碼文字中的數字進行分組。

isinstance(object, classinfo)

Return true if the object argument is an instance of the classinfo argument, or of a (direct, indirect or virtual) subclass thereof. If object is not an object of the given type, the function always returns false. If classinfo is a tuple of type objects (or recursively, other such tuples), return true if object is an instance of any of the types. If classinfo is not a type or tuple of types and such tuples, a TypeError exception is raised.

iter(object[, sentinel])

返回一個 iterator 對象。根據是否存在第二個實參，第一個實參的解釋是非常不同的。如果沒有第二個實參，object 必須是支持迭代協議（有 __iter__() 方法）的集合對象，或必須支持序列協議（有 __getitem__() 方法，且數字參數從 0 開始）。如果它不支持這些協議，會觸發 TypeError。如果有第二個實參 sentinel，那麼 object 必須是可調用的對象。這種情況下生成的迭代器，每次迭代調用它的 __next__() 方法時都會不帶實參地調用 object；如果返回的結果是 sentinel 則觸發 StopIteration，否則返回調用結果。另請參閱 迭代器類型。One useful application of the second form of iter() is to read lines of a file until a certain line is reached. The following example reads a file until the readline() method returns an empty string:with open('mydata.txt') as fp: for line in iter(fp.readline, ''): process_line(line)

len(s)

返回對象的長度（元素個數）。實參可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

class list([iterable])

雖然被稱為函數，list 實際上是一種可變序列類型，詳情請參閱 列表 和 序列類型 — list, tuple, range。

locals()

Update and return a dictionary representing the current local symbol table. Free variables are returned by locals() when it is called in function blocks, but not in class blocks.註解不要更改此字典的內容；更改不會影響解釋器使用的局部變量或自由變量的值。

map(function, iterable, ...)

返回一個將 function 應用於 iterable 中每一項並輸出其結果的迭代器。 如果傳入了額外的 iterable 參數，function 必須接受相同個數的實參並被應用於從所有可迭代對象中並行獲取的項。 當有多個可迭代對象時，最短的可迭代對象耗盡則整個迭代就將結束。 對於函數的輸入已經是參數元組的情況，請參閱 itertools.starmap()。

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

max(arg1, arg2, *args[, key])返回可迭代對象中最大的元素，或者返回兩個及以上實參中最大的。如果只提供了一個位置參數，它必須是非空 iterable，返回可迭代對象中最大的元素；如果提供了兩個及以上的位置參數，則返回最大的位置參數。有兩個可選只能用關鍵字的實參。key 實參指定排序函數用的參數，如傳給 list.sort() 的。default 實參是當可迭代對象為空時返回的值。如果可迭代對象為空，並且沒有給 default ，則會觸發 ValueError。如果有多個最大元素，則此函數將返回第一個找到的。這和其他穩定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。3.4 新版功能: keyword-only 實參 default 。

memoryview(obj)

返回由給定實參創建的“內存視圖”對象。有關詳細信息，請參閱 內存視圖。

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

min(arg1, arg2, *args[, key])返回可迭代對象中最小的元素，或者返回兩個及以上實參中最小的。如果只提供了一個位置參數，它必須是 iterable，返回可迭代對象中最小的元素；如果提供了兩個及以上的位置參數，則返回最小的位置參數。有兩個可選只能用關鍵字的實參。key 實參指定排序函數用的參數，如傳給 list.sort() 的。default 實參是當可迭代對象為空時返回的值。如果可迭代對象為空，並且沒有給 default ，則會觸發 ValueError。如果有多個最小元素，則此函數將返回第一個找到的。這和其他穩定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。3.4 新版功能: keyword-only 實參 default 。

next(iterator[, default])

通過調用 iterator 的 __next__() 方法獲取下一個元素。如果迭代器耗盡，則返回給定的 default，如果沒有默認值則觸發 StopIteration。

class object

返回一個沒有特徵的新對象。object 是所有類的基類。它具有所有 Python 類實例的通用方法。這個函數不接受任何實參。

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(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

打開 file 並返回對應的 file object。如果該文件不能打開，則觸發 OSError。file 是一個 path-like object，表示將要打開的文件的路徑（絕對路徑或者當前工作目錄的相對路徑），也可以是要被封裝的整數類型文件描述符。（如果是文件描述符，它會隨著返回的 I/O 對象關閉而關閉，除非 closefd 被設為 False 。）mode 是一個可選字符串，用於指定打開文件的模式。默認值是 'r' ，這意味著它以文本模式打開並讀取。其他常見模式有：寫入 'w' （截斷已經存在的文件）；排它性創建 'x' ；追加寫 'a' （在 一些 Unix 系統上，無論當前的文件指針在什麼位置，所有 寫入都會追加到文件末尾）。在文本模式，如果 encoding 沒有指定，則根據平臺來決定使用的編碼：使用 locale.getpreferredencoding(False) 來獲取本地編碼。（要讀取和寫入原始字節，請使用二進制模式並不要指定 encoding。）可用的模式有： 字符含義 'r'讀取（默認） 'w'寫入，並先截斷文件 'x'排它性創建，如果文件已存在則失敗 'a'寫入，如果文件存在則在末尾追加 'b'二進制模式 't'文本模式（默認） '+'更新磁盤文件（讀取並寫入） 'U'universal newlines mode (deprecated) 默認的模式是 'r' （打開並讀取文本，同 'rt' ）。對於二進制寫入， 'w+b' 模式打開並把文件截斷成 0 字節； 'r+b' 則不會截斷。正如在 概述 中提到的，Python區分二進制和文本I/O。以二進制模式打開的文件（包括 mode 參數中的 'b' ）返回的內容為 bytes`對象，不進行任何解碼。在文本模式下（默認情況下，或者在 *mode* 參數中包含 `’t’` ）時，文件內容返回為 str ，首先使用指定的 encoding （如果給定）或者使用平臺默認的的字節編碼解碼。

• 二進制文件以固定大小的塊進行緩衝；使用啟發式方法選擇緩衝區的大小，嘗試確定底層設備的“塊大小”或使用 io.DEFAULT_BUFFER_SIZE。在許多系統上，緩衝區的長度通常為4096或8192字節。
• “交互式”文本文件（ isatty() 返回 True 的文件）使用行緩衝。其他文本文件使用上述策略用於二進制文件。

encoding 是用於解碼或編碼文件的編碼的名稱。這應該只在文本模式下使用。默認編碼是依賴於平臺的（不 管 locale.getpreferredencoding() 返回何值），但可以使用任何Python支持的 text encoding 。有關支持的編碼列表，請參閱 codecs 模塊。

errors 是一個可選的字符串參數，用於指定如何處理編碼和解碼錯誤 - 這不能在二進制模式下使用。可以使用各種標準錯誤處理程序（列在 錯誤處理方案 ），但是使用 codecs.register_error() 註冊的任何錯誤處理名稱也是有效的。標準名稱包括:

• 如果存在編碼錯誤，'strict' 會引發 ValueError 異常。 默認值 None 具有相同的效果。
• 'ignore' 忽略錯誤。請注意，忽略編碼錯誤可能會導致數據丟失。
• 'replace' 會將替換標記（例如 '?' ）插入有錯誤數據的地方。
• 'surrogateescape' 將表示任何不正確的字節作為Unicode專用區中的代碼點，範圍從U+DC80到U+DCFF。當在寫入數據時使用 surrogateescape 錯誤處理程序時，這些私有代碼點將被轉回到相同的字節中。這對於處理未知編碼的文件很有用。
• 只有在寫入文件時才支持 'xmlcharrefreplace'。編碼不支持的字符將替換為相應的XML字符引用 nnn;。
• 'backslashreplace' 用Python的反向轉義序列替換格式錯誤的數據。
• 'namereplace' （也只在編寫時支持）用 \\N{...} 轉義序列替換不支持的字符。

newline 控制 universal newlines 模式如何生效（它僅適用於文本模式）。它可以是 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 來使用自定義開啟器。然後通過使用參數（ file，flags ）調用 opener 獲得文件對象的基礎文件描述符。 opener 必須返回一個打開的文件描述符（使用 os.open as opener 時與傳遞 None 的效果相同）。

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

下面的示例使用 os.open() 函數的 dir_fd 的形參，從給定的目錄中用相對路徑打開文件:

>>>

>>> import os

>>>

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

另請參閱文件操作模塊，例如 fileinput、io （聲明瞭 open()）、os、os.path、tempfile 和 shutil。

在 3.3 版更改:

增加了 opener 形參。

增加了 'x' 模式。

過去觸發的 IOError，現在是 OSError 的別名。

如果文件已存在但使用了排它性創建模式（ 'x' ），現在會觸發 FileExistsError。

在 3.4 版更改:

文件現在禁止繼承。

Deprecated since version 3.4, will be removed in version 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 存在，則對 z 取餘（比直接 pow(x, y) % z 計算更高效）。兩個參數形式的 pow(x, y) 等價於冪運算符： x**y。參數必須為數值類型。 對於混用的操作數類型，則適用二元算術運算符的類型強制轉換規則。 對於 int 操作數，結果具有與操作數相同的類型（轉換後），除非第二個參數為負值；在這種情況下，所有參數將被轉換為浮點數並輸出浮點數結果。 例如，10**2 返回 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，這意味著使用默認值。 如果沒有給出 objects，則 print() 將只寫入 end。file 參數必須是一個具有 write(string) 方法的對象；如果參數不存在或為 None，則將使用 sys.stdout。 由於要打印的參數會被轉換為文本字符串，因此 print() 不能用於二進制模式的文件對象。 對於這些對象，應改用 file.write(...)。輸出是否被緩存通常決定於 file，但如果 flush 關鍵字參數為真值，流會被強制刷新。在 3.3 版更改: 增加了 flush 關鍵字參數。

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

返回 property 屬性。fget 是獲取屬性值的函數。 fset 是用於設置屬性值的函數。 fdel 是用於刪除屬性值的函數。並且 doc 為屬性對象創建文檔字符串。一個典型的用法是定義一個託管屬性 x:class C:

<code>def __init__(self):         
\tself._x = None

def getx(self):
\treturn self._x

def setx(self, value):
\tself._x = value

def delx(self):
\tdel self._x
\tx = property(getx, setx, delx, "I'm the 'x' property.")/<code>

如果 c 是 C 的實例，c.x 將調用getter，c.x = value 將調用setter， del c.x 將調用deleter。

如果給出，doc 將成為該 property 屬性的文檔字符串。 否則該 property 將拷貝 fget 的文檔字符串（如果存在）。 這令使用 property() 作為 decorator 來創建只讀的特徵屬性可以很容易地實現:

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

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage/<code>

以上 @property 裝飾器會將 voltage() 方法轉化為一個具有相同名稱的只讀屬性的 “getter”，並將 voltage 的文檔字符串設置為 “Get the current voltage.”

特徵屬性對象具有 getter, setter 以及 deleter 方法，它們可用作裝飾器來創建該特徵屬性的副本，並將相應的訪問函數設為所裝飾的函數。 這最好是用一個例子來解釋:

<code>class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x/<code>

上述代碼與第一個例子完全等價。 注意一定要給附加函數與原始的特徵屬性相同的名稱 (在本例中為 x。)

返回的特徵屬性對象同樣具有與構造器參數相對應的屬性 fget, fset 和 fdel。

在 3.5 版更改: 特徵屬性對象的文檔字符串現在是可寫的。

range(stop)

range(start, stop[, step])雖然被稱為函數，但 range 實際上是一個不可變的序列類型，參見在 range 對象 與 序列類型 — list, tuple, range 中的文檔說明。

repr(object)

返回包含一個對象的可打印表示形式的字符串。 對於許多類型來說，該函數會嘗試返回的字符串將會與該對象被傳遞給 eval() 時所生成的對象具有相同的值，在其他情況下表示形式會是一個括在尖括號中的字符串，其中包含對象類型的名稱與通常包括對象名稱和地址的附加信息。 類可以通過定義 __repr__() 方法來控制此函數為它的實例所返回的內容。

reversed(seq)

返回一個反向的 iterator。 seq 必須是一個具有 __reversed__() 方法的對象或者是支持該序列協議（具有從 0 開始的整數類型參數的 __len__() 方法和 __getitem__() 方法）。

round(number[, ndigits])

返回 number 舍入到小數點後 ndigits 位精度的值。 如果 ndigits 被省略或為 None，則返回最接近輸入值的整數。對於支持 round() 的內置類型，值會被舍入到最接近的 10 的負 ndigits 次冪的倍數；如果與兩個倍數的距離相等，則選擇偶數 (因此，round(0.5) 和 round(-0.5) 均為 0 而 round(1.5) 為 2)。 任何整數值都可作為有效的 ndigits (正數、零或負數)。 如果 ndigits 被省略或為 None 則返回值將為整數。 否則返回值與 number 的類型相同。對於一般的 Python 對象 number, round 將委託給 number.__round__。

註解

對浮點數執行 round() 的行為可能會令人驚訝：例如，round(2.675, 2) 將給出 2.67 而不是期望的 2.68。 這不算是程序錯誤：這一結果是由於大多數十進制小數實際上都不能以浮點數精確地表示。 請參閱 浮點算術：爭議和限制 瞭解更多信息。

class set([iterable])

返回一個新的 set 對象，可以選擇帶有從 iterable 獲取的元素。 set 是一個內置類型。 請查看 set 和 集合類型 — 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])返回一個表示由 range(start, stop, step) 所指定索引集的 slice 對象。 其中 start 和 step 參數默認為 None。 切片對象具有僅會返回對應參數值（或其默認值）的只讀數據屬性 start, stop 和 step。 它們沒有其他的顯式功能；不過它們會被 NumPy 以及其他第三方擴展所使用。 切片對象也會在使用擴展索引語法時被生成。 例如: a[start:stop:step] 或 a[start:stop, i]。 請參閱 itertools.islice() 瞭解返回迭代器的一種替代版本。

sorted(iterable, *, key=None, reverse=False)

根據 iterable 中的項返回一個新的已排序列表。具有兩個可選參數，它們都必須指定為關鍵字參數。key 指定帶有單個參數的函數，用於從 iterable 的每個元素中提取用於比較的鍵 (例如 key=str.lower)。 默認值為 None (直接比較元素)。reverse 為一個布爾值。 如果設為 True，則每個列表元素將按反向順序比較進行排序。使用 functools.cmp_to_key() 可將老式的 cmp 函數轉換為 key 函數。內置的 sorted() 確保是穩定的。 如果一個排序確保不會改變比較結果相等的元素的相對順序就稱其為穩定的 — 這有利於進行多重排序（例如先按部門、再按薪級排序）。有關排序示例和簡要排序教程，請參閱 排序指南 。

@staticmethod將方法轉換為靜態方法。靜態方法不會接收隱式的第一個參數。要聲明一個靜態方法，請使用此語法class C: @staticmethod def f(arg1, arg2, ...): ...

The @staticmethod form is a function decorator – see the description of function definitions in 函數定義 for details.

It can be called either on the class (such as C.f()) or on an instance (such as C().f()). The instance is ignored except for its class.

Python中的靜態方法與Java或C ++中的靜態方法類似。另請參閱 classmethod() ，用於創建備用類構造函數的變體。

像所有裝飾器一樣，也可以像常規函數一樣調用 staticmethod ，並對其結果執行某些操作。比如某些情況下需要從類主體引用函數並且您希望避免自動轉換為實例方法。對於這些情況，請使用此語法:

class C:

builtin_open = staticmethod(open)

For more information on static methods, consult the documentation on the standard type hierarchy in 標準類型層級結構.

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')返回一個 str 版本的 object 。有關詳細信息，請參閱 str() 。str 是內置字符串 class 。更多關於字符串的信息查看 文本序列類型 — str。

sum(iterable[, start])

從 start 開始自左向右對 iterable 中的項求和並返回總計值。 start 默認為 0。 iterable 的項通常為數字，開始值則不允許為字符串。對某些用例來說，存在 sum() 的更好替代。 拼接字符串序列的更好更快方式是調用 ''.join(sequence)。 要以擴展精度對浮點值求和，請參閱 math.fsum()。 要拼接一系列可迭代對象，請考慮使用 itertools.chain()。

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

返回一個代理對象，它會將方法調用委託給 type 指定的父類或兄弟類。 這對於訪問已在類中被重載的繼承方法很有用。 搜索順序與 getattr() 所使用的相同，只是 type 指定的類型本身會被跳過。type 的 __mro__ 屬性列出了 getattr() 和 super() 所使用的方法解析順序。 該屬性是動態的，可以在繼承層級結構更新的時候任意改變。如果省略第二個參數，則返回的超類對象是未綁定的。 如果第二個參數為一個對象，則 isinstance(obj, type) 必須為真值。 如果第二個參數為一個類型，則 issubclass(type2, type) 必須為真值（這適用於類方法）。super 有兩個典型用例。 在具有單繼承的類層級結構中，super 可用來引用父類而不必顯式地指定它們的名稱，從而令代碼更易維護。 這種用法與其他編程語言中 super 的用法非常相似。第二個用例是在動態執行環境中支持協作多重繼承。 此用例為 Python 所獨有，在靜態編譯語言或僅支持單繼承的語言中是不存在的。 這使得實現“菱形圖”成為可能，在這時會有多個基類實現相同的方法。 好的設計強制要求這種方法在每個情況下具有相同的調用簽名（因為調用順序是在運行時確定的，也因為該順序要適應類層級結構的更改，還因為該順序可能包含在運行時之前未知的兄弟類）。對於以上兩個用例，典型的超類調用看起來是這樣的:

<code>class C(B):     
\tdef method(self, arg):         
  \t\tsuper().method(arg)    
# This does the same thing as:                                
# super(C, self).method(arg)/<code>

請注意 super() 是作為顯式加點屬性查找的綁定過程的一部分來實現的，例如 super().__getitem__(name)。 它做到這一點是通過實現自己的 __getattribute__() 方法，這樣就能以可預測的順序搜索類，並且支持協作多重繼承。 對應地，super() 在像 super()[name] 這樣使用語句或操作符進行隱式查找時則未被定義。

還要注意的是，除了零個參數的形式以外，super() 並不限於在方法內部使用。 兩個參數的形式明確指定參數並進行相應的引用。 零個參數的形式僅適用於類定義內部，因為編譯器需要填入必要的細節以正確地檢索到被定義的類，還需要讓普通方法訪問當前實例。

對於有關如何使用 super() 來如何設計協作類的實用建議，請參閱 使用 super() 的指南。

tuple([iterable])

雖然被稱為函數，但 tuple 實際上是一個不可變的序列類型，參見在 元組 與 序列類型 — list, tuple, range 中的文檔說明。

class type(object)

class type(name, bases, dict)傳入一個參數時，返回 object 的類型。 返回值是一個 type 對象，通常與 object.__class__ 所返回的對象相同。推薦使用 isinstance() 內置函數來檢測對象的類型，因為它會考慮子類的情況。傳入三個參數時，返回一個新的 type 對象。 這在本質上是 class 語句的一種動態形式。 name 字符串即類名並且會成為 __name__ 屬性；bases 元組列出基類並且會成為 __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__ 屬性可能會設為限制寫入（例如，類會使用 types.MappingProxyType 來防止直接更新字典）。不帶參數時，vars() 的行為類似 locals()。 請注意，locals 字典僅對於讀取起作用，因為對 locals 字典的更新會被忽略。

zip(*iterables)創建一個聚合了來自每個可迭代對象中的元素的迭代器。返回一個元組的迭代器，其中的第 i 個元組包含來自每個參數序列或可迭代對象的第 i 個元素。 當所輸入可迭代對象中最短的一個被耗盡時，迭代器將停止迭代。 當只有一個可迭代對象參數時，它將返回一個單元組的迭代器。 不帶參數時，它將返回一個空迭代器。 相當於:

<code>def zip(*iterables):     
# zip('ABCD', 'xy') --> Ax By     
\t\tsentinel = object()     
\t\titerators = [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)/<code>

函數會保證可迭代對象按從左至右的順序被求值。 使得可以通過 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 編程中不需要用到的高級函數。

This function is invoked by the import statement. It can be replaced (by importing the builtins module and assigning to builtins.__import__) in order to change semantics of the import statement, but doing so is

strongly

discouraged as it is usually simpler to use import hooks (see PEP 302) to attain the same goals and does not cause issues with code which assumes the default import implementation is in use. Direct use of __import__() is also discouraged in favor of importlib.import_module().該函數會導入 name 模塊，有可能使用給定的 globals 和 locals 來確定如何在包的上下文中解讀名稱。 fromlist 給出了應該從由 name 指定的模塊導入對象或子模塊的名稱。 標準實現完全不使用其 locals 參數，而僅使用 globals 參數來確定 import 語句的包上下文。level 指定是使用絕對還是相對導入。 0 (默認值) 意味著僅執行絕對導入。 level 為正數值表示相對於模塊調用 __import__() 的目錄，將要搜索的父目錄層數 (詳情參見 PEP 328)。當 name 變量的形式為 package.module 時，通常將會返回最高層級的包（第一個點號之前的名稱），而 不是 以 name 命名的模塊。 但是，當給出了非空的 fromlist 參數時，則將返回以 name 命名的模塊。例如，語句 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.eggs

saus = _temp.sausage

在這裡， spam.ham 模塊會由 __import__() 返回。 要導入的對象將從此對象中提取並賦值給它們對應的名稱。

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

在 3.3 版更改: Negative values for level are no longer supported (which also changes the default value to 0).

備註

解析器只接受 Unix 風格的行結束符。如果您從文件中讀取代碼，請確保用換行符轉換模式轉換 Windows 或 Mac 風格的換行符。

閱讀更多 山海皆可平z 的文章

關鍵字: Python 函數 內置