Arquivo de Orientada a Objeto

Metaclasses em Python

25/04/202622/04/2026 Por antonino

– Python
– Orientada a Objetos (POO)
1 – Classes e objetos
2 – Herança (simples e múltipla)
3 – Polimorfismo
4 – Encapsulamento (público, _protegido, __privado)
5 – Métodos mágicos (__init__, __call__, __add__, etc.)
6 – Propriedades (@property, setter, deleter)
7 – Classes abstratas (ABC, abstractmethod)
8 – Metaclasses (type, __new__)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Metaclasse é a classe de uma classe, assim como classe é de objeto. Ela define como as classes se comportam e são construídas. Primeiramente, type é a metaclasse padrão do Python. Por exemplo, type(MinhaClasse) retorna <class 'type'>. Além disso, você pode criar metaclasses personalizadas. A voz passiva é usada aqui: “as classes são criadas dinamicamente pela metaclasse”. Quando utilizar metaclasses? Em frameworks e bibliotecas complexas. Também para validação de classes ou registro automático. Metaclasses são um recurso avançado e poderoso. Vamos explorar type, __new__ e __init__ da metaclasse. Três subtítulos guiarão você por esse tópico profundo. Ao final, você entenderá o coração da orientação a objetos.

Type: a metaclasse padrão

type é a metaclasse de todas as classes em Python. Você pode criar classes dinamicamente com type(nome, bases, dicionário). Quando usar criação dinâmica? Em código gerado automaticamente. Também em metaprogramação avançada. A voz passiva é aplicada: “os atributos são passados como dicionário”. Exemplo de type como metaclasse:

# Forma tradicional (usando class)
class AnimalTradicional:
    def __init__(self, nome):
        self.nome = nome
    
    def falar(self):
        return "Som genérico"

# Mesma coisa, criada dinamicamente com type
def falar_dinamico(self):
    return "Som genérico"

AnimalDinamico = type('AnimalDinamico', (object,), {
    '__init__': lambda self, nome: setattr(self, 'nome', nome),
    'falar': falar_dinamico
})

# Demonstração
print("=== Criando Classes com type ===\n")
tradicional = AnimalTradicional("Rex")
dinamico = AnimalDinamico("Bob")

print(f"Tradicional: {tradicional.nome} - {tradicional.falar()}")
print(f"Dinâmico: {dinamico.nome} - {dinamico.falar()}")
print(f"type(AnimalTradicional): {type(AnimalTradicional)}")
print(f"type(AnimalDinamico): {type(AnimalDinamico)}")

# Criando classe com métodos e propriedades
def __init__(self, x, y):
    self.x = x
    self.y = y

def __add__(self, outro):
    return Ponto(self.x + outro.x, self.y + outro.y)

def __repr__(self):
    return f"Ponto({self.x}, {self.y})"

Ponto = type('Ponto', (object,), {
    '__init__': __init__,
    '__add__': __add__,
    '__repr__': __repr__
})

p1 = Ponto(3, 4)
p2 = Ponto(1, 2)
print(f"\nPonto: {p1}")
print(f"p1 + p2 = {p1 + p2}")

# Verificando a cadeia de metaclasses
print(f"\nCadeia de tipos:")
print(f"type(p1): {type(p1)}")
print(f"type(Ponto): {type(Ponto)}")
print(f"type(type(Ponto)): {type(type(Ponto))}")

# Forma tradicional (usando class)

class AnimalTradicional:

def __init__(self, nome):

self.nome = nome

def falar(self):

return "Som genérico"

# Mesma coisa, criada dinamicamente com type

def falar_dinamico(self):

return "Som genérico"

AnimalDinamico = type('AnimalDinamico', (object,), {

'__init__': lambda self, nome: setattr(self, 'nome', nome),

'falar': falar_dinamico

})

# Demonstração

print("=== Criando Classes com type ===\n")

tradicional = AnimalTradicional("Rex")

dinamico = AnimalDinamico("Bob")

print(f"Tradicional: {tradicional.nome} - {tradicional.falar()}")

print(f"Dinâmico: {dinamico.nome} - {dinamico.falar()}")

print(f"type(AnimalTradicional): {type(AnimalTradicional)}")

print(f"type(AnimalDinamico): {type(AnimalDinamico)}")

# Criando classe com métodos e propriedades

def __init__(self, x, y):

self.x = x

self.y = y

def __add__(self, outro):

return Ponto(self.x + outro.x, self.y + outro.y)

def __repr__(self):

return f"Ponto({self.x}, {self.y})"

Ponto = type('Ponto', (object,), {

'__init__': __init__,

'__add__': __add__,

'__repr__': __repr__

})

p1 = Ponto(3, 4)

