`builtins` --- 内置函数和异常#

这里描述了所有的内置函数和异常。它们也可以通过 builtins 模块访问。

函数和类型#

abs(x: Any) → Any#: 返回一个数的绝对值。参数可以是整数、浮点数，或任何实现了 __abs__() 的对象。

all(iterable: Iterable[Any]) → bool#: 如果 iterable 的所有元素都为真（或该可迭代对象为空），则返回 True。

any(iterable: Iterable[Any]) → bool#: 如果 iterable 中任意一个元素为真，则返回 True。如果该可迭代对象为空，则返回 False。

bin(x: int) → str#: 将整数转换为以 "0b" 为前缀的二进制字符串。参数必须是 Python 整数，或实现了 __index__() 的对象。

class bool(x: Any = False)#: 返回一个布尔值，即 True 或 False 之一。x 使用标准的真值测试过程进行转换。

class bytearray(source: int | str | Iterable[int] | bytes = b'', encoding: str = 'utf-8', errors: str = 'strict')#

范围在 0-255 之间的整数构成的可变序列。构造规则与 bytes 相同：可以由整数（创建一个该大小的零填充缓冲区）、整数的可迭代对象、带 encoding 的字符串，或任何支持缓冲协议的对象构造。支持标准的序列操作，以及原地修改。

classmethod fromhex(string: str) → bytearray#: 从十六进制数字对组成的字符串构造一个 bytearray。数字对之间的空白会被跳过；非十六进制字符会引发 ValueError。

append(val: int) → None#: 将单个值（范围在 0-255 之间的整数）追加到 bytearray 的末尾，使其增大一个字节。

center(width: int, fillbyte: bytes) → bytes#: 返回内容居中放置于长度为 width 的序列中的副本，并用 fillbyte 填充。与 CPython 不同，fillbyte 是必需的。当 width 不大于当前长度时，原样返回数据。

count(sub: bytes, start: int = 0, end: int = -1) → int#: 返回 sub 在切片 [start:end] 中非重叠出现的次数。

endswith(suffix: bytes, start: int = 0, end: int = -1) → bool#: 如果内容以 suffix 结尾，则返回 True。与 CPython 不同，suffix 不能是值的元组。

extend(iterable: Iterable[int]) → None#: 将 iterable 中的所有项追加到 bytearray 的末尾。作为对 CPython 的扩展，可以使用任何支持缓冲协议的对象。

find(sub: bytes, start: int = 0, end: int = -1) → int#: 返回 sub 在切片 [start:end] 中被找到的最小索引，若未找到则返回 -1。

format(*args: Any, **kwargs: Any) → str#: 以内容作为格式化字符串执行字符串格式化操作，返回格式化后的结果。

hex(sep: str = '') → str#: 为每个字节返回两位十六进制数字组成的字符串。如果给出可选的 sep（一个长度为 1 的字符串），它会被插入到相邻的字节值之间。

index(sub: bytes, start: int = 0, end: int = -1) → int#: 与 find() 类似，但当未找到 sub 时引发 ValueError。

isalpha() → bool#: 如果所有字节都是字母 ASCII 字符且至少有一个字节，则返回 True，否则返回 False。

isdigit() → bool#: 如果所有字节都是 ASCII 十进制数字且至少有一个字节，则返回 True，否则返回 False。

islower() → bool#: 如果所有区分大小写的字节都是小写且至少有一个区分大小写的字节，则返回 True，否则返回 False。

isspace() → bool#: 如果所有字节都是 ASCII 空白字符且至少有一个字节，则返回 True，否则返回 False。

isupper() → bool#: 如果所有区分大小写的字节都是大写且至少有一个区分大小写的字节，则返回 True，否则返回 False。

join(iterable: Iterable[bytes]) → bytes#: 返回一个 bytes 对象，它是 iterable 中各项的连接，并以 bytearray 内容作为分隔符。

lower() → bytes#: 返回内容的副本，其中所有 ASCII 大写字符都被转换为小写。

lstrip(chars: bytes | None = None) → bytes#: 返回去除了开头字节的副本。chars 指定要去除的字节集合；如果省略或为 None，则去除 ASCII 空白字符。

partition(sep: bytes) → tuple#: 在 sep 首次出现处分割，返回 (head, sep, tail)。如果未找到 sep，则返回内容后跟两个空对象。

replace(old: bytes, new: bytes, count: int = -1) → bytes#: 返回将所有出现的 old 替换为 new 后的副本。如果给出 count，则只替换前 count 次出现。

