Vestavěné typy¶

Generated Fri 19 Jun 2026 22:08:45 UTC

Výjimka¶

Všechny výjimky mají čitelné atributy `value` a `errno`, nejen `StopIteration` a `OSError`.¶

Příčina: MicroPython je optimalizován pro zmenšení velikosti kódu.

Řešení: Používejte value pouze u výjimek StopIteration a errno pouze u výjimek OSError. Nespoléhejte na tyto atributy u jiných výjimek.

Ukázkový kód:

e = Exception(1)
print(e.value)
print(e.errno)

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 9, in <module> AttributeError: 'Exception' object has no attribute 'value'	1 1

Řetězení výjimek není implementováno¶

Ukázkový kód:

try:
    raise TypeError
except TypeError:
    raise ValueError

CPython output:

MicroPython output:

Traceback (most recent call last):
  File "<stdin>", line 9, in <module>
TypeError

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 11, in <module>
ValueError

Traceback (most recent call last):
  File "<stdin>", line 11, in <module>
ValueError:

Uživatelsky definované atributy pro vestavěné výjimky nejsou podporovány¶

Příčina: MicroPython je vysoce optimalizován pro využití paměti.

Řešení: Používejte uživatelsky definované podtřídy výjimek.

Ukázkový kód:

e = Exception()
e.x = 0
print(e.x)

CPython output:	MicroPython output:
0	Traceback (most recent call last): File "<stdin>", line 9, in <module> AttributeError: 'Exception' object has no attribute 'x'

Výjimka v podmínce cyklu while může mít neočekávané číslo řádku¶

Příčina: Kontroly podmínky jsou optimalizovány tak, aby probíhaly na konci těla smyčky, a toto číslo řádku je hlášeno.

Ukázkový kód:

l = ["-foo", "-bar"]

i = 0
while l[i][0] == "-":
    print("iter")
    i += 1

CPython output:

MicroPython output:

iter
iter
Traceback (most recent call last):
  File "<stdin>", line 11, in <module>
IndexError: list index out of range

iter
iter
Traceback (most recent call last):
  File "<stdin>", line 13, in <module>
IndexError: list index out of range

Metoda Exception.init neexistuje.¶

Příčina: Vytváření podtříd nativních tříd není v MicroPython plně podporováno.

Řešení: Místo toho volejte pomocí super():

class A(Exception):
    def __init__(self):
        super().__init__()

Ukázkový kód:

class A(Exception):
    def __init__(self):
        Exception.__init__(self)


a = A()

CPython output:	MicroPython output:
	Traceback (most recent call last): File "<stdin>", line 18, in <module> File "<stdin>", line 15, in __init__ AttributeError: type object 'Exception' has no attribute '__init__'

OSError¶

OSError constructor returns a plain OSError for all errno values, rather than a relevant subtype.¶

Cause: MicroPython does not include the CPython-standard OSError subclasses.

Workaround: Catch OSError and use its errno attribute to discriminate the cause.

Ukázkový kód:

import errno

errno_list = [  # i.e. the set implemented by micropython
    errno.EPERM,
    errno.ENOENT,
    errno.EIO,
    errno.EBADF,
    errno.EAGAIN,
    errno.ENOMEM,
    errno.EACCES,
    errno.EEXIST,
    errno.ENODEV,
    errno.EISDIR,
    errno.EINVAL,
    errno.EOPNOTSUPP,
    errno.EADDRINUSE,
    errno.ECONNABORTED,
    errno.ECONNRESET,
    errno.ENOBUFS,
    errno.ENOTCONN,
    errno.ETIMEDOUT,
    errno.ECONNREFUSED,
    errno.EHOSTUNREACH,
    errno.EALREADY,
    errno.EINPROGRESS,
]


def errno_output_type(n):
    try:
        raise OSError(n, "")
    except OSError as e:
        return f"{type(e).__name__}"
    except Exception as e:
        return f"non-OSError {type(e).__name__}"
    else:
        return "no error"


