2. Built-in Functions

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

Built-in Functions
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()和intern()。它们记录在不必要的内置Function部分中。

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

2.5 版的新Function。

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

2.5 版的新Function。

2.3 版的新Function。

2.6 版的新Function。

2.2.1 版中的新Function。

在版本 2.3 中更改：如果未提供任何参数，则此函数返回False。

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

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

2.6 版的新Function。

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

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

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

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

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

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

2.2 版中的新Function。

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

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

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

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

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

Note

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

Warning

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

在版本 2.3 中进行了更改：添加了* flags 和* dont_inherit *参数。

在 2.6 版中进行了更改：支持编译 AST 对象。

在 2.7 版中进行了更改：允许使用 Windows 和 Mac 换行符。同样，以'exec'模式 Importing 的内容不必再以换行符结尾。

Note

从字符串转换时，该字符串不得在中心+或-运算符周围包含空格。例如，complex('1+2j')可以，但是complex('1 + 2j')可以提高ValueError。

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

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

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

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

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

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

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

Note

因为提供dir()主要是为了方便在交互式提示符下使用，所以它提供的是一组有趣的名称，而不是提供一组严格或一致定义的名称，并且其详细行为可能会因版本而异。例如，当参数为类时，元类属性不在结果列表中。

在版本 2.3 中进行了更改：不建议将divmod()与复数一起使用。

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

2.3 版的新Function。

在 2.6 版中进行了更改：添加了* start *参数。

在版本 2.4 中进行了更改：以前需要* locals *作为字典。

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

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

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

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

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

在版本 2.4 中进行了更改：以前需要* locals *作为字典。

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

Note

默认的* locals 的行为如下面的函数locals()所述：不应try对默认的 locals 字典进行修改。如果您需要在函数execfile()返回后查看代码对 locals 的影响，请传递一个明确的 locals *字典。 execfile()无法可靠地用于修改函数的本地变量。

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

2.2 版中的新Function。

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

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

如果参数是字符串，则它必须包含一个可能带符号的十进制或浮点数，并可能嵌入在空格中。参数也可以是[|-] nan 或[|-] inf。否则，参数可以是纯整数或长整数或浮点数，并返回具有相同值(在 Python 的浮点精度内)的浮点数。如果未提供任何参数，则返回0.0。

Note

传入字符串时，可能会返回 NaN 和 Infinity 的值，具体取决于基础 C 库。 Float 接受 NaN 和正负无穷字符串 nan，inf 和-inf。忽略大小写和开头以及开头-对于 NaN 都会忽略。浮点数始终将 NaN 和无穷表示为 nan，inf 或-inf。

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

Note

format(value, format_spec)仅调用value.__format__(format_spec)。

2.6 版的新Function。

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

2.4 版的新Function。

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

2.2 版中的新Function。

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

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

另请参见int()，以使用 16 为底的十六进制字符串转换为整数。

Note

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

在版本 2.4 中更改：以前仅返回未签名的 Literals。

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

此Function不会捕获用户错误。如果 Importing 在语法上无效，则将引发SyntaxError。如果评估期间出现错误，可能会引发其他 exceptions。

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

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

如果* x 不是数字或给定 base ，则 x 必须是代表基数 base 中integer literal的字符串或 Unicode 对象。可选地，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/0或0x/0X作为前缀。底数 0 意味着将字符串完全解释为整数 Literals，因此实际底数是 2、8、10 或 16.

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

在版本 2.2 中进行了更改：添加了对类型信息 Tuples 的支持。

在版本 2.3 中进行了更改：添加了对类型信息 Tuples 的支持。

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

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

2.2 版中的新Function。

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

Note

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

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

如果提供了一个位置参数，则* iterable *必须是非空的可迭代(例如，非空的字符串，Tuples 或列表)。返回迭代器中最大的项目。如果提供了两个或多个位置参数，则返回最大的位置参数。

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

在版本 2.5 中进行了更改：添加了对可选* key *参数的支持。

如果提供了一个位置参数，则* iterable *必须是非空的可迭代(例如，非空的字符串，Tuples 或列表)。返回 iterable 中的最小项。如果提供了两个或多个位置参数，则返回最小的位置参数。

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