rfind(sub: bytes, start: int = 0, end: int = -1) → int#: 返回 sub 在切片 [start:end] 中被找到的最大索引，若未找到则返回 -1。

rindex(sub: bytes, start: int = 0, end: int = -1) → int#: 与 rfind() 类似，但当未找到 sub 时引发 ValueError。

rpartition(sep: bytes) → tuple#: 在 sep 最后一次出现处分割，返回 (head, sep, tail)。如果未找到 sep，则返回两个空对象后跟内容。

rsplit(sep: bytes | None = None, maxsplit: int = -1) → list#: 在 sep 出现处将内容分割为一个片段列表，从右侧开始最多进行 maxsplit 次分割。如果 sep 为 None 或省略，则按连续的 ASCII 空白字符分割。

rstrip(chars: bytes | None = None) → bytes#: 返回去除了结尾字节的副本。chars 指定要去除的字节集合；如果省略或为 None，则去除 ASCII 空白字符。

split(sep: bytes | None = None, maxsplit: int = -1) → list#: 在 sep 出现处将内容分割为一个片段列表。如果 sep 为 None 或省略，则按连续的 ASCII 空白字符分割。

splitlines(keepends: bool = False) → list#: 返回各行组成的列表，在 \n、\r 和 \r\n 处断行。除非 keepends 为真，否则不包含换行符。

startswith(prefix: bytes, start: int = 0, end: int = -1) → bool#: 如果内容以 prefix 开头，则返回 True。与 CPython 不同，prefix 不能是元组，且 end 被接受但被忽略。

strip(chars: bytes | None = None) → bytes#: 返回去除了开头和结尾字节的副本。chars 指定要去除的字节集合；如果省略或为 None，则去除 ASCII 空白字符。

upper() → bytes#: 返回内容的副本，其中所有 ASCII 小写字符都被转换为大写。

class bytes(source: int | str | Iterable[int] = b'', encoding: str = 'utf-8', errors: str = 'strict')#

范围在 0-255 之间的整数构成的不可变序列。可由整数（零填充缓冲区）、整数的可迭代对象、带 encoding 的字符串，或任何支持缓冲协议的对象创建。字节字面量使用 b'...' 语法。

classmethod fromhex(string: str) → bytes#: 从十六进制数字对组成的字符串构造一个 bytes 对象。数字对之间的空白会被跳过；非十六进制字符会引发 ValueError。

center(width: int, fillbyte: bytes) → bytes#: 返回居中放置于长度为 width 的序列中的副本，并用 fillbyte（一个给出填充字节的长度为 1 的 bytes）填充。与 CPython 不同，fillbyte 是必需的。当 width 不大于其长度时，原样返回原对象。

count(sub: bytes, start: int = 0, end: int = -1) → int#: 返回 sub 在切片 [start:end] 中非重叠出现的次数。

decode(encoding: str = 'utf-8') → str#: 返回从字节解码得到的 str。在 MicroPython 中，encoding 参数被接受但实际上被忽略（字节会被重新解释为 UTF-8）。

endswith(suffix: bytes, start: int = 0, end: int = -1) → bool#: 如果字节以 suffix 结尾，则返回 True。与 CPython 不同，suffix 不能是要尝试的值的元组。

find(sub: bytes, start: int = 0, end: int = -1) → int#: 返回子序列 sub 在切片 [start:end] 中被找到的最小索引，若未找到则返回 -1。

format(*args: Any, **kwargs: Any) → str#: 以字节作为格式化字符串执行字符串格式化操作，返回格式化后的结果。

hex(sep: str = '') → str#: 为每个字节返回两位十六进制数字组成的字符串。如果给出可选的 sep（一个长度为 1 的字符串），它会被插入到相邻的字节值之间。

index(sub: bytes, start: int = 0, end: int = -1) → int#: 与 find() 类似，但当未找到 sub 时引发 ValueError。

isalpha() → bool#: 如果所有字节都是字母 ASCII 字符且至少有一个字节，则返回 True，否则返回 False。

isdigit() → bool#: 如果所有字节都是 ASCII 十进制数字且至少有一个字节，则返回 True，否则返回 False。

islower() → bool#: 如果所有区分大小写的字节都是小写且至少有一个区分大小写的字节，则返回 True，否则返回 False。

isspace() → bool#: 如果所有字节都是 ASCII 空白字符且至少有一个字节，则返回 True，否则返回 False。

