`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 物件，其為以 bytearray 內容作為分隔符，將 iterable 中的項目串接而成。

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 的字串，或任何符合緩衝協定的物件建立。Bytes 字面值使用 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#: 回傳由 bytes 解碼而成的 str。在 MicroPython 中，encoding 引數雖被接受但實際上會被忽略（bytes 會被重新解讀為 UTF-8）。

endswith(suffix: bytes, start: int = 0, end: int = -1) → bool#: 若 bytes 以 suffix 結尾，則回傳 True。與 CPython 不同，suffix 不能是要嘗試的值元組。

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

format(*args: Any, **kwargs: Any) → str#: 以 bytes 作為格式字串執行字串格式化操作，回傳格式化後的結果。

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 物件，其為以 bytes 物件本身作為分隔符，將 iterable 中的項目串接而成。

lower() → bytes#: 回傳將所有 ASCII 大寫字元轉換為小寫的副本。

lstrip(chars: bytes | None = None) → bytes#: 回傳移除前導位元組後的副本。chars 指定要移除的位元組集合；若省略或為 None，則移除 ASCII 空白。

partition(sep: bytes) → tuple#: 在 sep 第一次出現處分割，回傳 (head, sep, tail)。若未找到 sep，則回傳 bytes 後接兩個空 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 物件後接 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#: 若 bytes 以 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) 配對，以 2 元組形式回傳。對於一般的 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#: 回傳一個特性屬性。通常用作裝飾器，以在類別上定義受管理的屬性。

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 內建是 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 為類 bytes 物件，則 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 第一次出現處分割字串並回傳 3 元組 (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 最後一次出現處分割字串並回傳 3 元組 (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` --- 內建函式與例外#