2. 内置函数

Python 解释器内置了许多始终可用的函数。它们在此处按字母顺序列出。

		内置函数
`abs()`	`divmod()`	`input()`	`open()`	`staticmethod()`
`all()`	`enumerate()`	`int()`	`ord()`	`str()`
`any()`	`eval()`	`isinstance()`	`pow()`	`sum()`
`basestring()`	`execfile()`	`issubclass()`	`print()`	`super()`
`bin()`	`file()`	`iter()`	`property()`	`tuple()`
`bool()`	`filter()`	`len()`	`range()`	`type()`
`bytearray()`	`float()`	`list()`	`raw_input()`	`unichr()`
`callable()`	`format()`	`locals()`	`reduce()`	`unicode()`
`chr()`	`frozenset()`	`long()`	`reload()`	`vars()`
`classmethod()`	`getattr()`	`map()`	`repr()`	`xrange()`
`cmp()`	`globals()`	`max()`	`reversed()`	`zip()`
`compile()`	`hasattr()`	`memoryview()`	`round()`	`__import__()`
`complex()`	`hash()`	`min()`	`set()`
`delattr()`	`help()`	`next()`	`setattr()`
`dict()`	`hex()`	`object()`	`slice()`
`dir()`	`id()`	`oct()`	`sorted()`

此外，还有其他四个不再被认为必不可少的内置函数：apply()、buffer()、coerce()和[ X154X]实习生（）。它们记录在非必要内置函数部分。

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

all(iterable)

如果 iterable 的所有元素都为真（或者如果 iterable 为空），则返回 True。相当于：

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

2.5 版中的新功能。

any(iterable)

如果 iterable 的任何元素为真，则返回 True。如果可迭代对象为空，则返回 False。相当于：

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 版中的新功能。

class bool([x]): 返回一个布尔值，即 True 或 False 之一。 x 使用标准真值测试程序进行转换。如果 x 为 false 或省略，则返回 False；否则返回 True。 bool也是一个类，是int的子类。类 bool 不能被进一步子类化。它唯一的实例是 False 和 True。

2.2.1 版中的新功能。

2.3 版本变更：如果没有给出参数，该函数返回 False。

class bytearray([source[, encoding[, errors]]])

返回一个新的字节数组。这字节数组 class 是 0 <= x < 256 范围内的可变整数序列。它具有可变序列的大多数常用方法，在可变序列类型中描述，以及 str 类型具有的大多数方法，请参阅字符串方法。

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

如果是unicode，还必须给出encoding（可选，errors）参数； bytearray() 然后使用 unicode.encode() 将 unicode 转换为字节。
如果它是整数，则数组将具有该大小，并将使用空字节进行初始化。
如果是符合buffer接口的对象，则使用该对象的只读缓冲区来初始化bytes数组。
如果是 iterable，则必须是 0 <= x < 256 范围内的整数的可迭代对象，用作数组的初始内容。

如果没有参数，则会创建一个大小为 0 的数组。

2.6 版中的新功能。

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

chr(i): 返回 ASCII 码为整数 i 的一个字符的字符串。例如，chr(97) 返回字符串 'a'。这是 ord() 的倒数。参数必须在 [0..255] 范围内，包括；如果 i 超出该范围，则 ValueError 将升高。另见 unichr()。

classmethod(function)

返回函数的类方法。

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

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

@classmethod 形式是一个函数 decorator——详见函数定义。

可以在类（例如 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 可以是 Unicode 字符串、Latin-1 编码字符串或 AST 对象。有关如何使用 AST 对象的信息，请参阅 ast 模块文档。

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

mode 参数指定必须编译什么样的代码；如果 source 由一系列语句组成，则可以是 'exec'，如果由单个表达式组成，则可以是 'eval'，如果由一个表达式组成，则可以是 'single'单个交互式语句（在后一种情况下，将打印计算结果为 None 以外的值的表达式语句）。

可选参数 flags 和 dont_inherit 控制哪些未来语句（参见 PEP 236）影响 source 的编译. 如果两者都不存在（或两者都为零），则使用调用 compile() 的代码中有效的未来语句编译代码。如果给出了 flags 参数并且 dont_inherit 不是（或为零），那么除了那些会无论如何都要使用。如果 dont_inherit 是一个非零整数，那么 flags 参数就是它 - 编译调用周围有效的未来语句将被忽略。

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

