内置函数¶
Python 解释器内置了许多始终可用的函数和类型。它们在这里按字母顺序列出。
内置函数 |
|||
|---|---|---|---|
- aiter(async_iterable)¶
返回 异步迭代器 用于 异步可迭代对象。等效于调用
x.__aiter__()。注意：与
iter()不同，aiter()没有 2 参数变体。3.10 版本新增。
- all(iterable)¶
如果 iterable 的所有元素都为真（或者如果 iterable 为空），则返回
True。等效于def all(iterable): for element in iterable: if not element: return False return True
- awaitable anext(async_iterator)¶
- awaitable anext(async_iterator, 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()。
- class 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 参数可用于以几种不同的方式初始化数组
如果它是一个字符串，您还必须提供 encoding （以及可选的 errors）参数；然后
bytearray()使用str.encode()将字符串转换为字节。如果它是一个整数，则数组将具有该大小，并将使用空字节进行初始化。
如果它是一个符合 缓冲区接口 的对象，则将使用该对象的只读缓冲区来初始化字节数组。
如果它是一个可迭代对象，则它必须是范围为
0 <= x < 256的整数的可迭代对象，这些整数用作数组的初始内容。
如果没有参数，则会创建一个大小为 0 的数组。
- class bytes(source=b'')
- class bytes(source, encoding)
- class bytes(source, encoding, errors)
返回一个新的“字节”对象，它是 0 <= x < 256 范围内的整数的不可变序列。
bytes是bytearray的不可变版本——它具有相同的非变异方法以及相同的索引和切片行为。因此，构造函数参数的解释与
bytearray()相同。也可以使用字面量创建字节对象，请参阅 字符串和字节字面量。
另请参阅 二进制序列类型 — bytes、bytearray、memoryview、Bytes 对象 和 字节和字节数组操作。
- 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 版本弃用，在 3.13 版本中移除: 类方法不再能够包装其他描述符，例如
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'；如果由单个交互式语句组成（在后一种情况下，求值为None之外的内容的表达式语句将被打印），则可以是'single'。可选参数 flags 和 dont_inherit 控制应激活哪些编译器选项以及应允许哪些未来特性。 如果两者都不存在（或都为零），则代码将使用影响调用
compile()的代码的相同标志进行编译。 如果给定了 flags 参数，而 dont_inherit 没有给出（或为零），则除了无论如何都会使用的标志外，还会使用 flags 参数指定的编译器选项和未来语句。 如果 dont_inherit 是非零整数，则 flags 参数就是它——周围代码中的标志（未来特性和编译器选项）将被忽略。编译器选项和未来语句由位指定，这些位可以按位或运算在一起以指定多个选项。 指定给定未来特性所需的位字段可以在
compiler_flag属性上找到，该属性位于_Feature实例中，该实例位于__future__模块中。编译器标志可以在ast模块中找到，带有PyCF_前缀。参数 optimize 指定编译器的优化级别；默认值
-1选择解释器的优化级别，该级别由-O选项给出。 显式级别为0（无优化；__debug__为 true），1（删除断言，__debug__为 false）或2（也删除 docstring）。如果编译后的源无效，此函数将引发
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。复数类型在 数值类型 — int, float, complex 中描述。
在 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 必须是一个序列，一个 迭代器，或某些支持迭代的其他对象。
__next__()由enumerate()返回的迭代器的方法返回一个包含计数（从 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(source, /, globals=None, locals=None)¶
- 参数:
- 返回值:
已计算的表达式的结果。
- 引发:
语法错误会报告为异常。
警告
此函数执行任意代码。使用用户提供的输入调用它可能导致安全漏洞。
expression 参数会被解析并作为 Python 表达式（技术上来说，是一个条件列表）进行计算，使用 globals 和 locals 映射作为全局和局部命名空间。如果存在 globals 字典且它不包含键
__builtins__的值，则会在解析 expression 之前，将对内置模块builtins的字典的引用插入到该键下。这样，你可以在将自己的__builtins__字典插入到 globals 中，然后将其传递给eval()，从而控制可用于执行代码的内置函数。如果省略 locals 映射，则默认为 globals 字典。如果省略两个映射，则会在调用eval()的环境中，使用 globals 和 locals 执行表达式。请注意，如果 嵌套作用域（非局部）已经在调用eval()的作用域中被引用（例如通过nonlocal语句），则 eval() 将只能访问封闭环境中的嵌套作用域。示例
>>> x = 1 >>> eval('x+1') 2
此函数还可用于执行任意代码对象（例如由
compile()创建的代码对象）。在这种情况下，请传递代码对象而不是字符串。如果代码对象已使用'exec'作为 mode 参数编译，则eval()的返回值将为None。提示：语句的动态执行由
exec()函数支持。globals()和locals()函数分别返回当前全局和局部字典，它们对于传递给eval()或exec()使用可能很有用。如果给定的源是一个字符串，则会删除前导和尾随空格以及制表符。
有关可以安全评估仅包含字面量的表达式的字符串的函数，请参阅
ast.literal_eval()。使用代码对象作为参数引发 审计事件
exec。还可能引发代码编译事件。在 3.13 版本中更改: 现在可以将 globals 和 locals 参数作为关键字传递。
在 3.13 版本中更改: 默认 locals 命名空间的语义已按照
locals()内置函数的描述进行调整。
- exec(source, /, globals=None, locals=None, *, closure=None)¶
警告
此函数执行任意代码。使用用户提供的输入调用它可能导致安全漏洞。
此函数支持动态执行 Python 代码。source 必须是字符串或代码对象。如果它是字符串，则该字符串会被解析为一组 Python 语句，然后执行（除非发生语法错误）。 [1] 如果它是代码对象，则直接执行。在所有情况下，执行的代码都应作为文件输入有效（请参阅参考手册中的 文件输入 部分）。请注意，
nonlocal、yield和return语句即使在传递给exec()函数的代码的上下文中，也不能在函数定义之外使用。返回值是None。在所有情况下，如果省略可选部分，则代码将在当前作用域中执行。如果仅提供 globals，则它必须是一个字典（而不是字典的子类），它将用于全局变量和局部变量。如果给出 globals 和 locals，则它们分别用于全局变量和局部变量。如果提供，locals 可以是任何映射对象。请记住，在模块级别，全局变量和局部变量是同一个字典。
注意
当
exec获取两个单独的对象作为 globals 和 locals 时，代码的执行方式将如同它嵌入在类定义中一样。这意味着在执行的代码中定义的函数和类将无法访问在顶层分配的变量（因为“顶层”变量在类定义中被视为类变量）。如果 globals 字典不包含键
__builtins__的值，则会在该键下插入对内置模块builtins的字典的引用。这样，您可以通过在将 globals 传递给exec()之前，将您自己的__builtins__字典插入到 globals 中来控制哪些内置函数可用于执行的代码。closure 参数指定一个闭包，即一个 cellvars 元组。仅当 object 是包含 自由（闭包）变量 的代码对象时，此参数才有效。元组的长度必须与代码对象的
co_freevars属性的长度完全匹配。使用代码对象作为参数引发 审计事件
exec。还可能引发代码编译事件。在 3.11 版本中变更: 添加了 closure 参数。
在 3.13 版本中更改: 现在可以将 globals 和 locals 参数作为关键字传递。
在 3.13 版本中更改: 默认 locals 命名空间的语义已按照
locals()内置函数的描述进行调整。
- 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)。请参阅
itertools.filterfalse()，了解返回 iterable 中使 function 为假的元素的互补函数。
- 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。浮点类型在 数字类型 — int、float、complex 中描述。
在 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，则它必须是字符串、
bytes或bytearray实例，表示以 base 为基数的整数。可选地，字符串可以以+或-开头（中间没有空格），可以有前导零，可以被空格包围，并且数字之间可以散布单个下划线。一个 n 进制整数字符串包含数字，每个数字表示从 0 到 n-1 的一个值。值 0-9 可以用任何 Unicode 十进制数字表示。值 10-35 可以用
a到z(或A到Z) 表示。默认的进制为 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实际上是一个可变序列类型，如列表和序列类型 — list, tuple, range中所述。
- locals()¶
返回一个映射对象，表示当前的局部符号表，其中变量名作为键，它们当前绑定的引用作为值。
在模块作用域，以及使用
exec()或eval()并使用单个命名空间时，此函数返回与globals()相同的命名空间。在类作用域中，它返回将传递给元类构造函数的命名空间。
当使用带有单独的局部和全局参数的
exec()或eval()时，它会返回传递给函数调用的局部命名空间。在上述所有情况下，在给定的执行帧中每次调用
locals()都将返回相同的映射对象。通过locals()返回的映射对象所做的更改将显示为已赋值、重新赋值或已删除的局部变量，并且赋值、重新赋值或删除局部变量将立即影响返回的映射对象的内容。在优化作用域（包括函数、生成器和协程）中，每次调用
locals()都会返回一个新的字典，其中包含该函数局部变量的当前绑定和任何非局部单元格引用。在这种情况下，通过返回的字典进行的名称绑定更改不会写回到相应的局部变量或非局部单元格引用，并且赋值、重新赋值或删除局部变量和非局部单元格引用不会影响先前返回的字典的内容。在函数、生成器或协程中调用
locals()作为推导的一部分，等效于在包含作用域中调用它，但会包含推导的初始化迭代变量。在其他作用域中，它的行为就好像推导式作为嵌套函数运行一样。调用
locals()作为生成器表达式的一部分，等效于在嵌套的生成器函数中调用它。在 3.12 版本中更改: 根据 PEP 709 中的描述，更新了
locals()在推导式中的行为。
- 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。
- class object¶
这是所有其他类的最终基类。它具有所有 Python 类实例通用的方法。当构造函数被调用时，它会返回一个新的无特征对象。构造函数不接受任何参数。
- 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 和文本 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 来使用自定义的 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。使用参数
path、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类型的操作数底数和指数，如果存在 模数，则 模数 也必须是整数类型，且 模数 必须非零。如果存在 模数 且指数为负数，则底数必须与模数互质。在这种情况下，返回pow(inv_base, -exp, mod)，其中 inv_base 是 底数 模 模数 的逆元。下面是一个计算
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 设置文档字符串为 “Get the current 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 版本中更改: 属性对象的文档字符串现在可写。
- __name__¶
保存属性名称的属性。属性的名称可以在运行时更改。
在 3.13 版本中添加。
- class range(stop)
- class range(start, stop, step=1)
range实际上不是一个函数，而是一个不可变的序列类型，如 范围 和 序列类型 — 列表，元组，范围 中所述。
- repr(object)¶
返回一个包含对象可打印表示的字符串。对于许多类型，此函数会尝试返回一个字符串，该字符串在传递给
eval()时会生成具有相同值的对象；否则，该表示形式是一个用尖括号括起来的字符串，其中包含对象的类型名称，以及通常包括对象的名称和地址的附加信息。类可以通过定义__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__()方法和__getitem__()方法，其整数参数从0开始）。
- 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)必须为 true。如果第二个参数是一个类型，则issubclass(type2, type)必须为 true（这对于类方法很有用）。当在类的普通方法中直接调用时，可以省略两个参数（“零参数
super()”）。在这种情况下，type 将是封闭类，而 obj 将是直接封闭函数的第一个参数（通常为self）。（这意味着零参数super()将不会在嵌套函数（包括隐式创建嵌套函数的生成器表达式）中按预期工作。）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* 的类型。返回值是一个类型对象，通常与
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()。如果指定了对象但它没有
__dict__属性（例如，如果它的类定义了__slots__属性），则会引发TypeError异常。在 3.13 版本中更改: 在不带参数的情况下调用此函数的结果已更新，如
locals()内置函数中所述。
- 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)¶
注意
这是一个高级函数，在日常 Python 编程中不需要使用，与
importlib.import_module()不同。此函数由
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
在这里，从
__import__()返回spam.ham模块。从此对象中检索要导入的名称，并将其分配给各自的名称。如果只是想按名称导入模块（可能在包内），请使用
importlib.import_module()。3.3 版本更改: 不再支持 *level* 的负值（这也将默认值更改为 0）。
3.9 版本更改: 当使用命令行选项
-E或-I时，现在将忽略环境变量PYTHONCASEOK。
脚注