内置函数 — Python 文档

内置函数

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

内置函数
A abs() aiter() all() any() anext() ascii() B bin() bool() breakpoint() bytearray() bytes() C callable() chr() classmethod() compile() complex() D delattr() dict() dir() divmod()	E enumerate() eval() exec() F filter() float() format() frozenset() G getattr() globals() H hasattr() hash() help() hex() I id() input() int() isinstance() issubclass() iter()	L len() list() locals() M map() max() memoryview() min() N next() O object() oct() open() ord() P pow() print() property()	R range() repr() reversed() round() S set() setattr() slice() sorted() staticmethod() str() sum() super() T tuple() type() V vars() Z zip() _ __import__()

abs(x)

返回数字的绝对值。 参数可以是整数、浮点数或实现 __abs__() 的对象。 如果参数是复数，则返回其大小。

aiter(async_iterable)

为 异步迭代器 返回一个 异步迭代器 。 相当于调用 x.__aiter__()。

aiter(x)本身有一个__aiter__()方法返回x，所以aiter(aiter(x))和aiter(x)是一样的。

注意：与 iter() 不同，aiter() 没有 2 参数变体。

3.10 版中的新功能。

all(iterable)

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

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

any(iterable)

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

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

ascii(object)

作为 repr()，返回包含对象的可打印表示的字符串，但使用 \x 转义 repr() 返回的字符串中的非 ASCII 字符、\u 或 \U 转义。 这会生成一个类似于 Python 2 中 repr() 返回的字符串。

bin(x)

将整数转换为以“0b”为前缀的二进制字符串。 结果是一个有效的 Python 表达式。 如果 x 不是 Python int 对象，它必须定义一个返回整数的 __index__() 方法。 一些例子：

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

如果需要或不需要前缀“0b”，您可以使用以下任一方式。

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

另见 format() 了解更多信息。

class bool([x])

返回一个布尔值，即 True 或 False 之一。 x 使用标准的 真值测试程序 进行转换。 如果 x 为假或省略，则返回 False； 否则，返回 True。 bool 类是 int 的子类（参见 Numeric Types - int, float, complex）。 它不能被进一步子类化。 它的唯一实例是 False 和 True（请参阅 布尔值 ）。

在 3.7 版更改：x 现在是仅位置参数。

breakpoint(*args, **kws)

此函数将您带入调用站点的调试器。 具体来说，它调用 sys.breakpointhook()，直接传递 args 和 kws。 默认情况下，sys.breakpointhook() 调用 pdb.set_trace() 不需要参数。 在这种情况下，它纯粹是一个方便的函数，因此您不必显式导入 pdb 或输入尽可能多的代码来进入调试器。 但是，sys.breakpointhook() 可以设置为其他一些函数，而 breakpoint() 会自动调用它，让您进入选择的调试器。

3.7 版中的新功能。

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

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

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

• 如果是 string，则还必须给出 encoding（以及可选的 errors）参数； bytearray() 然后使用 str.encode() 将字符串转换为字节。

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

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

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

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

另请参阅 二进制序列类型 — 字节、字节数组、内存视图 和 字节数组对象 。

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

返回一个新的“字节”对象，它是 0 <= x < 256 范围内的不可变整数序列。 bytes 是 bytearray 的不可变版本——它具有相同的非变异方法以及相同的索引和切片行为。

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

字节对象也可以用文字创建，请参阅 字符串和字节文字 。

另请参阅 二进制序列类型 — 字节、字节数组、内存视图、字节对象和字节和字节数组操作。

callable(object)

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

3.2 版新功能： 该函数首先在 Python 3.0 中被移除，然后在 Python 3.2 中恢复。

chr(i)

返回表示 Unicode 代码点为整数 i 的字符的字符串。 例如，chr(97) 返回字符串 'a'，而 chr(8364) 返回字符串 '€'。 这是 ord() 的倒数。

参数的有效范围是从 0 到 1,114,111（以 16 为底的 0x10FFFF）。 如果 i 超出该范围，则会引发 ValueError。

@classmethod

将方法转换为类方法。

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

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

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

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

类方法不同于 C++ 或 Java 静态方法。 如果您需要这些，请参阅本节中的 staticmethod()。 有关类方法的更多信息，请参阅 标准类型层次结构 。