for n in errno_list:
    print(errno.errorcode[n], "=", errno_output_type(n))

CPython output:

MicroPython output:

EPERM = PermissionError
ENOENT = FileNotFoundError
EIO = OSError
EBADF = OSError
EAGAIN = BlockingIOError
ENOMEM = OSError
EACCES = PermissionError
EEXIST = FileExistsError
ENODEV = OSError
EISDIR = IsADirectoryError
EINVAL = OSError
ENOTSUP = OSError
EADDRINUSE = OSError
ECONNABORTED = ConnectionAbortedError
ECONNRESET = ConnectionResetError
ENOBUFS = OSError
ENOTCONN = OSError
ETIMEDOUT = TimeoutError
ECONNREFUSED = ConnectionRefusedError
EHOSTUNREACH = OSError
EALREADY = BlockingIOError
EINPROGRESS = BlockingIOError

EPERM = OSError
ENOENT = OSError
EIO = OSError
EBADF = OSError
EAGAIN = OSError
ENOMEM = OSError
EACCES = OSError
EEXIST = OSError
ENODEV = OSError
EISDIR = OSError
EINVAL = OSError
EOPNOTSUPP = OSError
EADDRINUSE = OSError
ECONNABORTED = OSError
ECONNRESET = OSError
ENOBUFS = OSError
ENOTCONN = OSError
ETIMEDOUT = OSError
ECONNREFUSED = OSError
EHOSTUNREACH = OSError
EALREADY = OSError
EINPROGRESS = OSError

bytearray¶

Přiřazení řezu pole s nepodporovanou pravou stranou¶

Ukázkový kód:

b = bytearray(4)
b[0:1] = [1, 2]
print(b)

CPython output:	MicroPython output:
bytearray(b'\x01\x02\x00\x00\x00')	Traceback (most recent call last): File "<stdin>", line 9, in <module> NotImplementedError: array/bytes required on right side

bytes¶

Objekty bytes podporují metodu .format()¶

Příčina: MicroPython se snaží být pravidelnější implementací, takže pokud str i bytes podporují __mod__() (operátor %), dává smysl podporovat format() pro obě. Podpora __mod__ může být také zkompilována pryč, čímž zbyde pouze format() pro formátování bytes.

Řešení: Pokud vás zajímá kompatibilita s CPython, nepoužívejte .format() na objektech bytes.

Ukázkový kód:

print(b"{}".format(1))

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 8, in <module> AttributeError: 'bytes' object has no attribute 'format'	b'1'

bytes() s klíčovými argumenty není implementováno¶

Řešení: Předejte kódování jako poziční parametr, např. print(bytes('abc', 'utf-8'))

Ukázkový kód:

print(bytes("abc", encoding="utf8"))

CPython output:	MicroPython output:
b'abc'	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: keyword argument(s) not implemented - use normal args instead

Indexování bytes s krokem != 1 není implementováno¶

Příčina: MicroPython je vysoce optimalizován pro využití paměti.

Řešení: Pro tuto velmi vzácnou operaci použijte explicitní smyčku.

Ukázkový kód:

print(b"123"[0:3:2])

CPython output:	MicroPython output:
b'13'	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: only slices with step=1 (aka None) are supported

complex¶

MicroPython’s complex() accepts certain incorrect values that CPython rejects¶

Příčina: MicroPython je vysoce optimalizován pro využití paměti.

Workaround: Do not use non-standard complex literals as argument to complex()

MicroPython’s complex() function accepts literals that contain a space and no sign between the real and imaginary parts, and interprets it as a plus.

Ukázkový kód:

try:
    print(complex("1 1j"))
except ValueError:
    print("ValueError")

CPython output:	MicroPython output:
ValueError	(1+1j)

dict¶

Pohled na klíče slovníku se nechová jako množina.¶