isupper() → bool#: 如果所有区分大小写的字节都是大写且至少有一个区分大小写的字节，则返回 True，否则返回 False。

join(iterable: Iterable[bytes]) → bytes#: 返回一个 bytes 对象，它是 iterable 中各项的连接，并以该 bytes 对象本身作为分隔符。

lower() → bytes#: 返回所有 ASCII 大写字符都被转换为小写后的副本。

lstrip(chars: bytes | None = None) → bytes#: 返回去除了开头字节的副本。chars 指定要去除的字节集合；如果省略或为 None，则去除 ASCII 空白字符。

partition(sep: bytes) → tuple#: 在 sep 首次出现处分割，返回 (head, sep, tail)。如果未找到 sep，则返回该字节后跟两个空 bytes 对象。

replace(old: bytes, new: bytes, count: int = -1) → bytes#: 返回将所有出现的 old 替换为 new 后的副本。如果给出 count，则只替换前 count 次出现。

rfind(sub: bytes, start: int = 0, end: int = -1) → int#: 返回 sub 在切片 [start:end] 中被找到的最大索引，若未找到则返回 -1。

rindex(sub: bytes, start: int = 0, end: int = -1) → int#: 与 rfind() 类似，但当未找到 sub 时引发 ValueError。

rpartition(sep: bytes) → tuple#: 在 sep 最后一次出现处分割，返回 (head, sep, tail)。如果未找到 sep，则返回两个空 bytes 对象后跟该字节。

rsplit(sep: bytes | None = None, maxsplit: int = -1) → list#: 在 sep 出现处将内容分割为一个片段列表，从右侧开始最多进行 maxsplit 次分割。如果 sep 为 None 或省略，则按连续的 ASCII 空白字符分割。

rstrip(chars: bytes | None = None) → bytes#: 返回去除了结尾字节的副本。chars 指定要去除的字节集合；如果省略或为 None，则去除 ASCII 空白字符。

split(sep: bytes | None = None, maxsplit: int = -1) → list#: 在 sep 出现处将内容分割为一个片段列表。如果 sep 为 None 或省略，则按连续的 ASCII 空白字符分割。

splitlines(keepends: bool = False) → list#: 返回各行组成的列表，在 \n、\r 和 \r\n 处断行。除非 keepends 为真，否则不包含换行符。

startswith(prefix: bytes, start: int = 0, end: int = -1) → bool#: 如果字节以 prefix 开头，则返回 True。与 CPython 不同，prefix 不能是元组，且 end 被接受但被忽略。

strip(chars: bytes | None = None) → bytes#: 返回去除了开头和结尾字节的副本。chars 指定要去除的字节集合；如果省略或为 None，则去除 ASCII 空白字符。

upper() → bytes#: 返回所有 ASCII 小写字符都被转换为大写后的副本。

callable(obj: Any) → bool#: 如果 obj 看起来可调用，则返回 True，否则返回 False。

chr(i: int) → str#: 返回一个单字符字符串，其 Unicode 码点为整数 i。

classmethod(func: Callable[..., Any]) → classmethod#: 将一个方法转换为类方法。通常用作装饰器。

compile(source: str | bytes, filename: str, mode: str) → Any#: 将 source 编译为可由 exec() 或 eval() 执行的代码对象。mode 是 "exec"、"eval" 或 "single" 之一。

class complex(real: float | str = 0, imag: float = 0)#: 由实部和虚部创建一个复数，或由字符串创建。

delattr(obj, name: str) → None#: 参数 name 应为字符串，此函数从 obj 给出的对象中删除名为该名称的属性。

class dict(*args, **kwargs)#

创建一个新字典。等价于 CPython 的 dict。

classmethod fromkeys(iterable: Iterable[Any], value: Any = None) → dict#: 创建一个新字典，其键取自 iterable，每个键都映射到 value（默认为 None）。在类型上调用，例如 dict.fromkeys(...)。

clear() → None#: 从字典中移除所有项，使其为空。如果字典是固定的（只读），则引发 TypeError。

copy() → dict#: 返回字典的浅拷贝。返回的对象与原对象类型相同（dict 或 OrderedDict），但不是固定的。

get(key: Any, default: Any = None) → Any#: 如果 key 在字典中，则返回其对应的值，否则返回 default（其本身默认为 None，因此这绝不会引发 KeyError）。字典不会被修改。

