Built-in Functions

Python 解释器内置了许多始终可用的Function和类型。它们按字母 Sequences 在此处列出。

• abs(* x *)

  • 返回数字的绝对值。参数可以是整数或浮点数。如果参数为复数，则返回其大小。如果* x *定义abs()，则abs(x)返回x.__abs__()。

• all(* iterable *)

  • 如果* iterable *的所有元素都为 true(或者 iterable 为空)，则返回True。相当于：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

• any(* iterable *)
  • 如果* iterable *的任何元素为 true，则返回True。如果 iterable 为空，则返回False。相当于：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

• ascii(* object *)

  • 作为repr()，返回包含对象的可打印表示形式的字符串，但是使用\x，\u或\U转义来转义repr()返回的字符串中的非 ASCII 字符。这将生成类似于 python 3 中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()。

• 类别 bool([* x *])
  • 返回布尔值，即True或False之一。 * x 使用标准Truth 测试程序转换。如果 x *为 false 或Ellipsis，则返回False；否则返回True。 bool类是int的子类(请参见数值类型-整数，浮点数，复数)。它不能进一步细分。它仅有的实例是False和True(请参阅Boolean Values)。

在 3.7 版中进行了更改：* x *现在是仅位置参数。

• breakpoint( *args ， * kws *)
  • 此Function使您进入呼叫站点的调试器。具体来说，它调用sys.breakpointhook()，直接传递args和kws。默认情况下，sys.breakpointhook()调用pdb.set_trace()且不包含任何参数。在这种情况下，它纯粹是一种便利Function，因此您不必显式导入pdb或键入尽可能多的代码即可进入调试器。但是，可以将sys.breakpointhook()设置为其他Function，并且breakpoint()将自动调用该Function，使您可以进入所选的调试器。

用参数breakpointhook引发auditing event builtins.breakpoint。

3.7 版中的新Function。

• • class * bytearray([源 [，编码 [，错误]]])
  • 返回一个新的字节数组。 bytearray类是一个可变的整数序列，范围为 0 <= x <256.它具有可变序列类型中描述的大多数可变序列的常用方法，以及bytes类型具有的大多数方法，请参见字节和字节数组操作。

可选的* source *参数可用于以几种不同的方式初始化数组：

• 如果它是* string ，则还必须提供 encoding (和可选的 errors *)参数； bytearray()然后使用str.encode()将字符串转换为字节。

• 如果它是* integer *，则数组将具有该大小，并将使用空字节进行初始化。

• 如果它是符合* buffer *接口的对象，则该对象的只读缓冲区将用于初始化 bytes 数组。

• 如果它是* iterable *，则它必须是0 <= x < 256范围内的整数的可迭代数，这些整数用作数组的初始内容。

没有参数，将创建大小为 0 的数组。

另请参见二进制序列类型-字节，字节数组，memoryview和Bytearray Objects。

• • class * bytes([源 [，编码 [，错误]]])
  • 返回一个新的“字节”对象，该对象是0 <= x < 256范围内的整数序列。 bytes是bytearray的不可变版本–它具有相同的非可变方法以及相同的索引和切片行为。

因此，构造函数参数将被解释为bytearray()。

字节对象也可以使用 Literals 创建，请参见字符串和字节 Literals。

另请参见二进制序列类型-字节，字节数组，memoryview，Bytes Objects和字节和字节数组操作。

• callable(* object *)
  • 如果* object 参数可调用，则返回True，否则返回False。如果返回True，则调用仍然有可能失败，但是如果是False，则调用 object *将永远不会成功。注意，类是可调用的(调用一个类将返回一个新实例)。如果实例的类具有call()方法，则这些实例是可调用的。

3.2 版中的新Function：此Function首先在 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
  • 将方法转换为类方法。

类方法将类作为隐式第一个参数接收，就像实例方法接收实例一样。要语句类方法，请使用以下惯用法：

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

@classmethod表单是函数decorator –有关详细信息，请参见Function definitions。

可以在类(例如C.f())或实例(例如C().f())上调用类方法。该实例除其类外均被忽略。如果为派生类调用类方法，则派生类对象作为隐式第一个参数传递。

类方法不同于 C 或 Java 静态方法。如果需要这些，请参见staticmethod()。

有关类方法的更多信息，请参见标准类型层次结构。