p2 = Ponto(1, 2)

print(f"\nPonto: {p1}")

print(f"p1 + p2 = {p1 + p2}")

# Verificando a cadeia de metaclasses

print(f"\nCadeia de tipos:")

print(f"type(p1): {type(p1)}")

print(f"type(Ponto): {type(Ponto)}")

print(f"type(type(Ponto)): {type(type(Ponto))}")

type é a base de todo sistema de classes. Toda classe em Python é uma instância de type.

Criando metaclasses personalizadas

Uma metaclasse personalizada herda de type. Sobrescreva __new__ para interceptar a criação da classe. Use __init__ para modificar a classe após criada. Quando usar metaclasse personalizada? Em ORMs e frameworks web. Também para singletons ou validação de interfaces. A voz passiva é aplicada: “os atributos da classe são inspecionados”. Exemplo de metaclasse personalizada:

class SingletonMeta(type):
    """Metaclasse que implementa o padrão Singleton."""
    
    _instancias = {}
    
    def __call__(cls, *args, **kwargs):
        """Controla a criação de instâncias."""
        if cls not in cls._instancias:
            print(f"Criando primeira instância de {cls.__name__}")
            cls._instancias[cls] = super().__call__(*args, **kwargs)
        else:
            print(f"Retornando instância existente de {cls.__name__}")
        return cls._instancias[cls]

class Configuracao(metaclass=SingletonMeta):
    """Classe Singleton para configurações."""
    
    def __init__(self, ambiente="producao"):
        self.ambiente = ambiente
        print(f"Configuração inicializada para {ambiente}")

# Demonstração
print("=== Singleton com Metaclasse ===\n")
c1 = Configuracao("desenvolvimento")
c2 = Configuracao("producao")

print(f"c1 é c2? {c1 is c2}")
print(f"c1.ambiente: {c1.ambiente}")
print(f"c2.ambiente: {c2.ambiente}")

# Metaclasse para validação de classes
class ValidadorMeta(type):
    """Metaclasse que valida se métodos obrigatórios existem."""
    
    def __new__(mcs, nome, bases, dicionario):
        """Valida a classe antes de criá-la."""
        if 'processar' not in dicionario:
            raise TypeError(f"Classe {nome} deve implementar método 'processar'")
        
        if 'nome' not in dicionario:
            raise TypeError(f"Classe {nome} deve ter atributo 'nome'")
        
        print(f"Classe {nome} validada com sucesso!")
        return super().__new__(mcs, nome, bases, dicionario)

class ProcessadorValido(metaclass=ValidadorMeta):
    nome = "Processador Válido"
    
    def processar(self, dados):
        return f"Processando: {dados}"

# Esta classe falharia (descomente para testar)
# class ProcessadorInvalido(metaclass=ValidadorMeta):
#     nome = "Inválido"
#     # Faltou o método processar!

print("\n=== Validação de Classes ===")
p = ProcessadorValido()
print(p.processar("dados importantes"))

# Metaclasse para registro automático
class RegistradorMeta(type):
    """Metaclasse que registra todas as classes criadas."""
    
    _classes = []
    
    def __new__(mcs, nome, bases, dicionario):
        nova_classe = super().__new__(mcs, nome, bases, dicionario)
        mcs._classes.append(nova_classe)
        print(f"Registrada classe: {nome}")
        return nova_classe
    
    @classmethod
    def listar_classes(mcs):
        return mcs._classes.copy()

class PluginA(metaclass=RegistradorMeta):
    pass

class PluginB(metaclass=RegistradorMeta):
    pass

class PluginC(metaclass=RegistradorMeta):
    pass

print("\n=== Registro Automático ===")
for cls in RegistradorMeta.listar_classes():
    print(f"Classe registrada: {cls.__name__}")

class SingletonMeta(type):

"""Metaclasse que implementa o padrão Singleton."""

_instancias = {}

def __call__(cls, *args, **kwargs):

"""Controla a criação de instâncias."""

if cls not in cls._instancias:

print(f"Criando primeira instância de {cls.__name__}")

cls._instancias[cls] = super().__call__(*args, **kwargs)

else:

print(f"Retornando instância existente de {cls.__name__}")

return cls._instancias[cls]

class Configuracao(metaclass=SingletonMeta):

"""Classe Singleton para configurações."""

def __init__(self, ambiente="producao"):

self.ambiente = ambiente

print(f"Configuração inicializada para {ambiente}")

# Demonstração

print("=== Singleton com Metaclasse ===\n")

c1 = Configuracao("desenvolvimento")

c2 = Configuracao("producao")

print(f"c1 é c2? {c1 is c2}")

print(f"c1.ambiente: {c1.ambiente}")

print(f"c2.ambiente: {c2.ambiente}")