Příčina: Není implementováno.

Řešení: Před použitím množinových operací explicitně převeďte klíče na množinu.

Ukázkový kód:

print({1: 2, 3: 4}.keys() & {1})

CPython output:	MicroPython output:
{1}	Traceback (most recent call last): File "<stdin>", line 8, in <module> TypeError: unsupported types for __and__: 'dict_view', 'set'

float¶

MicroPython allows implicit conversion of objects in maths operations while CPython does not.¶

Řešení: Pro kompatibilitu s CPython by objekty měly být zabaleny do float(obj).

Ukázkový kód:

class Test:
    def __float__(self):
        return 0.5


print(2.0 * Test())

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 14, in <module> TypeError: unsupported operand type(s) for *: 'float' and 'Test'	1.0

int¶

Metoda `bit_length` neexistuje.¶

Příčina: Metoda bit_length není implementována.

Řešení: Vyhněte se používání této metody v MicroPython.

Ukázkový kód:

x = 255
print("{} is {} bits long.".format(x, x.bit_length()))

CPython output:	MicroPython output:
255 is 8 bits long.	Traceback (most recent call last): File "<stdin>", line 9, in <module> AttributeError: 'int' object has no attribute 'bit_length'

Není dostupná konverze int pro typy odvozené od int¶

Řešení: Vyhněte se vytváření podtříd vestavěných typů, pokud to není skutečně nutné. Dávejte přednost https://en.wikipedia.org/wiki/Composition_over_inheritance .

Ukázkový kód:

class A(int):
    __add__ = lambda self, other: A(int(self) + other)


a = A(42)
print(a + a)

CPython output:	MicroPython output:
84	Traceback (most recent call last): File "<stdin>", line 14, in <module> File "<stdin>", line 10, in <lambda> TypeError: unsupported types for __radd__: 'int', 'int'

Metoda `to_bytes` neimplementuje parametr signed.¶

Příčina: Parametr signed (pouze jako klíčové slovo) není implementován pro int.to_bytes().

Pokud je celé číslo záporné, MicroPython se chová stejně jako CPython int.to_bytes(..., signed=True)

Pokud je celé číslo nezáporné, MicroPython se chová stejně jako CPython int.to_bytes(..., signed=False).

(Rozdíl je jemný, ale v CPython může kladné celé číslo převedené s signed=True vyžadovat o jeden bajt více ve výstupní délce, aby se vešel bit znaménka 0.)

Řešení: Buďte opatrní při volání to_bytes() na celém čísle, které může být záporné.

Ukázkový kód:

x = -1
print(x.to_bytes(1, "big"))

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 16, in <module> OverflowError: can't convert negative int to unsigned	b'\xff'

list¶

Mazání ze seznamu s krokem != 1 není implementováno¶

Řešení: Pro tuto vzácnou operaci použijte explicitní smyčku.

Ukázkový kód:

l = [1, 2, 3, 4]
del l[0:4:2]
print(l)

CPython output:	MicroPython output:
[2, 4]	Traceback (most recent call last): File "<stdin>", line 9, in <module> NotImplementedError:

Ukládání řezu seznamu s neiterovatelnými hodnotami na pravé straně není implementováno¶

Příčina: Pravá strana musí být tuple nebo list

Řešení: Použijte list(<iter>) na pravé straně pro převod iterovatelného objektu na list

Ukázkový kód:

l = [10, 20]
l[0:1] = range(4)
print(l)

CPython output:	MicroPython output:
[0, 1, 2, 3, 20]	Traceback (most recent call last): File "<stdin>", line 9, in <module> TypeError: object 'range' isn't a tuple or list

Ukládání do seznamu s krokem != 1 není implementováno¶

Řešení: Pro tuto vzácnou operaci použijte explicitní smyčku.

Ukázkový kód:

l = [1, 2, 3, 4]
l[0:4:2] = [5, 6]
print(l)