在版本 2.5 中进行了更改：添加了对可选* key *参数的支持。

2.6 版的新Function。

2.2 版中的新Function。

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

在版本 2.4 中更改：以前仅返回未签名的 Literals。

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

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

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

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

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

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

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

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

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

Note

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

from __future__ import print_function

2.6 版的新Function。

通常的用途是定义托管属性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()作为decorator轻松创建只读属性：

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

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

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

2.2 版中的新Function。

在版本 2.5 中进行了更改：如果未提供* doc ，请使用 fget *的 docstring。

在 2.6 版中进行了更改：添加了getter，setter和deleter属性。

>>> 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)
[]

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

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

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)时：

还有其他一些警告：

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

try:
    cache
except NameError:
    cache = {}

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

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

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

2.4 版的新Function。

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

Note

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

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

2.4 版的新Function。

可选参数* cmp ， key 和 reverse *与list.sort()方法(在可变序列类型部分中介绍)的含义相同。

通常，* key 和 reverse 转换过程比指定等效的 cmp 函数要快得多。这是因为 cmp 被每个列表元素多次调用，而 key 和 reverse 仅触摸每个元素一次。使用functools.cmp_to_key()将旧式 cmp 函数转换为 key *函数。

内置的sorted()Function保证稳定。如果排序保证不改变比较相等的元素的相对 Sequences，则该排序是稳定的-这有助于多次pass排序(例如，按部门排序，然后按薪级排序)。

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

2.4 版的新Function。

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

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

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

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

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

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

2.2 版中的新Function。

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

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

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

2.3 版的新Function。

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

Note

super()仅适用于new-style class。

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

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

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

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

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

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

2.2 版中的新Function。

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

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

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

2.2 版中的新Function。

2.0 版中的新Function。

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

如果未提供任何可选参数，则unicode()将模仿str()的行为，除了它返回 Unicode 字符串而不是 8 位字符串。更准确地说，如果* object *是 Unicode 字符串或子类，它将返回该 Unicode 字符串，而无需应用任何其他解码。

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

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

2.0 版中的新Function。

在版本 2.2 中更改：添加了对unicode()的支持。

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

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

CPython 实现细节： xrange()旨在简单快速。实现可能会施加限制以实现此目的。 Python 的 C 实现将所有参数限制为本机 C long(“短” Python 整数)，并且还要求元素数量适合本机 C long。如果需要更大的范围，可以使用itertools模块：islice(count(start, step), (stop-start+step-1+2*(step<0))//step)制作替代版本。

保证了可迭代对象的从左到右的评估 Sequences。这使使用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 版中的新Function。

在版本 2.4 中进行了更改：以前，zip()至少需要一个参数，而zip()提出了TypeError而不是返回空列表。

__import__(* name * [，* globals * [，* locals * [，* fromlist * [，* level *]]]])

Note

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

import语句调用此函数。可以替换它(pass导入builtin模块并分配给__builtin__.__import__)以更改import语句的语义，但是如今，使用导入钩子通常更简单(请参见 PEP 302)。很少使用import()，除非要导入仅在运行时知道其名称的模块。

该函数导入模块* name ，可能使用给定的 globals 和 locals *来确定如何在包上下文中解释该名称。 * fromlist 给出应从 name 给定的模块中导入的对象或子模块的名称。标准实现根本不使用其 locals 参数，而仅使用其 globals *来确定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()返回的。从该对象中，检索要导入的名称并将其分配给它们各自的名称。

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

在版本 2.5 中更改：添加了 level 参数。

在版本 2.5 中进行了更改：添加了对参数的关键字支持。

3.不必要的内置函数

在现代 Python 编程中，不再需要学习，了解或使用一些内置函数。将它们保留在此处以保持与为旧版本 Python 编写的程序向后兼容。

Python 程序员，培训师，学生和图书作者应随时绕过这些Function，而不必担心会丢失重要的内容。

从 2.3 版开始不推荐使用：使用function(*args, **keywords)而不是apply(function, args, keywords)(请参见解包参数列表)。

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

Footnotes

首页