# Metaclasse para validação de classes

class ValidadorMeta(type):

"""Metaclasse que valida se métodos obrigatórios existem."""

def __new__(mcs, nome, bases, dicionario):

"""Valida a classe antes de criá-la."""

if 'processar' not in dicionario:

raise TypeError(f"Classe {nome} deve implementar método 'processar'")

if 'nome' not in dicionario:

raise TypeError(f"Classe {nome} deve ter atributo 'nome'")

print(f"Classe {nome} validada com sucesso!")

return super().__new__(mcs, nome, bases, dicionario)

class ProcessadorValido(metaclass=ValidadorMeta):

nome = "Processador Válido"

def processar(self, dados):

return f"Processando: {dados}"

# Esta classe falharia (descomente para testar)

# class ProcessadorInvalido(metaclass=ValidadorMeta):

# nome = "Inválido"

# # Faltou o método processar!

print("\n=== Validação de Classes ===")

p = ProcessadorValido()

print(p.processar("dados importantes"))

# Metaclasse para registro automático

class RegistradorMeta(type):

"""Metaclasse que registra todas as classes criadas."""

_classes = []

def __new__(mcs, nome, bases, dicionario):

nova_classe = super().__new__(mcs, nome, bases, dicionario)

mcs._classes.append(nova_classe)

print(f"Registrada classe: {nome}")

return nova_classe

@classmethod

def listar_classes(mcs):

return mcs._classes.copy()

class PluginA(metaclass=RegistradorMeta):

pass

class PluginB(metaclass=RegistradorMeta):

pass

class PluginC(metaclass=RegistradorMeta):

pass

print("\n=== Registro Automático ===")

for cls in RegistradorMeta.listar_classes():

print(f"Classe registrada: {cls.__name__}")

Metaclasses interceptam a criação de classes no nível mais alto. Elas são extremamente poderosas, mas use com moderação.

new e init na metaclasse

__new__ cria a classe antes dela existir. __init__ inicializa a classe já criada. __call__ controla a criação de instâncias. Quando usar cada um? __new__ para modificar a estrutura. __init__ para adicionar atributos ou métodos extras. __call__ para singletons ou pools de objetos. A voz passiva é aplicada: “os atributos são adicionados após a criação”. Exemplo completo com todos os métodos:

class DebugMeta(type):
    """Metaclasse que debuga a criação de classes e instâncias."""
    
    def __new__(mcs, nome, bases, dicionario):
        print(f"[__new__] Criando classe: {nome}")
        print(f"  Bases: {bases}")
        print(f"  Atributos: {list(dicionario.keys())}")
        
        # Adiciona um atributo de classe
        dicionario['criado_por'] = 'DebugMeta'
        
        return super().__new__(mcs, nome, bases, dicionario)
    
    def __init__(cls, nome, bases, dicionario):
        print(f"[__init__] Inicializando classe: {nome}")
        super().__init__(nome, bases, dicionario)
    
    def __call__(cls, *args, **kwargs):
        print(f"[__call__] Criando instância de {cls.__name__}")
        print(f"  Args: {args}, Kwargs: {kwargs}")
        instancia = super().__call__(*args, **kwargs)
        print(f"  Instância criada: {instancia}")
        return instancia

class MinhaClasse(metaclass=DebugMeta):
    def __init__(self, valor):
        self.valor = valor
        print(f"  __init__ da instância: valor={valor}")
    
    def metodo(self):
        return f"Valor: {self.valor}"

print("=== Debug da Criação ===\n")
print("Definindo a classe...")
# A classe já é criada aqui

print("\nCriando instância...")
obj = MinhaClasse(42)
print(f"\nResultado do método: {obj.metodo()}")
print(f"Atributo de classe: {obj.criado_por}")

# Metaclasse para verificar convenções de nomenclatura
class NomenclaturaMeta(type):
    """Metaclasse que verifica nomes de métodos e atributos."""
    
    def __new__(mcs, nome, bases, dicionario):
        # Verifica nomes de métodos (devem ser snake_case)
        for key in dicionario:
            if callable(dicionario[key]) and not key.startswith('__'):
                if '_' not in key and key != key.lower():
                    print(f"Aviso: Método '{key}' não segue snake_case")
        
        # Garante que a classe tenha docstring
        if not dicionario.get('__doc__'):
            dicionario['__doc__'] = f"Classe {nome} gerada automaticamente"
        
        return super().__new__(mcs, nome, bases, dicionario)

class Calculadora(metaclass=NomenclaturaMeta):
    """Calculadora básica."""
    
    def somar(self, a, b):
        return a + b
    
    def multiplicar(self, a, b):
        return a * b