如果编译源无效，则该函数会引发 SyntaxError，如果源包含空字节，则会引发 TypeError。

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

笔记

在'single'或'eval'模式下编译多行代码字符串时，输入必须至少以一个换行符结束。这是为了方便检测code模块中不完整和完整的语句。

警告

由于 Python 的 AST 编译器中的堆栈深度限制，在编译为 AST 对象时，可能会因足够大/复杂的字符串而导致 Python 解释器崩溃。

2.3 版更改：添加了标志和 dont_inherit 参数。

2.6 版更改：支持编译 AST 对象。

2.7 版更改：允许使用 Windows 和 Mac 换行符。在 'exec' 模式下输入也不必再以换行符结尾。

class complex([real[, imag]])

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

笔记

从字符串转换时，字符串不能在中央 + 或 - 运算符周围包含空格。例如，complex('1+2j') 很好，但 complex('1 + 2j') 提高了 ValueError。

复杂类型在数字类型 — int、float、long、complex 中进行了描述。

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__', '__doc__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module
['Struct', '__builtins__', '__doc__', '__file__', '__name__',
 '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape(object):
        def __dir__(self):
            return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'perimeter', 'location']

笔记

因为 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 必须是一个序列、一个 iterator 或其他一些支持迭代的对象。 enumerate() 返回的迭代器的 next() 方法返回一个元组，其中包含一个计数（来自 start，默认为 0）和通过迭代获得的值 [ X191X]序列：

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

2.3 版中的新功能。

2.6 版更改：添加了 start 参数。

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

参数是 Unicode 或 Latin-1 编码的字符串和可选的全局变量和局部变量。如果提供， globals 必须是字典。如果提供，locals 可以是任何映射对象。

在 2.4 版更改：以前的 locals 必须是字典。

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

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

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

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

请参阅 ast.literal_eval() 以获取可以安全地使用仅包含文字的表达式计算字符串的函数。

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

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

参数是一个文件名和两个可选的字典。该文件使用 globals 和 locals 字典作为全局和本地命名空间作为一系列 Python 语句（类似于模块）进行解析和评估。如果提供，locals 可以是任何映射对象。请记住，在模块级别，全局变量和本地变量是同一个字典。如果两个单独的对象作为 globals 和 locals 传递，代码将被执行，就像它嵌入在类定义中一样。

在 2.4 版更改：以前的 locals 必须是字典。

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

笔记

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

file(name[, mode[, buffering]])

file 类型的构造函数，在 File Objects 部分进一步描述。构造函数的参数与下面描述的 open() 内置函数的参数相同。

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

2.2 版中的新功能。

filter(function, iterable)

从 iterable 中 function 返回 true 的那些元素构造一个列表。 iterable 可以是一个序列，一个支持迭代的容器，或者一个迭代器。如果 iterable 是字符串或元组，则结果也具有该类型；否则它总是一个列表。如果function为None，则假定恒等函数，即iterable中所有为false的元素都被移除。

请注意，如果函数不是 None 和 [item for item in iterable if item]，如果函数是 None，则 filter(function, iterable) 相当于 [item for item in iterable if function(item)]。

有关此函数的迭代器版本，请参阅 itertools.ifilter() 和 itertools.ifilterfalse()，包括一个变体，用于过滤函数返回 false 的元素。

class float([x])

返回由数字或字符串 x 构造的浮点数。

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

笔记

传入字符串时，可能会返回 NaN 和 Infinity 的值，具体取决于底层 C 库。 Float 接受字符串 nan、inf 和 -inf 表示 NaN 和正无穷大或负无穷大。对于 NaN，大小写和前导 + 会被忽略，前导 - 也会被忽略。 Float 始终将 NaN 和无穷大表示为 nan、inf 或 -inf。

float 类型在 Numeric Types — int, float, long, complex 中有描述。

format(value[, format_spec]): 将值转换为“格式化”表示，由 format_spec 控制。 format_spec 的解释将取决于 value 参数的类型，但是大多数内置类型使用标准格式语法： Format Specification Mini-语言。

笔记

format(value, format_spec) 只是调用 value.__format__(format_spec)。

2.6 版中的新功能。

class frozenset([iterable])