3.9 版更改： 类方法现在可以包装其他 描述符 ，例如 property()。

3.10 版更改： 类方法现在继承方法属性（__module__、__name__、__qualname__、__doc__ 和 __annotations__) 并拥有新的 __wrapped__ 属性。

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 控制应激活哪些 编译器选项 以及应允许哪些 未来功能 。 如果两者都不存在（或两者都为零），则使用影响调用 compile() 的代码的相同标志编译代码。 如果给出了 flags 参数并且 dont_inherit 不是（或为零）那么编译器选项和由 flags 参数指定的未来语句将被额外使用那些无论如何都会使用的。 如果 dont_inherit 是一个非零整数，那么 flags 参数就是它——周围代码中的标志（未来功能和编译器选项）被忽略。

编译器选项和 future 语句由位指定，这些位可以按位或运算在一起以指定多个选项。 指定给定未来功能所需的位域可以在 __future__ 模块中的 _Feature 实例的 compiler_flag 属性中找到。 编译器标志可以在ast模块中找到，带有PyCF_前缀。

参数 optimize 指定编译器的优化级别； -1 的默认值选择解释器的优化级别，由 -O 选项给出。 显式级别为 0（无优化；__debug__ 为真）、1（断言被移除，__debug__ 为假）或 2 （文档字符串也被删除）。

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

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

笔记

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

警告

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

3.2 版更改： 允许使用 Windows 和 Mac 换行符。 此外，'exec' 模式下的输入不必再以换行符结尾。 添加了 optimize 参数。

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

3.8 版新功能：ast.PyCF_ALLOW_TOP_LEVEL_AWAIT 现在可以通过标志来支持顶级 await、async for 和 async with ]。

class complex([real[, imag]])

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

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

笔记

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

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

3.6 版更改： 允许将数字与代码文字中的下划线分组。

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 和 映射类型 — dict。

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

dir([object])

不带参数，返回当前本地范围内的名称列表。 使用参数，尝试返回该对象的有效属性列表。

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

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

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

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

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

• 否则，该列表包含对象的属性名称、其类的属性名称以及其类的基类的属性的递归名称。

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

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

笔记

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

enumerate(iterable, start=0)

返回一个枚举对象。 iterable 必须是一个序列、一个 iterator 或其他一些支持迭代的对象。 enumerate() 返回的迭代器的 __next__() 方法返回一个包含计数的元组（来自 start，默认为 0）和从迭代 iterable。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

相当于：

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

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

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

expression 参数使用 globals 和 locals 字典作为全局和局部命名空间作为 Python 表达式（从技术上讲，条件列表）进行解析和评估。 如果 globals 字典存在并且不包含键 __builtins__ 的值，则在该字典下插入对内置模块 builtins 字典的引用解析 表达式 之前的键。 这样，您可以通过将您自己的 __builtins__ 字典插入到 globals 中，然后将其传递给 eval() 来控制哪些内置函数可用于执行的代码。 如果省略 locals 字典，则默认为 globals 字典。 如果两个字典都被省略，则在调用 eval() 的环境中使用 globals 和 locals 执行表达式。 请注意， eval() 无权访问封闭环境中的 嵌套作用域 （非本地）。

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

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

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

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

如果给定的源是一个字符串，那么前导和尾随空格和制表符将被去除。

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

exec(object[, globals[, locals]])

该函数支持 Python 代码的动态执行。 object 必须是字符串或代码对象。 如果是字符串，则该字符串将被解析为一组 Python 语句，然后执行该语句（除非发生语法错误）。 1 如果是代码对象，则简单执行。 在所有情况下，执行的代码都应作为文件输入有效（请参阅参考手册中的 文件输入 部分）。 请注意，即使在传递给 exec 的代码上下文中，nonlocal、yield 和 return 语句也不能在函数定义之外使用() 函数。 返回值为None。

在所有情况下，如果省略可选部分，代码将在当前范围内执行。 如果只提供了 globals，它必须是一个字典（而不是字典的子类），它将用于全局和局部变量。 如果给出 globals 和 locals，它们分别用于全局和局部变量。 如果提供，locals 可以是任何映射对象。 请记住，在模块级别，全局变量和本地变量是同一个字典。 如果 exec 获得两个单独的对象，分别为 globals 和 locals，则代码将被执行，就像它嵌入在类定义中一样。

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