class CalculadoraRuim(metaclass=NomenclaturaMeta):
    def Somar(self, a, b):  # Nome não segue convenção
        return a + b

print("\n=== Validação de Nomenclatura ===")
calc = Calculadora()
print(f"Soma: {calc.somar(5, 3)}")

# Metaclasse para adicionar logging automático
class LoggingMeta(type):
    """Adiciona logging a todos os métodos da classe."""
    
    def __new__(mcs, nome, bases, dicionario):
        for nome_metodo, metodo in dicionario.items():
            if callable(metodo) and not nome_metodo.startswith('__'):
                # Envolve o método com logging
                def fazer_log(method):
                    def logged_method(self, *args, **kwargs):
                        print(f"[LOG] Chamando {method.__name__}")
                        resultado = method(self, *args, **kwargs)
                        print(f"[LOG] {method.__name__} retornou {resultado}")
                        return resultado
                    return logged_method
                dicionario[nome_metodo] = fazer_log(metodo)
        
        return super().__new__(mcs, nome, bases, dicionario)

class Banco(metaclass=LoggingMeta):
    def depositar(self, valor):
        return f"Depositado R${valor:.2f}"
    
    def sacar(self, valor):
        return f"Sacado R${valor:.2f}"
    
    def saldo(self):
        return 1000.00

print("\n=== Logging Automático ===")
banco = Banco()
banco.depositar(500)
banco.sacar(200)
print(f"Saldo: R${banco.saldo():.2f}")

100

101

102

103

104

105

106

107

108

109

class DebugMeta(type):

"""Metaclasse que debuga a criação de classes e instâncias."""

def __new__(mcs, nome, bases, dicionario):

print(f"[__new__] Criando classe: {nome}")

print(f" Bases: {bases}")

print(f" Atributos: {list(dicionario.keys())}")

# Adiciona um atributo de classe

dicionario['criado_por'] = 'DebugMeta'

return super().__new__(mcs, nome, bases, dicionario)

def __init__(cls, nome, bases, dicionario):

print(f"[__init__] Inicializando classe: {nome}")

super().__init__(nome, bases, dicionario)

def __call__(cls, *args, **kwargs):

print(f"[__call__] Criando instância de {cls.__name__}")

print(f" Args: {args}, Kwargs: {kwargs}")

instancia = super().__call__(*args, **kwargs)

print(f" Instância criada: {instancia}")

return instancia

class MinhaClasse(metaclass=DebugMeta):

def __init__(self, valor):

self.valor = valor

print(f" __init__ da instância: valor={valor}")

def metodo(self):

return f"Valor: {self.valor}"

print("=== Debug da Criação ===\n")

print("Definindo a classe...")

# A classe já é criada aqui

print("\nCriando instância...")

obj = MinhaClasse(42)

print(f"\nResultado do método: {obj.metodo()}")

print(f"Atributo de classe: {obj.criado_por}")

# Metaclasse para verificar convenções de nomenclatura

class NomenclaturaMeta(type):

"""Metaclasse que verifica nomes de métodos e atributos."""

def __new__(mcs, nome, bases, dicionario):

# Verifica nomes de métodos (devem ser snake_case)

for key in dicionario:

if callable(dicionario[key]) and not key.startswith('__'):

if '_' not in key and key != key.lower():

print(f"Aviso: Método '{key}' não segue snake_case")

# Garante que a classe tenha docstring

if not dicionario.get('__doc__'):

dicionario['__doc__'] = f"Classe {nome} gerada automaticamente"

return super().__new__(mcs, nome, bases, dicionario)

class Calculadora(metaclass=NomenclaturaMeta):

"""Calculadora básica."""

def somar(self, a, b):

return a + b

def multiplicar(self, a, b):

return a * b

class CalculadoraRuim(metaclass=NomenclaturaMeta):

def Somar(self, a, b): # Nome não segue convenção

return a + b

print("\n=== Validação de Nomenclatura ===")

calc = Calculadora()

print(f"Soma: {calc.somar(5, 3)}")

# Metaclasse para adicionar logging automático

class LoggingMeta(type):

"""Adiciona logging a todos os métodos da classe."""

def __new__(mcs, nome, bases, dicionario):

for nome_metodo, metodo in dicionario.items():

if callable(metodo) and not nome_metodo.startswith('__'):

# Envolve o método com logging

def fazer_log(method):

def logged_method(self, *args, **kwargs):

print(f"[LOG] Chamando {method.__name__}")

resultado = method(self, *args, **kwargs)

print(f"[LOG] {method.__name__} retornou {resultado}")

return resultado

return logged_method

dicionario[nome_metodo] = fazer_log(metodo)

return super().__new__(mcs, nome, bases, dicionario)

class Banco(metaclass=LoggingMeta):

