内置函数¶
Python 解释器内置了许多始终可用的函数和类型。它们在此处按字母顺序列出。
内置函数
A
abs()
aiter()
all()
anext()
any()
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(number, /)¶
返回一个数的绝对值。参数可以是整数、浮点数，或实现了 __abs__() 的对象。如果参数是复数，则返回其模。
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, /)
当被 await 时，返回给定异步迭代器的下一个项，如果给定 default 且迭代器已耗尽，则返回 default。
这是内置函数 next() 的异步变体，行为类似。
它调用 async_iterator 的 __anext__() 方法，返回一个可等待对象。await 它会返回迭代器的下一个值。如果给定了 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(integer, /)¶
将整数转换为以“0b”为前缀的二进制字符串。结果是有效的 Python 表达式。如果 integer 不是 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。
默认情况下，breakpoint() 的行为可以通过 PYTHONBREAKPOINT 环境变量进行更改。有关使用详细信息，请参阅 sys.breakpointhook()。
请注意，如果 sys.breakpointhook() 已被替换，则无法保证这一点。
引发 审计事件 builtins.breakpoint，参数为 breakpointhook。
在 3.7 版本加入。
class bytearray(source=b'')
class bytearray(source, encoding, errors='strict')
返回一个新的字节数组。bytearray 类是 0 <= x < 256 范围内整数的可变序列。它拥有大多数常用的可变序列方法（在可变序列类型中描述），以及 bytes 类型拥有的方法，参见字节和字节数组操作。
可选的 source 参数可以用于以几种不同的方式初始化数组
如果它是 string，您还必须提供 encoding (以及可选的 errors) 参数；bytearray() 然后使用 str.encode() 将字符串转换为字节。
如果它是一个 integer，数组将具有该大小并用空字节初始化。
如果它是一个符合缓冲区接口的对象，则对象的只读缓冲区将用于初始化字节数组。
如果它是一个 iterable，它必须是一个 0 <= x < 256 范围内整数的迭代器，这些整数用作数组的初始内容。
没有参数时，会创建一个大小为 0 的数组。
另请参阅 二进制序列类型 — bytes, bytearray, memoryview 和 Bytearray 对象。
class bytes(source=b'')
class bytes(source, encoding, errors='strict')
返回一个新的“bytes”对象，它是一个 0 <= x < 256 范围内整数的不可变序列。bytes 是 bytearray 的不可变版本——它具有相同的非变异方法以及相同的索引和切片行为。
因此，构造函数参数的解释与 bytearray() 相同。
字节对象也可以通过字面量创建，参见字符串和字节字面量。
另请参阅 二进制序列类型 — bytes, bytearray, memoryview、字节对象 和 字节和字节数组操作。
callable(object, /)¶
如果 object 参数看起来是可调用的，则返回 True，否则返回 False。如果此函数返回 True，则调用仍可能失败，但如果返回 False，则调用 object 永远不会成功。请注意，类是可调用的（调用类会返回一个新实例）；如果实例的类具有 __call__() 方法，则实例是可调用的。
在 3.2 版本加入: 此函数最初在 Python 3.0 中被移除，然后又在 Python 3.2 中重新引入。
chr(codepoint, /)¶
返回表示具有指定 Unicode 码点的字符的字符串。例如，chr(97) 返回字符串 'a'，而 chr(8364) 返回字符串 '€'。这与 ord() 相反。
参数的有效范围是 0 到 1,114,111 (十六进制为 0x10FFFF)。如果超出该范围，将引发 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 参数应给出代码的来源文件；如果不是从文件中读取，则传递一些可识别的值（通常使用 '
mode 参数指定要编译的代码类型；如果 source 包含一系列语句，则可以是 'exec'；如果它包含单个表达式，则可以是 'eval'；如果它包含单个交互式语句，则可以是 'single'（在后一种情况下，求值结果不为 None 的表达式语句将被打印出来）。
可选参数 flags 和 dont_inherit 控制应激活哪些编译器选项以及应允许哪些未来特性。如果两者都不存在（或都为零），则代码使用影响调用 compile() 的代码的相同标志进行编译。如果给定了 flags 参数而未给定 dont_inherit（或为零），则 flags 参数指定的编译器选项和未来语句将用于此外仍将使用的那些。如果 dont_inherit 是非零整数，则 flags 参数就是它——周围代码中的标志（未来特性和编译器选项）将被忽略。
编译器选项和未来语句由位指定，可以通过按位或运算符组合以指定多个选项。指定给定未来特性所需的位域可以作为 compiler_flag 属性在 __future__ 模块的 _Feature 实例上找到。编译器标志可以在 ast 模块中找到，前缀为 PyCF_。
参数 optimize 指定编译器的优化级别；默认值 -1 选择由 -O 选项给出的解释器优化级别。显式级别为 0 (无优化；__debug__ 为真)，1 (断言被移除，__debug__ 为假) 或 2 (文档字符串也被移除)。
如果编译后的源代码无效，此函数会引发 SyntaxError，如果源代码包含空字节，则会引发 ValueError。
如果您想将 Python 代码解析为其 AST 表示，请参阅 ast.parse()。
引发 审计事件 compile，参数为 source 和 filename。此事件也可能由隐式编译引发。
备注
在 '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") |
floatvalue sign absfloatvalue ("j" | "J")
如果参数是数字，则构造函数充当数值转换，类似于 int 和 float。对于一般的 Python 对象 x，complex(x) 会委托给 x.__complex__()。如果未定义 __complex__()，则会回退到 __float__()。如果未定义 __float__()，则会回退到 __index__()。
如果提供了两个参数或使用了关键字参数，则每个参数可以是任何数字类型（包括复数）。如果两个参数都是实数，则返回一个复数，其实部为 real，虚部为 imag。如果两个参数都是复数，则返回一个复数，其实部为 real.real-imag.imag，虚部为 real.imag+imag.real。如果其中一个参数是实数，则在上述表达式中仅使用其实部。
另请参阅 complex.from_number()，它只接受单个数字参数。
如果所有参数都省略，则返回 0j。
复数类型在数字类型 — int、float、complex中描述。
版本 3.6 中的改变: 允许使用下划线对数字进行分组，如代码字面量所示。
版本 3.8 中的改变: 如果未定义 __complex__() 和 __float__()，则回退到 __index__()。
自 3.14 版本弃用: 将复数作为 real 或 imag 参数传递现已弃用；它应该只作为单个位置参数传递。
delattr(object, name, /)¶
这是 setattr() 的一个亲戚。参数是一个对象和一个字符串。字符串必须是对象属性之一的名称。该函数删除命名属性，前提是对象允许。例如，delattr(x, 'foobar') 等价于 del x.foobar。name 不需要是 Python 标识符（参见 setattr()）。
class dict(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)
创建一个新字典。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。无论如何，如果 a % b 非零，则它与 b 符号相同，并且 0 <= abs(a % b) < abs(b)，q * b + a % b 非常接近 a。
enumerate(iterable, start=0)¶
返回一个 enumerate 对象。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(source, /, globals=None, locals=None)¶
参数:
source (str | 代码对象) – 一个 Python 表达式。
globals (dict | None) – 全局命名空间（默认值：None）。
locals (映射 | None) – 局部命名空间（默认值：None）。
返回:
已求值表达式的结果。
引发:
语法错误将作为异常报告。
警告
此函数执行任意代码。使用用户提供的输入调用它可能会导致安全漏洞。
expression 参数将被解析并作为 Python 表达式（技术上讲，是一个条件列表）进行求值，其中 globals 和 locals 映射用作全局和局部命名空间。如果 globals 字典存在并且不包含键 __builtins__ 的值，则在解析 expression 之前，会在该键下插入对内置模块 builtins 的字典的引用。这样，您就可以通过在将自己的 __builtins__ 字典传递给 eval() 之前插入它来控制可用于执行代码的内置函数。如果省略 locals 映射，则默认为 globals 字典。如果两个映射都省略，则表达式将在调用 eval() 的环境中以 globals 和 locals 执行。请注意，eval() 只有在封闭环境中的嵌套作用域（非局部变量）已被调用 eval() 的作用域引用时（例如通过 nonlocal 语句）才能访问它们。
示例
>>> 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] 如果是代码对象，则直接执行。在所有情况下，执行的代码都应作为文件输入有效（请参阅参考手册中的文件输入一节）。请注意，即使在传递给 exec() 函数的代码上下文中，nonlocal、yield 和 return 语句也不能在函数定义之外使用。返回值为 None。
在所有情况下，如果省略可选部分，代码将在当前作用域中执行。如果仅提供 globals，它必须是一个字典（而不是字典的子类），将用于全局变量和局部变量。如果提供了 globals 和 locals，它们将分别用于全局变量和局部变量。如果提供，locals 可以是任何映射对象。请记住，在模块级别，全局变量和局部变量是同一个字典。
备注
当 exec 将两个独立的对象作为 globals 和 locals 获取时，代码将像嵌入在类定义中一样执行。这意味着在执行的代码中定义的函数和类将无法访问在顶层分配的变量（因为“顶层”变量在类定义中被视为类变量）。
如果 globals 字典不包含键 __builtins__ 的值，则在该键下插入对内置模块 builtins 的字典的引用。这样，您就可以通过在将自己的 __builtins__ 字典传递给 exec() 之前插入它来控制可用于执行代码的内置函数。
closure 参数指定了一个闭包——一个 cellvars 元组。它仅在 object 是一个包含自由（闭包）变量的代码对象时有效。元组的长度必须与代码对象的 co_freevars 属性的长度完全匹配。
引发一个审计事件 exec，以代码对象作为参数。也可能会引发代码编译事件。
备注
内置函数 globals() 和 locals() 分别返回当前全局和局部命名空间，这对于作为 exec() 的第二和第三个参数使用可能很有用。
备注
默认的 locals 行为如下面函数 locals() 所述。如果您需要在函数 exec() 返回后查看代码对 locals 的影响，请传递一个显式的 locals 字典。
版本 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"
digitpart: digit (["_"] digit)*
number: [digitpart] "." digitpart | digitpart ["."]
exponent: ("e" | "E") [sign] digitpart
floatnumber: number [exponent]
absfloatvalue: floatnumber | infinity | nan
floatvalue: [sign] absfloatvalue
大小写不敏感，因此，例如，“inf”、“Inf”、“INFINITY”和“iNfINity”都是正无穷大的可接受拼写。
否则，如果参数是整数或浮点数，则返回具有相同值（在 Python 的浮点精度范围内）的浮点数。如果参数超出 Python 浮点数的范围，则会引发 OverflowError。
对于一个普通的 Python 对象 x，float(x) 会委托给 x.__float__()。如果 __float__() 未定义，则会回退到 __index__()。
另请参阅 float.from_number()，它只接受数字参数。
如果没有给出参数，则返回 0.0。
浮点类型在 数字类型 — int、float、complex 中描述。
版本 3.6 中的改变: 允许使用下划线对数字进行分组，如代码字面量所示。
版本 3.7 中的改变: 参数现在仅限位置。
3.8 版本新增: 如果 __float__() 未定义，则回退到 __index__()。
format(value, format_spec='', /)¶
根据 format_spec 控制将 value 转换为“格式化”表示形式。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=(), /)
返回一个新的 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，则返回 default，否则引发 AttributeError。name 不需要是 Python 标识符（参见 setattr()）。
备注
由于 私有名称修饰 在编译时发生，因此必须手动修饰私有属性（具有两个前导下划线的属性）的名称才能使用 getattr() 检索它。
globals()¶
返回实现当前模块命名空间的字典。对于函数内的代码，这在函数定义时设置，并且无论函数在哪里调用都保持不变。
hasattr(object, name, /)¶
参数是一个对象和一个字符串。如果字符串是对象某个属性的名称，则结果为 True，否则为 False。（这是通过调用 getattr(object, name) 并查看它是否引发 AttributeError> 来实现的。）
hash(object, /)¶
返回对象的哈希值（如果它有的话）。哈希值是整数。它们用于在字典查找期间快速比较字典键。比较相等的数值具有相同的哈希值（即使它们是不同类型，例如 1 和 1.0）。
备注
对于具有自定义 __hash__() 方法的对象，请注意 hash() 会根据主机机器的位宽截断返回值。
help()¶
help(request)
调用内置帮助系统。（此函数用于交互式使用。）如果没有给出参数，则交互式帮助系统会在解释器控制台启动。如果参数是字符串，则会将该字符串视为模块、函数、类、方法、关键字或文档主题的名称，并在控制台上打印帮助页面。如果参数是任何其他类型的对象，则会生成该对象的帮助页面。
请注意，如果在调用 help() 时，函数的参数列表中出现斜杠（/），这意味着斜杠之前的参数是仅限位置的。更多信息请参阅 关于仅限位置参数的 FAQ 条目。
此函数由 site 模块添加到内置命名空间。
3.4 版本新增: pydoc 和 inspect 的更改意味着可调用对象的报告签名现在更加全面和一致。
hex(integer, /)¶
将整数转换为以“0x”为前缀的小写十六进制字符串。如果 integer 不是 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 实现细节: 这是对象在内存中的地址。
引发 审计事件 builtins.id，参数为 id。
input()¶
input(prompt, /)
如果存在 prompt 参数，它会写入标准输出，不带尾随换行符。然后函数从输入中读取一行，将其转换为字符串（去除尾随换行符），并返回。当读取到 EOF 时，会引发 EOFError。示例
>>> s = input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"
如果加载了 readline 模块，则 input() 将使用它来提供复杂的行编辑和历史记录功能。
在读取输入之前，引发 审计事件 builtins.input，参数为 prompt。
成功读取输入后，引发 审计事件 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__()。对于浮点数，这会向零截断。
如果参数不是数字或者给出了 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 版本新增: int 字符串输入和字符串表示可以限制，以帮助避免拒绝服务攻击。当在将字符串转换为 int 或将 int 转换为字符串时超出限制时，会引发 ValueError。请参阅 整数字符串转换长度限制 文档。
3.14 版本新增: int() 不再委托给 __trunc__() 方法。
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(iterable, /)¶
iter(callable, sentinel, /)
返回一个 迭代器 对象。第一个参数的解释因第二个参数的存在与否而有很大不同。如果没有第二个参数，则单个参数必须是支持 可迭代 协议（__iter__() 方法）的集合对象，或者必须支持序列协议（从 0 开始的整数参数的 __getitem__() 方法）。如果它不支持这些协议中的任何一个，则会引发 TypeError。如果给出第二个参数 sentinel，则第一个参数必须是可调用对象。在这种情况下创建的迭代器将在每次调用其 __next__() 方法时调用 callable 而不带参数；如果返回的值等于 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(object, /)¶
返回对象的长度（项目数）。参数可以是序列（如字符串、字节、元组、列表或范围）或集合（如字典、集合或冻结集合）。
CPython 实现细节: len 在长度大于 sys.maxsize 时（例如 range(2 ** 100)）引发 OverflowError。
class list(iterable=(), /)
list 实际上是一个可变序列类型，而不是一个函数，如 列表 和 序列类型 — list、tuple、range 中所述。
locals()¶
返回一个映射对象，表示当前局部符号表，其中变量名作为键，其当前绑定的引用作为值。
在模块作用域中，以及在使用 exec() 或 eval() 并只传递一个命名空间时，此函数返回与 globals() 相同的命名空间。
在类作用域中，它返回将传递给元类构造函数的命名空间。
当使用 exec() 或 eval() 并单独传递局部和全局参数时，它返回传递给函数调用的局部命名空间。
在上述所有情况下，在给定执行帧中每次调用 locals() 都将返回 相同 的映射对象。通过 locals() 返回的映射对象所做的更改将作为已赋值、重新赋值或删除的局部变量可见，并且赋值、重新赋值或删除局部变量将立即影响返回的映射对象的内容。
在 优化作用域 中（包括函数、生成器和协程），每次调用 locals() 都会返回一个新字典，其中包含函数局部变量和任何非局部单元格引用的当前绑定。在这种情况下，通过返回的字典进行的名称绑定更改 不会 写回相应的局部变量或非局部单元格引用，并且赋值、重新赋值或删除局部变量和非局部单元格引用 不会 影响先前返回的字典的内容。
在函数、生成器或协程中，将 locals() 作为推导式的一部分调用，等同于在包含作用域中调用它，不同之处在于推导式初始化的迭代变量将包含在内。在其他作用域中，它的行为就像推导式作为嵌套函数运行一样。
将 locals() 作为生成器表达式的一部分调用，等同于在嵌套生成器函数中调用它。
3.12 版本新增: locals() 在推导式中的行为已按照 PEP 709 中的描述进行了更新。
3.13 版本新增: 作为 PEP 667 的一部分，修改此函数返回的映射对象的语义现已定义。在 优化作用域 中的行为现已如上所述。除了定义之外，在其他作用域中的行为与以前的版本保持不变。
map(function, iterable, /, *iterables, strict=False)¶
返回一个迭代器，它将 function 应用于 iterable 的每个项目，并生成结果。如果传递了额外的 iterables 参数，function 必须接受相同数量的参数，并并行应用于所有可迭代对象的项目。对于多个可迭代对象，当最短的可迭代对象耗尽时，迭代器停止。如果 strict 为 True 并且其中一个可迭代对象在其他可迭代对象之前耗尽，则会引发 ValueError。对于函数输入已排列成参数元组的情况，请参阅 itertools.starmap()。
3.14 版本新增: 添加了 strict 参数。
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，则在迭代器耗尽时返回 default，否则引发 StopIteration。
class object¶
这是所有其他类的终极基类。它具有所有 Python 类实例共有的方法。当调用构造函数时，它会返回一个新的无特征对象。构造函数不接受任何参数。
备注
object 实例 不 具有 __dict__ 属性，因此你不能为 object 的实例分配任意属性。
oct(integer, /)¶
将整数转换为以“0o”为前缀的八进制字符串。结果是有效的 Python 表达式。如果 integer 不是 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 参数，默认缓冲策略如下
二进制文件以固定大小的块进行缓冲；当设备块大小可用时，缓冲区大小为 max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)。在大多数系统上，缓冲区通常为 128 千字节。
“交互式”文本文件（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 的功能）。
新创建的文件是 不可继承的。
以下示例使用 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。
引发 审计事件 open，参数为 path、mode、flags。
mode 和 flags 参数可能已根据原始调用进行了修改或推断。
3.3 版本中的变化
添加了 opener 参数。
添加了 'x' 模式。
IOError 以前会被引发，现在它是 OSError 的别名。
现在，如果文件以独占创建模式 ('x') 打开时已存在，则会引发 FileExistsError。
3.4 版本中的变化
文件现在不可继承。
3.5 版本中的变化
如果系统调用被中断并且信号处理程序没有引发异常，则函数现在会重试系统调用，而不是引发 InterruptedError 异常（有关原因，请参阅 PEP 475）。
添加了 'namereplace' 错误处理程序。
3.6 版本中的变化
添加了对实现 os.PathLike 的对象的支持。
在 Windows 上，打开控制台缓冲区可能会返回 io.RawIOBase 的子类，而不是 io.FileIO。
3.11 版本中的变化: 'U' 模式已移除。
ord(character, /)¶
返回字符的序数值。
如果参数是一个单字符字符串，则返回该字符的 Unicode 码点。例如，ord('a') 返回整数 97，ord('€')（欧元符号）返回 8364。这与 chr() 相反。
如果参数是长度为 1 的 bytes 或 bytearray 对象，则返回其单个字节值。例如，ord(b'a') 返回整数 97。
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 为属性创建文档字符串。
典型用法是定义一个托管属性 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 将调用 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”，并将其文档字符串设置为“Get the current voltage.”
@getter¶
@setter¶
@deleter¶
property 对象具有 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 实际上不是一个函数，而是一个不可变序列类型，如 区间 和 序列类型 — list、tuple、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(object, /)¶
返回一个逆向迭代器。参数必须是具有 __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。这不是一个 bug：这是因为大多数十进制分数不能精确地表示为浮点数。有关更多信息，请参阅 浮点数算术：问题和限制。
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() 等访问。
备注
由于 私有名称重整 在编译时发生，因此必须手动重整私有属性（具有两个前导下划线的属性）的名称才能使用 setattr() 设置它。
class slice(stop, /)¶
class slice(start, stop, step=None, /)
返回一个 切片 对象，表示由 range(start, stop, step) 指定的索引集。start 和 step 参数默认为 None。
切片对象具有只读数据属性 start、stop 和 step，它们仅返回参数值（或其默认值）。它们没有其他明确的功能；但是，它们被 NumPy 和其他第三方包使用。
start¶
stop¶
step¶
当使用扩展索引语法时也会生成切片对象。例如：a[start:stop:step] 或 a[start:stop, i]。有关返回 迭代器 的替代版本，请参阅 itertools.islice()。
3.12 版本发生变更: 切片对象现在是可哈希的（前提是 start、stop 和 step 都是可哈希的）。
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(*, encoding='utf-8', errors='strict')
class str(object)
class str(object, encoding, errors='strict')
class str(object, *, errors)
返回 object 的 str 版本。有关详细信息，请参阅 str()。
str 是内置的字符串类。有关字符串的通用信息，请参阅文本序列类型 — str。
sum(iterable, /, start=0)¶
从左到右将 start 和 iterable 的项目相加，并返回总和。iterable 的项目通常是数字，并且起始值不允许是字符串。
对于某些用例，sum() 有很好的替代方案。连接字符串序列的首选、快速方法是调用 ''.join(sequence)。要以扩展精度添加浮点值，请参阅 math.fsum()。要连接一系列可迭代对象，请考虑使用 itertools.chain()。
3.8 版本发生变更: start 参数可以指定为关键字参数。
3.12 版本发生变更: 浮点数求和改为使用在大多数构建中提供更高精度和更好可交换性的算法。
3.14 版本发生变更: 添加了复数求和的专门化，使用与浮点数求和相同的算法。
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() 使用的方法解析搜索顺序。该属性是动态的，并且可以在继承层次结构更新时更改。
如果省略第二个参数，则返回的超对象是未绑定的。如果第二个参数是一个对象，则 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() 对于使用语句或运算符（例如 super()[name]）进行的隐式查找是未定义的。
另请注意，除了零参数形式外，super() 并不限于在方法内部使用。两参数形式精确指定参数并进行适当的引用。零参数形式仅在类定义内部有效，因为编译器会填写必要的详细信息以正确检索正在定义的类，以及访问普通方法的当前实例。
有关如何使用 super() 设计协作类的实用建议，请参阅 guide to using super()。
3.14 版本发生变更: super 对象现在是pickleable 和copyable。
class tuple(iterable=(), /)
tuple 实际上不是一个函数，而是一个不可变序列类型，如 元组 和 序列类型 — list、tuple、range 中所述。
class type(object, /)¶
class type(name, bases, dict, /, **kwargs)
使用一个参数时，返回 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() 的可迭代对象可能具有不同的长度；有时是设计使然，有时是由于准备这些可迭代对象的代码中的 bug。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
在这里，spam.ham 模块是从 __import__() 返回的。从这个对象中，要导入的名称被检索并分配给它们各自的名称。
如果您只是想按名称导入模块（可能在包中），请使用 importlib.import_module()。
3.3 版本发生变更: 不再支持 level 的负值（这也将默认值更改为 0）。
3.9 版本发生变更: 当使用命令行选项 -E 或 -I 时，环境变量 PYTHONCASEOK 现在被忽略。
脚注
[1]
请注意，解析器只接受 Unix 风格的行尾约定。如果您从文件读取代码，请确保使用换行符转换模式来转换 Windows 或 Mac 风格的换行符。