笔记

内置函数 globals() 和 locals() 分别返回当前的全局和局部字典，这对于传递用作第二个和第三个参数可能很有用exec()。

笔记

默认的 locals 的行为如下面的函数 locals() 所述：不应尝试修改默认的 locals 字典。 如果您需要在函数 exec() 返回后查看代码对 locals 的影响，请传递显式 locals 字典。

filter(function, iterable)

从 iterable 中 function 返回 true 的那些元素构造一个迭代器。 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.filterfalse() 以获取返回 iterable 元素的补充函数，其中 函数 返回 false。

class float([x])

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

如果参数是一个字符串，它应该包含一个十进制数，可选地前面有一个符号，并可选地嵌入空格中。 可选符号可以是'+'或'-'； '+' 符号对产生的值没有影响。 参数也可以是表示 NaN（非数字）或正无穷大或负无穷大的字符串。 更准确地说，删除前导和尾随空白字符后，输入必须符合以下语法：

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

这里 floatnumber 是 Python 浮点文字的形式，在 浮点文字 中进行了描述。 大小写不重要，因此，例如，“inf”、“Inf”、“INFINITY”和“iNfINity”都是正无穷大的可接受拼写。

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

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

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

例子：

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

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

3.6 版更改： 允许将数字与代码文字中的下划线分组。

在 3.7 版更改：x 现在是仅位置参数。

在 3.8 版更改：如果未定义 __float__()，则回退到 __index__()。

format(value[, format_spec])

将 值 转换为“格式化”表示，由 format_spec 控制。 format_spec 的解释将取决于 value 参数的类型； 但是，大多数内置类型都使用标准格式语法：格式规范迷你语言。

默认的 format_spec 是一个空字符串，通常与调用 str(value) 产生相同的效果。

对 format(value, format_spec) 的调用被转换为 type(value).__format__(value, format_spec)，它在搜索值的 __format__() 方法时绕过实例字典。 如果方法搜索到达 object 并且 format_spec 非空，或者 format_spec 或返回值不是字符串。

在 3.4 版更改：如果 format_spec 不是空字符串，则 object().__format__(format_spec) 引发 TypeError。

class frozenset([iterable])

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

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

getattr(object, name[, default])

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

笔记

由于 私有名称修改 发生在编译时，必须手动修改私有属性（带有两个前导下划线的属性）名称，以便使用 getattr() 检索它。

globals()

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

hasattr(object, name)

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

hash(object)

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

笔记

对于具有自定义 __hash__() 方法的对象，请注意 hash() 根据主机的位宽截断返回值。 有关详细信息，请参阅 __hash__()。

help([object])

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

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

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

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 为基数将十六进制字符串转换为整数。

笔记

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

id(object)

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

input([prompt])

如果存在 prompt 参数，则将其写入标准输出，而没有尾随换行符。 然后该函数从输入中读取一行，将其转换为字符串（去除尾随的换行符），然后返回该字符串。 读取 EOF 时，会引发 EOFError。 例子：

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

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

class 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-n 字面量由 0 到 n-1 的数字组成，其中 a 到 z（或 A 到 Z）的值为 10 到 35 . 默认 基数 为 10。 允许的值为 0 和 2–36。 Base-2、-8 和 -16 字面量可以选择性地以 0b/0B、0o/0O 或 0x 作为前缀]/0X，就像代码中的整数文字一样。 基数 0 表示准确解释为代码文字，因此实际基数为 2、8、10 或 16，因此 int('010', 0) 不合法，而 int('010') 也是如此如 int('010', 8)。

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

在 3.4 版更改： 如果 base 不是 int 的实例并且 base 对象有一个 base.__index__[ X138X] 方法，该方法被调用以获得基数的整数。 以前的版本使用 base.__int__ 而不是 base.__index__。

3.6 版更改： 允许将数字与代码文字中的下划线分组。

在 3.7 版更改：x 现在是仅位置参数。

在 3.8 版更改：如果未定义 __int__()，则回退到 __index__()。

isinstance(object, classinfo)