def depositar(self, valor):

return f"Depositado R${valor:.2f}"

def sacar(self, valor):

return f"Sacado R${valor:.2f}"

def saldo(self):

return 1000.00

print("\n=== Logging Automático ===")

banco = Banco()

banco.depositar(500)

banco.sacar(200)

print(f"Saldo: R${banco.saldo():.2f}")

Metaclasses operam no momento da definição da classe. A fórmula de profundidade da metaprogramação: $M = \text{objeto} \to \text{classe} \to \text{metaclasse} \to \text{type}$ Metaclasses são ferramentas avançadas para situações específicas. Use-as com sabedoria e documente bem seu propósito. Para 99% dos casos, herança e composição são suficientes. Mas quando precisar de poder real, as metaclasses estão lá.

Classes Abstratas em Python

25/04/202622/04/2026 Por antonino

– Python
– Orientada a Objetos (POO)
1 – Classes e objetos
2 – Herança (simples e múltipla)
3 – Polimorfismo
4 – Encapsulamento (público, _protegido, __privado)
5 – Métodos mágicos (__init__, __call__, __add__, etc.)
6 – Propriedades (@property, setter, deleter)
7 – Classes abstratas (ABC, abstractmethod)
8 – Metaclasses (type, __new__)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Classes abstratas servem como modelos para outras classes. Elas não permitem instanciação direta pelo programador. Primeiramente, use from abc import ABC, abstractmethod. Por exemplo, class Forma(ABC): define uma classe abstrata. Além disso, @abstractmethod força a implementação nas filhas. Assim, você garante uma interface consistente em toda hierarquia. Consequentemente, o código fica mais confiável e previsível. Quando utilizar classes abstratas? Em hierarquias de classes bem definidas. Também quando você quer garantir uma interface consistente. Por outro lado, para classes simples e isoladas, não são necessárias. Python oferece o módulo abc para essa funcionalidade. Então, vamos explorar conceitos, implementação e boas práticas. Três subtítulos guiarão você pelo mundo das classes abstratas. Portanto, ao final, você projetará hierarquias robustas e consistentes.

Criando classes abstratas com abc

Uma classe abstrata herda de ABC (Abstract Base Class). Métodos abstratos usam o decorador @abstractmethod. Classes filhas devem implementar todos os métodos abstratos. Quando usar essa abordagem? Em frameworks e bibliotecas. Também para definir contratos entre equipes diferentes. Exemplo de classe abstrata:

from abc import ABC, abstractmethod
import math

class Forma(ABC):
    """Classe abstrata para todas as formas geométricas."""
    
    @abstractmethod
    def area(self):
        """Calcula a área da forma (deve ser implementado)."""
        pass
    
    @abstractmethod
    def perimetro(self):
        """Calcula o perímetro da forma (deve ser implementado)."""
        pass
    
    def descricao(self):
        """Método concreto (não precisa ser sobrescrito)."""
        return f"Área: {self.area():.2f}, Perímetro: {self.perimetro():.2f}"

# Tentar instanciar classe abstrata gera erro
try:
    f = Forma()
except TypeError as e:
    print(f"Erro: {e}")

# Classes concretas (implementam os métodos abstratos)
class Retangulo(Forma):
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura
    
    def area(self):
        return self.largura * self.altura
    
    def perimetro(self):
        return 2 * (self.largura + self.altura)

class Circulo(Forma):
    def __init__(self, raio):
        self.raio = raio
    
    def area(self):
        return math.pi * self.raio ** 2
    
    def perimetro(self):
        return 2 * math.pi * self.raio

class Triangulo(Forma):
    def __init__(self, base, altura, lado1, lado2, lado3):
        self.base = base
        self.altura = altura
        self.lado1 = lado1
        self.lado2 = lado2
        self.lado3 = lado3
    
    def area(self):
        return (self.base * self.altura) / 2
    
    def perimetro(self):
        return self.lado1 + self.lado2 + self.lado3

# Demonstração
print("=== Classes Abstratas ===\n")
formas = [
    Retangulo(5, 3),
    Circulo(4),
    Triangulo(6, 4, 3, 4, 5)
]

for forma in formas:
    print(f"{forma.__class__.__name__}: {forma.descricao()}")

# Verificação de tipos
print(f"\nRetangulo é subclasse de Forma? {issubclass(Retangulo, Forma)}")
print(f"Circulo é instância de Forma? {isinstance(Circulo(2), Forma)}")

from abc import ABC, abstractmethod

import math

class Forma(ABC):

"""Classe abstrata para todas as formas geométricas."""

@abstractmethod

def area(self):

"""Calcula a área da forma (deve ser implementado)."""

pass

@abstractmethod

def perimetro(self):