返回一个新的 frozenset 对象，可以选择使用取自 iterable 的元素。 frozenset 是一个内置类。有关此类的文档，请参阅 frozenset 和 Set Types — set、frozenset。

对于其他容器，请参阅内置的 set、list、tuple 和 dict 类，以及集合[ X136X] 模块。

2.4 版中的新功能。

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

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

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

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

help([object])

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

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

2.2 版中的新功能。

hex(x)

将整数（任意大小）转换为以“0x”为前缀的小写十六进制字符串，例如：

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'

如果 x 不是 Python int 或 long 对象，它必须定义一个返回字符串的 __hex__() 方法。

另请参阅 int() 以使用以 16 为基数将十六进制字符串转换为整数。

笔记

要获取浮点数的十六进制字符串表示形式，请使用 float.hex() 方法。

2.4 版更改：以前只返回无符号文字。

id(object): 返回对象的“身份”。这是一个整数（或长整数），保证在此对象的生命周期内是唯一且恒定的。生命周期不重叠的两个对象可能具有相同的 id() 值。

input([prompt])

相当于 eval(raw_input(prompt))。

此函数不会捕获用户错误。如果输入在语法上无效，则会引发 SyntaxError。如果评估期间出现错误，则可能会引发其他异常。

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

考虑将 raw_input() 函数用于用户的一般输入。

class int(x=0) class int(x, base=10)

返回由数字或字符串 x 构造的整数对象，如果没有给出参数，则返回 0。如果 x 是一个数字，它可以是一个普通整数、一个长整数或一个浮点数。如果 x 是浮点数，则转换向零截断。如果参数在整数范围之外，则该函数返回一个长对象。

如果 x 不是数字或者如果给出了 base，则 x 必须是一个字符串或 Unicode 对象，表示中的整数文字基数基数。或者，文字可以在 + 或 - 之前（中间没有空格）并用空格包围。 base-n 字面量由 0 到 n-1 的数字组成，其中 a 到 z（或 A 到 Z）的值为 10 到 35 . 默认基数为 10。允许的值为 0 和 2–36。 Base-2、-8 和 -16 字面量可以选择性地以 0b/0B、0o/0O/0 为前缀，或 0x/0X，就像代码中的整数文字一样。基数 0 表示将字符串准确地解释为整数文字，因此实际基数是 2、8、10 或 16。

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

isinstance(object, classinfo): 如果 object 参数是 classinfo 参数或其（直接、间接或 virtual）子类的实例，则返回 true。如果 classinfo 是类型对象（新样式类）并且 object 是该类型的对象或（直接、间接或 virtual），则也返回 true ) 的子类。如果 object 不是给定类型的类实例或对象，则该函数始终返回 false。如果 classinfo 是类或类型对象（或递归地，其他此类元组）的元组，如果 object 是任何类或类型的实例，则返回 true。如果 classinfo 不是类、类型或类、类型和此类元组的元组，则会引发 TypeError 异常。

2.2 版更改：添加了对类型信息元组的支持。

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

2.3 版更改：添加了对类型信息元组的支持。

iter(o[, sentinel])

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

iter() 第二种形式的一个有用应用是读取文件的行，直到到达某一行。以下示例读取文件，直到 readline() 方法返回空字符串：

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

2.2 版中的新功能。

len(s): 返回对象的长度（项目数）。参数可以是序列（例如字符串、字节、元组、列表或范围）或集合（例如字典、集合或冻结集合）。

class list([iterable])

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

list 是可变序列类型，如序列类型 — str、unicode、列表、元组、字节数组、缓冲区、xrange 中所述。对于其他容器，请参阅内置的 dict、set 和 tuple 类，以及 collections 模块。

locals(): 更新并返回代表当前本地符号表的字典。自由变量在功能块中调用时由 locals() 返回，但不在类块中调用。

笔记

本词典内容不得修改；更改可能不会影响解释器使用的局部变量和自由变量的值。

class long(x=0) class long(x, base=10)

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

long 类型在 Numeric Types — int, float, long, complex 中有描述。

map(function, iterable, ...): 将 function 应用于 iterable 的每一项并返回结果列表。如果传递了额外的 iterable 参数，则 function 必须采用那么多参数并并行应用于所有可迭代项中的项目。如果一个迭代器比另一个更短，则假定用 None 项进行扩展。如果function为None，则假定恒等函数；如果有多个参数，map() 返回一个由元组组成的列表，其中包含来自所有可迭代对象的相应项（一种转置操作）。 iterable 参数可以是一个序列或任何可迭代对象；结果总是一个列表。

