附录 C：内置函数

构造函数

构造函数用于创建给定类型的对象。

注意

在 Python 中，类型是一个构造函数；在 Python 中根本没有区别。因此，您可以使用 type 函数（我们将在稍后讨论）来查找对象的类型，然后创建相同类型的实例。

首先，我们将查看构造函数，这些函数通常用于转换。这是因为通常存在方便的文字语法，或者在 bool 的情况下，只有两个这样的常量，True 和 False。

bool([x])

使用标准的真值测试过程将值转换为布尔值。如果 x 为假或省略，则返回 False；否则返回 True。 bool 也是一个类，它是 int 的子类。类 bool 不能再进一步子类化。它的唯一实例是 False 和 True。

如果没有给出参数，则此函数返回 False。

chr(i)

返回一个字符串，其中包含一个 ASCII 码为整数 i 的字符。例如，chr(97) 返回字符串 'a'。这是 ord() 的反函数。参数必须在 [0..255] 范围内，包括端点；如果 i 超出该范围，则会引发 ValueError。另请参见 unichr().

complex([real[, imag]])

创建一个值为 real + imag*j 的复数，或将字符串或数字转换为复数。如果第一个参数是字符串，它将被解释为复数，并且函数必须在没有第二个参数的情况下调用。第二个参数永远不能是字符串。每个参数可以是任何数值类型（包括复数）。如果省略 imag，则默认为零，并且该函数用作类似于 int()、long() 和 float() 的数值转换函数。如果省略两个参数，则返回 0j。

dict([arg])

创建一个新的数据字典，可以选择从 arg 中获取项目。字典类型在 映射类型 — dict 中描述。

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

虽然有一个方便的字面量用于创建 dict 对象

a_dict = { 'alpha' : 1, 'beta' : 2, 'gamma' : 3 }

使用 dict 函数创建它们可能更方便

a_dict = dict(alpha=1, beta=2, gamma=3)

当然，在这种情况下，正在创建的条目的键必须是有效的 Python 关键字。

float([x])

将字符串或数字转换为浮点数。如果参数是字符串，它必须包含一个可能带符号的十进制或浮点数，可能嵌入在空格中。参数也可以是 [+|-]nan 或 [+|-]inf。否则，参数可以是普通整数或长整数或浮点数，并且返回具有相同值（在 Python 的浮点精度范围内）的浮点数。如果没有给出参数，则返回 0.0。

frozenset([iterable])

返回一个 frozenset 对象，可以选择从 iterable 中获取元素。frozenset 类型在 集合类型 — set, frozenset 中描述。

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

int([x[, radix]])

将字符串或数字转换为普通整数。如果参数是字符串，它必须包含一个可能带符号的十进制数，可以表示为 Python 整数，可能嵌入在空格中。radix 参数给出转换的基数（默认值为 10），可以是 [2, 36] 范围内的任何整数，或零。如果 radix 为零，则根据字符串的内容确定正确的基数；解释与整数字面量相同。（参见 数值字面量。）如果指定了 radix 并且 x 不是字符串，则会引发 TypeError。否则，参数可以是普通整数或长整数或浮点数。将浮点数转换为整数会截断（朝零）。如果参数在整数范围内，则将返回长对象。如果没有给出参数，则返回 0。

整数类型在 数值类型 - int, float, long, complex 中有描述。

iter(o[, sentinel])

返回一个 迭代器 对象。第一个参数的解释方式取决于第二个参数的存在与否。如果没有第二个参数，o 必须是一个支持迭代协议的集合对象（__iter__() 方法），或者它必须支持序列协议（__getitem__() 方法，使用从 0 开始的整数参数）。如果它不支持这两个协议中的任何一个，则会引发 TypeError。如果给出了第二个参数 sentinel，则 o 必须是一个可调用对象。在这种情况下创建的迭代器将对每次调用其 next() 方法时调用 o，不带任何参数；如果返回的值等于 sentinel，则会引发 StopIteration，否则将返回该值。

在版本 2.2 中新增。

list([iterable])

返回一个列表，其项目与 iterable 的项目相同，顺序也相同。iterable 可以是序列、支持迭代的容器或迭代器对象。如果 iterable 已经是列表，则会创建一个副本并返回，类似于 iterable[:]。例如，list('abc') 返回 ['a', 'b', 'c']，而 list( (1, 2, 3) ) 返回 [1, 2, 3]。如果没有给出参数，则返回一个新的空列表，[]。

list 是一个可变序列类型，如 序列类型 - str, unicode, list, tuple, bytearray, buffer, xrange 中所述。对于其他容器，请参见内置的 dict、set 和 tuple 类，以及 collections 模块。

object()

返回一个新的无特征对象。 object 是所有新式类的基类。它具有所有新式类实例共有的方法。

在版本 2.2 中新增。

在版本 2.3 中更改: 此函数不接受任何参数。以前，它接受参数但会忽略它们。

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

打开一个文件，返回一个file类型的对象，如第文件对象节所述。如果无法打开文件，则会引发IOError。在打开文件时，最好使用open()，而不是直接调用file构造函数。

前两个参数与stdio的fopen()相同：filename是要打开的文件名，mode是一个字符串，指示如何打开文件。

mode最常用的值是'r'用于读取，'w'用于写入（如果文件已存在则截断文件），以及'a'用于追加（在某些Unix系统上，这意味着所有写入都追加到文件末尾，无论当前的查找位置如何）。如果省略mode，则默认为'r'。默认情况下使用文本模式，这可能会将'\n'字符转换为平台特定的表示形式，并在写入和读取时进行转换。因此，在打开二进制文件时，应在mode值后附加'b'以二进制模式打开文件，这将提高可移植性。（即使在不区分二进制文件和文本文件的系统上，附加'b'也很有用，因为它充当文档。）有关mode的更多可能值，请参见下文。