CPython output:	MicroPython output:
[5, 2, 6, 4]	Traceback (most recent call last): File "<stdin>", line 9, in <module> NotImplementedError:

memoryview¶

memoryview může být neplatné, pokud je změněna velikost jeho cíle¶

Příčina: CPython zabraňuje objektu bytearray nebo io.bytesIO měnit velikost, pokud existuje objekt memoryview, který na něj odkazuje. MicroPython vyžaduje, aby programátor ručně zajistil, že velikost objektu není měněna, dokud na něj odkazuje jakékoli memoryview.

V nejhorším případě může změna velikosti objektu, který je cílem memoryview, způsobit, že memoryview odkazuje na neplatnou uvolněnou paměť (chyba use-after-free) a poškodí běhové prostředí MicroPython.

Řešení: Neměňte velikost žádného objektu bytearray nebo io.bytesIO, který má přiřazené memoryview.

Ukázkový kód:

b = bytearray(b"abcdefg")
m = memoryview(b)
b.extend(b"hijklmnop")
print(b, bytes(m))

CPython output:	MicroPython output:
Traceback (most recent call last): File "<stdin>", line 12, in <module> BufferError: Existing exports of data: object cannot be re-sized	bytearray(b'abcdefghijklmnop') b'abcdefg'

range¶

Range objects with large start or stop arguments misbehave.¶

Cause: Intermediate calculations overflow the C mp_int_t type

Workaround: Avoid using such ranges

Ukázkový kód:

from sys import maxsize

# A range including `maxsize-1` cannot be created
try:
    print(range(-maxsize - 1, 0))
except OverflowError:
    print("OverflowError")

# A range with `stop-start` exceeding sys.maxsize has incorrect len(), while CPython cannot calculate len().
try:
    print(len(range(-maxsize, maxsize)))
except OverflowError:
    print("OverflowError")

# A range with `stop-start` exceeding sys.maxsize has incorrect len()
try:
    print(len(range(-maxsize, maxsize, maxsize)))
except OverflowError:
    print("OverflowError")

CPython output:	MicroPython output:
range(-9223372036854775808, 0) OverflowError 2	OverflowError 0 0

str¶

MicroPython accepts the „,“ grouping option with any radix, unlike CPython¶

Cause: To reduce code size, MicroPython does not issue an error for this combination

Workaround: Do not use a format string like {:,b} if CPython compatibility is required.

Ukázkový kód:

try:
    print("{:,b}".format(99))
except ValueError:
    print("ValueError")
try:
    print("{:,x}".format(99))
except ValueError:
    print("ValueError")
try:
    print("{:,o}".format(99))
except ValueError:
    print("ValueError")

CPython output:	MicroPython output:
ValueError ValueError ValueError	110,0011 63 143

MicroPython accepts but does not properly implement the „,“ or „_“ grouping character for float values¶

Cause: To reduce code size, MicroPython does not implement this combination. Grouping characters will not appear in the number’s significant digits and will appear at incorrect locations in leading zeros.

Workaround: Do not use a format string like {:,f} if exact CPython compatibility is required.

Ukázkový kód:

print("{:,f}".format(3141.159))
print("{:_f}".format(3141.159))
print("{:011,.2f}".format(3141.159))
print("{:011_.2f}".format(3141.159))

CPython output:	MicroPython output:
3,141.159000 3_141.159000 0,003,141.16 0_003_141.16	3141.159000 3141.159000 000,3141.16 0_003141.16

Atributy/indexování nejsou implementovány¶

Ukázkový kód:

print("{a[0]}".format(a=[1, 2]))

CPython output:	MicroPython output:
1	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: attributes not supported

str(…) s klíčovými argumenty není implementováno¶

Řešení: Zadejte formát kódování přímo. Např. print(bytes('abc', 'utf-8'))

Ukázkový kód:

print(str(b"abc", encoding="utf8"))