max(iterable[, key]) max(arg1, arg2, *args[, key])

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

如果提供了一个位置参数，则 iterable 必须是非空可迭代对象（例如非空字符串、元组或列表）。返回迭代中最大的项目。如果提供了两个或更多位置参数，则返回最大的位置参数。

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

在 2.5 版更改：添加了对可选 key 参数的支持。

memoryview(obj): 返回从给定参数创建的“内存视图”对象。有关更多信息，请参阅内存视图类型。

min(iterable[, key]) min(arg1, arg2, *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 版中的新功能。

class object: 返回一个新的无特征对象。 object 是所有新样式类的基础。它具有新样式类的所有实例通用的方法。

2.2 版中的新功能。

2.3 版更改：此函数不接受任何参数。以前，它接受参数但忽略它们。

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

2.4 版更改：以前只返回无符号文字。

open(name[, mode[, buffering]])

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

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

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

可选的 buffering 参数指定文件所需的缓冲区大小：0 表示未缓冲，1 表示行缓冲，任何其他正值表示使用（大约）该大小（以字节为单位）的缓冲区。负数 buffering 表示使用系统默认值，通常为 tty 设备行缓冲，为其他文件完全缓冲。如果省略，则使用系统默认值。 2

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

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

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

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

2.5 版更改：引入了对模式字符串首字母的限制。

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

pow(x, y[, z])

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

参数必须具有数字类型。对于混合操作数类型，二元算术运算符的强制规则适用。对于 int 和 long int 操作数，除非第二个参数为负，否则结果与操作数具有相同的类型（强制转换后）；在这种情况下，所有参数都转换为浮点数，并提供浮点数结果。例如，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(*objects, sep=' ', end='\\n', file=sys.stdout)

将 objects 打印到流 file，由 sep 分隔，后跟 end。 sep、end 和 file（如果存在）必须作为关键字参数给出。

所有非关键字参数都转换为像 str() 这样的字符串并写入流，由 sep 分隔，后跟 end。 sep 和 end 都必须是字符串；它们也可以是 None，即使用默认值。如果没有给出 objects，print() 只会写出 end。

file 参数必须是具有 write(string) 方法的对象；如果它不存在或 None，将使用 sys.stdout。输出缓冲由 file 决定。例如，使用 file.flush() 确保立即出现在屏幕上。

笔记

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

from __future__ import print_function

2.6 版中的新功能。

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

返回 new-style classes（派生自 object 的类）的属性属性。

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

一个典型的用途是定义一个托管属性 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.")

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

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

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

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

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

属性对象具有 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 属性。

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

这是一个多功能函数，用于创建包含等差数列的列表。它最常用于 for 循环中。参数必须是普通整数。如果省略 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)
[]

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，则在计算中将其放置在可迭代项的前面，并在可迭代项为空时作为默认值。如果未给出 initializer 且 iterable 仅包含一项，则返回第一项。大致相当于：

def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        try:
            initializer = next(it)
        except StopIteration:
            raise TypeError('reduce() of empty sequence with no initial value')
    accum_value = initializer
    for x in it:
        accum_value = function(accum_value, x)
    return accum_value

reload(module)

重新加载之前导入的模块。参数必须是一个模块对象，所以它之前必须成功导入。如果您使用外部编辑器编辑了模块源文件并希望在不离开 Python 解释器的情况下试用新版本，这将非常有用。返回值是模块对象（与 module 参数相同）。

当执行 reload(module) 时：

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

还有一些其他注意事项：

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

try:
    cache
except NameError:
    cache = {}

重新加载内置或动态加载的模块通常不是很有用。不建议重载sys、__main__、builtins等关键模块。在许多情况下，扩展模块不会被设计为多次初始化，并且在重新加载时可能会以任意方式失败。

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

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

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

reversed(seq): 返回一个反向迭代器。 seq 必须是具有 __reversed__() 方法或支持序列协议的对象（__len__() 方法和 __getitem__() 方法，整数参数从 [ X176X]）。

2.4 版中的新功能。