可选的bufsize参数指定文件所需的缓冲区大小：0表示不缓冲，1表示行缓冲，任何其他正值表示使用（大约）该大小的缓冲区。负bufsize表示使用系统默认值，通常对于tty设备而言是行缓冲，而对于其他文件而言是完全缓冲。如果省略，则使用系统默认值。

模式'r+'、'w+'和'a+'以更新模式打开文件（请注意，'w+'会截断文件）。在区分二进制文件和文本文件的系统上，在模式后附加'b'以二进制模式打开文件；在没有这种区别的系统上，添加'b'没有影响。

除了标准的fopen()值之外，mode还可以是'U'或'rU'。Python 通常使用通用换行符支持；提供'U'以文本文件形式打开文件，但行可以由以下任何一项终止：Unix 换行符约定'\n'、Macintosh 约定'\r'或 Windows 约定'\r\n'。Python 程序将所有这些外部表示形式视为'\n'。如果 Python 在没有通用换行符支持的情况下构建，则带有'U'的mode与普通文本模式相同。请注意，以这种方式打开的文件对象还具有一个名为newlines的属性，其值为None（如果尚未看到任何换行符）、'\n'、'\r'、'\r\n'或包含所有已见换行符类型的元组。

Python 强制执行，在剥离'U'后，模式以'r'、'w'或'a'开头。

Python 提供了许多文件处理模块，包括 fileinput、os、os.path、tempfile 和 shutil。

ord(c)

给定一个长度为一的字符串，返回一个整数，表示字符的 Unicode 代码点（如果参数是 Unicode 对象），或字节的值（如果参数是 8 位字符串）。例如，ord('a') 返回整数 97，ord(u'\u2020') 返回 8224。这是 chr()（对于 8 位字符串）和 unichr()（对于 Unicode 对象）的逆运算。如果给定一个 Unicode 参数，并且 Python 使用 UCS2 Unicode 构建，则字符的代码点必须在 [0..65535]（含）范围内；否则字符串长度为 2，并且会引发 TypeError。

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

这是一个通用的函数，用于创建包含算术级数的列表。它最常用于 for 循环。

但是，我们建议使用 xrange 代替。

参数必须是普通整数。如果省略 step 参数，则默认为 1。如果省略 start 参数，则默认为 0。完整形式返回一个普通整数列表 [start, start + step, start + 2 * step, ...]。如果 step 为正，则最后一个元素是小于 stop 的最大 start + i * step；如果 step 为负，则最后一个元素是大于 stop 的最小 start + i * step。step 不能为零（否则会引发 ValueError）。示例

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

set([iterable])

返回一个新的集合，可选地包含从 iterable 中获取的元素。集合类型在 Set Types — set, frozenset 中描述。

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

版本 2.4 中新增。

str([object])

返回一个包含对象可打印表示的字符串。对于字符串，这将返回字符串本身。与 repr(object) 的区别在于 str(object) 不总是尝试返回一个对 eval() 可接受的字符串；它的目标是返回一个可打印的字符串。如果没有给出参数，则返回空字符串，''。

有关字符串的更多信息，请参阅 序列类型 — str、unicode、list、tuple、bytearray、buffer、xrange，它描述了序列功能（字符串是序列），以及 字符串方法 部分中描述的特定于字符串的方法。要输出格式化的字符串，请使用模板字符串或 字符串格式化操作 部分中描述的 % 运算符。此外，请参阅 字符串服务 部分。另请参阅 unicode()。

tuple([iterable])

返回一个元组，其项目与 iterable 的项目相同且顺序相同。iterable 可以是序列、支持迭代的容器或迭代器对象。如果 iterable 已经是元组，则会原样返回。例如，tuple('abc') 返回 ('a', 'b', 'c')，而 tuple([1, 2, 3]) 返回 (1, 2, 3)。如果没有给出参数，则返回一个新的空元组，()。

tuple 是一个不可变的序列类型，如 序列类型 — str、unicode、list、tuple、bytearray、buffer、xrange 中所述。对于其他容器，请参阅内置的 dict、list 和 set 类，以及 collections 模块。

type(name, bases, dict)

返回一个新的类型对象。这本质上是 class 语句的动态形式。name 字符串是类名，并成为 __name__ 属性；bases 元组列出了基类，并成为 __bases__ 属性；dict 字典是包含类体定义的命名空间，并成为 __dict__ 属性。例如，以下两个语句创建了相同的 type 对象

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

在版本 2.2 中新增。

unichr(i)

返回一个 Unicode 字符串，该字符串包含 Unicode 代码为整数 i 的单个字符。例如，unichr(97) 返回字符串 u'a'。这是 ord() 对 Unicode 字符串的逆运算。参数的有效范围取决于 Python 的配置方式 - 它可能是 UCS2 [0..0xFFFF] 或 UCS4 [0..0x10FFFF]。否则将引发 ValueError。对于 ASCII 和 8 位字符串，请参见 chr()。

版本 2.0 中新增。

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

使用以下模式之一返回 object 的 Unicode 字符串版本

如果给出了 encoding 和/或 errors，unicode() 将解码对象，该对象可以是 8 位字符串或使用 encoding 的编解码器的字符缓冲区。encoding 参数是一个字符串，给出编码的名称；如果编码未知，则会引发 LookupError。错误处理根据 errors 进行；这指定了对输入编码中无效字符的处理。如果 errors 为 'strict'（默认值），则在错误时会引发 ValueError，而 'ignore' 的值会导致错误被静默忽略，而 'replace' 的值会导致使用官方 Unicode 替换字符 U+FFFD 来替换无法解码的输入字符。另请参见 codecs 模块。

