Kerntaal¶

Generated Fri 19 Jun 2026 22:08:45 UTC

Klassen¶

De speciale methode del is niet geïmplementeerd voor door de gebruiker gedefinieerde klassen¶

Voorbeeldcode:

import gc

class Foo:
    def __del__(self):
        print("__del__")

f = Foo()
del f

gc.collect()

CPython output:	MicroPython output:
__del__

`__init_subclass__` isn’t automatically called.¶

Cause: MicroPython does not currently implement PEP 487.

Workaround: Manually call __init_subclass__ after class creation if needed. e.g.:

class A(Base):
    pass
A.__init_subclass__()

Voorbeeldcode:

class Base:
    @classmethod
    def __init_subclass__(cls):
        print(f"Base.__init_subclass__({cls.__name__})")


class A(Base):
    pass

CPython output:	MicroPython output:
Base.__init_subclass__(A)

`__init_subclass__` isn’t an implicit classmethod.¶

Cause: MicroPython does not currently implement PEP 487. __init_subclass__ is not currently in the list of special-cased class/static methods.

Workaround: Decorate declarations of __init_subclass__ with @classmethod.

Voorbeeldcode:

def regularize_spelling(text, prefix="bound_"):
    # for regularizing across the CPython "method" vs MicroPython "bound_method" spelling for the type of a bound classmethod
    if text.startswith(prefix):
        return text[len(prefix) :]
    return text


class A:
    def __init_subclass__(cls):
        pass

    @classmethod
    def manual_decorated(cls):
        pass


a = type(A.__init_subclass__).__name__
b = type(A.manual_decorated).__name__

print(regularize_spelling(a))
print(regularize_spelling(b))
if a != b:
    print("FAIL")

CPython output:	MicroPython output:
method method	function method FAIL

MicroPython doesn’t support parameterized `__init_subclass__` class customization.¶

Cause: MicroPython does not currently implement PEP 487. The MicroPython syntax tree does not include a kwargs node after the class inheritance list.

Workaround: Use class variables or another mechanism to specify base-class customizations.

Voorbeeldcode:

class Base:
    @classmethod
    def __init_subclass__(cls, arg=None, **kwargs):
        cls.init_subclass_was_called = True
        print(f"Base.__init_subclass__({cls.__name__}, {arg=!r}, {kwargs=!r})")


class A(Base, arg="arg"):
    pass


# Regularize across MicroPython not automatically calling __init_subclass__ either.
if not getattr(A, "init_subclass_was_called", False):
    A.__init_subclass__()

CPython output:	MicroPython output:
Base.__init_subclass__(A, arg='arg', kwargs={})	Traceback (most recent call last): File "<stdin>", line 16, in <module> TypeError: function doesn't take keyword arguments

`__init_subclass__` can’t be defined a cooperatively-recursive way.¶

Cause: MicroPython does not currently implement PEP 487. The base object type does not have an __init_subclass__ implementation.

Workaround: Omit the recursive __init_subclass__ call unless it’s known that the grandparent also defines it.

Voorbeeldcode:

class Base:
    @classmethod
    def __init_subclass__(cls, **kwargs):
        cls.init_subclass_was_called = True
        super().__init_subclass__(**kwargs)


class A(Base):
    pass


# Regularize across MicroPython not automatically calling __init_subclass__ either.
if not getattr(A, "init_subclass_was_called", False):
    A.__init_subclass__()

CPython output:	MicroPython output:
	Traceback (most recent call last): File "<stdin>", line 22, in <module> File "<stdin>", line 13, in __init_subclass__ AttributeError: 'super' object has no attribute '__init_subclass__'

De Method Resolution Order (MRO) voldoet niet aan de CPython-standaard¶

Oorzaak: Diepte-eerst niet-uitputtende volgorde voor methode-opzoeken

Oplossing: Vermijd complexe klassehiërarchieën met meervoudige overerving en complexe methode-overschrijvingen. Houd er rekening mee dat veel talen meervoudige overerving helemaal niet ondersteunen.

Voorbeeldcode:

class Foo:
    def __str__(self):
        return "Foo"


class C(tuple, Foo):
    pass


t = C((1, 2, 3))
print(t)

CPython output:	MicroPython output:
Foo	(1, 2, 3)

Naamvervorming van private klasseleden is niet geïmplementeerd¶

Oorzaak: De MicroPython-compiler implementeert geen naamvervorming voor private klasseleden.

