Tipi incorporati¶

Generated Fri 19 Jun 2026 22:08:45 UTC

Eccezione¶

Tutte le eccezioni hanno attributi leggibili `value` ed `errno`, non solo `StopIteration` e `OSError`.¶

Causa: MicroPython è ottimizzato per ridurre la dimensione del codice.

Soluzione alternativa: Usare value solo sulle eccezioni StopIteration ed errno solo sulle eccezioni OSError. Non usare né fare affidamento su questi attributi per altre eccezioni.

Codice di esempio:

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

Concatenamento di eccezioni non implementato¶

Codice di esempio:

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:

Gli attributi definiti dall’utente per le eccezioni incorporate non sono supportati¶

Causa: MicroPython è altamente ottimizzato per l’utilizzo della memoria.

Soluzione alternativa: Usare sottoclassi di eccezioni definite dall’utente.

Codice di esempio:

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'

Un’eccezione nella condizione del ciclo while può avere un numero di riga inatteso¶

Causa: I controlli delle condizioni sono ottimizzati per avvenire alla fine del corpo del ciclo e viene riportato quel numero di riga.

Codice di esempio:

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

Il metodo Exception.init non esiste.¶

Causa: La creazione di sottoclassi di classi native non è completamente supportata in MicroPython.

Soluzione alternativa: Usare invece super():

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

Codice di esempio:

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.

Codice di esempio:

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¶

Assegnazione di slice di array con RHS non supportato¶

Codice di esempio:

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¶

Gli oggetti bytes supportano il metodo .format()¶

Causa: MicroPython punta a essere un’implementazione più uniforme: poiché sia str che bytes supportano __mod__() (l’operatore %), ha senso supportare format() per entrambi. Il supporto per __mod__ può anche essere escluso dalla compilazione, lasciando solo format() per la formattazione di bytes.

Soluzione alternativa: Se si desidera compatibilità con CPython, non usare .format() sugli oggetti bytes.

Codice di esempio:

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() con argomenti keyword non implementato¶

Soluzione alternativa: Passare la codifica come parametro posizionale, ad es. print(bytes('abc', 'utf-8'))

Codice di esempio:

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

L’indicizzazione di bytes con passo != 1 non è implementata¶

Causa: MicroPython è altamente ottimizzato per l’utilizzo della memoria.

Soluzione alternativa: Usare un ciclo esplicito per questa operazione molto rara.

Codice di esempio:

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¶

Causa: MicroPython è altamente ottimizzato per l’utilizzo della memoria.

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.

Codice di esempio:

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

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

dict¶

La vista delle chiavi del dizionario non si comporta come un insieme.¶

Causa: Non implementato.

Soluzione alternativa: Convertire esplicitamente le chiavi in un insieme prima di usare operazioni su insiemi.

Codice di esempio:

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.¶

Soluzione alternativa: Gli oggetti devono essere racchiusi in float(obj) per compatibilità con CPython.

Codice di esempio:

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¶

Il metodo `bit_length` non esiste.¶

Causa: Il metodo bit_length non è implementato.

Soluzione alternativa: Evitare di usare questo metodo su MicroPython.

Codice di esempio:

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'

Nessuna conversione int disponibile per i tipi derivati da int¶

Soluzione alternativa: Evitare di creare sottoclassi dei tipi incorporati a meno che non sia strettamente necessario. Preferire https://en.wikipedia.org/wiki/Composition_over_inheritance .

Codice di esempio:

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'

Il metodo `to_bytes` non implementa il parametro signed.¶

Causa: Il parametro keyword-only signed non è implementato per int.to_bytes().

Quando il numero intero è negativo, MicroPython si comporta come CPython int.to_bytes(..., signed=True)

Quando il numero intero è non negativo, MicroPython si comporta come CPython int.to_bytes(..., signed=False).

(La differenza è sottile, ma in CPython un intero positivo convertito con signed=True può richiedere un byte in più nella lunghezza dell’output, per contenere il bit di segno 0.)

Soluzione alternativa: Prestare attenzione quando si chiama to_bytes() su un valore intero che potrebbe essere negativo.

Codice di esempio:

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¶

La cancellazione di lista con passo != 1 non è implementata¶

Soluzione alternativa: Usare un ciclo esplicito per questa rara operazione.