在 2.6 版更改：添加了编写自定义 __reversed__() 方法的可能性。

round(number[, ndigits]): 返回小数点后四舍五入为 ndigits 位的浮点值 number。如果省略 ndigits，则默认为零。结果是一个浮点数。值四舍五入到最接近的 10 的乘方减去 ndigits 的倍数；如果两个倍数相等，则舍入远离 0（例如，round(0.5) 为 1.0，round(-0.5) 为 -1.0）。

笔记

round() 对于浮点数的行为可能令人惊讶：例如，round(2.675, 2) 给出 2.67 而不是预期的 2.68。这不是错误：这是大多数十进制分数不能完全表示为浮点数的结果。有关详细信息，请参阅浮点运算：问题和限制。

class set([iterable])

返回一个新的 set 对象，可以选择使用取自 iterable 的元素。 set 是一个内置类。有关此类的文档，请参阅 set 和 Set Types — set、frozenset。

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

2.4 版中的新功能。

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

class slice(stop)

class slice(start, stop[, step])

返回一个 slice 对象，表示由 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 只接触每个元素一次。使用 functools.cmp_to_key() 将旧式 cmp 函数转换为 key 函数。

内置的 sorted() 函数保证稳定。如果排序保证不改变比较相等的元素的相对顺序，则它是稳定的——这有助于多次排序（例如，按部门排序，然后按工资等级排序）。

有关排序示例和简短的排序教程，请参阅 Sorting HOW TO。

2.4 版中的新功能。

staticmethod(function)

返回函数的静态方法。

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

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

@staticmethod 形式是一个函数 decorator——详见函数定义。

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

Python 中的静态方法类似于 Java 或 C++ 中的静态方法。另请参阅 classmethod() 以获取可用于创建备用类构造函数的变体。

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

2.2 版中的新功能。

2.4 版更改：添加了函数装饰器语法。

class str(object=)

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

有关字符串的更多信息，请参阅序列类型 — str、unicode、列表、元组、字节数组、缓冲区、描述序列功能的 xrange，以及中描述的特定于字符串的方法]字符串方法部分。要输出格式化字符串，请使用模板字符串或字符串格式化操作部分中描述的 % 运算符。此外，请参阅 String Services 部分。另见 unicode()。

sum(iterable[, start])

从左到右求和 start 和 iterable 的项目并返回总数。 start 默认为 0。 iterable 的项通常是数字，起始值不允许是字符串。

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

2.3 版中的新功能。

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

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

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

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

笔记

super() 仅适用于新式类 es。

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() 不限于使用内部方法。两个参数形式准确地指定参数并进行适当的引用。

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

2.2 版中的新功能。

tuple([iterable])

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

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

class type(object) class type(name, bases, dict)

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

使用三个参数，返回一个新的类型对象。这本质上是 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 码为整数 i 的一个字符的 Unicode 字符串。例如，unichr(97) 返回字符串 u'a'。对于 Unicode 字符串，这是 ord() 的反函数。参数的有效范围取决于 Python 的配置方式——它可能是 UCS2 [0..0xFFFF] 或 UCS4 [0..0x10FFFF]。 ValueError 否则升高。对于 ASCII 和 8 位字符串，请参阅 chr()。

2.0 版中的新功能。

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

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

如果给出 encoding 和/或 errors，则 unicode() 将使用 的编解码器解码对象，该对象可以是 8 位字符串或字符缓冲区]编码。 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、列表、元组、字节数组、缓冲区、描述序列功能（Unicode 字符串是序列）的 xrange，以及在字符串方法部分。要输出格式化字符串，请使用模板字符串或字符串格式化操作部分中描述的 % 运算符。此外，请参阅 String Services 部分。另见 str()。

2.0 版中的新功能。

2.2 版更改：添加了对 __unicode__() 的支持。

vars([object])

返回具有 __dict__ 属性的模块、类、实例或任何其他对象的 __dict__ 属性。

模块和实例等对象具有可更新的 __dict__ 属性；但是，其他对象可能对其 __dict__ 属性有写限制（例如，新式类使用 dictproxy 来防止直接更新字典）。

在没有参数的情况下，vars() 的行为类似于 locals()。注意，locals 字典仅对读取有用，因为对 locals 字典的更新被忽略。

xrange(stop)