items() → Any#: 返回一个动态视图对象，覆盖 (key, value) 对，它会反映字典后续的更改，并支持迭代、len()、in 运算符以及集合比较运算符。

keys() → Any#: 返回一个动态视图对象，覆盖键，它会反映字典后续的更改，并支持迭代、len()、in 运算符以及集合比较运算符。

pop(key: Any, default: Any = None) → Any#: 从字典中移除 key 并返回其值。如果 key 不存在，且提供了 default，则返回 default；否则引发 KeyError。如果字典是固定的，则引发 TypeError。

popitem() → tuple#: 移除并返回任意一个 (key, value) 对作为二元组。对于普通的 dict，所选的对是不确定的；对于 OrderedDict，则移除最后插入的对（LIFO）。如果字典为空则引发 KeyError，如果字典是固定的则引发 TypeError。

setdefault(key: Any, default: Any = None) → Any#: 如果 key 在字典中，则返回其值。否则以 default（默认为 None）为值插入 key 并返回该值。如果字典是固定的，则引发 TypeError。

update(*args: Any, **kwargs: Any) → None#: 就地更新字典。最多接受一个位置参数：可以是另一个字典，或一个由两元素 (key, value) 对组成的可迭代对象（每个都必须恰好产生两项，否则引发 ValueError）。然后将关键字参数作为以字符串为键的条目添加进来。已有的键会被覆盖。如果字典是固定的，则引发 TypeError。

values() → Any#: 返回一个动态视图对象，覆盖值，它会反映字典后续的更改，并支持迭代和 len()。

__getitem__(key: Any) → Any#: 返回 self[key]。实现索引运算符 d[key]；如果 key 不存在，则引发 KeyError。

__setitem__(key: Any, value: Any) → None#: 将 self[key] 设置为 value。实现 d[key] = value。

__delitem__(key: Any) → None#: 删除 self[key]。实现 del d[key]；如果 key 不存在，则引发 KeyError。

dir(obj: Any = None) → list#: 不带参数时，返回当前局部作用域中的名称列表。带一个参数时，返回该对象的有效属性列表。

divmod(a: Any, b: Any) → tuple#: 对于两个（非复数）数字，以元组形式返回 (a // b, a % b) 这一对值。

enumerate(iterable: Iterable[Any], start: int = 0) → Iterator[tuple]#: 返回一个 enumerate 对象，从 iterable 产生 (index, value) 对，索引从 start 开始。

eval(expression: str | bytes, globals: dict | None = None, locals: dict | None = None) → Any#: 对以字符串（或已编译的代码对象）形式给出的 Python 表达式求值，并返回结果。

exec(object: str | bytes, globals: dict | None = None, locals: dict | None = None) → None#: 动态执行以字符串或已编译的代码对象形式提供的 Python 代码。

filter(function: Callable[[Any], Any] | None, iterable: Iterable[Any]) → Iterator[Any]#: 从 iterable 中 function 返回真值的那些元素构造一个迭代器。如果 function 为 None，则假定为恒等函数。

class float(x: str | bytes | int | float = 0.0)#: 返回一个由数字或字符串 x 构造的浮点数。

class frozenset(iterable: Iterable[Any] = ())#

返回一个新的 frozenset 对象，可选地包含取自 iterable 的元素。frozenset 是 set 的不可变、可哈希变体。

copy() → frozenset#: 返回 frozenset 的浅拷贝。

difference(*others: Iterable[Any]) → frozenset#: 返回一个新的 frozenset，包含该 frozenset 中不在任何 others 中的元素。每个参数都可以是任意可迭代对象。

intersection(other: Iterable[Any]) → frozenset#: 返回一个新的 frozenset，包含该 frozenset 与 other 共有的元素。在 MicroPython 中只接受单个 other 参数（CPython 接受多个）。

isdisjoint(other: Iterable[Any]) → bool#: 如果该 frozenset 与 other 没有共同元素，则返回 True。

issubset(other: Iterable[Any]) → bool#: 如果该 frozenset 的每个元素都在 other 中，则返回 True。

issuperset(other: Iterable[Any]) → bool#: 如果 other 的每个元素都在该 frozenset 中，则返回 True。

symmetric_difference(other: Iterable[Any]) → frozenset#: 返回一个新的 frozenset，包含仅在该 frozenset 或仅在 other 中、但不同时在两者中的元素。在 MicroPython 中只接受单个 other 参数。

union(other: Iterable[Any]) → frozenset#: 返回一个新的 frozenset，包含来自该 frozenset 和 other 的元素。在 MicroPython 中只接受单个 other 参数（CPython 接受多个）。

