0Pricing
Python Academy · Aula

Como as classes Python são criadas

Entenda type, a metaclasse padrão e os ganchos de criação de classes.

Como as classes Python são criadas é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

type() é uma metaclasse

Toda classe em Python é uma instância de type. type também é uma classe — é a metaclasse de todas as metaclasses.

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

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

Forma de três argumentos de type()

type(name, bases, namespace) cria uma nova classe dinamicamente. É exatamente isso que as instruções class fazem internamente.

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

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

Etapas de criação de classes

Quando o Python encontra uma instrução class, ele: 1) resolve a metaclasse; 2) prepara o espaço de nomes; 3) executa o corpo da classe; 4) chama 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) é um método de classe da metaclasse que retorna o dicionário do espaço de nomes usado durante a execução do corpo da classe. Substitua-o para usar um OrderedDict ou um mapeamento 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__ versus __init__ em type

type.__new__ cria o objeto de classe; type.__init__ o inicializa. Para metaclasses, substitua __new__ para personalizar a criação de classes.

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 classe versus metaclasses

Os decoradores de classe são aplicados após a criação; as metaclasses controlam a própria criação. Para extensões simples, prefira decoradores. Use metaclasses quando precisar afetar o processo de criação.

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__ é chamado na classe base sempre que uma subclasse é definida. É uma alternativa leve às metaclasses para personalizar o comportamento das subclasses.

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 é uma metaclasse integrada que permite criar classes base abstratas por meio de @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

Inspecionando a metaclasse de uma classe

Use type(cls) para encontrar a metaclasse de uma classe e cls.__mro__ para ver a ordem de resolução de métodos.

class Meta(type): pass

class Foo(metaclass=Meta): pass

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

Herança de metaclasses

A metaclasse de uma classe é herdada por suas subclasses. Se duas classes base tiverem metaclasses diferentes, deverá ser usada a mais derivada (ou surgirá um conflito).

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

Quando usar metaclasses

Use metaclasses para: registrar subclasses automaticamente, impor invariantes de classe, detectar campos de ORM (como o Model do Django) e definir rotas de estruturas de API. Na maioria dos casos, use __init_subclass__ ou decoradores de classe.

# 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

Verificação rápida

O que type("Dog", (Animal,), {"speak": lambda self: "woof"}) faz?

Recapitulação

Toda classe é uma instância de type. O processo de criação de classes é: resolver a metaclasse → preparar o espaço de nomes → executar o corpo → chamar a metaclasse. Prefira __init_subclass__ para ganchos simples de subclasses; use uma metaclasse completa somente quando precisar controlar a própria criação da classe.

Perguntas Frequentes

A aula “Como as classes Python são criadas” é grátis?

Sim — o texto completo de “Como as classes Python são criadas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Como as classes Python são criadas”?

Entenda type, a metaclasse padrão e os ganchos de criação de classes. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Como as classes Python são criadas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Como as classes Python são criadas
  2. Escrita de metaclasses personalizadas
  3. Descritores: __get__, __set__, __delete__
  4. __slots__ e otimização de memória
← Voltar para Python Academy