Codice di esempio:

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:

L’assegnazione di slice di lista con un non-iterabile a destra non è implementata¶

Causa: Il lato destro è limitato a essere una tupla o una lista

Soluzione alternativa: Usare list(<iter>) sul lato destro per convertire l’iterabile in una lista

Codice di esempio:

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

L’assegnazione di lista con passo != 1 non è implementata¶

Soluzione alternativa: Usare un ciclo esplicito per questa rara operazione.

Codice di esempio:

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 può diventare non valida se il suo oggetto di riferimento viene ridimensionato¶

Causa: CPython impedisce a un oggetto bytearray o io.bytesIO di cambiare dimensione mentre esiste un oggetto memoryview che vi fa riferimento. MicroPython richiede al programmatore di garantire manualmente che un oggetto non venga ridimensionato mentre un memoryview vi fa riferimento.

Nel caso peggiore, ridimensionare un oggetto che è il bersaglio di una memoryview può causare il riferimento da parte della/e memoryview a memoria liberata non valida (un bug use-after-free) e corrompere il runtime di MicroPython.

Soluzione alternativa: Non modificare la dimensione di nessun oggetto bytearray o io.bytesIO a cui è assegnata una memoryview.

Codice di esempio:

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

Codice di esempio:

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.

Codice di esempio:

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.

Codice di esempio:

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

Attributi/indicizzazione non implementati¶

Codice di esempio:

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(…) con argomenti keyword non implementato¶

Soluzione alternativa: Inserire il formato di codifica direttamente, ad es. print(bytes('abc', 'utf-8'))

Codice di esempio:

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() e str.rjust() non implementati¶

Causa: MicroPython è altamente ottimizzato per l’utilizzo della memoria. Sono disponibili soluzioni alternative semplici.

Soluzione alternativa: Invece di s.ljust(10) usare "%-10s" % s, invece di s.rjust(10) usare "% 10s" % s. In alternativa, "{:<10}".format(s) o "{:>10}".format(s).

Codice di esempio:

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 come primo argomento per rsplit, ad es. str.rsplit(None, n), non è implementato¶

Codice di esempio:

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)

L’indicizzazione con passo != 1 non è ancora implementata¶

Codice di esempio:

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¶

L’accesso a tuple con passo != 1 non è implementato¶

Codice di esempio:

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

Tipi incorporati¶

Eccezione¶

Tutte le eccezioni hanno attributi leggibili value ed errno, non solo StopIteration e OSError.¶

Concatenamento di eccezioni non implementato¶

Gli attributi definiti dall’utente per le eccezioni incorporate non sono supportati¶

Un’eccezione nella condizione del ciclo while può avere un numero di riga inatteso¶

Il metodo Exception.__init__ non esiste.¶

OSError¶

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

bytearray¶

Assegnazione di slice di array con RHS non supportato¶

bytes¶

Gli oggetti bytes supportano il metodo .format()¶

bytes() con argomenti keyword non implementato¶

L’indicizzazione di bytes con passo != 1 non è implementata¶

complex¶

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

dict¶

La vista delle chiavi del dizionario non si comporta come un insieme.¶

float¶

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

int¶

Il metodo bit_length non esiste.¶

Nessuna conversione int disponibile per i tipi derivati da int¶

Il metodo to_bytes non implementa il parametro signed.¶

list¶

La cancellazione di lista con passo != 1 non è implementata¶

L’assegnazione di slice di lista con un non-iterabile a destra non è implementata¶

L’assegnazione di lista con passo != 1 non è implementata¶

memoryview¶

memoryview può diventare non valida se il suo oggetto di riferimento viene ridimensionato¶

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¶

Attributi/indicizzazione non implementati¶

str(…) con argomenti keyword non implementato¶

str.ljust() e str.rjust() non implementati¶

None come primo argomento per rsplit, ad es. str.rsplit(None, n), non è implementato¶

L’indicizzazione con passo != 1 non è ancora implementata¶

tuple¶

L’accesso a tuple con passo != 1 non è implementato¶

Tutte le eccezioni hanno attributi leggibili `value` ed `errno`, non solo `StopIteration` e `OSError`.¶

Il metodo Exception.init non esiste.¶

Il metodo `bit_length` non esiste.¶

Il metodo `to_bytes` non implementa il parametro signed.¶