getattr(obj: Any, name: str, default: Any = None) → Any#: 返回 obj 中名为该名称的属性的值。如果该属性不存在，则在提供了 default 时返回 default，否则引发 AttributeError。

globals() → dict#: 返回一个表示当前模块全局符号表的字典。

hasattr(obj: Any, name: str) → bool#: 如果 obj 具有名为给定 name 的属性，则返回 True，否则返回 False。

hash(obj: Any) → int#: 返回 obj 的哈希值（如果它有的话）。哈希值是整数，用于在字典查找过程中快速比较字典的键。

hex(x: int) → str#: 将整数转换为以 "0x" 为前缀的小写十六进制字符串。

id(obj: Any) → int#: 返回一个对象的标识。这是一个整数，保证在该对象的生命周期内唯一且恒定。

input(prompt: str = '') → str#: 从标准输入读取一行并将其作为字符串返回（不含末尾换行符）。如果给出 prompt，则会先将其写入标准输出（不含末尾换行符）。

class int(x: str | bytes | int | float = 0, base: int = 10)#

classmethod from_bytes(bytes: bytes, byteorder: str) → int#: 在 MicroPython 中，byteorder 参数必须是位置参数（这与 CPython 兼容）。

to_bytes(size: int, byteorder: str) → bytes#: 在 MicroPython 中，byteorder 参数必须是位置参数（这与 CPython 兼容）。

备注
不支持 CPython 中可选的 signed 关键字参数。MicroPython 当前将负整数转换为有符号，将正整数转换为无符号。（详情。）

isinstance(obj: Any, classinfo: type | tuple) → bool#: 如果 obj 是 classinfo 或其任意子类的实例，则返回 True。classinfo 可以是一个类或一个类的元组。

issubclass(cls: type, classinfo: type | tuple) → bool#: 如果 cls 是 classinfo 的子类（直接、间接或虚拟），则返回 True。

iter(obj: Any, sentinel: Any = None) → Iterator[Any]#: 返回一个迭代器对象。带一个参数时，obj 必须支持迭代协议。带两个参数时，obj 必须可调用，且当它返回 sentinel 时迭代停止。

len(obj: Any) → int#: 返回容器中项的数量。

class list(iterable: Iterable[Any] = ())#

构建一个新列表，可选地由 iterable 中的项填充。

append(object: Any) → None#: 将 object 追加到列表的末尾。

clear() → None#: 从列表中移除所有项，使其为空。

copy() → list#: 返回列表的浅拷贝。

count(value: Any) → int#: 返回列表中等于 value 的元素数量。

extend(iterable: Iterable[Any]) → None#: 将 iterable 中的所有项追加到列表的末尾。如果 iterable 本身是一个列表，则直接复制其各项；否则对其进行迭代。

index(value: Any, start: int = 0, stop: int = -1) → int#: 返回第一个等于 value 的元素的索引，在切片 [start:stop] 中搜索。如果 value 不存在，则引发 ValueError。

insert(index: int, object: Any) → None#: 在位置 index 之前插入 object。负的 index 会被解释为相对于列表末尾，并且索引会被钳制到有效范围内（因此超出任一端的值会在开头或末尾插入）。

pop(index: int = -1) → Any#: 移除并返回位于 index 处的项（默认为最后一项）。如果列表为空或 index 超出范围，则引发 IndexError。

remove(value: Any) → None#: 移除第一个等于 value 的元素。如果 value 不存在，则引发 ValueError。

reverse() → None#: 就地反转列表中各项的顺序。

sort(*, key: Callable[[Any], Any] | None = None, reverse: bool = False) → None#: 就地对列表中的各项进行排序。key 和 reverse 是仅限关键字参数。如果给出 key，它是一个应用于每个元素以产生比较值的函数；reverse 表示按降序排序。

备注
与 CPython 不同，MicroPython 的列表排序不稳定。

locals() → dict#: 返回一个表示当前局部符号表的字典。

map(function: Callable[..., Any], *iterables: Iterable[Any]) → Iterator[Any]#: 返回一个迭代器，它将 function 应用于 iterables 的每一项，并产生其结果。

max(*args: Any, key: Callable[[Any], Any] | None = None, default: Any = None) → Any#: 若带单个可迭代对象参数，则返回其中最大的项。若带两个或更多参数，则返回最大的参数。