如果 object 参数是 classinfo 参数或其（直接、间接或 virtual）子类的实例，则返回 True . 如果 object 不是给定类型的对象，函数总是返回 False。 如果 classinfo 是类型对象的元组（或递归，其他此类元组）或多种类型的 联合类型，则返回 True 如果 object ] 是任何类型的实例。 如果 classinfo 不是类型或类型元组和此类元组，则会引发 TypeError 异常。

3.10 版更改： classinfo 可以是 联合类型 。

issubclass(class, classinfo)

如果 class 是 classinfo 的子类（直接、间接或 virtual），则返回 True。 一个类被认为是它自己的一个子类。 classinfo 可以是类对象的元组或 联合类型 ，在这种情况下，如果 class 是任何条目的子类，则返回 True 类信息。 在任何其他情况下，会引发 TypeError 异常。

3.10 版更改： classinfo 可以是 联合类型 。

iter(object[, sentinel])

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

另见 迭代器类型 。

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)

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

class list([iterable])

list 实际上是一个可变序列类型，而不是一个函数，如 Lists 和 序列类型 — 列表、元组、范围 中所述。

locals()

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

笔记

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

map(function, iterable, ...)

返回一个迭代器，将 function 应用于 iterable 的每一项，产生结果。 如果传递了额外的 iterable 参数，则 function 必须采用那么多参数并并行应用于所有可迭代项中的项目。 对于多个可迭代对象，当最短的可迭代对象耗尽时，迭代器将停止。 对于函数输入已经排列成参数元组的情况，请参阅 itertools.starmap()。

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

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

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

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

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

3.4 版新功能：default 仅关键字参数。

3.8版本变更：键可以是None。

class memoryview(object)

返回从给定参数创建的“内存视图”对象。 有关详细信息，请参阅 内存视图 。

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

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

如果提供了一个位置参数，它应该是一个 iterable。 返回迭代中的最小项。 如果提供了两个或更多位置参数，则返回位置参数中最小的一个。

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

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

3.4 版新功能：default 仅关键字参数。

3.8版本变更：键可以是None。

next(iterator[, default])

通过调用 __next__() 方法从 iterator 检索下一项。 如果给出 default，则在迭代器耗尽时返回，否则引发 StopIteration。

class object

返回一个新的无特征对象。 object 是所有类的基础。 它具有所有 Python 类实例通用的方法。 此函数不接受任何参数。

笔记

object 确实 not 有 __dict__，所以你不能将任意属性分配给 object 类的实例。

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对象。 如果无法打开文件，则会引发 OSError。 有关如何使用此功能的更多示例，请参阅 读取和写入文件 。

file 是一个 类似路径的对象 ，给出要打开的文件的路径名（绝对或相对于当前工作目录）或要包装的文件的整数文件描述符。 （如果给出了文件描述符，除非 closefd 设置为 False，否则它会在返回的 I/O 对象关闭时关闭。）

mode 是一个可选字符串，用于指定打开文件的模式。 默认为 'r'，表示以文本模式打开阅读。 其他常见的值是 'w' 用于写入（如果文件已经存在则截断文件），'x' 用于独占创建，以及 'a' 用于附加（在 some[X170X ] Unix 系统，意味着 all 写入追加到文件的末尾而不管当前的查找位置）。 在文本模式下，如果未指定 encoding，则使用的编码取决于平台：调用 locale.getpreferredencoding(False) 以获取当前区域设置编码。 （对于读取和写入原始字节，请使用二进制模式并保留 encoding 未指定。）可用模式有：

特点	意义
'r'	开放阅读（默认）
'w'	打开写入，先截断文件
'x'	打开独占创建，如果文件已经存在则失败
'a'	打开以进行写入，如果存在则附加到文件末尾
'b'	二进制模式
't'	文本模式（默认）
'+'	开放更新（读取和写入）

默认模式为'r'（打开阅读文本，'rt'的同义词）。 模式 'w+' 和 'w+b' 打开并截断文件。 模式 'r+' 和 'r+b' 不截断地打开文件。

正如 Overview 中提到的，Python 区分二进制和文本 I/O。 以二进制模式打开的文件（包括 mode 参数中的 'b'）返回内容为 bytes 对象，无需任何解码。 在文本模式下（默认情况下，或者当 't' 包含在 mode 参数中时），文件的内容作为 str 返回，字节已在使用依赖于平台的编码或使用指定的 encoding 解码（如果给定）。