"""Calcula o perímetro da forma (deve ser implementado)."""

pass

def descricao(self):

"""Método concreto (não precisa ser sobrescrito)."""

return f"Área: {self.area():.2f}, Perímetro: {self.perimetro():.2f}"

# Tentar instanciar classe abstrata gera erro

try:

f = Forma()

except TypeError as e:

print(f"Erro: {e}")

# Classes concretas (implementam os métodos abstratos)

class Retangulo(Forma):

def __init__(self, largura, altura):

self.largura = largura

self.altura = altura

def area(self):

return self.largura * self.altura

def perimetro(self):

return 2 * (self.largura + self.altura)

class Circulo(Forma):

def __init__(self, raio):

self.raio = raio

def area(self):

return math.pi * self.raio ** 2

def perimetro(self):

return 2 * math.pi * self.raio

class Triangulo(Forma):

def __init__(self, base, altura, lado1, lado2, lado3):

self.base = base

self.altura = altura

self.lado1 = lado1

self.lado2 = lado2

self.lado3 = lado3

def area(self):

return (self.base * self.altura) / 2

def perimetro(self):

return self.lado1 + self.lado2 + self.lado3

# Demonstração

print("=== Classes Abstratas ===\n")

formas = [

Retangulo(5, 3),

Circulo(4),

Triangulo(6, 4, 3, 4, 5)

]

for forma in formas:

print(f"{forma.__class__.__name__}: {forma.descricao()}")

# Verificação de tipos

print(f"\nRetangulo é subclasse de Forma? {issubclass(Retangulo, Forma)}")

print(f"Circulo é instância de Forma? {isinstance(Circulo(2), Forma)}")

Classes abstratas garantem que todas as filhas tenham a mesma interface. Elas funcionam como contratos formais no seu código. Portanto, use-as para evitar erros de implementação.

Métodos abstratos com implementação parcial

Classes abstratas podem ter métodos concretos também. Métodos abstratos podem ter implementação (chamável com super()). Isso permite reaproveitar código comum entre as filhas. Quando usar essa abordagem? Em padrões Template Method. Também para fornecer comportamento padrão opcional. Assim, você evita duplicação desnecessária de código. Exemplo de classe abstrata com implementação parcial:

from abc import ABC, abstractmethod

class Animal(ABC):
    """Classe abstrata com implementação parcial."""
    
    def __init__(self, nome):
        self.nome = nome
    
    @abstractmethod
    def fazer_som(self):
        """Cada animal deve implementar seu som."""
        pass
    
    @abstractmethod
    def mover(self):
        """Cada animal deve implementar seu movimento."""
        pass
    
    def apresentar(self):
        """Método concreto que usa métodos abstratos."""
        return f"{self.nome} diz '{self.fazer_som()}' e {self.mover()}"
    
    def __str__(self):
        return f"Animal: {self.nome}"

# Classes concretas
class Cachorro(Animal):
    def fazer_som(self):
        return "Au au!"
    
    def mover(self):
        return "corre pelo parque"

class Gato(Animal):
    def fazer_som(self):
        return "Miau!"
    
    def mover(self):
        return "anda silenciosamente"

class Passaro(Animal):
    def fazer_som(self):
        return "Piu piu!"
    
    def mover(self):
        return "voa pelo céu"

# Exemplo com método abstrato que tem implementação
class Veiculo(ABC):
    @abstractmethod
    def ligar(self):
        """Liga o veículo (pode ser chamado via super())."""
        print("Veículo: verificando sistemas básicos")
    
    @abstractmethod
    def desligar(self):
        print("Veículo: desligando sistemas")

class Carro(Veiculo):
    def ligar(self):
        super().ligar()  # Chama implementação da classe mãe
        print("Carro: motor ligado, pronto para dirigir")
    
    def desligar(self):
        super().desligar()
        print("Carro: motor desligado, chave removida")

class Moto(Veiculo):
    def ligar(self):
        super().ligar()
        print("Moto: partida elétrica acionada")
    
    def desligar(self):
        super().desligar()
        print("Moto: cortando ignição")

# Demonstração
print("=== Implementação Parcial ===\n")
animais = [Cachorro("Rex"), Gato("Mimi"), Passaro("Piu")]
for animal in animais:
    print(animal.apresentar())

print("\n=== Veículos com super() ===")
carro = Carro()
moto = Moto()

print("Ligando carro:")
carro.ligar()
print("\nDesligando carro:")
carro.desligar()

print("\nLigando moto:")
moto.ligar()
print("\nDesligando moto:")
moto.desligar()

from abc import ABC, abstractmethod

class Animal(ABC):

"""Classe abstrata com implementação parcial."""

def __init__(self, nome):

self.nome = nome