Oplossing: Voorkom botsingen met globale namen door handmatig een uniek voorvoegsel toe te voegen aan de naam van het private klasselid.

Voorbeeldcode:

def __print_string(string):
    print(string)


class Foo:
    def __init__(self, string):
        self.string = string

    def do_print(self):
        __print_string(self.string)


example_string = "Example String to print."

class_item = Foo(example_string)
print(class_item.string)

class_item.do_print()

CPython output:

MicroPython output:

Example String to print.
Traceback (most recent call last):
  File "<stdin>", line 26, in <module>
  File "<stdin>", line 18, in do_print
NameError: name '_Foo__print_string' is not defined. Did you mean: '__print_string'?

Example String to print.
Example String to print.

Bij het afleiden van native typen leidt het aanroepen van een methode in `init(self, ...)` vóór `super().init()` tot een `AttributeError` (of een segfault als `MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG` niet is ingeschakeld).¶

Oorzaak: MicroPython heeft geen aparte __new__- en __init__-methoden in native typen.

Oplossing: Roep eerst super().__init__() aan.

Voorbeeldcode:

class L1(list):
    def __init__(self, a):
        self.append(a)


try:
    L1(1)
    print("OK")
except AttributeError:
    print("AttributeError")


class L2(list):
    def __init__(self, a):
        super().__init__()
        self.append(a)


try:
    L2(1)
    print("OK")
except AttributeError:
    print("AttributeError")

CPython output:	MicroPython output:
OK OK	AttributeError OK

Bij overerving van meerdere klassen roept super() slechts één klasse aan¶

Oorzaak: Zie De Method Resolution Order (MRO) voldoet niet aan de CPython-standaard

Oplossing: Zie De Method Resolution Order (MRO) voldoet niet aan de CPython-standaard

Voorbeeldcode:

class A:
    def __init__(self):
        print("A.__init__")


class B(A):
    def __init__(self):
        print("B.__init__")
        super().__init__()


class C(A):
    def __init__(self):
        print("C.__init__")
        super().__init__()


class D(B, C):
    def __init__(self):
        print("D.__init__")
        super().__init__()


D()

CPython output:	MicroPython output:
D.__init__ B.__init__ C.__init__ A.__init__	D.__init__ B.__init__ A.__init__

Het aanroepen van een getter-eigenschap via super() in een subklasse retourneert een property-object, niet de waarde¶

Voorbeeldcode:

class A:
    @property
    def p(self):
        return {"a": 10}


class AA(A):
    @property
    def p(self):
        return super().p


a = AA()
print(a.p)

CPython output:	MicroPython output:
{'a': 10}	<property>

Exceptions¶

Throwing a derived exception class instance in its `init` without first calling `super().init` is a TypeError¶

Cause: In MicroPython, an object is incompletely constructed if it does not call its superclass init function or return normally from its __init__. This prevents its usage in some circumstances.

Workaround: Call the superclass __init__ method before raising the exception.

Voorbeeldcode:

class C(Exception):
    def __init__(self):
        raise self


class C1(Exception):
    def __init__(self):
        super().__init__()
        raise self


try:
    C()
except Exception as e:
    print(type(e).__name__)

try:
    C1()
except Exception as e:
    print(type(e).__name__)

CPython output:	MicroPython output:
C C1	TypeError C1

Functies¶

Foutmeldingen voor methoden kunnen onverwachte argumentaantallen weergeven¶

Oorzaak: MicroPython telt “self” mee als argument.

Oplossing: Interpreteer foutmeldingen met de bovenstaande informatie in gedachten.

Voorbeeldcode:

try:
    [].append()
except Exception as e:
    print(e)

CPython output:	MicroPython output:
list.append() takes exactly one argument (0 given)	function takes 2 positional arguments but 1 were given

Functieobjecten hebben het attribuut `module` niet¶

Oorzaak: MicroPython is geoptimaliseerd voor een kleinere codeomvang en lager RAM-gebruik.

Oplossing: Gebruik sys.modules[function.__globals__['__name__']] voor niet-ingebouwde modules.

Voorbeeldcode:

def f():
    pass


print(f.__module__)

CPython output:	MicroPython output:
__main__	Traceback (most recent call last): File "<stdin>", line 13, in <module> AttributeError: 'function' object has no attribute '__module__'