允许使用额外的模式字符 'U'，它不再有任何效果，被视为已弃用。 它之前在文本模式下启用了 通用换行符 ，这成为 Python 3.0 中的默认行为。 有关详细信息，请参阅 newline 参数的文档。

笔记

Python 不依赖于底层操作系统的文本文件概念； 所有处理都由 Python 本身完成，因此与平台无关。

buffering 是一个可选整数，用于设置缓冲策略。 传递 0 以关闭缓冲（仅在二进制模式下允许），1 以选择行缓冲（仅在文本模式下可用），以及一个大于 1 的整数以指示固定大小块缓冲区的大小（以字节为单位）。 当没有给出 buffering 参数时，默认缓冲策略的工作方式如下：

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

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

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

errors 是一个可选字符串，指定如何处理编码和解码错误——这不能在二进制模式下使用。 有多种标准错误处理程序可用（在 错误处理程序 下列出），但已使用 codecs.register_error() 注册的任何错误处理名称也是有效的。 标准名称包括：

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

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

• 'replace' 导致替换标记（例如 '?'）被插入到格式错误的数据中。

• 'surrogateescape' 将任何不正确的字节表示为从 U+DC80 到 U+DCFF 的低代理代码单元。 当写入数据时使用 surrogateescape 错误处理程序时，这些代理代码单元将被转换回相同的字节。 这对于处理未知编码的文件很有用。

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

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

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

newline 控制 universal newlines 模式如何工作（它只适用于文本模式）。 它可以是 None、、'\n'、'\r' 和 '\r\n'。 它的工作原理如下：

• 从流中读取输入时，如果 newline 为 None，则启用通用换行符模式。 输入中的行可以以 '\n'、'\r' 或 '\r\n' 结尾，这些在返回给调用者之前会被转换为 '\n'。 如果是 ，则启用通用换行符模式，但行尾未翻译返回给调用者。 如果它具有任何其他合法值，则输入行仅由给定的字符串终止，并且行尾未翻译地返回给调用者。

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

如果 closefd 是 False 并且给出了文件描述符而不是文件名，则在文件关闭时底层文件描述符将保持打开状态。 如果给定文件名 closefd 必须是 True（默认值）； 否则会报错。

可以通过将可调用对象作为 opener 传递来使用自定义开启器。 然后通过使用 (file, flags) 调用 opener 来获取文件对象的底层文件描述符。 opener 必须返回一个打开的文件描述符（将 os.open 作为 opener 传递会产生类似于传递 None 的功能）。

新创建的文件是不可继承的。

以下示例使用 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()函数返回的文件对象的类型取决于模式。 当使用 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。

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

在 3.3 版中更改：

• 添加了 opener 参数。

• 添加了 'x' 模式。

• IOError 曾经被提出，现在是 OSError 的别名。

• FileExistsError 如果以独占创建模式打开的文件 ('x') 已经存在，则会引发。

在 3.4 版中更改：

• 该文件现在是不可继承的。

在 3.5 版中更改：

• 如果系统调用被中断并且信号处理程序没有引发异常，该函数现在重试系统调用而不是引发 InterruptedError 异常（参见 PEP 475 ] 的理由）。

• 添加了 'namereplace' 错误处理程序。

在 3.6 版中更改：

• 添加支持以接受实现 os.PathLike 的对象。

• 在 Windows 上，打开控制台缓冲区可能会返回 io.RawIOBase 的子类，而不是 io.FileIO。

ord(c)

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

pow(base, exp[, mod])

将base返回给exp的幂； 如果存在 mod，则返回 base 的幂 exp，取模 mod（比 pow(base, exp) % mod 计算效率更高） . 双参数形式 pow(base, exp) 相当于使用幂运算符：base**exp。

参数必须具有数字类型。 对于混合操作数类型，二元算术运算符的强制规则适用。 对于 int 操作数，除非第二个参数为负，否则结果与操作数具有相同的类型（强制转换后）； 在这种情况下，所有参数都转换为浮点数，并提供浮点数结果。 例如，pow(10, 2) 返回 100，而 pow(10, -2) 返回 0.01。 对于类型为 int 或 float 的负底数和非整数指数，将提供复数结果。 例如，pow(-9, 0.5) 返回一个接近于 3j 的值。