CPython output:	MicroPython output:
abc	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: keyword argument(s) not implemented - use normal args instead

str.ljust() a str.rjust() nejsou implementovány¶

Příčina: MicroPython je vysoce optimalizován pro využití paměti. Jsou k dispozici snadná alternativní řešení.

Řešení: Místo s.ljust(10) použijte "%-10s" % s, místo s.rjust(10) použijte "% 10s" % s. Alternativně "{:<10}".format(s) nebo "{:>10}".format(s).

Ukázkový kód:

print("abc".ljust(10))

CPython output:	MicroPython output:
abc	Traceback (most recent call last): File "<stdin>", line 8, in <module> AttributeError: 'str' object has no attribute 'ljust'

None jako první argument pro rsplit, např. str.rsplit(None, n), není implementováno¶

Ukázkový kód:

print("a a a".rsplit(None, 1))

CPython output:	MicroPython output:
['a a', 'a']	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: rsplit(None,n)

Indexování s krokem != 1 zatím není implementováno¶

Ukázkový kód:

print("abcdefghi"[0:9:2])

CPython output:	MicroPython output:
acegi	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: only slices with step=1 (aka None) are supported

tuple¶

Načítání tuple s krokem != 1 není implementováno¶

Ukázkový kód:

print((1, 2, 3, 4)[0:4:2])

CPython output:	MicroPython output:
(1, 3)	Traceback (most recent call last): File "<stdin>", line 8, in <module> NotImplementedError: only slices with step=1 (aka None) are supported

Vestavěné typy¶

Výjimka¶

Všechny výjimky mají čitelné atributy value a errno, nejen StopIteration a OSError.¶

Řetězení výjimek není implementováno¶

Uživatelsky definované atributy pro vestavěné výjimky nejsou podporovány¶

Výjimka v podmínce cyklu while může mít neočekávané číslo řádku¶

Metoda Exception.__init__ neexistuje.¶

OSError¶

OSError constructor returns a plain OSError for all errno values, rather than a relevant subtype.¶

bytearray¶

Přiřazení řezu pole s nepodporovanou pravou stranou¶

bytes¶

Objekty bytes podporují metodu .format()¶

bytes() s klíčovými argumenty není implementováno¶

Indexování bytes s krokem != 1 není implementováno¶

complex¶

MicroPython’s complex() accepts certain incorrect values that CPython rejects¶

dict¶

Pohled na klíče slovníku se nechová jako množina.¶

float¶

MicroPython allows implicit conversion of objects in maths operations while CPython does not.¶

int¶

Metoda bit_length neexistuje.¶

Není dostupná konverze int pro typy odvozené od int¶

Metoda to_bytes neimplementuje parametr signed.¶

list¶

Mazání ze seznamu s krokem != 1 není implementováno¶

Ukládání řezu seznamu s neiterovatelnými hodnotami na pravé straně není implementováno¶

Ukládání do seznamu s krokem != 1 není implementováno¶

memoryview¶

memoryview může být neplatné, pokud je změněna velikost jeho cíle¶

range¶

Range objects with large start or stop arguments misbehave.¶

str¶

MicroPython accepts the „,“ grouping option with any radix, unlike CPython¶

MicroPython accepts but does not properly implement the „,“ or „_“ grouping character for float values¶

Atributy/indexování nejsou implementovány¶

str(…) s klíčovými argumenty není implementováno¶

str.ljust() a str.rjust() nejsou implementovány¶

None jako první argument pro rsplit, např. str.rsplit(None, n), není implementováno¶

Indexování s krokem != 1 zatím není implementováno¶

tuple¶

Načítání tuple s krokem != 1 není implementováno¶

Všechny výjimky mají čitelné atributy `value` a `errno`, nejen `StopIteration` a `OSError`.¶

Metoda Exception.init neexistuje.¶

Metoda `bit_length` neexistuje.¶

Metoda `to_bytes` neimplementuje parametr signed.¶