Door de gebruiker gedefinieerde attributen voor functies worden niet ondersteund¶

Oorzaak: MicroPython is sterk geoptimaliseerd voor geheugengebruik.

Oplossing: Gebruik een extern woordenboek, bijv. FUNC_X[f] = 0.

Voorbeeldcode:

def f():
    pass


f.x = 0
print(f.x)

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

Generator¶

exit() van de contextmanager wordt niet aangeroepen in een generator die niet tot voltooiing wordt uitgevoerd¶

Voorbeeldcode:

class foo(object):
    def __enter__(self):
        print("Enter")

    def __exit__(self, *args):
        print("Exit")


def bar(x):
    with foo():
        while True:
            x += 1
            yield x


def func():
    g = bar(0)
    for _ in range(3):
        print(next(g))


func()

CPython output:	MicroPython output:
Enter 1 2 3 Exit	Enter 1 2 3

Uitvoeringsomgeving¶

Lokale variabelen zijn niet opgenomen in het resultaat van locals()¶

Oorzaak: MicroPython onderhoudt geen symbolische lokale omgeving; deze is geoptimaliseerd tot een array van slots. Lokale variabelen zijn daardoor niet via een naam toegankelijk.

Voorbeeldcode:

def test():
    val = 2
    print(locals())


test()

CPython output:	MicroPython output:
{'val': 2}	{'test': <function test at 0x7f5d74c05260>, '__name__': '__main__', '__file__': '<stdin>'}

Code die wordt uitgevoerd in de functie eval() heeft geen toegang tot lokale variabelen¶

Oorzaak: MicroPython onderhoudt geen symbolische lokale omgeving; deze is geoptimaliseerd tot een array van slots. Lokale variabelen zijn daardoor niet via een naam toegankelijk. In de praktijk is eval(expr) in MicroPython gelijkwaardig aan eval(expr, globals(), globals()).

Voorbeeldcode:

val = 1


def test():
    val = 2
    print(val)
    eval("print(val)")


test()

CPython output:	MicroPython output:
2 2	2 1

f-strings¶

f-strings ondersteunen geen aaneenschakeling met aangrenzende letterlijke tekenreeksen als die accolades bevatten¶

Oorzaak: MicroPython is geoptimaliseerd voor coderuimte.

Oplossing: Gebruik de +-operator tussen letterlijke tekenreeksen wanneer ze niet allebei f-strings zijn

Voorbeeldcode:

x, y = 1, 2
print("aa" f"{x}")  # works
print(f"{x}" "ab")  # works
print("a{}a" f"{x}")  # fails
print(f"{x}" "a{}b")  # fails

CPython output:	MicroPython output:
aa1 1ab a{}a1 1a{}b	aa1 1ab Traceback (most recent call last): File "<stdin>", line 12, in <module> IndexError: tuple index out of range

f-strings kunnen geen expressies ondersteunen die parsering vereisen om onevenwichtige geneste accolades en haakjes op te lossen¶

Oorzaak: MicroPython is geoptimaliseerd voor coderuimte.

Oplossing: Gebruik altijd evenwichtige accolades en haakjes in expressies binnen f-strings

Voorbeeldcode:

print(f"{'hello { world'}")
print(f"{'hello ] world'}")

CPython output:	MicroPython output:
hello { world hello ] world	Traceback (most recent call last): File "<stdin>", line 9 SyntaxError: invalid syntax

f-strings ondersteunen geen !a-conversies¶

Oorzaak: MicroPython implementeert ascii() niet

Oplossing: Geen

Voorbeeldcode:

f"{'unicode text'!a}"

CPython output:	MicroPython output:
	Traceback (most recent call last): File "<stdin>", line 8 SyntaxError: invalid syntax

import¶

Het attribuut path van een pakket heeft een ander type (een enkele tekenreeks in plaats van een lijst van tekenreeksen) in MicroPython¶

Oorzaak: MicroPython ondersteunt geen naamruimtepakketten die over het bestandssysteem zijn verdeeld. Bovendien is het importsysteem van MicroPython sterk geoptimaliseerd voor minimaal geheugengebruik.

Oplossing: De details van importafhandeling zijn inherent implementatieafhankelijk. Vertrouw niet op dergelijke details in draagbare toepassingen.

Voorbeeldcode:

import modules

print(modules.__path__)

CPython output:	MicroPython output:
['/home/runner/work/openmv-doc/openmv-doc/micropython/tests/cpydiff/modules']	../tests/cpydiff/modules