对于 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(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

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

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

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

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

3.3 版更改： 添加 flush 关键字参数。

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

返回一个属性属性。

fget 是获取属性值的函数。 fset是用于设置属性值的函数。 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() 作为 装饰器 轻松创建只读属性：

class Parrot:
    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:
    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。

3.5 版更改： 属性对象的文档字符串现在是可写的。

class range(stop)

class range(start, stop[, step])

range 实际上是一个不可变的序列类型，而不是一个函数，如 Ranges 和 Sequence Types — 列表、元组、范围 中所述。

repr(object)

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

reversed(seq)

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

round(number[, ndigits])

返回 number 小数点后四舍五入到 ndigits 精度。 如果 ndigits 被省略或者是 None，它返回与其输入最接近的整数。

对于支持 [X34X]round() 的内置类型，值四舍五入到最接近的 10 的幂减去 ndigits 的倍数； 如果两个倍数相等，则向偶数选择舍入（例如，round(0.5) 和 round(-0.5) 都是 0，而 round(1.5) 是2）。 任何整数值都对 ndigits 有效（正、零或负）。 如果省略 ndigits 或 None，则返回值为整数。 否则，返回值的类型与 number 相同。

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

笔记

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

class set([iterable])

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

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

setattr(object, name, value)

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

笔记

由于 私有名称修改 发生在编译时，必须手动修改私有属性（带有两个前导下划线的属性）名称，以便使用 setattr() 对其进行设置。

class slice(stop)

class slice(start, stop[, step])

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

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

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

有两个可选参数，必须指定为关键字参数。

key 指定一个参数的函数，用于从 iterable 中的每个元素中提取比较键（例如，key=str.lower）。 默认值为 None（直接比较元素）。

reverse 是一个布尔值。 如果设置为 True，则列表元素的排序就像每次比较都颠倒了一样。

使用 functools.cmp_to_key() 将旧式 cmp 函数转换为 key 函数。

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

排序算法仅使用项目之间的 < 比较。 虽然定义 __lt__() 方法就足以进行排序，但 PEP 8 建议实现所有六个 丰富的比较。 这将有助于避免在将相同数据与其他排序工具（例如 max() 依赖于不同的底层方法）一起使用时出现错误。 实现所有六个比较还有助于避免混合类型比较的混淆，这些比较可以调用反射 __gt__() 方法。

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

@staticmethod

将方法转换为静态方法。

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

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

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

可以在类（例如 C.f()）或实例（例如 C().f()）上调用静态方法。 此外，它们可以作为常规函数调用（例如 f()）。

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

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

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

3.10 版更改： 静态方法现在继承方法属性（__module__、__name__、__qualname__、__doc__ 和 __annotations__)，有一个新的 __wrapped__ 属性，现在可以作为常规函数调用。

class str(object=)
class str(object=b, encoding='utf-8', errors='strict')

返回 object 的 str 版本。 有关详细信息，请参阅 str()。

str 是内置字符串 class。 有关字符串的一般信息，请参阅 文本序列类型 — str。

sum(iterable, /, start=0)

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

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

3.8 版更改： start 参数可以指定为关键字参数。

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

返回一个代理对象，该对象将方法调用委托给 类型 的父类或兄弟类。 这对于访问在类中被覆盖的继承方法很有用。

object-or-type决定了要搜索的方法解析顺序。 搜索从 type 之后的类开始。

例如，如果 object-or-type 的 __mro__ 是 D -> B -> C -> A -> object 并且 type 的值是 B，那么super() 搜索 C -> A -> object。

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

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

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

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

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

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

除了方法查找，super() 也适用于属性查找。 一个可能的用例是在父类或兄弟类中调用 描述符 。

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

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

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

class tuple([iterable])

tuple 实际上是一个不可变的序列类型，而不是一个函数，如 Tuples 和 Sequence Types — list, tuple, range 中所述。

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

使用一个参数，返回 对象 的类型。 返回值是一个类型对象，通常与 object.__class__ 返回的对象相同。

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