class memoryview(obj: Any)#: 创建一个引用 obj 的 memoryview，obj 必须支持缓冲协议（例如 bytes、bytearray、array.array）。它允许对底层内存进行零拷贝访问和切片；对 memoryview 切片返回的是另一个 memoryview 而不是副本。

min(*args: Any, key: Callable[[Any], Any] | None = None, default: Any = None) → Any#: 若带单个可迭代对象参数，则返回其中最小的项。若带两个或更多参数，则返回最小的参数。

next(iterator: Iterator[Any], default: Any = None) → Any#: 从 iterator 中获取下一项。如果给出 default 且迭代器已耗尽，则返回 default 而不引发 StopIteration。

class object#: 返回一个新的无特征对象。object 是所有类的基类。

oct(x: int) → str#: 将整数转换为以 "0o" 为前缀的八进制字符串。

open(file: str, mode: str = 'r', **kwargs) → Any#: 打开 file 并返回相应的文件对象。mode 默认为用于文本读取的 "r"。

ord(c: str) → int#: 以整数形式返回单字符字符串 c 的 Unicode 码点。

pow(base: Any, exp: Any, mod: Any | None = None) → Any#: 返回 base 的 exp 次幂。如果给出 mod，则返回 base ** exp % mod（比显式形式计算得更高效）。

print(*objects: Any, sep: str = ' ', end: str = '\n', file: Any = None) → None#: 将 objects 打印到文本流 file，各项之间以 sep 分隔，并以 end 结尾。

property(fget: Callable[[Any], Any] | None = None, fset: Callable[[Any, Any], None] | None = None, fdel: Callable[[Any], None] | None = None, doc: str | None = None) → property#: 返回一个 property 属性。通常用作装饰器，以在类上定义托管属性。

range(*args: int) → range#: 返回一个不可变的整数序列。以 range(stop)、range(start, stop) 或 range(start, stop, step) 形式调用。

repr(obj: Any) → str#: 返回一个包含 obj 可打印表示的字符串。

reversed(seq: Any) → Iterator[Any]#: 返回给定序列的值的反向迭代器。

round(number: Any, ndigits: int | None = None) → Any#: 返回 number 四舍五入到 ndigits 位小数的结果。如果省略 ndigits，则返回最接近的整数。

class set(iterable: Iterable[Any] = ())#

返回一个新的 set 对象，可选地包含取自 iterable 的元素。

add(elem: Any) → None#: 将元素 elem 添加到集合中。

clear() → None#: 从集合中移除所有元素。

copy() → set#: 返回集合的浅拷贝。

difference(*others: Iterable[Any]) → set#: 返回一个新集合，包含该集合中不在任何 others 中的元素。每个参数都可以是任意可迭代对象。

difference_update(*others: Iterable[Any]) → None#: 从集合中移除在任意 others 中找到的所有元素（就地操作）。

discard(elem: Any) → None#: 如果元素 elem 存在于集合中，则将其移除。与 remove() 不同，当 elem 不存在时这不会引发错误。

intersection(other: Iterable[Any]) → set#: 返回一个新集合，包含该集合与 other 共有的元素。在 MicroPython 中只接受单个 other 参数（CPython 接受多个）。

intersection_update(other: Iterable[Any]) → None#: 更新集合，只保留同时也在 other 中找到的元素（就地操作）。在 MicroPython 中只接受单个 other 参数。

isdisjoint(other: Iterable[Any]) → bool#: 如果该集合与 other 没有共同元素，则返回 True。

issubset(other: Iterable[Any]) → bool#: 如果该集合的每个元素都在 other 中，则返回 True。

issuperset(other: Iterable[Any]) → bool#: 如果 other 的每个元素都在该集合中，则返回 True。

pop() → Any#: 从集合中移除并返回任意一个元素。如果集合为空，则引发 KeyError。

remove(elem: Any) → None#: 从集合中移除元素 elem。如果 elem 不包含在集合中，则引发 KeyError。

symmetric_difference(other: Iterable[Any]) → set#: 返回一个新集合，包含仅在该集合或仅在 other 中、但不同时在两者中的元素。在 MicroPython 中只接受单个 other 参数。

symmetric_difference_update(other: Iterable[Any]) → None#: 更新集合，只保留仅在该集合或仅在 other 中、但不同时在两者中的元素（就地操作）。在 MicroPython 中只接受单个 other 参数。

union(other: Iterable[Any]) → set#: 返回一个新集合，包含来自该集合和 other 的元素。在 MicroPython 中只接受单个 other 参数（CPython 接受多个）。