@abstractmethod

def fazer_som(self):

"""Cada animal deve implementar seu som."""

pass

@abstractmethod

def mover(self):

"""Cada animal deve implementar seu movimento."""

pass

def apresentar(self):

"""Método concreto que usa métodos abstratos."""

return f"{self.nome} diz '{self.fazer_som()}' e {self.mover()}"

def __str__(self):

return f"Animal: {self.nome}"

# Classes concretas

class Cachorro(Animal):

def fazer_som(self):

return "Au au!"

def mover(self):

return "corre pelo parque"

class Gato(Animal):

def fazer_som(self):

return "Miau!"

def mover(self):

return "anda silenciosamente"

class Passaro(Animal):

def fazer_som(self):

return "Piu piu!"

def mover(self):

return "voa pelo céu"

# Exemplo com método abstrato que tem implementação

class Veiculo(ABC):

@abstractmethod

def ligar(self):

"""Liga o veículo (pode ser chamado via super())."""

print("Veículo: verificando sistemas básicos")

@abstractmethod

def desligar(self):

print("Veículo: desligando sistemas")

class Carro(Veiculo):

def ligar(self):

super().ligar() # Chama implementação da classe mãe

print("Carro: motor ligado, pronto para dirigir")

def desligar(self):

super().desligar()

print("Carro: motor desligado, chave removida")

class Moto(Veiculo):

def ligar(self):

super().ligar()

print("Moto: partida elétrica acionada")

def desligar(self):

super().desligar()

print("Moto: cortando ignição")

# Demonstração

print("=== Implementação Parcial ===\n")

animais = [Cachorro("Rex"), Gato("Mimi"), Passaro("Piu")]

for animal in animais:

print(animal.apresentar())

print("\n=== Veículos com super() ===")

carro = Carro()

moto = Moto()

print("Ligando carro:")

carro.ligar()

print("\nDesligando carro:")

carro.desligar()

print("\nLigando moto:")

moto.ligar()

print("\nDesligando moto:")

moto.desligar()

Métodos abstratos com implementação base são úteis e flexíveis. Eles permitem extensão sem duplicação de código. Portanto, use essa técnica para bases sólidas.

Propriedades abstratas e verificação de interface

Propriedades também podem ser declaradas como abstratas. Use @property e @abstractmethod juntos. Isso força as classes filhas a implementarem getters e setters. Quando usar propriedades abstratas? Em atributos obrigatórios. Também para garantir que certos dados estejam disponíveis. Além disso, a verificação ocorre em tempo de instanciação. Exemplo de propriedades abstratas:

from abc import ABC, abstractmethod

class Funcionario(ABC):
    """Classe abstrata com propriedades abstratas."""
    
    def __init__(self, nome):
        self.nome = nome
    
    @property
    @abstractmethod
    def salario(self):
        """Salário do funcionário (propriedade abstrata)."""
        pass
    
    @property
    @abstractmethod
    def cargo(self):
        """Cargo do funcionário (propriedade abstrata)."""
        pass
    
    @abstractmethod
    def trabalhar(self):
        """Realiza o trabalho específico."""
        pass
    
    def exibir_informacoes(self):
        return f"{self.cargo}: {self.nome} - R${self.salario:.2f}"

class Desenvolvedor(Funcionario):
    def __init__(self, nome, salario_base, bonus=0):
        super().__init__(nome)
        self._salario_base = salario_base
        self._bonus = bonus
    
    @property
    def salario(self):
        return self._salario_base + self._bonus
    
    @property
    def cargo(self):
        return "Desenvolvedor"
    
    def trabalhar(self):
        return f"{self.nome} está programando em Python"

class Gerente(Funcionario):
    def __init__(self, nome, salario_base, equipe_size):
        super().__init__(nome)
        self._salario_base = salario_base
        self._equipe_size = equipe_size
    
    @property
    def salario(self):
        return self._salario_base + (self._equipe_size * 500)
    
    @property
    def cargo(self):
        return "Gerente"
    
    def trabalhar(self):
        return f"{self.nome} está gerenciando {self._equipe_size} pessoas"

class Estagiario(Funcionario):
    def __init__(self, nome, bolsa):
        super().__init__(nome)
        self._bolsa = bolsa
    
    @property
    def salario(self):
        return self._bolsa
    
    @property
    def cargo(self):
        return "Estagiário"
    
    def trabalhar(self):
        return f"{self.nome} está aprendendo e ajudando"

# Demonstração
print("=== Propriedades Abstratas ===\n")
funcionarios = [
    Desenvolvedor("Ana", 5000, 1000),
    Gerente("Carlos", 8000, 5),
    Estagiario("Mariana", 1500)
]