MicroPython ondersteunt geen naamruimtepakketten die over het bestandssysteem zijn verdeeld.¶

Oorzaak: Het importsysteem van MicroPython is sterk geoptimaliseerd voor eenvoud, minimaal geheugengebruik en minimale zoekoverhead in het bestandssysteem.

Oplossing: Installeer modules die tot hetzelfde naamruimtepakket behoren niet in verschillende mappen. Voor MicroPython wordt aanbevolen maximaal drie zoekpaden voor modules te hanteren: één voor de huidige toepassing, één per gebruiker (schrijfbaar) en één systeembreed (niet-schrijfbaar).

Voorbeeldcode:

import sys

sys.path.append(sys.path[1] + "/modules")
sys.path.append(sys.path[1] + "/modules2")

import subpkg.foo
import subpkg.bar

print("Two modules of a split namespace package imported")

CPython output:	MicroPython output:
Two modules of a split namespace package imported	Traceback (most recent call last): File "<stdin>", line 14, in <module> ImportError: no module named 'subpkg.bar'

Kerntaal¶

Klassen¶

De speciale methode __del__ is niet geïmplementeerd voor door de gebruiker gedefinieerde klassen¶

__init_subclass__ isn’t automatically called.¶

__init_subclass__ isn’t an implicit classmethod.¶

MicroPython doesn’t support parameterized __init_subclass__ class customization.¶

__init_subclass__ can’t be defined a cooperatively-recursive way.¶

De Method Resolution Order (MRO) voldoet niet aan de CPython-standaard¶

Naamvervorming van private klasseleden is niet geïmplementeerd¶

Bij het afleiden van native typen leidt het aanroepen van een methode in __init__(self, ...) vóór super().__init__() tot een AttributeError (of een segfault als MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG niet is ingeschakeld).¶

Bij overerving van meerdere klassen roept super() slechts één klasse aan¶

Het aanroepen van een getter-eigenschap via super() in een subklasse retourneert een property-object, niet de waarde¶

Exceptions¶

Throwing a derived exception class instance in its __init__ without first calling super().__init__ is a TypeError¶

Functies¶

Foutmeldingen voor methoden kunnen onverwachte argumentaantallen weergeven¶

Functieobjecten hebben het attribuut __module__ niet¶

Door de gebruiker gedefinieerde attributen voor functies worden niet ondersteund¶

Generator¶

__exit__() van de contextmanager wordt niet aangeroepen in een generator die niet tot voltooiing wordt uitgevoerd¶

Uitvoeringsomgeving¶

Lokale variabelen zijn niet opgenomen in het resultaat van locals()¶

Code die wordt uitgevoerd in de functie eval() heeft geen toegang tot lokale variabelen¶

f-strings¶

f-strings ondersteunen geen aaneenschakeling met aangrenzende letterlijke tekenreeksen als die accolades bevatten¶

f-strings kunnen geen expressies ondersteunen die parsering vereisen om onevenwichtige geneste accolades en haakjes op te lossen¶

f-strings ondersteunen geen !a-conversies¶

import¶

Het attribuut __path__ van een pakket heeft een ander type (een enkele tekenreeks in plaats van een lijst van tekenreeksen) in MicroPython¶

MicroPython ondersteunt geen naamruimtepakketten die over het bestandssysteem zijn verdeeld.¶

De speciale methode del is niet geïmplementeerd voor door de gebruiker gedefinieerde klassen¶

`__init_subclass__` isn’t automatically called.¶

`__init_subclass__` isn’t an implicit classmethod.¶

MicroPython doesn’t support parameterized `__init_subclass__` class customization.¶

`__init_subclass__` can’t be defined a cooperatively-recursive way.¶

Bij het afleiden van native typen leidt het aanroepen van een methode in `init(self, ...)` vóór `super().init()` tot een `AttributeError` (of een segfault als `MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG` niet is ingeschakeld).¶

Throwing a derived exception class instance in its `init` without first calling `super().init` is a TypeError¶

Functieobjecten hebben het attribuut `module` niet¶

exit() van de contextmanager wordt niet aangeroepen in een generator die niet tot voltooiing wordt uitgevoerd¶

Het attribuut path van een pakket heeft een ander type (een enkele tekenreeks in plaats van een lijst van tekenreeksen) in MicroPython¶