如果没有给出可选参数，unicode() 将模仿 str() 的行为，只是它返回 Unicode 字符串而不是 8 位字符串。更准确地说，如果 object 是 Unicode 字符串或子类，它将返回该 Unicode 字符串，没有任何额外的解码应用。

对于提供 __unicode__() 方法的对象，它将调用该方法（不带参数）以创建 Unicode 字符串。对于所有其他对象，将请求 8 位字符串版本或表示形式，然后使用 'strict' 模式下的默认编码的编解码器将其转换为 Unicode 字符串。

有关 Unicode 字符串的更多信息，请参见 序列类型 - str、unicode、list、tuple、bytearray、buffer、xrange，它描述了序列功能（Unicode 字符串是序列），以及 字符串方法 部分中描述的特定于字符串的方法。要输出格式化的字符串，请使用模板字符串或 字符串格式化操作 部分中描述的 % 运算符。此外，请参见 字符串服务 部分。另请参见 str()。

用作装饰器：classmethod、staticmethod、property

slice 很少直接使用。

super 类型 - 3 个参数形式编译

数学内置函数

大多数数学函数在 math（或 cmath 用于复数数学）中定义。这些是内置的函数

abs、cmp、divmod、pow、round

您可能需要使用命名函数

可迭代对象上的函数

下一组内置函数对可迭代对象进行操作，在 Jython 中，这也包括实现 java.util.Iterator 接口的所有 Java 对象。

特别是，

enumerate(iterable)

zip([iterable, ...])

The zip 函数通过遍历每个iterable来创建一个元组列表。一个非常常见的用法是使用 zip 来创建一个 dict，其中一个 iterable 具有键，另一个具有值。这在处理 CSV 文件（来自标题行）或数据库游标（来自 description 属性）时很常见。但是，您可能希望考虑使用 collections.namedtuple 代替

.. function:: sorted(iterable[, cmp[, key[, reverse]]])

The sorted 函数返回一个排序后的列表。使用可选的 key 参数指定一个键函数来控制排序方式。例如，这将按列表中元素的长度对列表进行排序

>>> sorted(['Massachusetts', 'Colorado', 'New York', 'California', 'Utah'], key=len)
['Utah', 'Colorado', 'New York', 'California', 'Massachusetts']

而这个将对 Unicode 字符串列表进行排序，而不考虑字符是大写还是小写

>>> sorted(['apple', 'Cherry', 'banana'])
['Cherry', 'apple', 'banana']

>>> sorted(['apple', 'Cherry', 'banana'], key=str.upper)
['apple', 'banana', 'Cherry']

虽然使用 key 函数需要构建要排序的列表的装饰版本，但在实践中，这比在每次比较时调用 cmp 函数使用更少的开销。我们建议您利用键排序。

all(iterable), any(iterable)

all 和 any 也会尽可能地进行短路。

以及 sum(iterable[, start=0]) 是您会经常使用到的函数。

max(iterable[, key]) or max([, arg, ...][, key]); min(iterable[, key]) or min([, arg, ...][, key])

The max 和 min 函数接受 key 函数作为可选参数。

虽然 filter、map 和 reduce 仍然有用，但它们的使用在很大程度上被使用其他函数以及生成器表达式所取代。The range 函数仍然用于创建给定序列的列表，但为了便携性最终移植到 Python 3.x，使用 list(xrange()) 更好。

一些建议

• 生成器表达式（或列表推导）比 filter 更易于使用。
• 大多数有趣但简单的 reduce 用法可以通过 sum 实现。任何更复杂的操作都应该编写为生成器。

all(iterable)

如果 iterable 中的所有元素都为真，则返回 True，否则返回 False 并停止迭代。（如果 iterable 为空，则此函数返回 True）。

any(iterable)

如果 iterable 中的任何元素都为真，则返回 True，停止迭代。否则返回 False 并停止迭代。（如果 iterable 为空，则此函数返回 True）。

enumerate(iterable)

filter(function, iterable)

sum(iterable[, start=0])

命名空间函数

namespace - __import__, delattr, dir, getattr, locals, globals, hasattr, reload, setattr, vars

getattr

注意

Java 动态集成。getattr 的支持特殊方法是 __getattr__。当 Jython 代码被编译时，它实际上使用 __getattr__ 来实现属性查找。因此 x.y.z 实际上被编译为等效的链 x.__getattr__(‘y’).__getattr__(‘z’)。或者，为了更有效地进行 Java 集成，支持 __findattr__。如果属性不是给定对象的一部分，它将返回 null 而不是抛出 AttributeError。但是，如果您要将方法调用链接在一起以维护 Python 异常处理语义，请使用 __getattr__。

如果给定的 Jython 类实现了一个 Java 接口（或扩展了一个 Java 类，但这在 Jython 中不如在 Java 中更可取），那么使用这些实例的 Java 代码可以静态绑定方法查找。

[Clamp 项目支持一种替代方法来公开 Java 接口，以便从 Jython 代码创建接口。但是，我不确定这种方法是否最佳实践。Java 中的 Java 接口在互操作性方面非常精确。其他部分很有用，例如 Jython 类 Java 代理的 AOT 编译。]

创建代码对象：编译、评估、执行

评估 - eval、execfile、谓词 - 可调用、isinstance、issubclass 十六进制、八进制、id、hash、ord、repr 长度 输入、rawinput

只需参考这些的文档：已弃用的函数 - apply、buffer、coerce、intern …