update(*others: Iterable[Any]) → None#: 更新集合，添加来自所有 others 的元素（就地操作）。

setattr(obj: Any, name: str, value: Any) → None#: 将 obj 上名为该名称的属性设置为 value。它是 getattr() 的对应函数。

class slice#: slice 内置是切片对象所属的类型。

sorted(iterable: Iterable[Any], key: Callable[[Any], Any] | None = None, reverse: bool = False) → list#: 由 iterable 中的各项返回一个新的已排序列表。

staticmethod(func: Callable[..., Any]) → staticmethod#: 将一个方法转换为静态方法。通常用作装饰器。

class str(object: Any = '', encoding: str = 'utf-8', errors: str = 'strict')#

返回 object 的字符串版本。如果 object 是类字节对象，则 encoding 和 errors 参数控制解码方式。

center(width: int) → str#: 返回字符串居中放置于长度为 width 的字段中的副本，并用空格填充。在 MicroPython 中只使用空格作为填充字符（没有填充字符参数），且当 width 不大于其长度时原样返回原字符串。

count(sub: str, start: int = 0, end: int = -1) → int#: 返回 sub 在切片 [start:end] 中非重叠出现的次数。空的 sub 会对字符之间的每个间隙计数。

encode(encoding: str = 'utf-8', errors: str = 'strict') → bytes#: 返回一个对该字符串进行编码的 bytes 对象。MicroPython 实际上忽略这些参数并使用 UTF-8；errors 被接受但不起作用。等价于 bytes(s, "utf-8")。

endswith(suffix: str | tuple, start: int = 0, end: int = -1) → bool#: 如果字符串以给定的 suffix 结尾，则返回 True，suffix 可以是单个字符串或要尝试的字符串元组。可选的 start 和 end 将比较限制在切片 [start:end] 内。

find(sub: str, start: int = 0, end: int = -1) → int#: 返回子串 sub 在字符串切片 [start:end] 中被找到的最小索引，若未找到则返回 -1。

format(*args: Any, **kwargs: Any) → str#: 执行字符串格式化操作，将由花括号 {} 分隔的替换字段替换为来自 args 和 kwargs 的值。支持标准的格式规范迷你语言。

index(sub: str, start: int = 0, end: int = -1) → int#: 与 find() 类似，但当在切片 [start:end] 中未找到子串 sub 时引发 ValueError。

isalpha() → bool#: 如果字符串中所有字符都是字母且字符串非空，则返回 True，否则返回 False。

isdigit() → bool#: 如果字符串中所有字符都是数字且字符串非空，则返回 True，否则返回 False。

islower() → bool#: 如果字符串至少包含一个字母字符且所有此类字符都是小写，则返回 True，否则返回 False。

isspace() → bool#: 如果字符串中所有字符都是空白字符且字符串非空，则返回 True，否则返回 False。

isupper() → bool#: 如果字符串至少包含一个字母字符且所有此类字符都是大写，则返回 True，否则返回 False。

join(iterable: Iterable[str]) → str#: 连接 iterable 中的各字符串，在元素之间插入该字符串作为分隔符。各项必须是字符串，否则引发 TypeError。

lower() → str#: 返回字符串所有字符都转换为小写后的副本。

lstrip(chars: str | None = None) → str#: 返回去除了开头字符的字符串副本。如果省略 chars 或其为 None，则去除空白字符；否则将 chars 视为要去除的字符集合。

partition(sep: str) → tuple#: 在 sep 首次出现处分割字符串，并返回一个三元组 (head, sep, tail)。如果未找到 sep，则返回 (self, "", "")。空的 sep 会引发 ValueError。

replace(old: str, new: str, count: int = -1) → str#: 返回所有出现的子串 old 都被替换为 new 后的字符串副本。如果给出非负的 count，则只替换前 count 次出现。

rfind(sub: str, start: int = 0, end: int = -1) → int#: 返回子串 sub 在字符串切片 [start:end] 中被找到的最大索引，若未找到则返回 -1。

rindex(sub: str, start: int = 0, end: int = -1) → int#: 与 rfind() 类似，但当在切片 [start:end] 中未找到子串 sub 时引发 ValueError。

rpartition(sep: str) → tuple#: 在 sep 最后一次出现处分割字符串，并返回一个三元组 (head, sep, tail)。如果未找到 sep，则返回 ("", "", self)。空的 sep 会引发 ValueError。