• compile((* source ， filename ， mode ， flags = 0 ， dont_inherit = False ， optimize = -1 *)
  • 将* source *编译为代码或 AST 对象。可以由exec()或eval()执行代码对象。 * source *可以是普通字符串，字节字符串或 AST 对象。有关如何使用 AST 对象的信息，请参阅ast模块文档。

• filename *参数应提供从中读取代码的文件；如果未从文件中读取该值，则传递一些可识别的值(通常使用'<string>')。

• mode 参数指定必须编译的代码类型；如果 source *由一系列语句组成，则可以为'exec'；如果由单个表达式组成，则为'eval'；如果由单个交互式语句组成，则为'single'(在后一种情况下，表达式的计算结果不是None则为打印)。

可选参数* flags 和 dont_inherit 控制哪个future statements影响 source 的编译。如果都不存在(或两个都不为零)，则使用调用compile()的代码中有效的将来语句来编译代码。如果给定了 flags 参数，而* dont_inherit 不为(或为零)，则除了将始终使用的那些语句外，还将使用 flags 参数指定的 Future 语句。如果* dont_inherit 是非零整数，则使用 flags *参数–忽略围绕编译调用有效的将来语句。

将来的语句由位指定，这些位可以按位或以指定多个语句。可以在future模块中_Feature实例上的compiler_flag属性中找到指定给定Function所需的位域。

可选参数* flags *还控制是否允许已编译的源包含顶级await，async for和async with。设置位ast.PyCF_ALLOW_TOP_LEVEL_AWAIT时，返回代码对象在co_code中设置了CO_COROUTINE，并且可以passawait eval(code_object)交互执行。

• optimize *参数指定编译器的优化级别；默认值-1选择-O选项给定的解释器的优化级别。显式级别为0(无优化； __debug__为 true)，1(语句已删除，__debug__为 false)或2(也删除了文档字符串)。

如果编译的源无效，则此函数引发SyntaxError，如果源包含空字节，则引发ValueError。

如果要将 Python 代码解析为 AST 表示形式，请参见ast.parse()。

用参数source和filename引发auditing event compile。也可以pass隐式编译引发此事件。

在版本 3.2 中更改：允许使用 Windows 和 Mac 换行符。同样，以'exec'模式 Importing 的内容不必再以换行符结尾。添加了* optimize *参数。

在版本 3.5 中进行了更改：以前，在* source *中遇到空字节时，引发了TypeError。

3.8 版中的新Function：ast.PyCF_ALLOW_TOP_LEVEL_AWAIT现在可以传入标志，以支持顶级await，async for和async with。

• • class * complex([* real * [，* imag *]])
  • 返回值为* real * * imag * * 1j 的复数，或将字符串或数字转换为复数。如果第一个参数是字符串，它将被解释为复数，并且必须在没有第二个参数的情况下调用该函数。第二个参数不能是字符串。每个参数可以是任何数字类型(包括复数)。如果Ellipsis* imag *，则默认为零，并且构造函数用作int和float之类的数字转换。如果两个参数都Ellipsis，则返回0j。

对于一般的 Python 对象x，complex(x)委托给x.__complex__()。如果未定义__complex__()，则回退到float()。如果未定义__float__()，那么它会退回到index()。

复杂类型在数值类型-整数，浮点数，复数中描述。

在版本 3.6 中更改：允许将带下划线的数字分组，如代码 Literals 中所示。

在 3.8 版中进行了更改：如果未定义complex()和float()，则回退到index()。

• delattr(* object ， name *)
  • 这是setattr()的亲戚。参数是一个对象和一个字符串。该字符串必须是对象属性之一的名称。如果对象允许，该函数将删除命名属性。例如，delattr(x, 'foobar')等效于del x.foobar。

• • class * dict(*** kwarg *)
• • class * dict(* mapping ，** kwarg *)
• • class * dict(* iterable ，** kwarg *)
  • 创建一个新的字典。 dict对象是字典类。有关此类的文档，请参见dict和Map 类型— dict。

对于其他容器，请参见内置的list，set和tuple类以及collections模块。

• dir([* object *])
  • 不带参数的情况下，返回当前本地范围内的名称列表。使用一个参数try返回该对象的有效属性列表。

如果对象具有名为dir()的方法，则将调用此方法，并且该方法必须返回属性列表。这允许实现自定义getattr()或getattribute()函数的对象自定义dir()报告其属性的方式。

如果对象不提供dir()，则该函数将尽最大努力从该对象的dict属性(如果已定义)及其类型对象中收集信息。结果列表不一定是完整的，并且当对象具有自定义getattr()时可能会不准确。

默认的dir()机制在不同类型的对象上的行为有所不同，因为它试图产生最相关的信息，而不是完整的信息：

• 如果对象是模块对象，则列表包含模块属性的名称。

• 如果对象是类型或类对象，则列表包含其属性的名称以及递归其基础属性的名称。

• 否则，列表将包含对象的属性名称，其类的属性名称以及递归其类的 Base Class 的属性。

结果列表按字母 Sequences 排序。例如：

>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

• divmod(* a ， b *)

  • 使用两个(非复数)数字作为参数，并在使用整数除法时返回Pair包含其商和余数的数字。对于混合操作数类型，适用于二进制算术运算符的规则。对于整数，结果与(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()方法返回一个 Tuples，该 Tuples 包含一个计数(从 start 开始，默认为 0)和pass对 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')]

Equivalent to:

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

• eval(* expression * [，* globals * [，* locals *]])
  • 参数是一个字符串以及可选的全局变量和局部变量。如果提供，* globals 必须是字典。如果提供， locals *可以是任何 Map 对象。

• expression 参数使用 globals 和 locals 字典作为全局和局部名称空间，被解析并评估为 Python 表达式(从技术上来说是条件列表)。如果存在 globals 字典并且不包含键__builtins__的值，则在解析 expression 之前，将在该键下插入对内置模块builtins的字典的引用。这意味着 expression 通常具有对标准builtins模块的完全访问权限，并且会传播受限的环境。如果Ellipsis locals 字典，则默认为 globals 字典。如果Ellipsis两个字典，则在调用eval()的环境中使用 globals 和 locals 执行表达式。注意， eval()*在封闭环境中无权访问nested scopes(nonlocal 语言)。

返回值是求值表达式的结果。语法错误被报告为异常。例：

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

此函数还可以用于执行任意代码对象(例如compile()创建的对象)。在这种情况下，传递代码对象而不是字符串。如果代码对象已使用'exec'作为* mode *参数进行编译，则eval()的返回值为None。

提示：exec()函数支持动态执行语句。 globals()和locals()函数分别返回当前的全局字典和局部字典，这对于传递给eval()或exec()可能有用。

有关可以安全地使用仅包含 Literals 的表达式求值的字符串的函数，请参见ast.literal_eval()。

使用代码对象作为参数引发auditing event exec。代码编译事件也可能引发。

• exec((* object * [，* globals * [，* locals *]])
  • 该Function支持动态执行 Python 代码。 * object *必须是字符串或代码对象。如果是字符串，则将字符串解析为一组 Python 语句，然后执行该语句(除非发生语法错误)。 [1]如果是代码对象，则只需执行即可。在所有情况下，执行的代码都可以作为文件 Importing 有效(请参见《参考手册》中的“文件 Importing”部分)。请注意，即使在传递给exec()函数的代码的上下文内，也不能在函数定义之外使用return和yield语句。返回值为None。

在所有情况下，如果Ellipsis了可选部分，则代码将在当前范围内执行。如果仅提供* globals ，则它必须是字典(而不是字典的子类)，该字典将用于全局变量和局部变量。如果给出了 globals 和 locals ，它们分别用于全局变量和局部变量。如果提供， locals 可以是任何 Map 对象。请记住，在模块级别，全局变量和局部变量是相同的字典。如果 exec 获得了两个单独的对象 globals 和 locals *，则代码将像嵌入在类定义中一样执行。

如果* globals 词典不包含键__builtins__的值，则在该键下插入对内置模块builtins的词典的引用。这样，您可以pass将自己的__builtins__字典插入 globals *，然后再将其传递给exec()，从而控制执行的代码可以使用哪些内置函数。

使用代码对象作为参数引发auditing event exec。代码编译事件也可能引发。

• filter((* function ， iterable *)
  • 从Function返回 true 的* iterable *元素构造一个迭代器。 * iterable 可以是序列，支持迭代的容器或迭代器。如果 function 为None，则假定身份函数，即，删除 iterable *的所有错误元素。

请注意，如果函数不是None，则filter(function, iterable)等效于生成器表达式(item for item in iterable if function(item))，如果函数不是None，则等效于(item for item in iterable if item)。

有关返回* iterable 元素(其中 function *返回 false)的互补函数，请参见itertools.filterfalse()。

• 类别 float([* x *])
  • 返回由数字或字符串* x *构造的浮点数。

如果参数是字符串，则应包含一个十进制数字，可以选择在其后加上一个符号，并可以选择将其嵌入空白中。可选符号可以是'+'或'-'； '+'符号对产生的值没有影响。参数也可以是表示 NaN(非数字)或正无穷大的字符串。更准确地说，删除前导和尾随空白字符后，Importing 必须符合以下语法：

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

这里floatnumber是浮点 Literals中描述的 Python 浮点 Literals 形式。大小写无关紧要，因此，例如，“ inf”，“ Inf”，“ INFINITY”和“ iNfINity”都是可以表示正无穷大的拼写。

否则，如果参数是整数或浮点数，则返回具有相同值(在 Python 的浮点精度内)的浮点数。如果参数超出 Python 浮点数的范围，则将引发OverflowError。

对于一般的 Python 对象x，float(x)委托给x.__float__()。如果未定义__float__()，则回退到index()。

如果没有给出参数，则返回0.0。

Examples:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

浮点类型在数值类型-整数，浮点数，复数中描述。

在版本 3.6 中更改：允许将带下划线的数字分组，如代码 Literals 中所示。

在 3.7 版中进行了更改：* x *现在是仅位置参数。

在 3.8 版中进行了更改：如果未定义float()，则回退到index()。

• format(* value * [，* format_spec *])
  • 根据* format_spec 的控制，将 value *转换为“格式化”的表示形式。 * 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。

• 类别 frozenset([可迭代])

  • 返回一个新的frozenset对象，可以选择包含来自* iterable *的元素。 frozenset是内置类。有关此类的文档，请参见frozenset和集合类型-集合，frozenset。

对于其他容器，请参见内置的set，list，tuple和dict类以及collections模块。

• getattr(* object ， name * [，* default *])

  • 返回* object *的命名属性的值。 * name 必须为字符串。如果字符串是对象属性之一的名称，则结果是该属性的值。例如，getattr(x, 'foobar')等效于x.foobar。如果 named 属性不存在，则返回 default *(如果提供)，否则引发AttributeError。

• globals ( )

  • 返回表示当前全局符号表的字典。这始终是当前模块的字典(在函数或方法中，这是定义该模块的模块，而不是从中调用该模块的模块)。

• hasattr(* object ， name *)

  • 参数是一个对象和一个字符串。如果字符串是对象属性之一的名称，则结果为True，否则为False。 (这是pass调用getattr(object, name)并查看它是否引发AttributeError来实现的。)

• hash(* object *)

  • 返回对象的哈希值(如果有)。哈希值是整数。它们用于在字典查找期间快速比较字典关键字。比较相等的数值具有相同的哈希值(即使它们的类型不同，例如 1 和 1.0)。

• help([* object *])
  • 调用内置的帮助系统。 (此Function旨在用于交互式使用.)如果未提供任何参数，则交互式帮助系统将在解释器控制台上启动。如果参数是字符串，则将字符串作为模块，函数，类，方法，关键字或文档主题的名称进行查找，并在控制台上打印帮助页面。如果自变量是任何其他类型的对象，则会在该对象上生成帮助页面。

请注意，如果在函数的参数列表中出现斜杠(/)，则在调用help()时，表示斜杠之前的参数仅是位置参数。有关更多信息，请参见仅位置参数的 FAQ 条目。

site模块将此Function添加到内置名称空间中。

在版本 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')
>>> 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 为底的十六进制字符串转换为整数。

• id(* object *)
  • 返回对象的“身份”。这是一个整数，可以保证在此对象的生存期内唯一且恒定。具有不重叠生存期的两个对象可能具有相同的id()值。

CPython 实现细节： 这是对象在内存中的地址。

• input([提示])
  • 如果存在* prompt *参数，则将其写入标准输出而不会在末尾添加换行符。然后，该函数从 Importing 中读取一行，将其转换为字符串(带末尾的换行符)，然后将其返回。读取 EOF 时，将引发EOFError。例：

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

如果加载了readline模块，则input()将使用它来提供详细的行编辑和历史记录Function。

在读取 Importing 之前引发带有参数prompt的auditing event builtins.input

成功读取 Importing 后，将引发审核事件builtins.input/result及其结果。

• 类别 int([* x *])

• • class * int(* x ， base = 10 *)
  • 返回由数字或字符串* x 构造的整数对象，如果未提供任何参数，则返回0。如果 x 定义int()，则int(x)返回x.__int__()。如果 x 定义index()，则返回x.__index__()。如果 x *定义trunc()，则返回x.__trunc__()。对于浮点数，它会截断为零。

如果* x 不是数字或给定 base ，则 x 必须是字符串，bytes或bytearray实例，表示基数 base 中的integer literal。可选地，Literals 可以以+或-(中间没有空格)开头，并用空格包围。以 n 为底的原义 Literals 由数字 0 到 n-1 组成，其中a到z(或A到Z)的值是 10 到 35.默认值 base *是 10.允许的值是 0 和 2–36.与代码中的整数 Literals 一样，Base-2，-8 和-16Literals 可以选择以0b/0B，0o/0O或0x/0X作为前缀。基数 0 意味着将其完全解释为代码 Literals，因此实际基数为 2、8、10 或 16，因此int('010', 0)是不合法的，而int('010')和int('010', 8)都是合法的。

整数类型在数值类型-整数，浮点数，复数中描述。

在版本 3.4 中进行了更改：如果* base 不是int的实例，并且 base *对象具有base.index方法，则将调用该方法以获取基数的整数。以前的版本使用base.int而不是base.index。

在版本 3.6 中更改：允许将带下划线的数字分组，如代码 Literals 中所示。

在 3.7 版中进行了更改：* x *现在是仅位置参数。

在 3.8 版中进行了更改：如果未定义int()，则回退到index()。

• isinstance(* object ， classinfo *)

  • 如果* object 参数是 classinfo 参数或其(直接，间接或virtual)子类的实例，则返回True。如果 object 不是给定类型的对象，则该函数始终返回False。如果 classinfo 是类型对象的 Tuples(或递归，其他类似的 Tuples)，则如果 object 是任何类型的实例，则返回True。如果 classinfo *不是类型或类型 Tuples 以及此类 Tuples，则会引发TypeError异常。

• issubclass(* class ， classinfo *)

  • 如果* class 是 classinfo *的子类(直接，间接或virtual)，则返回True。类被认为是其自身的子类。 * classinfo 可能是一个类对象的 Tuples，在这种情况下，将检查 classinfo *中的每个条目。在任何其他情况下，都会引发TypeError异常。

• iter(* object * [，* sentinel *])

  • 返回一个iterator对象。根据第二个参数的存在，第一个参数的解释非常不同。如果没有第二个参数，则* object 必须是支持迭代协议(iter()方法)的集合对象，或者它必须支持序列协议(以0开头的整数参数的getitem()方法)。如果它不支持这些协议中的任何一个，则引发TypeError。如果给定第二个参数 sentinel ，则 object 必须是可调用的对象。在这种情况下创建的迭代器将在每次调用next()方法时不带参数的 object ；如果返回的值等于 sentinel *，则将引发StopIteration，否则将返回该值。

另请参见Iterator Types。

第二种形式iter()的一个有用应用是构建一个块读取器。例如，从二进制数据库文件读取固定宽度的块，直到到达文件末尾：

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

• len(* s *)
  • 返回对象的长度(项目数)。参数可以是序列(例如字符串，字节，Tuples，列表或范围)或集合(例如字典，集合或冻结集合)。

• 类别 list([可迭代])

  • list不是函数，实际上是可变的序列类型，如Lists和序列类型-列表，Tuples，范围所述。

• locals ( )

  • 更新并返回代表当前本地符号表的字典。当在Function块中调用locals()时，locals()返回自由变量，但在类块中则不。请注意，在模块级别，locals()和globals()是同一词典。

• map((Function*，可迭代，* ... *)

  • 返回一个对* iterable 的每一项应用 function 的迭代器，产生结果。如果传递了额外的 iterable 参数，则 function *必须接受那么多参数，并并行应用于所有可迭代对象的项。对于多个可迭代对象，当最短可迭代对象耗尽时，迭代器将停止。对于函数 Importing 已经安排在参数 Tuples 中的情况，请参见itertools.starmap()。

• max((* iterable ，** [，* key ， default *])

• max(* arg1 ， arg2 ，* args * [，* key *])

  • 返回可迭代的最大项或两个或多个参数中的最大项。

如果提供了一个位置参数，则应为iterable。返回迭代器中最大的项目。如果提供了两个或多个位置参数，则返回最大的位置参数。

有两个可选的仅关键字参数。 * key *参数指定一个单参数排序函数，例如用于list.sort()的函数。 * default 参数指定如果提供的 iterable 为空，则返回一个对象。如果 iterable 为空且未提供 default *，则引发ValueError。

如果有多个最大项，则该函数返回遇到的第一个项。这与诸如sorted(iterable, key=keyfunc, reverse=True)[0]和heapq.nlargest(1, iterable, key=keyfunc)之类的其他排序稳定性保持工具一致。

3.4 版中的新Function：* default *仅关键字参数。

在版本 3.8 中更改：键可以为None。

• 类别 memoryview(* obj *)

  • 返回从给定参数创建的“memoryview”对象。有关更多信息，请参见Memory Views。

• min((* iterable ，** [，* key ， default *])

• min(* arg1 ， arg2 ，* args * [，* key *])

  • 返回可迭代的最小项或两个或多个参数中的最小项。

如果提供了一个位置参数，则应为iterable。返回 iterable 中的最小项。如果提供了两个或多个位置参数，则返回最小的位置参数。

有两个可选的仅关键字参数。 * key *参数指定一个单参数排序函数，例如用于list.sort()的函数。 * default 参数指定如果提供的 iterable 为空，则返回一个对象。如果 iterable 为空且未提供 default *，则引发ValueError。

如果最少有多个项目，则该函数返回遇到的第一个项目。这与诸如sorted(iterable, key=keyfunc)[0]和heapq.nsmallest(1, iterable, key=keyfunc)之类的其他排序稳定性保持工具一致。

3.4 版中的新Function：* default *仅关键字参数。

在版本 3.8 中更改：键可以为None。

• next(迭代器 [，默认])

  • pass调用next()方法从* iterator 中检索下一项。如果给定了 default *，则迭代器用尽了它，否则返回StopIteration。

• 类 object

  • 返回一个新的无 Feature 对象。 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，给出了要打开的文件的路径名(相对于当前工作目录的绝对路径或相对于当前工作目录的路径)或要包装的文件的整数文件 Descriptors。 (如果给出了文件 Descriptors，除非 closefd *设置为False，否则它在关闭返回的 I/O 对象时将关闭.)

• mode 是一个可选字符串，用于指定打开文件的模式。默认为'r'，表示可以在文本模式下阅读。其他常用值包括'w'用于写入(如果文件已经存在，则将其截断)，'x'用于排它创建和'a'用于附加(在某些* Unix 系统上，这意味着* all 将附加写入文件的末尾，而不考虑当前搜寻位置)。在文本模式下，如果未指定 encoding ，则使用的编码取决于平台：调用locale.getpreferredencoding(False)以获取当前的语言环境编码。 (要读取和写入原始字节，请使用二进制模式，而未指定 encoding *.)可用模式为：

默认模式是'r'(打开以读取文本，同义词'rt')。模式'w+'和'w+b'打开并截断文件。模式'r+'和'r+b'可以无截断地打开文件。

如Overview中所述，Python 区分二进制 I/O 和文本 I/O。以二进制模式打开的文件(包括* mode 参数中的'b')以bytes对象的形式返回内容，而没有进行任何解码。在文本模式下(默认模式，或者 mode 参数中包含't')，文件内容以str的形式返回，首先使用与平台有关的编码或指定的 encoding *解码字节。给定的。

允许使用附加模式字符'U'，该字符不再起作用，被认为已弃用。以前它以文本模式启用universal newlines，这已成为 Python 3.0 中的默认行为。有关更多详细信息，请参阅newline参数的文档。

• buffering 是用于设置缓冲策略的可选整数。传递 0 来关闭缓冲(仅在二进制模式下允许)，传递 1 来选择行缓冲(仅在文本模式下可用)，并传递大于 1 的整数来指示固定大小的块缓冲区的字节大小。如果不指定 buffering *参数，则默认的缓冲策略如下：

• 二进制文件以固定大小的块缓冲；缓冲区的大小是pass试探法来确定底层设备的“块大小”并回退到io.DEFAULT_BUFFER_SIZE来选择的。在许多系统上，缓冲区的长度通常为 4096 或 8192 字节。

• “交互式”文本文件(isatty()返回True的文件)使用行缓冲。其他文本文件将上述策略用于二进制文件。

• encoding *是用于解码或编码文件的编码名称。仅应在文本模式下使用。默认编码取决于平台(无论locale.getpreferredencoding()返回什么)，但是可以使用 Python 支持的任何text encoding。有关支持的编码列表，请参见codecs模块。

• errors *是一个可选字符串，用于指定如何处理编码和解码错误-不能在二进制模式下使用。可以使用多种标准错误处理程序(在Error Handlers之下列出)，尽管已向codecs.register_error()注册的任何错误处理名称也有效。标准名称包括：

• 如果存在编码错误，则'strict'引发ValueError异常。 None的默认值具有相同的效果。

• 'ignore'忽略错误。请注意，忽略编码错误会导致数据丢失。

• 'replace'使替换标记(例如'?')插入数据格式不正确的地方。

• 'surrogateescape'将代表任何不正确的字节，作为 Unicode 专用区域中的代码点，范围从 U DC80 到 U DCFF。当在写入数据时使用surrogateescape错误处理程序时，这些专用代码点将被转换回相同的字节。这对于处理未知编码的文件很有用。

• 'xmlcharrefreplace'仅在写入文件时受支持。编码不支持的字符被替换为适当的 XML 字符参考&#nnn;。

• 'backslashreplace'用 Python 的反斜杠转义序列替换格式错误的数据。

• 'namereplace'(也仅在写入时受支持)用\N{...}转义序列替换了不受支持的字符。

换行符控制universal newlines模式的工作方式(仅适用于文本模式)。可以是None，''，'\n'，'\r'和'\r\n'。其工作方式如下：

• 从流中读取 Importing 时，如果* newline *为None，则启用通用换行模式。Importing 中的行可以以'\n'，'\r'或'\r\n'结尾，并且在返回给调用者之前将其转换为'\n'。如果为''，则启用通用换行模式，但是行结尾未翻译地返回给呼叫者。如果它具有任何其他合法值，则 Importing 行仅由给定的字符串终止，并且该行的末尾不翻译就返回给调用方。

• 将输出写入流时，如果* newline 为None，则写入的任何'\n'字符都将转换为系统默认的行分隔符os.linesep。如果 newline 是''或'\n'，则不会进行翻译。如果 newline *是其他任何合法值，则将写入的任何'\n'字符转换为给定的字符串。

如果* closefd 为False并且给出了文件 Descriptors 而不是文件名，则在关闭文件时，底层文件 Descriptors 将保持打开状态。如果给定文件名， closefd *必须为True(默认值)，否则将引发错误。

可以pass将 callable 传递为* opener 来使用自定义打开器。然后pass使用( file ， flags )调用 opener *获得文件对象的基础文件 Descriptors。 * opener 必须返回打开的文件 Descriptors(传递os.open作为 opener *导致的Function类似于传递None)。

新创建的文件是non-inheritable。

下面的示例使用os.open()函数的dir_fd参数打开相对于给定目录的文件：

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

open()函数返回的file object的类型取决于模式。当使用open()以文本模式('w'，'r'，'wt'，'rt'等)打开文件时，它将返回io.TextIOBase的子类(特别是io.TextIOWrapper)。当使用带缓冲的二进制模式打开文件时，返回的类是io.BufferedIOBase的子类。确切的类有所不同：在读取二进制模式下，它返回io.BufferedReader；在写二进制和附加二进制模式下，它返回io.BufferedWriter，在读/写模式下它返回io.BufferedRandom。禁用缓冲后，将返回原始流io.RawIOBase，io.FileIO的子类。

另请参见文件处理模块，例如fileinput，io(其中语句了open())，os，os.path，tempfile和shutil。

用参数file，mode，flags引发auditing event open。

mode和flags参数可能已被修改或从原始调用中推断出来。

从 3.4 版开始不推荐使用，将在 3.9 版中删除：'U'模式。

• ord(* c *)

  • 给定一个表示一个 Unicode 字符的字符串，返回一个整数，表示该字符的 Unicode 代码点。例如，ord('a')返回整数97，而ord('€')(欧元符号)返回8364。这是chr()的逆。

• pow(* base ， exp * [，* mod *])

  • 将* base 返回到幂 exp ；如果存在 mod ，则将 base 返回到幂 exp ，以 mod *为模(比pow(base, exp) % mod的计算效率更高)。两个参数的形式pow(base, exp)等效于使用幂运算符base**exp。

参数必须具有数字类型。对于混合操作数类型，适用于二进制算术运算符的强制规则。对于int个操作数，除非第二个参数为负，否则结果与操作数的类型相同(强制后)；否则，结果与操作数相同。在这种情况下，所有参数都将转换为 float 并传递 float 结果。例如，10**2返回100，但是10**-2返回0.01。

对于int个操作数* base 和 exp ，如果存在 mod ，则 mod 也必须是整数类型，而 mod 必须非零。如果存在 mod 且 exp 为负，则 base 必须相对于 mod 为素数。在这种情况下，将返回pow(inv_base, -exp, mod)，其中 inv_base 是 base 模 mod *的逆。

这是计算38模97的逆的示例：

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

在版本 3.8 中更改：对于int个操作数，pow的三参数形式现在允许第二个参数为负，从而允许计算模逆。

在版本 3.8 中更改：允许关键字参数。以前，仅支持位置参数。

• print(对象， sep =''， end =' n'， file = sys.stdout ， flush = False *)
  • 将* object 打印到文本流 file 中，以 sep 分隔，然后以 end *分隔。 * sep ， end ， file 和 flush *(如果存在)必须作为关键字参数给出。

所有非关键字参数都将转换为类似于str()的字符串，并写入流中，以* sep 分隔，后跟 end *。 * sep 和 end 都必须是字符串；它们也可以是None，表示使用默认值。如果没有给出 object ，print()将只写 end *。

• file *参数必须是具有write(string)方法的对象；如果它不存在或None，将使用sys.stdout。由于打印的参数将转换为文本字符串，因此print()不能与二进制模式文件对象一起使用。对于这些，请改用file.write(...)。

通常是否由* file 确定是否缓冲输出，但是如果 flush *关键字参数为 true，则将强制刷新流。

在版本 3.3 中进行了更改：添加了* flush *关键字参数。

• • class * property(* fget = None ， fset = None ， fdel = None ， doc = None *)
  • 返回属性属性。

• fget *是用于获取属性值的函数。 * fset *是用于设置属性值的Function。 * fdel *是用于删除属性值的函数。 * doc *为属性创建一个文档字符串。

通常的用途是定义托管属性x：

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

如果* c 是 C *的实例，则c.x将调用 getter，而c.x = value将调用 setter，而del c.x是删除器。

如果给定，* doc 将是属性属性的文档字符串。否则，该属性将复制 fget *的文档字符串(如果存在)。这样就可以使用property()作为decorator轻松创建只读属性：

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

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

@property装饰器将voltage()方法转换为具有相同名称的只读属性的“获取器”，并且将* voltage *的文档字符串设置为“获取当前电压”。

属性对象具有可用作装饰器的getter，setter和deleter方法，可创建属性的副本，并将相应的访问器函数设置为装饰函数。最好用一个例子解释一下：

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

此代码与第一个示例完全等效。确保为其他Function赋予与原始属性相同的名称(在这种情况下为x.)

返回的属性对象还具有与构造函数参数相对应的属性fget，fset和fdel。

在版本 3.5 中进行了更改：现在可以写入属性对象的文档字符串。

• 类别 range(停止)

• • class * range(* start ， stop * [，* step *])
  • range实际上不是一个不变的序列类型，而不是一个函数，如Ranges和序列类型-列表，Tuples，范围所述。

• repr(* object *)

  • 返回包含对象的可打印表示形式的字符串。对于许多类型，此函数会try返回一个字符串，该字符串在传递给eval()时将产生具有相同值的对象，否则表示形式是一个用尖括号括起来的字符串，其中包含对象类型的名称以及其他内容。信息通常包括对象的名称和地址。一个类可以pass定义repr()方法来控制此函数为其实例返回的内容。

• reversed(* seq *)

  • 返回反向iterator。 * seq *必须是具有reversed()方法或支持序列协议(len()方法和getitem()方法的整数参数以0开头)的对象。

• round(* number * [，* ndigits *])

  • 在小数点后返回数字舍入为* ndigits 精度。如果Ellipsis ndigits *或为None，则将最接近的整数返回到其 Importing。

对于支持round()的内置类型，值被四舍五入为 10 的最接近的倍数乘以幂减* ndigits ；如果两个倍数相等地接近，则朝着偶数选择取整(因此round(0.5)和round(-0.5)均为0，而round(1.5)则为2)。任何整数值对于 ndigits (正，零或负)有效。如果Ellipsis ndigits 或None，则返回值为整数。否则，返回值的类型与 number *相同。

对于一般的 Python 对象number，round委托给number.__round__。

• 类别 set([可迭代])

  • 返回一个新的set对象，可以选择包含来自* iterable *的元素。 set是内置类。有关此类的文档，请参见set和集合类型-集合，frozenset。

对于其他容器，请参见内置的frozenset，list，tuple和dict类以及collections模块。

• setattr((* object ， name ， value *)

  • 这是getattr()的对应项。参数是一个对象，一个字符串和一个任意值。该字符串可以命名现有属性或新属性。该函数将值分配给属性(如果对象允许)。例如，setattr(x, 'foobar', 123)等效于x.foobar = 123。

• 类别 slice(停止)

• • class * slice(* start ， stop * [，* step *])
  • 返回表示由range(start, stop, step)指定的索引集的slice对象。 * start 和 step *参数默认为None。切片对象具有只读数据属性start，stop和step，它们仅返回参数值(或其默认值)。它们没有其他显式Function。但是，它们被数值 Python 和其他第三方扩展使用。使用扩展索引语法时，也会生成切片对象。例如：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()Function保证稳定。如果排序保证不改变比较相等的元素的相对 Sequences，则该排序是稳定的-这有助于多次pass排序(例如，按部门排序，然后按薪级排序)。

有关排序示例和简短的排序教程，请参见排序方式。

• @ staticmethod
  • 将方法转换为静态方法。

静态方法不会收到隐式的第一个参数。要语句静态方法，请使用以下惯用法：

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

@staticmethod表单是函数decorator –有关详细信息，请参见Function definitions。

可以在类(例如C.f())或实例(例如C().f())上调用静态方法。

Python 中的静态方法类似于 Java 或 C 中的静态方法。另请参见classmethod()，该变量对于创建备用类构造函数很有用。

像所有装饰器一样，也可以将staticmethod作为常规函数调用并对其结果进行处理。在某些情况下，当您需要从类主体中引用函数并且希望避免自动转换为实例方法时，这是必需的。对于这些情况，请使用以下惯用法：

class C:
    builtin_open = staticmethod(open)

有关静态方法的更多信息，请参见标准类型层次结构。

• • class * str(* object =''*)
• • class * str(* object = b''， encoding ='utf-8'， errors ='strict'*)
  • 返回**的str版本。有关详情，请参见str()。

str是内置字符串class。有关字符串的一般信息，请参见Literals 序列类型-str。

• sum(* iterable ，/， start = 0 *)
  • 从左到右对* start 和 iterable *的项求和，并返回总数。 * iterable *的项目通常是数字，并且起始值不允许为字符串。

对于某些用例，可以使用sum()替代。连接字符串序列的首选快速方法是调用''.join(sequence)。要以扩展的精度添加浮点值，请参见math.fsum()。要串联一系列可迭代对象，请考虑使用itertools.chain()。

在版本 3.8 中更改：可以将* start *参数指定为关键字参数。

• super([类型 [，对象或类型]])
  • 返回将方法调用委托给* type *的父级或同级类的代理对象。这对于访问已在类中重写的继承方法很有用。

“对象或类型”确定要搜索的方法解析 Sequences。搜索从* type *之后的类开始。

例如，如果* object-or-type 的mro是D -> B -> C -> A -> object，而 type *的值是B，则super()搜索C -> A -> object。

• object-or-type *的mro属性列出了getattr()和super()所使用的方法分辨率搜索 Sequences。该属性是动态的，并且在继承层次结构更新时可以更改。

如果Ellipsis第二个参数，则返回的超级对象是未绑定的。如果第二个参数是一个对象，则isinstance(obj, type)必须为 true。如果第二个参数是类型，则issubclass(type2, type)必须为 true(这对于类方法很有用)。

• super 有两个典型的用例。在具有单一继承的类层次结构中， super 可用于引用父类而无需显式命名它们，从而使代码更具可维护性。这种用法与其他编程语言中 super *的用法非常相似。

第二个用例是在动态执行环境中支持协作式多重继承。该用例是 Python 特有的，在静态编译语言或仅支持单继承的语言中找不到。这样就可以在多个 Base Class 实现相同方法的情况下实现“菱形图”。良好的设计表明，此方法在每种情况下都具有相同的调用签名(因为调用的 Sequences 是在运行时确定的，因为该 Sequences 可以适应类层次结构中的更改，并且因为该 Sequences 可以包含在运行时之前未知的同级类)。

对于这两种用例，典型的超类调用如下所示：

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

除了方法查找之外，super()还适用于属性查找。一种可能的用例是在父类或同级类中调用descriptors。

请注意，super()是作为诸如super().__getitem__(name)之类的显式点分属性查找的绑定过程的一部分而实现的。它pass实现自己的getattribute()方法以支持可协作多重继承的可预测 Sequences 搜索类来实现。因此，对于使用语句或super()[name]之类的隐式查找，未定义super()。

还要注意，除了零参数形式外，super()不限于使用内部方法。两个参数形式准确地指定了参数并进行了适当的引用。零参数形式仅在类定义内起作用，因为编译器会填充必要的详细信息以正确检索要定义的类，以及为常规方法访问当前实例。

有关如何使用super()设计协作类的实用建议，请参见使用 super()的指南。

• 类别 tuple([可迭代])

  • tuple实际上不是一个不变的序列类型，而不是一个函数，如Tuples和序列类型-列表，Tuples，范围所述。

• 类别 type(对象)

• • class * type(* name ， base ， dict *)
  • 使用一个参数，返回* object *的类型。返回值是类型对象，通常与object.class返回的对象相同。

建议使用isinstance()内置函数来测试对象的类型，因为它考虑了子类。

具有三个参数，返回一个新的类型对象。这本质上是class语句的动态形式。 * name *字符串是类名称，并成为name属性； * base *Tuples 逐项列出 Base Class 并成为bases属性； * dict *字典是包含类主体定义的名称空间，并被复制到标准字典中成为dict属性。例如，以下两个语句创建相同的type对象：

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

另请参见Type Objects。

在版本 3.6 中进行了更改：不会覆盖type.__new__的type的子类可能不再使用单参数形式来获取对象的类型。

• vars([* object *])
  • 返回模块，类，实例或具有dict属性的任何其他对象的dict属性。

对象(例如模块和实例)具有可更新的dict属性；但是，其他对象可能对其dict属性具有写限制(例如，类使用types.MappingProxyType来防止直接字典更新)。

没有参数，vars()的行为就像locals()。请注意，由于忽略了本地字典的更新，因此本地字典仅对读取有用。

• zip(** iterables *)
  • 创建一个迭代器，以聚合每个可迭代对象中的元素。

返回一个 Tuples 的迭代器，其中第* i 个 Tuples 包含每个参数序列或可迭代对象中的第 i *个元素。当最短的可迭代 Importing 耗尽时，迭代器将停止。使用单个可迭代参数，它返回 1Tuples 的迭代器。没有参数，它将返回一个空的迭代器。相当于：

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

保证了可迭代对象的从左到右的评估 Sequences。这使使用zip(*[iter(s)]*n)将数据系列聚类为 n 个长度的组成为一个习惯用法。这将相同迭代器重复n次，以便每个输出 Tuples 具有对迭代器的n调用的结果。这具有将 Importing 分成 n 个长度的块的效果。

当您不关心较长的可迭代项的尾部不匹配的值时，zip()仅应与不等长的 Importing 一起使用。如果这些值很重要，请改用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 编程中不需要的高级Function。

import语句调用此函数。可以替换它(pass导入builtins模块并分配给builtins.__import__)以更改import语句的语义，但是强烈建议不要这样做，因为使用导入钩子(参见 PEP 302)通常更容易达到相同的目标，并且不会导致假定使用默认导入实现的代码出现问题。不建议直接使用import()来支持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 中进行了更改：* level *的负值不再受支持(还将默认值更改为 0)。

Footnotes

• [1]
  • 请注意，解析器仅接受 Unix 样式的行尾约定。如果要从文件中读取代码，请确保使用换行符转换模式来转换 Windows 或 Mac 风格的换行符。