使用三个参数，返回一个新的类型对象。 这本质上是 class 语句的动态形式。 name 字符串是类名并成为 __name__ 属性。 bases 元组包含基类并成为 __bases__ 属性； 如果为空，则添加所有类的最终基类 object。 dict 字典包含类主体的属性和方法定义； 它可以在成为 __dict__ 属性之前被复制或包装。 以下两个语句创建相同的 type 对象：

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

另见 类型对象 。

提供给三个参数形式的关键字参数以与类定义中的关键字（除了 metaclass）相同的方式传递给适当的元类机制（通常是 __init_subclass__()）。

另见自定义类创建。

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

vars([object])

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

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

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

如果指定了对象但它没有 __dict__ 属性（例如，如果其类定义了 __slots__ 属性），则会引发 TypeError 异常。

zip(*iterables, strict=False)

并行迭代多个可迭代对象，从每个可迭代对象中生成一个元素的元组。

例子：

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

更正式地：zip() 返回一个元组迭代器，其中第 i 元组包含来自每个参数可迭代对象的第 i 元素。

考虑 zip() 的另一种方式是将行转换为列，将列转换为行。 这类似于转置矩阵。

zip() 是惰性的：在迭代迭代之前不会处理元素，例如 通过 for 循环或包装在 列表 中。

需要考虑的一件事是传递给 zip() 的可迭代对象可能有不同的长度； 有时是设计使然，有时是因为准备这些迭代的代码中的错误。 Python 提供了三种不同的方法来处理这个问题：

• 默认情况下，zip() 在最短迭代用完时停止。 它将忽略较长迭代中的剩余项目，将结果截断为最短迭代的长度：

  >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
  [(0, 'fee'), (1, 'fi'), (2, 'fo')]

• zip() 通常用于假设可迭代对象长度相等的情况。 在这种情况下，建议使用 strict=True 选项。 它的输出与常规 zip() 相同：

  >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
  [('a', 1), ('b', 2), ('c', 3)]

  与默认行为不同，它检查迭代的长度是否相同，如果它们不相同，则引发 ValueError：

  >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True))
  Traceback (most recent call last):
    ...
  ValueError: zip() argument 2 is longer than argument 1

  如果没有 strict=True 参数，任何导致不同长度迭代的错误都将被消除，可能在程序的其他部分表现为难以发现的错误。

• 较短的可迭代对象可以填充一个常量值，以使所有可迭代对象具有相同的长度。 这是由 itertools.zip_longest() 完成的。

边缘情况：使用单个可迭代参数，zip() 返回一个 1 元组的迭代器。 没有参数，它返回一个空的迭代器。

技巧和窍门：

• 可迭代对象的从左到右的评估顺序是有保证的。 这使得使用 zip(*[iter(s)]*n, strict=True) 将数据系列聚类为 n 长度组的习语成为可能。 这将重复 same 迭代器 n 次，以便每个输出元组具有对迭代器的 n 调用的结果。 这具有将输入分成 n 个长度的块的效果。

• zip() 结合 * 操作符可用于解压缩列表：

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

3.10 版更改： 添加 strict 参数。

__import__(name, globals=None, locals=None, fromlist=(), level=0)

笔记

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

该函数由 import 语句调用。 可以替换它（通过导入 builtins 模块并分配给 builtins.__import__）以更改 import 语句的语义，但这样做是 强烈[ X175X] 不鼓励，因为使用导入钩子通常更简单（参见 PEP 302）来实现相同的目标并且不会导致代码问题，假设默认导入实现正在使用中. 直接使用 __import__() 也不鼓励直接使用 importlib.import_module()。

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

level 指定是使用绝对导入还是相对导入。 0（默认）表示只执行绝对导入。 level 的正值表示相对于调用 __import__() 模块的目录要搜索的父目录的数量（参见 PEP 328 ] 了解详情）。

当 name 变量的形式为 package.module 时，通常返回顶层包（直到第一个点的名称），而不是 名为的模块通过 名称 。 但是，当给出一个非空的 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 版更改： 不再支持 级别 的负值（这也将默认值更改为 0）。

3.9 版本更改： 当命令行选项 -E 或 -I 被使用时，环境变量 PYTHONCASEOK 现在被忽略。

脚注

1

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