运算符

abs(x)

返回数字的绝对值。参数可以是普通整数、长整数或浮点数。如果参数是复数，则返回其大小。

all(iterable)

如果iterable 中的所有元素都为真，则返回 True。等效于

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

版本 2.5 中新增。

any(iterable)

如果iterable 中的任何元素为真，则返回 True。等效于

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

版本 2.5 中新增。

basestring()

此抽象类型是 str 和 unicode 的超类。它不能被调用或实例化，但可以用来测试一个对象是否是 str 或 unicode 的实例。 isinstance(obj, basestring) 等效于 isinstance(obj, (str, unicode))。

版本 2.3 中新增。

bin(x)

将整数转换为二进制字符串。结果是一个有效的 Python 表达式。如果x 不是 Python int 对象，则它必须定义一个 __index__() 方法，该方法返回一个整数。

版本 2.6 中新增。

callable(object)

如果object 参数看起来是可调用的，则返回 True，否则返回 False。如果返回 true，则调用仍然可能失败，但如果返回 false，则调用object 将永远不会成功。请注意，类是可调用的（调用类将返回一个新实例）；如果类实例具有 __call__() 方法，则类实例是可调用的。

classmethod(function)

为function 返回一个类方法。

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

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

@classmethod 形式是一个函数 decorator - 有关详细信息，请参阅 Function definitions 中对函数定义的描述。

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

类方法不同于 C++ 或 Java 的静态方法。如果您需要静态方法，请参阅本节中的 staticmethod()。

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

在版本 2.2 中新增。

版本 2.4 中的更改: 添加了函数装饰器语法。

cmp(x, y)

比较两个对象 x 和 y，并根据结果返回一个整数。如果 x < y，则返回值为负数；如果 x == y，则返回值为零；如果 x > y，则返回值为正数。

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

将 source 编译成代码或 AST 对象。代码对象可以通过 exec 语句执行，也可以通过调用 eval() 进行评估。source 可以是字符串或 AST 对象。有关如何使用 AST 对象的信息，请参阅 ast 模块文档。

filename 参数应该给出代码读取的文件；如果代码不是从文件读取的，则传递一些可识别的值（'<string>' 通常用于此目的）。

mode 参数指定要编译的代码类型；如果 source 包含一系列语句，则可以为 'exec'；如果 source 包含单个表达式，则可以为 'eval'；如果 source 包含单个交互式语句，则可以为 'single'（在后一种情况下，计算结果不为 None 的表达式语句将被打印）。

可选参数 flags 和 dont_inherit 控制哪些未来语句（请参阅 PEP 236）会影响 source 的编译。如果两者都不存在（或两者都为零），则代码将使用调用 compile 的代码中有效的那些未来语句进行编译。如果给出了 flags 参数，而 dont_inherit 不存在（或为零），则除了将要使用的那些未来语句之外，还会使用 flags 参数指定的未来语句。如果 dont_inherit 是一个非零整数，则 flags 参数就是它——调用 compile 时有效的未来语句将被忽略。

未来语句由位指定，这些位可以按位或运算以指定多个语句。指定给定功能所需的位域可以在 __future__ 模块中的 _Feature 实例上找到为 compiler_flag 属性。

如果编译后的源代码无效，此函数会引发 SyntaxError，如果源代码包含空字节，则会引发 TypeError。

注意

使用多行语句编译字符串时，行尾必须用单个换行符 ('\n') 表示，并且输入必须以至少一个换行符结尾。如果行尾用 '\r\n' 表示，请使用 str.replace() 将它们更改为 '\n'。

版本 2.3 中的变更: 添加了 flags 和 dont_inherit 参数。

版本 2.6 中的变更: 支持编译 AST 对象。

delattr(object, name)

这是 setattr() 的一个近亲。参数是一个对象和一个字符串。该字符串必须是对象属性名称之一。该函数删除指定的属性，前提是对象允许这样做。例如，delattr(x, 'foobar') 等效于 del x.foobar。

dir([object])

没有参数时，返回当前局部作用域中的名称列表。如果有参数，则尝试返回该对象的有效属性列表。

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

如果对象没有提供 __dir__()，则该函数会尽力从对象的 __dict__ 属性（如果已定义）及其类型对象中收集信息。生成的列表不一定是完整的，并且当对象具有自定义 __getattr__() 时可能不准确。

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

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

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