for func in funcionarios:
    print(func.exibir_informacoes())
    print(f"  Trabalho: {func.trabalhar()}")
    print()

# Verificação de interface (todos implementam os métodos)
def processar_funcionario(func: Funcionario):
    """Função que aceita qualquer Funcionário (polimorfismo)."""
    print(f"Processando: {func.exibir_informacoes()}")

print("=== Processamento Polimórfico ===")
processar_funcionario(Desenvolvedor("João", 6000, 500))

# Exemplo de verificação de tipo abstrato
from abc import ABCMeta

class Plugin(metaclass=ABCMeta):
    """Outra forma de declarar classe abstrata (alternativa)."""
    
    @abstractmethod
    def executar(self, dados):
        pass
    
    @abstractmethod
    def nome(self):
        pass

class PluginA(Plugin):
    def executar(self, dados):
        return f"PluginA processou: {dados}"
    
    def nome(self):
        return "Plugin A"

print("\n=== Plugin com metaclass ===")
plugin = PluginA()
print(f"Plugin: {plugin.nome()}")
print(plugin.executar("dados importantes"))

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

from abc import ABC, abstractmethod

class Funcionario(ABC):

"""Classe abstrata com propriedades abstratas."""

def __init__(self, nome):

self.nome = nome

@property

@abstractmethod

def salario(self):

"""Salário do funcionário (propriedade abstrata)."""

pass

@property

@abstractmethod

def cargo(self):

"""Cargo do funcionário (propriedade abstrata)."""

pass

@abstractmethod

def trabalhar(self):

"""Realiza o trabalho específico."""

pass

def exibir_informacoes(self):

return f"{self.cargo}: {self.nome} - R${self.salario:.2f}"

class Desenvolvedor(Funcionario):

def __init__(self, nome, salario_base, bonus=0):

super().__init__(nome)

self._salario_base = salario_base

self._bonus = bonus

@property

def salario(self):

return self._salario_base + self._bonus

@property

def cargo(self):

return "Desenvolvedor"

def trabalhar(self):

return f"{self.nome} está programando em Python"

class Gerente(Funcionario):

def __init__(self, nome, salario_base, equipe_size):

super().__init__(nome)

self._salario_base = salario_base

self._equipe_size = equipe_size

@property

def salario(self):

return self._salario_base + (self._equipe_size * 500)

@property

def cargo(self):

return "Gerente"

def trabalhar(self):

return f"{self.nome} está gerenciando {self._equipe_size} pessoas"

class Estagiario(Funcionario):

def __init__(self, nome, bolsa):

super().__init__(nome)

self._bolsa = bolsa

@property

def salario(self):

return self._bolsa

@property

def cargo(self):

return "Estagiário"

def trabalhar(self):

return f"{self.nome} está aprendendo e ajudando"

# Demonstração

print("=== Propriedades Abstratas ===\n")

funcionarios = [

Desenvolvedor("Ana", 5000, 1000),

Gerente("Carlos", 8000, 5),

Estagiario("Mariana", 1500)

]

for func in funcionarios:

print(func.exibir_informacoes())

print(f" Trabalho: {func.trabalhar()}")

print()

# Verificação de interface (todos implementam os métodos)

def processar_funcionario(func: Funcionario):

"""Função que aceita qualquer Funcionário (polimorfismo)."""

print(f"Processando: {func.exibir_informacoes()}")

print("=== Processamento Polimórfico ===")

processar_funcionario(Desenvolvedor("João", 6000, 500))

# Exemplo de verificação de tipo abstrato

from abc import ABCMeta

class Plugin(metaclass=ABCMeta):

"""Outra forma de declarar classe abstrata (alternativa)."""

@abstractmethod

def executar(self, dados):

pass

@abstractmethod

def nome(self):

pass

class PluginA(Plugin):

def executar(self, dados):

return f"PluginA processou: {dados}"

def nome(self):

return "Plugin A"

print("\n=== Plugin com metaclass ===")

plugin = PluginA()

print(f"Plugin: {plugin.nome()}")

print(plugin.executar("dados importantes"))

Propriedades abstratas garantem que atributos essenciais existam. A fórmula de uma classe abstrata bem projetada: $C_{\text{abstrata}} = \text{interface} + \text{implementação comum}$ Classes abstratas são ferramentas poderosas para arquitetura de software. Use-as para definir contratos claros e evitar duplicação. Portanto, seu sistema ficará mais robusto e fácil de estender. Finalmente, pratique com exemplos reais do seu dia a dia.

Type: a metaclasse padrão

Criando metaclasses personalizadas

__new__ e __init__ na metaclasse

Criando classes abstratas com abc

Métodos abstratos com implementação parcial

Propriedades abstratas e verificação de interface

new e init na metaclasse