rsplit(sep: str | None = None, maxsplit: int = -1) → list#: 以 sep 作为分隔符从右侧将字符串分割为子串列表，最多进行 maxsplit 次分割。在没有 maxsplit（或为负值）时，其行为与 split() 完全相同；在 MicroPython 中，以非负 n 调用 rsplit(None, n) 会引发 NotImplementedError。

rstrip(chars: str | None = None) → str#: 返回去除了结尾字符的字符串副本。如果省略 chars 或其为 None，则去除空白字符；否则将 chars 视为要去除的字符集合。

split(sep: str | None = None, maxsplit: int = -1) → list#: 以 sep 作为分隔符将字符串分割为子串列表，最多进行 maxsplit 次分割。如果省略 sep 或其为 None，则按连续的空白字符分割并忽略开头的空白；否则空的 sep 会引发 ValueError。

splitlines(keepends: bool = False) → list#: 返回字符串中各行组成的列表，在 \n、\r 和 \r\n 处断行。除非 keepends 为真，否则不包含换行符。

startswith(prefix: str | tuple, start: int = 0, end: int = -1) → bool#: 如果字符串以给定的 prefix 开头，则返回 True，prefix 可以是单个字符串或要尝试的字符串元组。可选的 start 和 end 将比较限制在切片 [start:end] 内。

strip(chars: str | None = None) → str#: 返回去除了开头和结尾字符的字符串副本。如果省略 chars 或其为 None，则去除空白字符；否则将 chars 视为要去除的字符集合。

upper() → str#: 返回字符串所有字符都转换为大写后的副本。

sum(iterable: Iterable[Any], start: Any = 0) → Any#: 从左到右对 start 和 iterable 中的各项求和，并返回总和。

super(type: type | None = None, obj_or_type: Any | None = None) → Any#: 返回一个代理对象，它将方法调用委托给 type 的父类或兄弟类。这对于访问在类中被重写的继承方法很有用。

class tuple(iterable: Iterable[Any] = ())#

构建一个新元组，可选地由 iterable 中的项填充。元组是不可变序列。

count(value: Any) → int#: 返回元组中等于 value 的元素数量。

index(value: Any, start: int = 0, stop: int = -1) → int#: 返回第一个等于 value 的元素的索引，在切片 [start:stop] 中搜索。如果 value 不存在，则引发 ValueError。

type(obj: Any) → type#: 带一个参数时，返回 obj 的类型。返回值是一个类型对象。

zip(*iterables: Iterable[Any]) → Iterator[tuple]#: 返回一个元组的迭代器，其中第 i 个元组包含来自每个参数可迭代对象的第 i 个元素。当最短的输入可迭代对象耗尽时，迭代停止。

异常#

exception AssertionError#: 当 assert 语句失败时引发。

exception AttributeError#: 当属性引用或赋值失败时引发。

exception Exception#: 所有非系统退出异常的公共基类。

exception ImportError#: 当 import 语句未能找到模块定义时引发。

exception IndexError#: 当序列下标超出范围时引发。

exception KeyboardInterrupt#

当用户中断程序执行时引发，通常是在 REPL 上按下 Ctrl+C。

另见软变砖（无法启动）相关内容。

exception KeyError#: 当映射（字典）的键在现有键集合中找不到时引发。

exception MemoryError#: 当某项操作耗尽内存时引发。

exception NameError#: 当找不到局部或全局名称时引发。

exception NotImplementedError#: 当调用抽象方法或未实现的功能时引发。

exception OSError#: 当系统函数返回与系统相关的错误时引发。

exception RuntimeError#: 当检测到不属于任何其他类别的错误时引发。

exception StopIteration#: 由 next() 和迭代器的 __next__() 方法引发，用以表示没有更多项了。

exception SyntaxError#: 当解析器遇到语法错误时引发。

exception SystemExit#

由 sys.exit() 引发，以请求解释器终止。与大多数异常不同，它在未被捕获时不会产生回溯。

在 OpenMV Cam 上，未处理的 SystemExit 当前会导致 MicroPython 的软复位。

exception TypeError#: 当对不适当类型的对象应用某项操作或函数时引发。

exception ValueError#: 当内置操作或函数接收到类型正确但值不适当的参数时引发。

exception ZeroDivisionError#: 当除法或取模运算的第二个参数为零时引发。

builtins --- 内置函数和异常#

函数和类型#

异常#

`builtins` --- 内置函数和异常#