xrange(start, stop[, step])

此函数与 range() 非常相似，但返回一个 xrange 对象而不是列表。这是一个不透明的序列类型，它产生与相应列表相同的值，实际上并没有同时存储它们。 xrange() 相对于 range() 的优势是最小的（因为 xrange() 仍然需要在被要求时创建值），除非非常大范围用于内存不足的机器或当所有范围的元素从未使用过时（例如当循环通常以 break 终止时）。有关 xrange 对象的更多信息，请参阅 XRange 类型和序列类型 — str、unicode、列表、元组、字节数组、缓冲区、xrange。

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 == list(x2) and y == list(y2)
True

2.0 版中的新功能。

在 2.4 版更改：以前， zip() 需要至少一个参数，而 zip() 引发了 TypeError 而不是返回一个空列表。

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

笔记

与 importlib.import_module() 不同，这是日常 Python 编程中不需要的高级函数。

该函数由 import 语句调用。它可以被替换（通过导入 __builtin__ 模块并分配给 __builtin__.__import__）以更改 import 语句的语义，但现在它通常更易于使用导入挂钩（参见 PEP 302）。直接使用 __import__() 很少见，除非您想导入名称仅在运行时已知的模块。

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

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

当 name 变量的形式为 package.module 时，通常返回顶层包（直到第一个点的名称），而不是 名为的模块通过名称。但是，当给出一个非空的 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__() 返回的。从该对象中，检索要导入的名称并分配给它们各自的名称。

如果您只想按名称导入模块（可能在包内），请使用 importlib.import_module()。

2.5 版更改：增加了等级参数。

2.5 版更改：增加了对参数的关键字支持。

3. 非必要的内置函数

在现代 Python 编程中，有几个内置函数不再是学习、了解或使用所必需的。它们被保留在这里是为了保持与为旧版本 Python 编写的程序的向后兼容性。

Python 程序员、培训师、学生和书籍作者应该可以随意绕过这些函数，而不必担心会遗漏一些重要的东西。

apply(function, args[, keywords]): function 参数必须是可调用对象（用户定义或内置函数或方法，或类对象），而 args 参数必须是序列。函数以args作为参数列表被调用；参数的数量是元组的长度。如果存在可选的 keywords 参数，则它必须是一个键为字符串的字典。它指定要添加到参数列表末尾的关键字参数。调用 apply() 与只调用 function(args) 不同，因为在这种情况下总是只有一个参数。 apply()的使用等价于function(*args, **keywords)。

自 2.3 版起已弃用：使用 function(*args, **keywords) 而不是 apply(function, args, keywords)（请参阅解包参数列表）。

buffer(object[, offset[, size]]): object 参数必须是支持缓冲区调用接口的对象（如字符串、数组和缓冲区）。将创建一个引用 object 参数的新缓冲区对象。缓冲区对象将是从 object 开头（或从指定的 offset）开始的切片。切片将延伸到 object 的末尾（或具有由 size 参数指定的长度）。

coerce(x, y): 使用与算术运算相同的规则，返回由转换为公共类型的两个数字参数组成的元组。如果强制无法实现，则提高 TypeError。

intern(string): 在“interned”字符串表中输入string并返回interned字符串——它是string本身或副本。实习字符串对于在字典查找中获得一点性能很有用 - 如果字典中的键是实习的，并且查找键是实习的，则键比较（散列后）可以通过指针比较而不是字符串比较来完成。通常，Python 程序中使用的名称会自动插入，用于保存模块、类或实例属性的字典具有插入键。

2.3 版更改：实习字符串不是不朽的（就像它们曾经在 Python 2.2 及之前的版本中一样）；您必须保留对 intern() 的返回值的引用才能从中受益。

脚注

1: 它的使用相对较少，因此不保证被制成声明。
2: 当前指定缓冲区大小对没有 setvbuf() 的系统没有影响。指定缓冲区大小的接口不是使用调用 setvbuf() 的方法完成的，因为在执行任何 I/O 后调用时可能会转储核心，并且没有可靠的方法来确定是否是这种情况.
3: 在当前的实现中，局部变量绑定通常不会受到这种影响，但从其他范围（例如模块）检索的变量可能会受到影响。这可能会改变。

2. 内置函数 — Python 文档

2. 内置函数

3. 非必要的内置函数