Types intégrés¶

Generated Fri 19 Jun 2026 22:08:45 UTC

Exception¶

Toutes les exceptions possèdent des attributs `value` et `errno` lisibles, pas seulement `StopIteration` et `OSError`.¶

Cause : MicroPython est optimisé pour réduire la taille du code.

Contournement : N’utilisez value que sur les exceptions StopIteration, et errno que sur les exceptions OSError. N’utilisez pas ces attributs sur d’autres exceptions et ne vous y fiez pas.

Exemple de code

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

Chaînage des exceptions non implémenté¶

Exemple de code

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:

Les attributs définis par l’utilisateur pour les exceptions intégrées ne sont pas pris en charge¶

Cause : MicroPython est fortement optimisé pour l’utilisation de la mémoire.

Contournement : Utilisez des sous-classes d’exceptions définies par l’utilisateur.

Exemple de code

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'

Une exception dans la condition d’une boucle while peut signaler un numéro de ligne inattendu¶

Cause : Les vérifications de condition sont optimisées pour s’effectuer à la fin du corps de la boucle, et c’est ce numéro de ligne qui est signalé.

Exemple de code

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

La méthode Exception.init n’existe pas.¶

Cause : La création de sous-classes à partir de classes natives n’est pas entièrement prise en charge dans MicroPython.

Contournement : Utilisez plutôt super()

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

Exemple de code

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.

Exemple de code

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¶

L’affectation par tranche de tableau avec un membre droit non supporté¶

Exemple de code

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¶

Les objets bytes prennent en charge la méthode .format()¶

Cause : MicroPython vise une implémentation plus cohérente : puisque str et bytes supportent tous deux __mod__() (l’opérateur %), il est logique que format() soit également supporté pour les deux. La prise en charge de __mod__ peut aussi être exclue à la compilation, ce qui laisse uniquement format() pour le formatage des bytes.

Contournement : Si la compatibilité CPython est requise, n’utilisez pas .format() sur des objets bytes.

Exemple de code

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() avec des arguments nommés non implémenté¶

Contournement : Passez l’encodage comme argument positionnel, par ex. print(bytes('abc', 'utf-8'))

Exemple de code

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’indexation de bytes avec un pas != 1 n’est pas implémentée¶

Cause : MicroPython est fortement optimisé pour l’utilisation de la mémoire.

Contournement : Utilisez une boucle explicite pour cette opération très rare.

Exemple de code

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¶

Cause : MicroPython est fortement optimisé pour l’utilisation de la mémoire.

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.

Exemple de code

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

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

dict¶

La vue des clés d’un dictionnaire ne se comporte pas comme un ensemble.¶

Cause : Non implémenté.

Contournement : Convertissez explicitement les clés en ensemble avant d’utiliser les opérations sur les ensembles.

Exemple de code

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

Contournement : Encapsulez les objets dans float(obj) pour assurer la compatibilité avec CPython.

Exemple de code

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¶

La méthode `bit_length` n’existe pas.¶

Cause : La méthode bit_length n’est pas implémentée.

Contournement : Évitez d’utiliser cette méthode dans MicroPython.

Exemple de code

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'

Aucune conversion int disponible pour les types dérivés de int¶

Contournement : Évitez de créer des sous-classes de types intégrés sauf si c’est vraiment nécessaire. Préférez https://en.wikipedia.org/wiki/Composition_over_inheritance .

Exemple de code

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'

La méthode `to_bytes` n’implémente pas le paramètre signed.¶

Cause : Le paramètre nommé signed n’est pas implémenté pour int.to_bytes().

Lorsque l’entier est négatif, MicroPython se comporte comme CPython avec int.to_bytes(..., signed=True)

Lorsque l’entier est non négatif, MicroPython se comporte comme CPython avec int.to_bytes(..., signed=False).

(La différence est subtile : dans CPython, un entier positif converti avec signed=True peut nécessiter un octet supplémentaire dans la longueur de sortie, afin de loger le bit de signe 0.)

Contournement : Soyez vigilant lorsque vous appelez to_bytes() sur une valeur entière susceptible d’être négative.

Exemple de code

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 suppression de liste avec un pas != 1 n’est pas implémentée¶

Contournement : Utilisez une boucle explicite pour cette opération rare.

Exemple de code

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:

Le stockage par tranche de liste avec un non-itérable en membre droit n’est pas implémenté¶

Cause : Le membre droit doit être un tuple ou une liste

Contournement : Utilisez list(<iter>) en membre droit pour convertir l’itérable en liste

Exemple de code

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

Le stockage de liste avec un pas != 1 n’est pas implémenté¶

Contournement : Utilisez une boucle explicite pour cette opération rare.

Exemple de code

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 peut devenir invalide si son objet cible est redimensionné¶

Cause : CPython empêche un objet bytearray ou io.bytesIO de changer de taille tant qu’un objet memoryview y fait référence. MicroPython exige que le programmeur s’assure manuellement qu’un objet n’est pas redimensionné pendant qu’un memoryview y fait référence.

Dans le pire des cas, redimensionner un objet cible d’un memoryview peut amener le ou les memoryview à référencer de la mémoire libérée invalide (bogue d’utilisation après libération) et corrompre l’environnement d’exécution MicroPython.

Contournement : Ne modifiez pas la taille d’un objet bytearray ou io.bytesIO auquel un memoryview est assigné.

Exemple de code

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

Exemple de code

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.

Exemple de code

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.

Exemple de code

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

Attributs/indices non implémentés¶

Exemple de code

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(…) avec des arguments nommés non implémenté¶

Contournement : Saisissez le format d’encodage directement, par ex. print(bytes('abc', 'utf-8'))

Exemple de code

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() et str.rjust() non implémentés¶

Cause : MicroPython est fortement optimisé pour l’utilisation de la mémoire. Des contournements simples existent.

Contournement : Au lieu de s.ljust(10) utilisez "%-10s" % s, au lieu de s.rjust(10) utilisez "% 10s" % s. Vous pouvez aussi utiliser "{:<10}".format(s) ou "{:>10}".format(s).

Exemple de code

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 comme premier argument de rsplit, comme str.rsplit(None, n), n’est pas implémenté¶

Exemple de code

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’indexation avec un pas != 1 n’est pas encore implémentée¶

Exemple de code

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¶

Le chargement de tuple avec un pas != 1 n’est pas implémenté¶

Exemple de code

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

Types intégrés¶

Exception¶

Toutes les exceptions possèdent des attributs value et errno lisibles, pas seulement StopIteration et OSError.¶

Chaînage des exceptions non implémenté¶

Les attributs définis par l’utilisateur pour les exceptions intégrées ne sont pas pris en charge¶

Une exception dans la condition d’une boucle while peut signaler un numéro de ligne inattendu¶

La méthode Exception.__init__ n’existe pas.¶

OSError¶

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

bytearray¶

L’affectation par tranche de tableau avec un membre droit non supporté¶

bytes¶

Les objets bytes prennent en charge la méthode .format()¶

bytes() avec des arguments nommés non implémenté¶

L’indexation de bytes avec un pas != 1 n’est pas implémentée¶

complex¶

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

dict¶

La vue des clés d’un dictionnaire ne se comporte pas comme un ensemble.¶

float¶

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

int¶

La méthode bit_length n’existe pas.¶

Aucune conversion int disponible pour les types dérivés de int¶

La méthode to_bytes n’implémente pas le paramètre signed.¶

list¶

La suppression de liste avec un pas != 1 n’est pas implémentée¶

Le stockage par tranche de liste avec un non-itérable en membre droit n’est pas implémenté¶

Le stockage de liste avec un pas != 1 n’est pas implémenté¶

memoryview¶

memoryview peut devenir invalide si son objet cible est redimensionné¶

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¶

Attributs/indices non implémentés¶

str(…) avec des arguments nommés non implémenté¶

str.ljust() et str.rjust() non implémentés¶

None comme premier argument de rsplit, comme str.rsplit(None, n), n’est pas implémenté¶

L’indexation avec un pas != 1 n’est pas encore implémentée¶

tuple¶

Le chargement de tuple avec un pas != 1 n’est pas implémenté¶

Toutes les exceptions possèdent des attributs `value` et `errno` lisibles, pas seulement `StopIteration` et `OSError`.¶

La méthode Exception.init n’existe pas.¶

La méthode `bit_length` n’existe pas.¶

La méthode `to_bytes` n’implémente pas le paramètre signed.¶