内置函数¶
Python 解释器内置了许多始终可用的函数和类型。它们按字母顺序在此处列出。
内置函数 |
|||
|---|---|---|---|
- aiter(async_iterable)¶
返回 异步可迭代对象 的 异步迭代器。相当于调用
x.__aiter__()。注意：与
iter()不同，aiter()没有双参数变体。3.10 版新增。
- all(iterable)¶
如果 *iterable* 的所有元素都为真（或者如果 iterable 为空），则返回
True。相当于def all(iterable): for element in iterable: if not element: return False return True
- 可等待 anext(async_iterator)¶
- 可等待 anext(async_iterator, default)
等待时，返回给定 异步迭代器 的下一个项目，如果给出 *default* 并且迭代器已耗尽，则返回 *default*。
这是内置函数
next()的异步变体，行为类似。这将调用 *async_iterator* 的
__anext__()方法，返回一个 可等待对象。等待它会返回迭代器的下一个值。如果给出了 *default*，则在迭代器耗尽时返回它，否则将引发StopAsyncIteration。3.10 版新增。
- any(iterable)¶
如果 *iterable* 的任何元素为真，则返回
True。如果 iterable 为空，则返回False。相当于def any(iterable): for element in iterable: if element: return True return False
- ascii(object)¶
与
repr()一样，返回一个包含对象的可打印表示形式的字符串，但使用\x、\u或\U转义符对repr()返回的字符串中的非 ASCII 字符进行转义。这将生成一个类似于 Python 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()。
- 类 bool(object=False, /)¶
返回一个布尔值，即
True或False之一。参数使用标准的 真值测试程序 进行转换。如果参数为假或省略，则返回False；否则返回True。bool类是int的子类（请参阅 数字类型 — int、float、complex）。它不能被进一步子类化。它的唯一实例是False和True（请参阅 布尔类型 - bool）。版本 3.7 中的变化： 该参数现在仅限位置。
- breakpoint(*args, **kws)¶
此函数会在调用站点处将您放入调试器。具体来说，它会调用
sys.breakpointhook()，并将args和kws直接传递过去。默认情况下，sys.breakpointhook()会调用pdb.set_trace()，并且不期望任何参数。在这种情况下，它纯粹是一个方便函数，因此您不必显式导入pdb或键入太多代码来进入调试器。但是，可以将sys.breakpointhook()设置为其他函数，并且breakpoint()将自动调用该函数，从而允许您进入所选的调试器。如果无法访问sys.breakpointhook()，则此函数将引发RuntimeError。默认情况下，可以使用
PYTHONBREAKPOINT环境变量更改breakpoint()的行为。有关使用详情，请参阅sys.breakpointhook()。请注意，如果已替换
sys.breakpointhook()，则不保证会发生这种情况。引发带有参数
breakpointhook的 审计事件builtins.breakpoint。版本 3.7 中的新功能。
- class bytearray(source=b'')
- class bytearray(source, encoding)
- class bytearray(source, encoding, errors)
返回一个新的字节数组。
bytearray类是一个可变序列，其中包含范围为 0 <= x < 256 的整数。它具有 可变序列类型 中描述的大多数常用方法，以及bytes类型的大多数方法，请参阅 字节和字节数组操作。可选的 source 参数可用于以几种不同的方式初始化数组
如果它是 string，则还必须提供 encoding（以及可选的 errors）参数；
bytearray()然后使用str.encode()将字符串转换为字节。如果它是 integer，则数组将具有该大小，并将使用空字节进行初始化。
如果它是一个符合 缓冲区接口 的对象，则将使用该对象的只读缓冲区来初始化字节数组。
如果它是 iterable，则它必须是范围为
0 <= x < 256的整数的迭代器，这些整数将用作数组的初始内容。
如果没有参数，则会创建一个大小为 0 的数组。
- class bytes(source=b'')
- class bytes(source, encoding)
- class bytes(source, encoding, errors)
返回一个新的“字节”对象，该对象是一个不可变序列，其中包含范围为
0 <= x < 256的整数。bytes是bytearray的不可变版本 – 它具有相同的非变异方法以及相同的索引和切片行为。因此，构造函数参数的解释与
bytearray()相同。字节对象也可以使用字面量创建，请参阅 字符串和字节字面量。
- callable(object)¶
如果 object 参数看起来是可调用的，则返回
True，否则返回False。如果返回True，则调用仍然可能失败，但如果返回False，则调用 object 将永远不会成功。请注意，类是可调用的（调用类会返回一个新实例）；如果实例的类具有__call__()方法，则该实例是可调用的。版本 3.2 中的新功能： 此函数首先在 Python 3.0 中被移除，然后在 Python 3.2 中被带回。
- chr(i)¶
返回表示 Unicode 代码点为整数 *i* 的字符的字符串。例如，
chr(97)返回字符串'a'，而chr(8364)返回字符串'€'。这是ord()的逆操作。参数的有效范围是从 0 到 1,114,111（十六进制为 0x10FFFF）。如果 *i* 超出该范围，将引发
ValueError。
- @classmethod¶
将方法转换为类方法。
类方法接收类作为隐式第一个参数，就像实例方法接收实例一样。要声明类方法，请使用以下习惯用法
class C: @classmethod def f(cls, arg1, arg2): ...
@classmethod形式是一个函数 装饰器 - 有关详细信息，请参阅 函数定义。可以在类（例如
C.f()）或实例（例如C().f()）上调用类方法。除了类的实例外，实例将被忽略。如果为派生类调用类方法，则派生类对象将作为隐含的第一个参数传递。类方法不同于 C++ 或 Java 静态方法。如果您需要这些，请参阅本节中的
staticmethod()。有关类方法的更多信息，请参阅 标准类型层次结构。在 3.9 版更改: 类方法现在可以包装其他 描述符，例如
property()。在 3.10 版更改: 类方法现在继承方法属性（
__module__、__name__、__qualname__、__doc__和__annotations__）并具有新的__wrapped__属性。在 3.11 版更改: 类方法不能再包装其他 描述符，例如
property()。
- 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__模块中的_Feature实例上找到指定给定未来特性所需的位字段，作为compiler_flag属性。编译器标志 可以在ast模块中找到，前缀为PyCF_。参数 *optimize* 指定编译器的优化级别；默认值
-1选择-O选项给出的解释器的优化级别。显式级别为0（无优化；__debug__为真）、1（断言被删除，__debug__为假）或2（文档字符串也被删除）。如果编译的源代码无效，此函数将引发
SyntaxError，如果源代码包含空字节，则引发ValueError。如果要将 Python 代码解析为其 AST 表示，请参阅
ast.parse()。引发带有参数
source和filename的 审计事件compile。隐式编译也可能引发此事件。注意
在
'single'或'eval'模式下编译包含多行代码的字符串时，输入必须至少以一个换行符结尾。这是为了方便在code模块中检测不完整和完整的语句。警告
由于 Python 的 AST 编译器中的堆栈深度限制，在编译为 AST 对象时，使用足够大/复杂的字符串可能会导致 Python 解释器崩溃。
版本 3.2 中的变化： 允许使用 Windows 和 Mac 换行符。此外，
'exec'模式下的输入不再需要以换行符结尾。添加了 optimize 参数。版本 3.5 中的变化： 以前，当在 source 中遇到空字节时会引发
TypeError。版本 3.8 中的新功能： 现在可以在标志中传递
ast.PyCF_ALLOW_TOP_LEVEL_AWAIT以启用对顶级await、async for和async with的支持。
- class complex(number=0, /)¶
- class complex(string, /)
- class complex(real=0, imag=0)
将单个字符串或数字转换为复数，或从实部和虚部创建复数。
例子
>>> complex('+1.23') (1.23+0j) >>> complex('-4.5j') -4.5j >>> complex('-1.23+4.5j') (-1.23+4.5j) >>> complex('\t( -1.23+4.5J )\n') (-1.23+4.5j) >>> complex('-Infinity+NaNj') (-inf+nanj) >>> complex(1.23) (1.23+0j) >>> complex(imag=-4.5) -4.5j >>> complex(-1.23, 4.5) (-1.23+4.5j)
如果参数是字符串，则它必须包含实部（格式与
float()相同）或虚部（格式相同，但带有'j'或'J'后缀），或者同时包含实部和虚部（在这种情况下，虚部的符号是必需的）。字符串可以选择性地用空格和圆括号'('和')'包围，它们将被忽略。字符串在'+'、'-'、'j'或'J'后缀和十进制数之间不能包含空格。例如，complex('1+2j')可以，但complex('1 + 2j')会引发ValueError。更准确地说，在删除括号以及前导和尾随空格字符后，输入必须符合以下语法中的complexvalue生成规则complexvalue ::=
floatvalue|floatvalue("j" | "J") |floatvaluesignabsfloatvalue("j" | "J")如果参数是一个数字，则构造函数的作用类似于
int和float的数字转换。对于一般的 Python 对象x，complex(x)委托给x.__complex__()。如果未定义__complex__()，则它会回退到__float__()。如果未定义__float__()，则它会回退到__index__()。如果提供了两个参数或使用了关键字参数，则每个参数可以是任何数字类型（包括复数）。如果两个参数都是实数，则返回一个实部为 real、虚部为 imag 的复数。如果两个参数都是复数，则返回一个实部为
real.real-imag.imag、虚部为real.imag+imag.real的复数。如果其中一个参数是实数，则在上述表达式中仅使用其实部。如果省略所有参数，则返回
0j。复数类型在 数字类型 - 整数、浮点数、复数 中进行了描述。
版本 3.6 中的变化： 允许像在代码字量中那样使用下划线对数字进行分组。
版本 3.8 中的变化： 如果未定义
__complex__()和__float__()，则回退到__index__()。
- delattr(object, name)¶
这是
setattr()的一个相关函数。参数是一个对象和一个字符串。该字符串必须是对象属性之一的名称。该函数删除指定的属性，前提是对象允许这样做。例如，delattr(x, 'foobar')等效于del x.foobar。name 不必是 Python 标识符（请参阅setattr()）。
- class dict(**kwarg)
- class dict(mapping, **kwarg)
- class dict(iterable, **kwarg)
创建一个新的字典。
dict对象是字典类。有关此类的文档，请参阅dict和 映射类型 - dict。有关其他容器，请参阅内置的
list、set和tuple类，以及collections模块。
- dir()¶
- 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* 必须是一个序列、一个 迭代器 或其他支持迭代的对象。由
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(iterable, start=0): n = start for elem in iterable: yield n, elem n += 1
- eval(expression, globals=None, locals=None)¶
- 参数：
- 返回值：
计算出的表达式的结果。
- 引发：
语法错误将作为异常报告。
使用 *globals* 和 *locals* 字典作为全局和本地命名空间，将 *expression* 参数解析为 Python 表达式（从技术上讲，是一个条件列表）并对其进行计算。如果 *globals* 字典存在并且不包含键
__builtins__的值，则在解析 *expression* 之前，将在该键下插入对内置模块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。也可能会引发代码编译事件。
- exec(object, globals=None, locals=None, /, *, closure=None)¶
此函数支持动态执行 Python 代码。object 必须是字符串或代码对象。如果它是一个字符串，则该字符串将被解析为一组 Python 语句，然后执行这些语句（除非发生语法错误）。[1] 如果它是一个代码对象，则直接执行它。在所有情况下，执行的代码都应视为有效的文件输入（请参阅参考手册中的“文件输入”部分）。请注意，即使在传递给
exec()函数的代码上下文中，nonlocal、yield和return语句也不能在函数定义之外使用。返回值为None。在所有情况下，如果省略可选部分，则代码将在当前作用域中执行。如果仅提供 globals，则它必须是一个字典（而不是字典的子类），它将同时用于全局变量和局部变量。如果同时提供了 globals 和 locals，则它们分别用于全局变量和局部变量。如果提供，locals 可以是任何映射对象。请记住，在模块级别，globals 和 locals 是同一个字典。
注意
大多数用户应该只传递 globals 参数，而不要传递 locals。如果 exec 获取两个独立的对象作为 globals 和 locals，则代码的执行方式就好像它嵌入在类定义中一样。
如果 globals 字典不包含键
__builtins__的值，则会在该键下插入对内置模块builtins字典的引用。这样，您就可以通过在将自己的__builtins__字典插入 globals 后再将其传递给exec()来控制可供执行的代码使用的内置函数。closure 参数指定一个闭包——一个 cellvars 元组。它仅在 object 是包含自由变量的代码对象时有效。元组的长度必须与代码对象引用的自由变量的数量完全匹配。
使用代码对象作为参数引发 审计事件
exec。也可能会引发代码编译事件。注意
默认的 locals 的行为方式如下所述，用于函数
locals()：不应尝试修改默认的 locals 字典。如果您需要在函数exec()返回后查看代码对 locals 的影响，请传递一个显式的 locals 字典。在 3.11 版更改: 添加了 closure 参数。
- filter(function, iterable)¶
从 iterable 中 function 为真的元素构造一个迭代器。iterable 可以是序列、支持迭代的容器或迭代器。如果 function 是
None，则假定为恒等函数，也就是说，将删除 iterable 中所有为假的元素。请注意，如果 function 不是
None，则filter(function, iterable)等效于生成器表达式(item for item in iterable if function(item))；如果 function 是None，则等效于(item for item in iterable if item)。有关返回 iterable 中 function 为假的元素的补充函数，请参阅
itertools.filterfalse()。
- class float(number=0.0, /)¶
- class float(string, /)
返回从数字或字符串构造的浮点数。
例子
>>> float('+1.23') 1.23 >>> float(' -12345\n') -12345.0 >>> float('1e-003') 0.001 >>> float('+1E6') 1000000.0 >>> float('-Infinity') -inf
如果参数是字符串，它应该包含一个十进制数，可以选择在其前面加上符号，并可以选择嵌入空格中。可选符号可以是
'+'或'-'；'+'符号对生成的值没有影响。参数也可以是表示 NaN（非数字）、正无穷或负无穷的字符串。更准确地说，在删除前导和尾随空格字符后，输入必须符合以下语法中的floatvalue生成规则sign ::= "+" | "-" infinity ::= "Infinity" | "inf" nan ::= "nan" digit ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd> digitpart ::=
digit(["_"]digit)* number ::= [digitpart] "."digitpart|digitpart["."] exponent ::= ("e" | "E") [sign]digitpartfloatnumber ::=number[exponent] absfloatvalue ::=floatnumber|infinity|nanfloatvalue ::= [sign]absfloatvalue大小写不敏感，因此，例如，“inf”、“Inf”、“INFINITY”和“iNfINity”都是可接受的正无穷拼写。
否则，如果参数是整数或浮点数，则返回具有相同值（在 Python 的浮点数精度内）的浮点数。如果参数超出 Python 浮点数的范围，则会引发
OverflowError。对于一般的 Python 对象
x，float(x)委托给x.__float__()。如果未定义__float__()，则它会回退到__index__()。如果没有给出参数，则返回
0.0。浮点类型在 数值类型 - 整数、浮点数、复数 中进行了描述。
版本 3.6 中的变化： 允许像在代码字量中那样使用下划线对数字进行分组。
版本 3.7 中的变化： 该参数现在仅限位置。
在 3.8 版更改: 如果未定义
__float__()，则回退到__index__()。
- format(value, format_spec='')¶
将 value 转换为“格式化”表示形式，由 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 或返回值不是字符串，则会引发TypeError异常。在 3.4 版更改: 如果 format_spec 不是空字符串，则
object().__format__(format_spec)会引发TypeError。
- class frozenset(iterable=set())
返回一个新的
frozenset对象，可以选择从 iterable 中获取元素。frozenset是一个内置类。有关此类的文档，请参阅frozenset和 集合类型 - set、frozenset。有关其他容器，请参阅内置的
set、list、tuple和dict类，以及collections模块。
- getattr(object, name)¶
- getattr(object, name, default)
返回 object 的命名属性的值。name 必须是字符串。如果字符串是对象属性之一的名称，则结果是该属性的值。例如，
getattr(x, 'foobar')等效于x.foobar。如果命名属性不存在，则返回 default（如果提供），否则引发AttributeError。name 不必是 Python 标识符（请参阅setattr()）。
- globals()¶
返回实现当前模块命名空间的字典。对于函数内的代码，这是在定义函数时设置的，并且无论在何处调用函数都保持不变。
- hasattr(object, name)¶
参数是一个对象和一个字符串。如果字符串是对象属性之一的名称，则结果为
True，否则为False。（这是通过调用getattr(object, name)并查看它是否引发AttributeError来实现的。）
- hash(object)¶
返回对象的哈希值（如果它有的话）。哈希值是整数。它们用于在字典查找期间快速比较字典键。比较相等的数值具有相同的哈希值（即使它们的类型不同，例如 1 和 1.0）。
注意
对于具有自定义
__hash__()方法的对象，请注意hash()会根据主机机器的位宽截断返回值。
- help()¶
- help(request)
调用内置帮助系统。（此函数旨在用于交互式使用。）如果没有给出参数，则交互式帮助系统将在解释器控制台上启动。如果参数是一个字符串，则该字符串将被作为模块、函数、类、方法、关键字或文档主题的名称进行查找，并在控制台上打印帮助页面。如果参数是任何其他类型的对象，则会生成该对象的帮助页面。
请注意，如果在调用
help()时，函数的参数列表中出现斜杠 (/)，则表示斜杠之前的参数是仅限位置参数。有关更多信息，请参阅 关于仅限位置参数的常见问题解答条目。此函数由
site模块添加到内置命名空间中。
- 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()值。**CPython 实现细节：**这是对象在内存中的地址。
使用参数
id引发 审计事件builtins.id。
- input()¶
- input(prompt)
如果存在 *prompt* 参数，则将其写入标准输出，不带尾随换行符。然后，该函数从输入中读取一行，将其转换为字符串（去除尾随换行符），并返回该字符串。当读取到 EOF 时，将引发
EOFError。例子>>> s = input('--> ') --> Monty Python's Flying Circus >>> s "Monty Python's Flying Circus"
如果加载了
readline模块，则input()将使用它来提供精细的行编辑和历史记录功能。在读取输入之前，使用参数
prompt引发 审计事件builtins.input在成功读取输入后，使用结果引发 审计事件
builtins.input/result。
- class int(number=0, /)¶
- class int(string, /, base=10)
返回从数字或字符串构造的整数对象，如果未给出参数，则返回
0。例子
>>> int(123.45) 123 >>> int('123') 123 >>> int(' -12_345\n') -12345 >>> int('FACE', 16) 64206 >>> int('0xface', 0) 64206 >>> int('01110011', base=2) 115
如果参数定义了
__int__()，则int(x)返回x.__int__()。如果参数定义了__index__()，则返回x.__index__()。如果参数定义了__trunc__()，则返回x.__trunc__()。对于浮点数，这将向零截断。如果参数不是数字，或者给出了 *base*，则它必须是表示基数为 *base* 的整数的字符串、
bytes或bytearray实例。字符串可以选择以+或-开头（中间没有空格），可以有前导零，可以由空格包围，并且可以在数字之间穿插单个下划线。基数为 n 的整数字符串包含数字，每个数字表示 0 到 n-1 之间的值。值 0-9 可以由任何 Unicode 十进制数字表示。值 10-35 可以由
a到z（或A到Z）表示。默认的 *base* 为 10。允许的基数为 0 和 2-36。基数为 2、-8 和 -16 的字符串可以选择以0b/0B、0o/0O或0x/0X为前缀，就像代码中的整数文字一样。对于基数 0，字符串的解释方式类似于代码中的 整数文字，因为实际基数由前缀确定为 2、8、10 或 16。基数 0 也不允许前导零：int('010', 0)不合法，而int('010')和int('010', 8)合法。整数类型在 数字类型 - int、float、complex 中进行了描述。
版本 3.4 中变更: 如果 base 不是
int的实例，并且 base 对象有一个base.__index__方法，则调用该方法来获取基数的整数。以前的版本使用base.__int__而不是base.__index__。版本 3.6 中的变化： 允许像在代码字量中那样使用下划线对数字进行分组。
版本 3.7 中变更: 第一个参数现在仅限位置参数。
版本 3.8 中变更: 如果未定义
__int__()，则回退到__index__()。版本 3.11 中变更: 不推荐使用委托给
__trunc__()。版本 3.11 中变更:
int字符串输入和字符串表示形式可以受到限制，以帮助避免拒绝服务攻击。当在将字符串转换为int时或将int转换为字符串将超过限制时，会引发ValueError。请参阅整数字符串转换长度限制文档。
- isinstance(object, classinfo)¶
如果 object 参数是 classinfo 参数的实例，或者其（直接、间接或 虚拟）子类的实例，则返回
True。如果 object 不是给定类型的对象，则该函数始终返回False。如果 classinfo 是类型对象的元组（或递归地，其他此类元组）或多个类型的 联合类型，则如果 object 是任何类型的实例，则返回True。如果 classinfo 不是类型或类型的元组以及此类元组，则会引发TypeError异常。如果较早的检查成功，则可能不会为无效类型引发TypeError。版本 3.10 中变更: classinfo 可以是 联合类型。
- issubclass(class, classinfo)¶
如果 class 是 classinfo 的子类（直接、间接或 虚拟），则返回
True。一个类被认为是它自己的子类。classinfo 可以是类对象的元组（或递归地，其他此类元组）或 联合类型，在这种情况下，如果 class 是 classinfo 中任何条目的子类，则返回True。在任何其他情况下，都会引发TypeError异常。版本 3.10 中变更: classinfo 可以是 联合类型。
- iter(object)¶
- iter(object, sentinel)
返回一个 迭代器 对象。根据第二个参数的存在，第一个参数的解释方式截然不同。如果没有第二个参数，则 object 必须是支持 可迭代 协议（
__iter__()方法）的集合对象，或者它必须支持序列协议（从0开始，使用整数参数的__getitem__()方法）。如果它不支持这两个协议中的任何一个，则会引发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)¶
返回对象的长度（项数）。参数可以是序列（例如字符串、字节、元组、列表或范围）或集合（例如字典、集合或冻结集合）。
CPython 实现细节：
len在长度大于sys.maxsize时引发OverflowError，例如range(2 ** 100)。
- class list
- class list(iterable)
list不是函数，而实际上是一个可变序列类型，如 列表 和 序列类型 - 列表、元组、范围 中所述。
- locals()¶
更新并返回表示当前局部符号表的字典。当
locals()在函数块中调用时，它会返回自由变量，但在类块中不会返回。请注意，在模块级别，locals()和globals()是同一个字典。注意
不应修改此字典的内容；更改可能不会影响解释器使用的局部变量和自由变量的值。
- map(function, iterable, *iterables)¶
返回一个迭代器，它将 *function* 应用于 *iterable* 的每个项，并产生结果。如果传递了额外的 *iterables* 参数，则 *function* 必须接受那么多参数，并并行应用于所有可迭代对象中的项。对于多个可迭代对象，当最短的可迭代对象耗尽时，迭代器将停止。对于函数输入已排列成参数元组的情况，请参阅
itertools.starmap()。
- max(iterable, *, key=None)¶
- max(iterable, *, default, key=None)
- max(arg1, arg2, *args, key=None)
返回可迭代对象中的最大项，或两个或多个参数中的最大值。
如果提供了一个位置参数，则它应该是一个 可迭代对象。返回可迭代对象中的最大项。如果提供了两个或多个位置参数，则返回位置参数中的最大值。
有两个可选的仅关键字参数。*key* 参数指定一个单参数排序函数，如
list.sort()中使用的函数。*default* 参数指定在提供的可迭代对象为空时返回的对象。如果可迭代对象为空且未提供 *default*，则会引发ValueError。如果有多个项最大，则该函数返回遇到的第一个项。这与其他保持排序稳定性的工具一致，例如
sorted(iterable, key=keyfunc, reverse=True)[0]和heapq.nlargest(1, iterable, key=keyfunc)。在 3.4 版更改: 添加了 *default* 仅关键字参数。
在 3.8 版更改: *key* 可以是
None。
- class memoryview(object)
返回从给定参数创建的“内存视图”对象。有关更多信息，请参阅 内存视图。
- min(iterable, *, key=None)¶
- min(iterable, *, default, key=None)
- min(arg1, arg2, *args, key=None)
返回可迭代对象中的最小项，或两个或多个参数中的最小值。
如果提供了一个位置参数，则它应该是一个 可迭代对象。返回可迭代对象中的最小项。如果提供了两个或多个位置参数，则返回位置参数中的最小值。
有两个可选的仅关键字参数。*key* 参数指定一个单参数排序函数，如
list.sort()中使用的函数。*default* 参数指定在提供的可迭代对象为空时返回的对象。如果可迭代对象为空且未提供 *default*，则会引发ValueError。如果有多个项最小，则该函数返回遇到的第一个项。这与其他保持排序稳定性的工具一致，例如
sorted(iterable, key=keyfunc)[0]和heapq.nsmallest(1, iterable, key=keyfunc)。在 3.4 版更改: 添加了 *default* 仅关键字参数。
在 3.8 版更改: *key* 可以是
None。
- next(iterator)¶
- next(iterator, default)
通过调用 迭代器 的
__next__()方法从迭代器中检索下一项。如果给定了 *default*，则在迭代器耗尽时返回它，否则将引发StopIteration。
- 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 并返回相应的 文件对象。如果文件无法打开，则会引发
OSError。有关如何使用此函数的更多示例，请参阅读取和写入文件。file 是一个 类路径对象，给出要打开的文件的路径名（绝对路径或相对于当前工作目录的路径），或者是要包装的文件的整数文件描述符。（如果给定了文件描述符，则在关闭返回的 I/O 对象时将关闭该文件描述符，除非 closefd 设置为
False。）mode 是一个可选字符串，用于指定打开文件的模式。它默认为
'r'，表示以文本模式打开以进行读取。其他常见的值包括'w'（用于写入，如果文件已存在则截断文件）、'x'（用于独占创建）和'a'（用于追加，在*某些* Unix 系统上，这意味着*所有*写入都追加到文件末尾，而不管当前的查找位置如何）。在文本模式下，如果未指定 encoding，则使用的编码取决于平台：调用locale.getencoding()以获取当前的区域设置编码。（对于读取和写入原始字节，请使用二进制模式，并将 encoding 保留为未指定。）可用的模式有：字符
含义
'r'打开以进行读取（默认）
'w'打开以进行写入，首先截断文件
'x'打开以进行独占创建，如果文件已存在则失败
'a'打开以进行写入，如果文件存在则追加到文件末尾
'b'二进制模式
't'文本模式（默认）
'+'打开以进行更新（读取和写入）
默认模式为
'r'（打开以读取文本，与'rt'同义）。模式'w+'和'w+b'打开并截断文件。模式'r+'和'r+b'打开文件而不进行截断。如概述中所述，Python 区分二进制和文本 I/O。以二进制模式打开的文件（包括 mode 参数中的
'b'）将内容作为bytes对象返回，而不进行任何解码。在文本模式下（默认模式，或者当 mode 参数中包含't'时），文件的内容作为str返回，字节已使用平台相关的编码或指定的 encoding（如果已给出）进行解码。注意
Python 不依赖于底层操作系统对文本文件的概念；所有处理都由 Python 本身完成，因此与平台无关。
buffering 是一个可选整数，用于设置缓冲策略。传递 0 可关闭缓冲（仅在二进制模式下允许），传递 1 可选择行缓冲（仅在以文本模式写入时可用），传递大于 1 的整数表示固定大小块缓冲区的大小（以字节为单位）。请注意，以这种方式指定缓冲区大小适用于二进制缓冲 I/O，但
TextIOWrapper（即使用mode='r+'打开的文件）将具有另一种缓冲。要在TextIOWrapper中禁用缓冲，请考虑对io.TextIOWrapper.reconfigure()使用write_through标志。如果未给出 buffering 参数，则默认缓冲策略的工作方式如下：二进制文件以固定大小的块进行缓冲；缓冲区的大小是使用启发式方法选择的，该方法试图确定底层设备的“块大小”，并在失败时回退到
io.DEFAULT_BUFFER_SIZE。在许多系统上，缓冲区通常为 4096 或 8192 字节长。“交互式”文本文件（
isatty()返回True的文件）使用行缓冲。其他文本文件使用上述针对二进制文件描述的策略。
encoding 是用于解码或编码文件的编码的名称。这应该仅在文本模式下使用。默认编码取决于平台（
locale.getencoding()返回的任何内容），但可以使用 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 决定了如何从流中解析换行符。它可以是
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的功能）。新创建的文件是 不可继承的。
以下示例使用 dir_fd 参数
os.open()函数打开相对于给定目录的文件：>>> 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。使用参数
file、mode、flags引发 审计事件open。mode和flags参数可能已从原始调用中修改或推断出来。3.3 版中的更改：
添加了 opener 参数。
添加了
'x'模式。如果以独占创建模式（
'x'）打开的文件已存在，则现在会引发FileExistsError。
3.4 版中的更改：
该文件现在是不可继承的。
3.5 版中的更改：
如果系统调用被中断并且信号处理程序没有引发异常，则该函数现在会重试系统调用，而不是引发
InterruptedError异常（有关基本原理，请参阅 PEP 475）。添加了
'namereplace'错误处理程序。
3.6 版中的更改：
添加了对接受实现
os.PathLike的对象的,在 Windows 上，打开控制台缓冲区可能会返回
io.RawIOBase的子类，而不是io.FileIO。
3.11 版中的更改： 已删除
'U'模式。
- ord(c)¶
给定一个表示一个 Unicode 字符的字符串，返回一个表示该字符的 Unicode 代码点的整数。例如，
ord('a')返回整数97，而ord('€')（欧元符号）返回8364。这是chr()的逆运算。
- pow(base, exp, mod=None)¶
返回 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或float的负底数和整数指数，将返回浮点数结果。例如，pow(-9, 2.0)返回81.0。对于
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=None, 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 为 true，则会强制刷新流。
在 3.3 版更改: 添加了 flush 关键字参数。
- class property(fget=None, fset=None, fdel=None, doc=None)¶
返回一个属性属性。
fget 是用于获取属性值的函数。fset 是用于设置属性值的函数。fdel 是用于删除属性值的函数。doc 为属性创建文档字符串。
典型的用法是定义一个托管属性
xclass 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将调用 deleter。如果给出了 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 的文档字符串设置为“获取当前电压”。- @getter¶
- @setter¶
- @deleter¶
属性对象具有
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=1)
range实际上是一个不可变序列类型，而不是函数，如 范围 和 序列类型 — 列表、元组、范围 中所述。
- repr(object)¶
返回一个字符串，其中包含对象的 printable 表示形式。对于许多类型，此函数会尝试返回一个字符串，该字符串在传递给
eval()时会生成具有相同值的 object；否则，表示形式是一个用尖括号括起来的字符串，其中包含对象的类型名称以及其他信息，通常包括对象的名称和地址。类可以通过定义__repr__()方法来控制此函数为其实例返回的内容。如果无法访问sys.displayhook()，则此函数将引发RuntimeError。此类具有可以被求值的自定义表示形式
class Person: def __init__(self, name, age): self.name = name self.age = age def __repr__(self): return f"Person('{self.name}', {self.age})"
- reversed(seq)¶
返回一个反向 迭代器。seq 必须是一个具有
__reversed__()方法或支持序列协议（__len__()方法和从0开始的整数参数的__getitem__()方法）的对象。
- round(number, ndigits=None)¶
返回 number，舍入到小数点后 ndigits 位精度。如果省略 ndigits 或为
None，则返回最接近其输入的整数。对于支持
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
- class set(iterable)
返回一个新的
set对象，可以选择从 iterable 中获取元素。set是一个内置类。有关此类的文档，请参阅set和 集合类型 — set、frozenset。对于其他容器，请参阅内置的
frozenset、list、tuple和dict类，以及collections模块。
- setattr(object, name, value)¶
这是
getattr()的对应函数。参数是一个对象、一个字符串和一个任意值。字符串可以命名现有属性或新属性。该函数将值赋给属性，前提是对象允许这样做。例如，setattr(x, 'foobar', 123)等效于x.foobar = 123。除非对象选择强制执行，例如在自定义
__getattribute__()中或通过__slots__，否则 name 不必是 标识符和关键字 中定义的 Python 标识符。名称不是标识符的属性将无法使用点符号访问，但可以通过getattr()等访问。
- class slice(stop)¶
- class slice(start, stop, step=None)
返回一个 切片 对象，表示由
range(start, stop, step)指定的索引集。start 和 step 参数默认为None。- start¶
- stop¶
- step¶
切片对象具有只读数据属性
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__()方法。有关排序示例和简短的排序教程，请参阅 排序技术。
- @staticmethod¶
将方法转换为静态方法。
静态方法不接收隐式的第一个参数。要声明静态方法，请使用以下习惯用法
class C: @staticmethod def f(arg1, arg2, argN): ...
@staticmethod形式是一个函数 装饰器——有关详细信息，请参阅 函数定义。可以在类上（例如
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是内置字符串 类。有关字符串的一般信息，请参阅 文本序列类型 — str。
- sum(iterable, /, start=0)¶
从左到右对 start 和 iterable 的项求和并返回总数。iterable 的项通常是数字，并且不允许 start 值是字符串。
对于某些用例，
sum()有一些很好的替代方案。连接字符串序列的首选快速方法是调用''.join(sequence)。要以扩展精度添加浮点值，请参阅math.fsum()。要连接一系列可迭代对象，请考虑使用itertools.chain()。在 3.8 版更改: start 参数可以作为关键字参数指定。
在 3.12 版更改: 浮点数求和切换到一种在大多数版本上提供更高精度的算法。
- class super¶
- class super(type, object_or_type=None)
返回一个代理对象，该对象将方法调用委托给 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()使用的方法解析搜索顺序。该属性是动态的，并且可以在继承层次结构更新时更改。如果省略第二个参数，则返回的 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()[name]）的隐式查找，super()未定义。还要注意的是，除了零参数形式之外，
super()不限于在方法内部使用。双参数形式精确地指定了参数并进行了适当的引用。零参数形式仅在类定义内部有效，因为编译器会填写必要的详细信息以正确检索正在定义的类，以及访问普通方法的当前实例。有关如何使用
super()设计协作类的实用建议，请参阅 super() 使用指南。
- class tuple
- class tuple(iterable)
tuple不是函数，而实际上是一种不可变序列类型，如 元组 和 序列类型 — 列表、元组、范围 中所述。
- 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()¶
- 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循环或将其包装在list中，不会处理元素。需要考虑的一件事是，传递给
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>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True): ... print(item) ... (0, 'fee') (1, 'fi') (2, 'fo') 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 长度组成为可能。这会重复 相同 的迭代器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语句的语义，但强烈建议不要这样做，因为通常使用导入钩子（请参阅 PEP 302）来实现相同的目标更简单，并且不会对假设使用默认导入实现的代码造成问题。也不鼓励直接使用__import__()，而推荐使用importlib.import_module()。该函数导入模块 name，可能使用给定的 globals 和 locals 来确定如何在包上下文中解释名称。fromlist 给出了应该从 name 给出的模块中导入的对象或子模块的名称。标准实现根本不使用其 locals 参数，并且仅使用其 globals 来确定
import语句的包上下文。level 指定是使用绝对导入还是相对导入。
0（默认值）表示仅执行绝对导入。level 的正值表示相对于调用__import__()的模块目录要搜索的父目录数（有关详细信息，请参阅 PEP 328）。当 name 变量的形式为
package.module时，通常返回顶级包（直到第一个点的名称），而不是 name 命名的模块。但是，当给定非空的 fromlist 参数时，将返回 name 命名的模块。例如，语句
import spam会生成类似于以下代码的字节码spam = __import__('spam', globals(), locals(), [], 0)
语句
import spam.ham会导致此调用spam = __import__('spam.ham', globals(), locals(), [], 0)
请注意
__import__()在此处如何返回顶级模块，因为这是由import语句绑定到名称的对象。另一方面，语句
from spam.ham import eggs, sausage as saus会导致_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0) eggs = _temp.eggs saus = _temp.sausage
此处，
spam.ham模块从__import__()返回。从此对象中检索要导入的名称，并将其分配给各自的名称。如果只想按名称导入模块（可能在包中），请使用
importlib.import_module()。在 3.3 版更改: 不再支持 level 的负值（这也将默认值更改为 0）。
在 3.9 版更改: 当使用命令行选项
-E或-I时，将忽略环境变量PYTHONCASEOK。
脚注