>>> import struct
>>> dir()   # doctest: +SKIP
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)   # doctest: +NORMALIZE_WHITESPACE
['Struct', '__builtins__', '__doc__', '__file__', '__name__',
 '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Foo(object):
...     def __dir__(self):
...         return ["kan", "ga", "roo"]
...
>>> f = Foo()
>>> dir(f)
['ga', 'kan', 'roo']

注意

因为 dir() 主要作为交互式提示的便利工具提供，所以它试图提供一组有趣的名称，而不是试图提供一组严格或一致定义的名称，并且其详细行为可能会在不同版本之间发生变化。例如，当参数是类时，元类属性不在结果列表中。

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

版本 2.3 中变更: 使用 divmod() 处理复数已弃用。

enumerate(sequence[, start=0])

返回一个枚举对象。sequence 必须是一个序列、一个 迭代器，或其他支持迭代的对象。由 enumerate() 返回的迭代器的 next() 方法返回一个元组，包含一个计数（从 start 开始，默认值为 0）和从迭代 iterable 获得的相应值。 enumerate() 用于获取索引系列：(0, seq[0]), (1, seq[1]), (2, seq[2]), …. 例如

>>> for i, season in enumerate(['Spring', 'Summer', 'Fall', 'Winter']):
...     print i, season
0 Spring
1 Summer
2 Fall
3 Winter

版本 2.3 中新增。

版本 2.6 中新增: start 参数。

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

参数是一个字符串，以及可选的全局和局部变量。如果提供，globals 必须是一个字典。如果提供，locals 可以是任何映射对象。

版本 2.4 中变更: 以前 locals 必须是一个字典。

expression 参数被解析并作为 Python 表达式（严格来说，是一个条件列表）进行评估，使用 globals 和 locals 字典作为全局和局部命名空间。如果 globals 字典存在且缺少 ‘__builtins__’，则在解析 expression 之前将当前全局变量复制到 globals 中。这意味着 expression 通常可以完全访问标准 __builtin__ 模块，并且受限环境会被传播。如果省略 locals 字典，则默认为 globals 字典。如果两个字典都被省略，则表达式将在调用 eval() 的环境中执行。返回值是评估表达式的结果。语法错误将作为异常报告。示例

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

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

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

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

此函数类似于 exec 语句，但解析文件而不是字符串。它与 import 语句不同，因为它不使用模块管理——它无条件地读取文件，并且不创建新的模块。

参数是文件名和两个可选字典。文件被解析并作为一系列 Python 语句（类似于模块）进行评估，使用 globals 和 locals 字典作为全局和局部命名空间。如果提供，locals 可以是任何映射对象。

版本 2.4 中变更: 以前 locals 必须是一个字典。

如果省略了locals字典，则默认为globals字典。如果两个字典都被省略，则表达式将在execfile()被调用的环境中执行。返回值为None。

警告

默认的locals的行为与下面描述的函数locals()相同：不应尝试修改默认的locals字典。如果您需要在函数execfile()返回后查看代码对locals的影响，请传递一个显式的locals字典。 execfile()不能可靠地用于修改函数的局部变量。

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

用于file类型的构造函数，在文件对象部分有更详细的描述。构造函数的参数与下面描述的内置函数open()相同。

在打开文件时，最好使用open()，而不是直接调用此构造函数。 file更适合类型测试（例如，编写isinstance(f, file)）。

在版本 2.2 中新增。

filter(function, iterable)

从iterable中那些function返回True的元素构造一个列表。iterable可以是序列、支持迭代的容器或迭代器。如果iterable是字符串或元组，则结果也具有该类型；否则它始终是列表。如果function是None，则假定为标识函数，即，删除iterable中所有为False的元素。

请注意，如果function不是None，则filter(function, iterable)等效于[item for item in iterable if function(item)]；如果function是None，则等效于[item for item in iterable if item]。

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

getattr(object, name[, default])

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

globals()

返回一个字典，表示当前全局符号表。这始终是当前模块的字典（在函数或方法内部，这是定义它的模块，而不是调用它的模块）。

hasattr(object, name)

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

hash(object)

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

help([object])

调用内置帮助系统。（此函数旨在用于交互式使用。）如果没有给出参数，则交互式帮助系统将在解释器控制台上启动。如果参数是一个字符串，则该字符串将被查找为模块、函数、类、方法、关键字或文档主题的名称，并在控制台上打印帮助页面。如果参数是任何其他类型的对象，则会生成有关该对象的帮助页面。

此函数由 site 模块添加到内置命名空间中。

在版本 2.2 中新增。

hex(x)

将一个整数（任何大小）转换为十六进制字符串。结果是一个有效的 Python 表达式。

在版本 2.4 中更改: 以前只返回无符号文字。

id(object)

返回对象的“标识”。这是一个整数（或长整数），保证在对象的生命周期内对该对象是唯一且恒定的。两个生命周期不重叠的对象可能具有相同的 id() 值。（实现说明：这是对象的地址。）

input([prompt])

等效于 eval(raw_input(prompt))。

警告

此函数不能防止用户错误！它期望输入一个有效的 Python 表达式；如果输入在语法上无效，则会引发 SyntaxError。如果在评估期间发生错误，可能会引发其他异常。（另一方面，有时这正是你在编写供专家使用的快速脚本时所需要的。）

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

考虑使用 raw_input() 函数来获取用户的常规输入。

isinstance(object, classinfo)

如果 object 参数是 classinfo 参数的实例，或者其（直接或间接）子类的实例，则返回 true。如果 classinfo 是一个类型对象（新式类），并且 object 是该类型或其（直接或间接）子类的对象，则也返回 true。如果 object 不是类实例或给定类型的对象，则该函数始终返回 false。如果 classinfo 既不是类对象也不是类型对象，它可能是一个类或类型对象的元组，或者可能递归地包含其他此类元组（其他序列类型不被接受）。如果 classinfo 不是类、类型或类、类型和此类元组的元组，则会引发 TypeError 异常。

在版本 2.2 中更改: 添加了对类型信息元组的支持。

issubclass(class, classinfo)

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

版本 2.3 中的变更: 添加了对类型信息元组的支持。

len(s)

返回对象的长度（项目数量）。参数可以是序列（字符串、元组或列表）或映射（字典）。

locals()

更新并返回一个字典，表示当前的局部符号表。

警告

不应该修改此字典的内容；更改可能不会影响解释器使用的局部变量的值。

当在函数块中调用locals()时，自由变量将被返回。自由变量的修改可能不会影响解释器使用的值。在类块中不会返回自由变量。

long([x[, radix]])

将字符串或数字转换为长整数。如果参数是字符串，它必须包含一个可能带符号的任意大小的数字，可能嵌入在空格中。radix参数的解释方式与int()相同，并且只有在x是字符串时才能给出。否则，参数可以是普通整数、长整数或浮点数，并返回具有相同值的 long 整数。浮点数转换为整数会截断（朝零方向）。如果没有给出参数，则返回0L。

long 类型在数值类型 — int、float、long、complex中描述。

map(function, iterable, ...)

将function应用于iterable的每个项目，并返回结果列表。如果传递了额外的iterable参数，function必须接受那么多参数，并并行应用于所有可迭代对象中的项目。如果一个可迭代对象比另一个可迭代对象短，则假设它用None项目扩展。如果function是None，则假设为恒等函数；如果有多个参数，map()返回一个列表，该列表包含来自所有可迭代对象的对应项目的元组（一种转置操作）。iterable参数可以是序列或任何可迭代对象；结果始终是列表。

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

对于单个参数iterable，返回非空可迭代对象（如字符串、元组或列表）中最大的项目。对于多个参数，返回参数中最大的那个。

可选的key参数指定一个单参数排序函数，类似于list.sort()中使用的函数。如果提供了key参数，它必须以关键字形式给出（例如，max(a,b,c,key=func)）。

版本 2.5 中的变更: 添加了对可选key参数的支持。

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

对于单个参数iterable，返回非空可迭代对象（如字符串、元组或列表）中最小的项目。对于多个参数，返回参数中最小的那个。

可选的 key 参数指定一个单参数排序函数，类似于用于 list.sort() 的函数。如果提供 key 参数，则必须以关键字形式提供（例如，min(a,b,c,key=func)）。

版本 2.5 中的变更: 添加了对可选key参数的支持。

next(iterator[, default])

通过调用其 next() 方法从 iterator 中检索下一个项目。如果提供了 default，则在迭代器耗尽时返回它，否则将引发 StopIteration。

版本 2.6 中新增。

oct(x)

将一个整数（任何大小）转换为八进制字符串。结果是一个有效的 Python 表达式。

在版本 2.4 中更改: 以前只返回无符号文字。

pow(x, y[, z])

返回 x 的 y 次方；如果存在 z，则返回 x 的 y 次方，模 z（计算效率比 pow(x, y) % z 更高）。双参数形式 pow(x, y) 等效于使用幂运算符：x**y。

参数必须具有数值类型。对于混合操作数类型，二元算术运算符的强制转换规则适用。对于 int 和 long int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负数；在这种情况下，所有参数都将转换为 float，并返回 float 结果。例如，10**2 返回 100，但 10**-2 返回 0.01。（此功能在 Python 2.2 中添加。在 Python 2.1 及之前版本中，如果两个参数都是整数类型并且第二个参数为负数，则会引发异常。）如果第二个参数为负数，则必须省略第三个参数。如果存在 z，则 x 和 y 必须为整数类型，并且 y 必须为非负数。（此限制在 Python 2.2 中添加。在 Python 2.1 及之前版本中，浮点数 3 参数 pow() 返回平台相关的结果，具体取决于浮点数舍入事故。）

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

将 object(s) 打印到流 file 中，用 sep 分隔，并在后面加上 end。如果存在，sep、end 和 file 必须作为关键字参数给出。

所有非关键字参数都将转换为字符串，就像 str() 所做的那样，并写入流中，用 sep 分隔，并在后面加上 end。sep 和 end 都必须是字符串；它们也可以是 None，这意味着使用默认值。如果未给出任何 object，print() 将只写入 end。

file 参数必须是一个具有 write(string) 方法的对象；如果它不存在或为 None，则将使用 sys.stdout。

注意

此函数通常不可用作内置函数，因为名称 print 被识别为 print 语句。要禁用该语句并使用 print() 函数，请在模块顶部使用此未来语句

from __future__ import print_function

版本 2.6 中新增。

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

为 新式类（从 object 派生的类）返回一个属性属性。

fget 是一个用于获取属性值的函数，类似地，fset 是一个用于设置的函数，而 fdel 是一个用于删除属性的函数。典型的用法是定义一个受管理的属性 x

class C(object):
    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.")

如果给出，doc 将是属性的文档字符串。否则，该属性将复制fget的文档字符串（如果存在）。这使得使用 property() 作为 装饰器 轻松创建只读属性。

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

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

将 voltage() 方法转换为具有相同名称的只读属性的“getter”。

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

class C(object):
    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

此代码与第一个示例完全等效。确保为附加函数提供与原始属性相同的名称（在本例中为 x）。

返回的属性还具有属性 fget、fset 和 fdel，分别对应于构造函数参数。

在版本 2.2 中新增。

在版本 2.5 中更改： 如果未给出 doc，则使用 fget 的文档字符串。

在版本 2.6 中更改： 添加了 getter、setter 和 deleter 属性。

raw_input([prompt])

如果存在 prompt 参数，则将其写入标准输出，不带尾随换行符。然后，该函数从输入中读取一行，将其转换为字符串（剥离尾随换行符），并返回该字符串。当读取 EOF 时，将引发 EOFError。示例

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

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

reduce(function, iterable[, initializer])

将两个参数的 function 累积应用于 iterable 的项目，从左到右，以便将 iterable 减少为单个值。例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 计算 ((((1+2)+3)+4)+5)。左参数 x 是累积值，右参数 y 是来自 iterable 的更新值。如果存在可选的 initializer，则将其放置在 iterable 的项目之前进行计算，并在 iterable 为空时用作默认值。如果未给出 initializer 且 iterable 仅包含一个项目，则返回第一个项目。

reload(module)

重新加载先前导入的 module。该参数必须是模块对象，因此它必须已成功导入。如果您使用外部编辑器编辑了模块源文件，并且想要尝试新版本而不退出 Python 解释器，这将很有用。返回值是模块对象（与 module 参数相同）。

当执行 reload(module) 时

• Python 模块的代码将被重新编译，并且模块级代码将被重新执行，定义一组新的对象，这些对象绑定到模块字典中的名称。扩展模块的 init 函数不会第二次调用。
• 与 Python 中所有其他对象一样，旧对象只有在它们的引用计数降至零后才会被回收。
• 模块命名空间中的名称将更新为指向任何新的或更改的对象。
• 对旧对象的其它引用（例如模块外部的名称）不会重新绑定到指向新对象，如果需要，必须在它们出现的每个命名空间中进行更新。

还有一些其他的注意事项。

如果模块在语法上正确，但其初始化失败，则它的第一个 import 语句不会在本地绑定它的名称，但会将一个（部分初始化的）模块对象存储在 sys.modules 中。要重新加载模块，您必须首先再次 import 它（这将把名称绑定到部分初始化的模块对象），然后才能 reload() 它。

当模块被重新加载时，它的字典（包含模块的全局变量）将被保留。名称的重新定义将覆盖旧的定义，因此这通常不是问题。如果模块的新版本没有定义旧版本定义的名称，则旧定义将保留。如果模块维护一个全局表或对象缓存，则此功能可以用于模块的优势 - 使用 try 语句，它可以测试表的是否存在，并在需要时跳过其初始化。

try:
    cache
except NameError:
    cache = {}

重新加载内置模块或动态加载模块是合法的，但通常没有太大用处，除了 sys、__main__ 和 __builtin__。但是，在许多情况下，扩展模块并非设计为初始化多次，并且在重新加载时可能会以任意方式失败。

如果模块使用 from … import … 从另一个模块导入对象，则调用另一个模块的 reload() 不会重新定义从它导入的对象 - 解决此问题的一种方法是重新执行 from 语句，另一种方法是使用 import 和限定名称（*module*.*name*）。

如果模块实例化了类的实例，则重新加载定义类的模块不会影响实例的方法定义 - 它们将继续使用旧的类定义。派生类也是如此。

repr(object)

返回一个包含对象可打印表示形式的字符串。这与转换（反引号）产生的值相同。有时能够将此操作作为普通函数访问会很有用。对于许多类型，此函数尝试返回一个字符串，该字符串在传递给 eval() 时会产生具有相同值的 object，否则表示形式是一个包含在尖括号中的字符串，其中包含 object 类型的名称以及其他信息，通常包括 object 的名称和地址。类可以通过定义 __repr__() 方法来控制此函数为其实例返回的内容。

reversed(seq)

返回一个反转的 迭代器。seq 必须是一个具有 __reversed__() 方法或支持序列协议（__len__() 方法和 __getitem__() 方法，其整数参数从 0 开始）的对象。

版本 2.4 中新增。

版本 2.6 中的变更: 添加了编写自定义 __reversed__() 方法的可能性。

round(x[, n])

返回浮点数 x 四舍五入到小数点后 n 位的值。如果省略 n，则默认为零。结果是一个浮点数。值四舍五入到最接近的 10 的负 n 次方倍数；如果两个倍数同样接近，则四舍五入远离 0（例如，round(0.5) 是 1.0，而 round(-0.5) 是 -1.0）。

setattr(object, name, value)

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

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

返回一个 切片 对象，表示由 range(start, stop, step) 指定的索引集。start 和 step 参数默认为 None。切片对象具有只读数据属性 start、stop 和 step，它们只返回参数值（或其默认值）。它们没有其他显式功能；但是它们被 Numerical Python 和其他第三方扩展使用。当使用扩展索引语法时，也会生成切片对象。例如：a[start:stop:step] 或 a[start:stop, i]。有关返回迭代器的备用版本的详细信息，请参阅 itertools.islice()。

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

从 iterable 中的项目返回一个新的排序列表。

可选参数 cmp、key 和 reverse 与 list.sort() 方法的含义相同（在 可变序列类型 部分中描述）。

cmp 指定一个自定义比较函数，它有两个参数（可迭代元素），应该根据第一个参数是否被认为小于、等于或大于第二个参数返回一个负数、零或正数：cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值为 None。

key 指定一个参数为一个的函数，用于从每个列表元素中提取比较键：key=str.lower。默认值为 None。

reverse 是一个布尔值。如果设置为 True，则列表元素将按反转比较的方式排序。

通常，key 和 reverse 转换过程比指定等效的 cmp 函数快得多。这是因为 cmp 对每个列表元素调用多次，而 key 和 reverse 只触碰每个元素一次。要将旧式 cmp 函数转换为 key 函数，请参阅 ASPN 食谱中的 CmpToKey 食谱。

版本 2.4 中新增。

staticmethod(function)

返回 function 的静态方法。

静态方法不会接收隐式第一个参数。要声明静态方法，请使用以下习惯用法

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

@staticmethod 形式是一个函数 装饰器 - 有关详细信息，请参阅 函数定义 中的函数定义描述。

它可以在类上调用（例如 C.f()）或在实例上调用（例如 C().f()）。除了它的类之外，实例会被忽略。

Python 中的静态方法类似于 Java 或 C++ 中的静态方法。有关更高级的概念，请参阅本节中的 classmethod()。

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

在版本 2.2 中新增。

版本 2.4 中的更改: 添加了函数装饰器语法。

sum(iterable[, start])

从左到右将 start 和 iterable 的项目相加，并返回总计。start 默认为 0。iterable 的项目通常是数字，不允许是字符串。连接字符串序列的快速正确方法是调用 ''.join(sequence)。请注意，sum(range(n), m) 等效于 reduce(operator.add, range(n), m) 要以扩展精度添加浮点值，请参阅 math.fsum()。

版本 2.3 中新增。

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

返回一个代理对象，该对象将方法调用委托给 type 的父类或同级类。这对于访问在类中被覆盖的继承方法很有用。搜索顺序与 getattr() 使用的顺序相同，只是 type 本身被跳过。

type 的 __mro__ 属性列出了 getattr() 和 super() 使用的方法解析搜索顺序。该属性是动态的，并且可以在每次更新继承层次结构时更改。

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

注意

super() 仅适用于 新式类。

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

第二个用例是在动态执行环境中支持协作多重继承。此用例是 Python 独有的，在静态编译语言或仅支持单一继承的语言中找不到。这使得实现“菱形图”成为可能，其中多个基类实现相同的方法。良好的设计要求此方法在每种情况下都具有相同的调用签名（因为调用的顺序是在运行时确定的，因为该顺序适应类层次结构的变化，并且因为该顺序可能包括在运行时之前未知的兄弟类）。

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

class C(B):
    def method(self, arg):
        super(C, self).method(arg)

请注意，super() 是作为显式点分属性查找（如 super().__getitem__(name)）的绑定过程的一部分实现的。它通过为以可预测顺序搜索类（支持协作多重继承）实现自己的 __getattribute__() 方法来实现这一点。因此，super() 对使用语句或运算符（如 super()[name]）的隐式查找未定义。

还要注意，super() 不限于在方法内部使用。两个参数形式精确地指定了参数，并进行了适当的引用。

在版本 2.2 中新增。

type(object)

返回object的类型。返回值是一个类型对象。建议使用 isinstance() 内置函数来测试对象的类型。

使用三个参数，type() 充当构造函数，如下所述。

vars([object])

没有参数，返回一个与当前局部符号表相对应的字典。如果参数是模块、类或类实例对象（或任何其他具有 __dict__ 属性的对象），则返回一个与对象符号表相对应的字典。

警告

返回的字典不应修改：对相应符号表的影响是未定义的。

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

此函数与 range() 非常相似，但返回一个“xrange 对象”而不是列表。这是一种不透明的序列类型，它生成与相应列表相同的值，而无需实际同时存储所有这些值。xrange() 相对于 range() 的优势很小（因为 xrange() 仍然需要在被要求时创建值），除非在内存不足的机器上使用非常大的范围，或者从未使用范围的所有元素（例如，当循环通常使用 break 终止时）。

注意

xrange() 旨在简单快捷。实现可能会施加限制以实现这一点。Python 的 C 实现将所有参数限制为本机 C 长整数（“短”Python 整数），并且还要求元素数量适合本机 C 长整数。如果需要更大的范围，可以使用 itertools 模块制作一个替代版本：islice(count(start, step), (stop-start+step-1)//step)。

zip([iterable, ...])

此函数返回一个元组列表，其中第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。返回的列表长度被截断为最短参数序列的长度。当有多个参数都具有相同的长度时，zip() 类似于 map()，其初始参数为 None。对于单个序列参数，它返回一个 1 元组列表。对于没有参数，它返回一个空列表。

可迭代对象的从左到右评估顺序是保证的。这使得可以使用 zip(*[iter(s)]*n) 将数据序列聚类为 n 长度组成为可能。

zip() 与 * 运算符结合使用可以解压缩列表

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> zipped
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zipped)
>>> x == x2, y == y2
True

版本 2.0 中新增。

在版本 2.4 中更改: 以前，zip() 至少需要一个参数，并且 zip() 会引发 TypeError 而不是返回一个空列表。

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

注意

这是一个高级函数，在日常 Python 编程中不需要。

此函数由 import 语句调用。它可以被替换（通过导入 builtins 模块并赋值给 builtins.__import__）以更改 import 语句的语义，但如今通常使用导入钩子更简单（参见 PEP 302）。直接使用 __import__() 很少见，除非在您想要导入其名称仅在运行时才知道的模块的情况下。

该函数导入模块 name，可能使用给定的 globals 和 locals 来确定如何在包上下文中解释该名称。fromlist 给出了应从 name 指定的模块导入的对象或子模块的名称。标准实现根本不使用其 locals 参数，并且仅使用其 globals 来确定 import 语句的包上下文。

level 指定是使用绝对导入还是相对导入。默认值为 -1，表示将尝试绝对导入和相对导入。 0 表示仅执行绝对导入。level 的正值表示相对于调用 __import__() 的模块的目录，要搜索的父目录数量。

当 name 变量的形式为 package.module 时，通常返回顶层包（第一个点之前的名称），而不是 name 指定的模块。但是，当给出非空的 fromlist 参数时，将返回 name 指定的模块。

例如，语句 import spam 导致的字节码类似于以下代码

spam = __import__('spam', globals(), locals(), [], -1)

语句 import spam.ham 导致以下调用

spam = __import__('spam.ham', globals(), locals(), [], -1)

请注意，__import__() 在这里返回顶层模块，因为这是由 import 语句绑定到名称的对象。

另一方面，语句 from spam.ham import eggs, sausage as saus 会导致

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], -1)
eggs = _temp.eggs
saus = _temp.sausage

这里，spam.ham 模块是从 __import__() 返回的。从这个对象中，检索要导入的名称并将其分配给各自的名称。

如果您只想按名称导入模块（可能在包中），您可以从 sys.modules 获取它

>>> import sys
>>> name = 'foo.bar.baz'
>>> __import__(name)
<module 'foo' from ...>
>>> baz = sys.modules[name]
>>> baz
<module 'foo.bar.baz' from ...>

版本 2.5 中的变更: 添加了 level 参数。

版本 2.5 中的变更: 添加了参数的关键字支持。