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)

返回一个布尔值,即 TrueFalse 之一。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 次分割。如果 sepNone 或省略,则按连续的 ASCII 空白字符分割。

rstrip(chars: bytes | None = None) bytes

返回去除了结尾字节的副本。chars 指定要去除的字节集合;如果省略或为 None,则去除 ASCII 空白字符。

split(sep: bytes | None = None, maxsplit: int = -1) list

sep 出现处将内容分割为一个片段列表。如果 sepNone 或省略,则按连续的 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 次分割。如果 sepNone 或省略,则按连续的 ASCII 空白字符分割。

rstrip(chars: bytes | None = None) bytes

返回去除了结尾字节的副本。chars 指定要去除的字节集合;如果省略或为 None,则去除 ASCII 空白字符。

split(sep: bytes | None = None, maxsplit: int = -1) list

sep 出现处将内容分割为一个片段列表。如果 sepNone 或省略,则按连续的 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

返回字典的浅拷贝。返回的对象与原对象类型相同(dictOrderedDict),但不是固定的。

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]

iterablefunction 返回真值的那些元素构造一个迭代器。如果 functionNone,则假定为恒等函数。

class float(x: str | bytes | int | float = 0.0)

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

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

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

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

如果 objclassinfo 或其任意子类的实例,则返回 Trueclassinfo 可以是一个类或一个类的元组。

issubclass(cls: type, classinfo: type | tuple) bool

如果 clsclassinfo 的子类(直接、间接或虚拟),则返回 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

就地对列表中的各项进行排序。keyreverse 是仅限关键字参数。如果给出 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 必须支持缓冲协议(例如 bytesbytearrayarray.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

返回 baseexp 次幂。如果给出 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 是类字节对象,则 encodingerrors 参数控制解码方式。

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 结尾,则返回 Truesuffix 可以是单个字符串或要尝试的字符串元组。可选的 startend 将比较限制在切片 [start:end] 内。

find(sub: str, start: int = 0, end: int = -1) int

返回子串 sub 在字符串切片 [start:end] 中被找到的最小索引,若未找到则返回 -1

format(*args: Any, **kwargs: Any) str

执行字符串格式化操作,将由花括号 {} 分隔的替换字段替换为来自 argskwargs 的值。支持标准的格式规范迷你语言。

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 开头,则返回 Trueprefix 可以是单个字符串或要尝试的字符串元组。可选的 startend 将比较限制在切片 [start:end] 内。

strip(chars: str | None = None) str

返回去除了开头和结尾字符的字符串副本。如果省略 chars 或其为 None,则去除空白字符;否则将 chars 视为要去除的字符集合。

upper() str

返回字符串所有字符都转换为大写后的副本。

sum(iterable: Iterable[Any], start: Any = 0) Any

从左到右对 startiterable 中的各项求和,并返回总和。

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

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