0Pricing
Python Academy · Lección

Cómo se crean las clases de Python

Comprenda type, la metaclase predeterminada y los hooks de creación de clases.

Cómo se crean las clases de Python es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

type() es una metaclase

Todas las clases de Python son instancias de type. type es a su vez una clase: es la metaclase de todas las metaclases.

# These are equivalent:
class Dog:
    sound = "woof"

Dog2 = type("Dog2", (), {"sound": "woof"})
print(type(Dog))    # <class 'type'>
print(type(Dog2))   # <class 'type'>

Forma de tres argumentos de type()

type(name, bases, namespace) crea una clase nueva dinámicamente. Esto es exactamente lo que hacen internamente las sentencias class.

Animal = type("Animal", (), {"speak": lambda self: "..."})
Dog = type("Dog", (Animal,), {"speak": lambda self: "woof"})

d = Dog()
print(d.speak())   # woof

Pasos para crear una clase

Cuando Python encuentra una sentencia class: 1) resuelve la metaclase, 2) prepara el espacio de nombres, 3) ejecuta el cuerpo de la clase y 4) llama a metaclass(name, bases, namespace).

# class Foo(Base, metaclass=Meta):
#   x = 1
#
# Equivalent to:
# namespace = Meta.__prepare__("Foo", (Base,))
# exec(class_body, namespace)
# Foo = Meta("Foo", (Base,), namespace)

__prepare__

__prepare__(name, bases, **kw) es un método de clase de la metaclase que devuelve el diccionario del espacio de nombres usado durante la ejecución del cuerpo de la clase. Sobrescríbalo para usar un OrderedDict o un mapeo personalizado.

class OrderedMeta(type):
    @classmethod
    def __prepare__(mcs, name, bases, **kw):
        print(f"Preparing namespace for {name}")
        return {}

class MyClass(metaclass=OrderedMeta):
    x = 1
    y = 2

__new__ frente a __init__ en type

type.__new__ crea el objeto de clase; type.__init__ lo inicializa. En las metaclases, sobrescriba __new__ para personalizar la creación de clases.

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kw):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kw)
        return cls._instances[cls]

class DB(metaclass=Singleton):
    pass

print(DB() is DB())  # True

Decoradores de clase frente a metaclases

Los decoradores de clase se aplican después de la creación; las metaclases controlan la creación en sí. Para ampliaciones sencillas, prefiera los decoradores. Use metaclases cuando necesite modificar el proceso de creación.

def add_repr(cls):
    cls.__repr__ = lambda self: f"{cls.__name__}()"
    return cls

@add_repr
class Widget:
    pass

print(Widget())  # Widget()

__init_subclass__

__init_subclass__ se llama en la clase base cada vez que se define una subclase. Es una alternativa ligera a las metaclases para personalizar el comportamiento de las subclases.

class Plugin:
    _registry = []

    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        Plugin._registry.append(cls)

class AudioPlugin(Plugin): pass
class VideoPlugin(Plugin): pass

print(Plugin._registry)  # [AudioPlugin, VideoPlugin]

ABCMeta

ABCMeta es una metaclase integrada que proporciona la funcionalidad de las clases base abstractas mediante @abstractmethod.

from abc import ABCMeta, abstractmethod

class Shape(metaclass=ABCMeta):
    @abstractmethod
    def area(self): ...

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return 3.14159 * self.r ** 2

# Shape()  # TypeError: Can't instantiate abstract class

Inspección de la metaclase de una clase

Use type(cls) para encontrar la metaclase de una clase y cls.__mro__ para consultar el orden de resolución de métodos.

class Meta(type): pass

class Foo(metaclass=Meta): pass

print(type(Foo))       # <class '__main__.Meta'>
print(Foo.__mro__)     # (Foo, object)

Herencia de metaclases

La metaclase de una clase se hereda en sus subclases. Si dos clases base tienen metaclases diferentes, debe usarse la más derivada o se producirá un conflicto.

class MyMeta(type): pass

class Base(metaclass=MyMeta): pass
class Child(Base): pass   # Child's metaclass is also MyMeta

print(type(Child))   # <class '__main__.MyMeta'>

Cuándo usar metaclases

Use metaclases para registrar subclases automáticamente, imponer invariantes de clase, detectar campos de ORM, como en el Model de Django, y definir el enrutamiento de frameworks de API. En la mayoría de los casos, use __init_subclass__ o decoradores de clase.

# Real-world: Django ORM uses ModelBase metaclass
# to collect field definitions into _meta

# You rarely need a custom metaclass;
# __init_subclass__ covers most plugin/registration patterns

Comprobación rápida

¿Qué hace type("Dog", (Animal,), {"speak": lambda self: "woof"})?

Recapitulación

Toda clase es una instancia de type. El proceso de creación de una clase es: resolver la metaclase → preparar el espacio de nombres → ejecutar el cuerpo → llamar a la metaclase. Prefiera __init_subclass__ para hooks sencillos de subclases; use una metaclase completa solo cuando necesite controlar la creación de la clase en sí.

Preguntas frecuentes

¿La lección «Cómo se crean las clases de Python» es gratis?

Sí — el texto completo de «Cómo se crean las clases de Python» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Cómo se crean las clases de Python»?

Comprenda type, la metaclase predeterminada y los hooks de creación de clases. Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Cómo se crean las clases de Python»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Cómo se crean las clases de Python
  2. Escritura de metaclases personalizadas
  3. Descriptores: __get__, __set__, __delete__
  4. __slots__ y optimización de memoria
← Volver a Python Academy