Lenguaje principal¶

Generated Fri 19 Jun 2026 22:08:45 UTC

Clases¶

El método especial del no está implementado para las clases definidas por el usuario¶

Código de ejemplo:

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__()

Código de ejemplo:

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.

Código de ejemplo:

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.

Código de ejemplo:

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.

Código de ejemplo:

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__'

El Orden de Resolución de Métodos (MRO) no es conforme con CPython¶

Causa: Orden de resolución de métodos en profundidad primero no exhaustivo

Solución: Evite jerarquías de clases complejas con herencia múltiple y anulaciones de métodos complejas. Tenga en cuenta que muchos lenguajes no admiten la herencia múltiple en absoluto.

Código de ejemplo:

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)

La deformación de nombres para miembros privados de clases no está implementada¶

Causa: El compilador de MicroPython no implementa la deformación de nombres para miembros privados de clases.

Solución: Evite usar o tener una colisión con nombres globales añadiendo manualmente un prefijo único al nombre del miembro privado de la clase.

Código de ejemplo:

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.

Al heredar tipos nativos, llamar a un método en `init(self, ...)` antes de `super().init()` lanza un `AttributeError` (o produce un fallo de segmentación si `MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG` no está habilitado).¶

Causa: MicroPython no tiene métodos __new__ y __init__ separados en los tipos nativos.

Solución: Llame a super().__init__() primero.

Código de ejemplo:

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

Al heredar de múltiples clases, super() solo llama a una clase¶

Causa: Véase El Orden de Resolución de Métodos (MRO) no es conforme con CPython

Solución: Véase El Orden de Resolución de Métodos (MRO) no es conforme con CPython

Código de ejemplo:

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__

Llamar a una propiedad getter de super() en una subclase devolverá un objeto property, no el valor¶

Código de ejemplo:

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.

Código de ejemplo:

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

Funciones¶

Los mensajes de error para métodos pueden mostrar conteos de argumentos inesperados¶

Causa: MicroPython cuenta «self» como un argumento.

Solución: Interprete los mensajes de error teniendo en cuenta la información anterior.

Código de ejemplo:

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

Los objetos función no tienen el atributo `module`¶

Causa: MicroPython está optimizado para reducir el tamaño del código y el uso de RAM.

Solución: Use sys.modules[function.__globals__['__name__']] para módulos no integrados.

Código de ejemplo:

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__'

Los atributos definidos por el usuario para las funciones no están admitidos¶

Causa: MicroPython está muy optimizado para el uso de memoria.

Solución: Use un diccionario externo, p. ej. FUNC_X[f] = 0.

Código de ejemplo:

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'

Generador¶

El gestor de contexto exit() no se llama en un generador que no se ejecuta hasta completarse¶

Código de ejemplo:

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

Tiempo de ejecución¶

Las variables locales no están incluidas en el resultado de locals()¶

Causa: MicroPython no mantiene un entorno local simbólico; está optimizado en una matriz de ranuras. Por lo tanto, las variables locales no son accesibles por nombre.

Código de ejemplo:

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


test()

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

El código que se ejecuta en la función eval() no tiene acceso a las variables locales¶

Causa: MicroPython no mantiene un entorno local simbólico; está optimizado en una matriz de ranuras. Por lo tanto, las variables locales no son accesibles por nombre. En la práctica, eval(expr) en MicroPython equivale a eval(expr, globals(), globals()).

Código de ejemplo:

val = 1


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


test()

CPython output:	MicroPython output:
2 2	2 1

f-strings¶

Las f-strings no admiten la concatenación con literales adyacentes si dichos literales contienen llaves¶

Causa: MicroPython está optimizado para el espacio de código.

Solución: Use el operador + entre cadenas literales cuando no sean ambas f-strings

Código de ejemplo:

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

Las f-strings no pueden admitir expresiones que requieran análisis para resolver llaves y corchetes anidados desequilibrados¶

Causa: MicroPython está optimizado para el espacio de código.

Solución: Use siempre llaves y corchetes equilibrados en expresiones dentro de f-strings

Código de ejemplo:

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

Las f-strings no admiten conversiones !a¶

Causa: MicroPython no implementa ascii()

Solución: Ninguna

Código de ejemplo:

f"{'unicode text'!a}"

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

import¶

El atributo path de un paquete tiene un tipo diferente (cadena simple en lugar de lista de cadenas) en MicroPython¶

Causa: MicroPython no admite paquetes de espacio de nombres divididos en el sistema de archivos. Además, el sistema de importación de MicroPython está muy optimizado para el uso mínimo de memoria.

Solución: Los detalles del manejo de importaciones son inherentemente dependientes de la implementación. No dependa de dichos detalles en aplicaciones portables.

Código de ejemplo:

import modules

print(modules.__path__)

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

MicroPython no admite paquetes de espacio de nombres divididos en el sistema de archivos.¶

Causa: El sistema de importación de MicroPython está muy optimizado para la simplicidad, el uso mínimo de memoria y la mínima sobrecarga de búsqueda en el sistema de archivos.

Solución: No instale módulos que pertenezcan al mismo paquete de espacio de nombres en directorios diferentes. Para MicroPython, se recomienda tener como máximo rutas de búsqueda de módulos de 3 componentes: para la aplicación actual, por usuario (escribible) y para todo el sistema (no escribible).

Código de ejemplo:

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'

Lenguaje principal¶

Clases¶

El método especial __del__ no está implementado para las clases definidas por el usuario¶

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

El Orden de Resolución de Métodos (MRO) no es conforme con CPython¶

La deformación de nombres para miembros privados de clases no está implementada¶

Al heredar tipos nativos, llamar a un método en __init__(self, ...) antes de super().__init__() lanza un AttributeError (o produce un fallo de segmentación si MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG no está habilitado).¶

Al heredar de múltiples clases, super() solo llama a una clase¶

Llamar a una propiedad getter de super() en una subclase devolverá un objeto property, no el valor¶

Exceptions¶

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

Funciones¶

Los mensajes de error para métodos pueden mostrar conteos de argumentos inesperados¶

Los objetos función no tienen el atributo __module__¶

Los atributos definidos por el usuario para las funciones no están admitidos¶

Generador¶

El gestor de contexto __exit__() no se llama en un generador que no se ejecuta hasta completarse¶

Tiempo de ejecución¶

Las variables locales no están incluidas en el resultado de locals()¶

El código que se ejecuta en la función eval() no tiene acceso a las variables locales¶

f-strings¶

Las f-strings no admiten la concatenación con literales adyacentes si dichos literales contienen llaves¶

Las f-strings no pueden admitir expresiones que requieran análisis para resolver llaves y corchetes anidados desequilibrados¶

Las f-strings no admiten conversiones !a¶

import¶

El atributo __path__ de un paquete tiene un tipo diferente (cadena simple en lugar de lista de cadenas) en MicroPython¶

MicroPython no admite paquetes de espacio de nombres divididos en el sistema de archivos.¶

El método especial del no está implementado para las clases definidas por el usuario¶

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

Al heredar tipos nativos, llamar a un método en `init(self, ...)` antes de `super().init()` lanza un `AttributeError` (o produce un fallo de segmentación si `MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG` no está habilitado).¶

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

Los objetos función no tienen el atributo `module`¶

El gestor de contexto exit() no se llama en un generador que no se ejecuta hasta completarse¶

El atributo path de un paquete tiene un tipo diferente (cadena simple en lugar de lista de cadenas) en MicroPython¶