Arquivo de Orientada a Objeto - Página 2 de 5

Propriedades 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

Propriedades permitem controlar o acesso a atributos de classe. Elas transformam métodos em atributos virtuais com lógica personalizada. Primeiramente, @property cria um getter para o atributo. Por exemplo, @property seguido de def nome(self). Além disso, @nome.setter define um setter para validação. O decorador @nome.deleter controla a deleção do atributo. A voz passiva é usada aqui: “os valores são validados antes de serem armazenados”. Quando utilizar propriedades? Em atributos que precisam de validação. Também para criar atributos calculados ou somente leitura. Propriedades mantêm a sintaxe simples de atributos públicos. Porém, elas adicionam lógica de negócio por trás dos panos. Vamos explorar cada tipo com exemplos práticos. Três subtítulos guiarão você pelas propriedades em Python. Ao final, você projetará classes mais seguras e expressivas.

Getter: lendo valores com @property

O decorador @property transforma um método em getter. Você acessa o valor como um atributo normal, sem parênteses. Quando usar getter? Para atributos calculados dinamicamente. Também para expor dados internos de forma controlada. A voz passiva é aplicada: “o valor é calculado a cada acesso”. Exemplo de getter:

class Circulo:
    """Círculo com propriedade calculada."""
    
    def __init__(self, raio):
        self._raio = raio  # Atributo "protegido"
    
    @property
    def raio(self):
        """Getter para o raio."""
        print("Acessando o raio")
        return self._raio
    
    @property
    def area(self):
        """Propriedade calculada (somente leitura)."""
        print("Calculando área...")
        return 3.14159 * self._raio ** 2
    
    @property
    def circunferencia(self):
        """Outra propriedade calculada."""
        return 2 * 3.14159 * self._raio

# Demonstração
print("=== Getter com @property ===\n")
c = Circulo(5)

# Acesso como atributo (sem parênteses)
print(f"Raio: {c.raio}")
print(f"Área: {c.area:.2f}")
print(f"Circunferência: {c.circunferencia:.2f}")

# Tentativa de atribuição direta (falha pois não há setter)
try:
    c.area = 100
except AttributeError as e:
    print(f"Erro: {e}")

class Retangulo:
    """Retângulo com getter formatado."""
    
    def __init__(self, largura, altura):
        self._largura = largura
        self._altura = altura
    
    @property
    def largura(self):
        return self._largura
    
    @property
    def altura(self):
        return self._altura
    
    @property
    def area(self):
        return self._largura * self._altura
    
    @property
    def perimetro(self):
        return 2 * (self._largura + self._altura)
    
    @property
    def dimensoes(self):
        """Retorna tupla com dimensões."""
        return (self._largura, self._altura)

print("\n=== Retângulo com Getters ===")
r = Retangulo(10, 5)
print(f"Largura: {r.largura}")
print(f"Altura: {r.altura}")
print(f"Área: {r.area}")
print(f"Perímetro: {r.perimetro}")
print(f"Dimensões: {r.dimensoes}")

class Circulo:

"""Círculo com propriedade calculada."""

def __init__(self, raio):

self._raio = raio # Atributo "protegido"

@property

def raio(self):

"""Getter para o raio."""

print("Acessando o raio")

return self._raio

@property

def area(self):

"""Propriedade calculada (somente leitura)."""

print("Calculando área...")

return 3.14159 * self._raio ** 2

@property

def circunferencia(self):

"""Outra propriedade calculada."""

return 2 * 3.14159 * self._raio

# Demonstração

print("=== Getter com @property ===\n")

c = Circulo(5)

# Acesso como atributo (sem parênteses)

print(f"Raio: {c.raio}")

print(f"Área: {c.area:.2f}")

print(f"Circunferência: {c.circunferencia:.2f}")

# Tentativa de atribuição direta (falha pois não há setter)

try:

c.area = 100

except AttributeError as e:

print(f"Erro: {e}")

class Retangulo:

"""Retângulo com getter formatado."""

def __init__(self, largura, altura):

self._largura = largura

self._altura = altura

@property

def largura(self):

return self._largura

@property

def altura(self):

return self._altura

@property

def area(self):

return self._largura * self._altura

@property

def perimetro(self):

return 2 * (self._largura + self._altura)

@property

def dimensoes(self):

"""Retorna tupla com dimensões."""

return (self._largura, self._altura)

print("\n=== Retângulo com Getters ===")

r = Retangulo(10, 5)

print(f"Largura: {r.largura}")

print(f"Altura: {r.altura}")

print(f"Área: {r.area}")

print(f"Perímetro: {r.perimetro}")

print(f"Dimensões: {r.dimensoes}")

Getters são ideais para atributos derivados ou somente leitura. Eles mantêm a interface limpa e consistente.

Setter: validando valores com @nome.setter

O setter permite validar dados antes de armazená-los. Use @nome.setter no método que recebe o novo valor. Quando usar setter? Para atributos que exigem validação. Por exemplo, idade negativa ou saldo insuficiente. A voz passiva é aplicada: “a validação é aplicada automaticamente”. Exemplo de setter:

class Pessoa:
    """Pessoa com validação de idade e nome."""
    
    def __init__(self, nome, idade):
        self._nome = None
        self._idade = None
        self.nome = nome  # Usa o setter
        self.idade = idade  # Usa o setter
    
    @property
    def nome(self):
        return self._nome
    
    @nome.setter
    def nome(self, valor):
        """Valida o nome (não pode ser vazio)."""
        if not valor or not valor.strip():
            raise ValueError("Nome não pode ser vazio")
        self._nome = valor.strip().title()
    
    @property
    def idade(self):
        return self._idade
    
    @idade.setter
    def idade(self, valor):
        """Valida idade (entre 0 e 150)."""
        if not isinstance(valor, int):
            raise TypeError("Idade deve ser um número inteiro")
        if valor < 0 or valor > 150:
            raise ValueError("Idade deve estar entre 0 e 150")
        self._idade = valor
    
    @property
    def pode_votar(self):
        """Propriedade calculada (somente leitura)."""
        return self._idade >= 16

# Demonstração
print("=== Setter com Validação ===\n")

p = Pessoa("ana maria", 25)
print(f"Nome: {p.nome}")
print(f"Idade: {p.idade}")
print(f"Pode votar: {p.pode_votar}")

# Tentativas com valores inválidos
try:
    p.nome = ""
except ValueError as e:
    print(f"Erro nome vazio: {e}")

try:
    p.idade = -5
except ValueError as e:
    print(f"Erro idade negativa: {e}")

try:
    p.idade = 200
except ValueError as e:
    print(f"Erro idade excessiva: {e}")

try:
    p.idade = "trinta"
except TypeError as e:
    print(f"Erro tipo inválido: {e}")

# Valores válidos
p.nome = "  joão silva  "
p.idade = 30
print(f"\nApós atualizações válidas:")
print(f"Nome: {p.nome}")
print(f"Idade: {p.idade}")

class ContaBancaria:
    """Conta com validação de saldo."""
    
    def __init__(self, titular, saldo_inicial=0):
        self.titular = titular
        self._saldo = 0
        self.saldo = saldo_inicial  # Usa setter
    
    @property
    def saldo(self):
        return self._saldo
    
    @saldo.setter
    def saldo(self, valor):
        """Valida saldo (não pode ser negativo)."""
        if valor < 0:
            raise ValueError("Saldo não pode ser negativo")
        self._saldo = valor
    
    def depositar(self, valor):
        if valor <= 0:
            raise ValueError("Valor do depósito deve ser positivo")
        self._saldo += valor
    
    def sacar(self, valor):
        if valor <= 0:
            raise ValueError("Valor do saque deve ser positivo")
        if valor > self._saldo:
            raise ValueError("Saldo insuficiente")
        self._saldo -= valor

print("\n=== Conta com Setter ===")
conta = ContaBancaria("Carlos", 1000)
print(f"Saldo inicial: R${conta.saldo:.2f}")

conta.depositar(500)
print(f"Após depósito: R${conta.saldo:.2f}")

conta.sacar(200)
print(f"Após saque: R${conta.saldo:.2f}")

try:
    conta.saldo = -50
except ValueError as e:
    print(f"Erro: {e}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

class Pessoa:

"""Pessoa com validação de idade e nome."""

def __init__(self, nome, idade):

self._nome = None

self._idade = None

self.nome = nome # Usa o setter

self.idade = idade # Usa o setter

@property

def nome(self):

return self._nome

@nome.setter

def nome(self, valor):

"""Valida o nome (não pode ser vazio)."""

if not valor or not valor.strip():

raise ValueError("Nome não pode ser vazio")

self._nome = valor.strip().title()

@property

def idade(self):

return self._idade

@idade.setter

def idade(self, valor):

"""Valida idade (entre 0 e 150)."""

if not isinstance(valor, int):

raise TypeError("Idade deve ser um número inteiro")

if valor < 0 or valor > 150:

raise ValueError("Idade deve estar entre 0 e 150")

self._idade = valor

@property

def pode_votar(self):

"""Propriedade calculada (somente leitura)."""

return self._idade >= 16

# Demonstração

print("=== Setter com Validação ===\n")

p = Pessoa("ana maria", 25)

print(f"Nome: {p.nome}")

print(f"Idade: {p.idade}")

print(f"Pode votar: {p.pode_votar}")

# Tentativas com valores inválidos

try:

p.nome = ""

except ValueError as e:

print(f"Erro nome vazio: {e}")

try:

p.idade = -5

except ValueError as e:

print(f"Erro idade negativa: {e}")

try:

p.idade = 200

except ValueError as e:

print(f"Erro idade excessiva: {e}")

try:

p.idade = "trinta"

except TypeError as e:

print(f"Erro tipo inválido: {e}")

# Valores válidos

p.nome = " joão silva "

p.idade = 30

print(f"\nApós atualizações válidas:")

print(f"Nome: {p.nome}")

print(f"Idade: {p.idade}")

class ContaBancaria:

"""Conta com validação de saldo."""

def __init__(self, titular, saldo_inicial=0):

self.titular = titular

self._saldo = 0

self.saldo = saldo_inicial # Usa setter

@property

def saldo(self):

return self._saldo

@saldo.setter

def saldo(self, valor):

"""Valida saldo (não pode ser negativo)."""

if valor < 0:

raise ValueError("Saldo não pode ser negativo")

self._saldo = valor

def depositar(self, valor):

if valor <= 0:

raise ValueError("Valor do depósito deve ser positivo")

self._saldo += valor

def sacar(self, valor):

if valor <= 0:

raise ValueError("Valor do saque deve ser positivo")

if valor > self._saldo:

raise ValueError("Saldo insuficiente")

self._saldo -= valor

print("\n=== Conta com Setter ===")

conta = ContaBancaria("Carlos", 1000)

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

conta.depositar(500)

print(f"Após depósito: R${conta.saldo:.2f}")

conta.sacar(200)

print(f"Após saque: R${conta.saldo:.2f}")

try:

conta.saldo = -50

except ValueError as e:

print(f"Erro: {e}")

Setters protegem a integridade dos seus dados. Eles centralizam a lógica de validação em um único lugar.

Deleter: controlando remoção de atributos

O deleter define o comportamento de del objeto.atributo. Use @nome.deleter para impedir ou logar deleções. Quando usar deleter? Em atributos que não devem ser removidos. Também para realizar limpeza antes da remoção. A voz passiva é aplicada: “a deleção é interceptada pelo deleter”. Exemplo de deleter:

class Configuracao:
    """Configuração que impede deleção de atributos críticos."""
    
    def __init__(self):
        self._db_url = "postgresql://localhost:5432"
        self._api_key = "segredo-123"
        self._debug = True
    
    @property
    def db_url(self):
        return self._db_url
    
    @db_url.deleter
    def db_url(self):
        raise AttributeError("Não é possível deletar a URL do banco")
    
    @property
    def api_key(self):
        return "********"  # Esconde o valor real
    
    @api_key.deleter
    def api_key(self):
        print("Log: Tentativa de deletar api_key (negado)")
        raise AttributeError("Não é possível deletar a chave da API")
    
    @property
    def debug(self):
        return self._debug
    
    @debug.setter
    def debug(self, valor):
        if not isinstance(valor, bool):
            raise TypeError("Debug deve ser booleano")
        self._debug = valor
    
    @debug.deleter
    def debug(self):
        print("Resetando debug para False em vez de deletar")
        self._debug = False

# Demonstração
print("=== Deleter em Ação ===\n")
config = Configuracao()

print(f"DB URL: {config.db_url}")
print(f"API Key: {config.api_key}")
print(f"Debug: {config.debug}")

# Tentativas de deleção
try:
    del config.db_url
except AttributeError as e:
    print(f"Erro ao deletar db_url: {e}")

try:
    del config.api_key
except AttributeError as e:
    print(f"Erro ao deletar api_key: {e}")

# Deleter com ação alternativa (não levanta erro)
del config.debug
print(f"Debug após deleção (resetado): {config.debug}")

# Exemplo prático: Cache com deleção controlada
class Cache:
    """Cache que registra quando itens são deletados."""
    
    def __init__(self):
        self._dados = {}
        self._acessos = {}
    
    @property
    def dados(self):
        """Retorna cópia dos dados (protege o original)."""
        return self._dados.copy()
    
    @dados.deleter
    def dados(self):
        """Limpa o cache e registra."""
        print(f"LIMPEZA: Removendo {len(self._dados)} itens do cache")
        self._dados.clear()
        self._acessos.clear()
    
    def adicionar(self, chave, valor):
        self._dados[chave] = valor
        self._acessos[chave] = 0
    
    def obter(self, chave):
        if chave in self._dados:
            self._acessos[chave] += 1
            return self._dados[chave]
        return None
    
    @property
    def estatisticas(self):
        return {
            "total_itens": len(self._dados),
            "acessos": self._acessos.copy()
        }

print("\n=== Cache com Deleter ===")
cache = Cache()
cache.adicionar("usuario_1", "Ana")
cache.adicionar("usuario_2", "Carlos")
cache.adicionar("usuario_3", "Maria")

print(f"Dados: {cache.dados}")
print(f"Estatísticas: {cache.estatisticas}")

# Deleta todo o cache via property
del cache.dados
print(f"Após deleção: {cache.dados}")

# Exemplo completo: Temperatura com conversão automática
class Temperatura:
    """Temperatura com propriedade em Celsius e Fahrenheit."""
    
    def __init__(self, celsius=0):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @celsius.setter
    def celsius(self, valor):
        if valor < -273.15:
            raise ValueError("Temperatura abaixo do zero absoluto")
        self._celsius = valor
    
    @celsius.deleter
    def celsius(self):
        print("Resetando temperatura para 0°C")
        self._celsius = 0
    
    @property
    def fahrenheit(self):
        """Propriedade calculada (conversão)."""
        return (self._celsius * 9/5) + 32
    
    @fahrenheit.setter
    def fahrenheit(self, valor):
        """Permite definir temperatura em Fahrenheit."""
        self.celsius = (valor - 32) * 5/9
    
    def __str__(self):
        return f"{self.celsius}°C = {self.fahrenheit:.1f}°F"

print("\n=== Temperatura com Propriedades ===")
temp = Temperatura(25)
print(temp)

temp.fahrenheit = 100
print(f"Após definir 100°F: {temp}")

del temp.celsius  # Reseta para 0
print(f"Após deleção: {temp}")

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

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

class Configuracao:

"""Configuração que impede deleção de atributos críticos."""

def __init__(self):

self._db_url = "postgresql://localhost:5432"

self._api_key = "segredo-123"

self._debug = True

@property

def db_url(self):

return self._db_url

@db_url.deleter

def db_url(self):

raise AttributeError("Não é possível deletar a URL do banco")

@property

def api_key(self):

return "********" # Esconde o valor real

@api_key.deleter

def api_key(self):

print("Log: Tentativa de deletar api_key (negado)")

raise AttributeError("Não é possível deletar a chave da API")

@property

def debug(self):

return self._debug

@debug.setter

def debug(self, valor):

if not isinstance(valor, bool):

raise TypeError("Debug deve ser booleano")

self._debug = valor

@debug.deleter

def debug(self):

print("Resetando debug para False em vez de deletar")

self._debug = False

# Demonstração

print("=== Deleter em Ação ===\n")

config = Configuracao()

print(f"DB URL: {config.db_url}")

print(f"API Key: {config.api_key}")

print(f"Debug: {config.debug}")

# Tentativas de deleção

try:

del config.db_url

except AttributeError as e:

print(f"Erro ao deletar db_url: {e}")

try:

del config.api_key

except AttributeError as e:

print(f"Erro ao deletar api_key: {e}")

# Deleter com ação alternativa (não levanta erro)

del config.debug

print(f"Debug após deleção (resetado): {config.debug}")

# Exemplo prático: Cache com deleção controlada

class Cache:

"""Cache que registra quando itens são deletados."""

def __init__(self):

self._dados = {}

self._acessos = {}

@property

def dados(self):

"""Retorna cópia dos dados (protege o original)."""

return self._dados.copy()

@dados.deleter

def dados(self):

"""Limpa o cache e registra."""

print(f"LIMPEZA: Removendo {len(self._dados)} itens do cache")

self._dados.clear()

self._acessos.clear()

def adicionar(self, chave, valor):

self._dados[chave] = valor

self._acessos[chave] = 0

def obter(self, chave):

if chave in self._dados:

self._acessos[chave] += 1

return self._dados[chave]

return None

@property

def estatisticas(self):

return {

"total_itens": len(self._dados),

"acessos": self._acessos.copy()

}

print("\n=== Cache com Deleter ===")

cache = Cache()

cache.adicionar("usuario_1", "Ana")

cache.adicionar("usuario_2", "Carlos")

cache.adicionar("usuario_3", "Maria")

print(f"Dados: {cache.dados}")

print(f"Estatísticas: {cache.estatisticas}")

# Deleta todo o cache via property

del cache.dados

print(f"Após deleção: {cache.dados}")

# Exemplo completo: Temperatura com conversão automática

class Temperatura:

"""Temperatura com propriedade em Celsius e Fahrenheit."""

def __init__(self, celsius=0):

self._celsius = celsius

@property

def celsius(self):

return self._celsius

@celsius.setter

def celsius(self, valor):

if valor < -273.15:

raise ValueError("Temperatura abaixo do zero absoluto")

self._celsius = valor

@celsius.deleter

def celsius(self):

print("Resetando temperatura para 0°C")

self._celsius = 0

@property

def fahrenheit(self):

"""Propriedade calculada (conversão)."""

return (self._celsius * 9/5) + 32

@fahrenheit.setter

def fahrenheit(self, valor):

"""Permite definir temperatura em Fahrenheit."""

self.celsius = (valor - 32) * 5/9

def __str__(self):

return f"{self.celsius}°C = {self.fahrenheit:.1f}°F"

print("\n=== Temperatura com Propriedades ===")

temp = Temperatura(25)

print(temp)

temp.fahrenheit = 100

print(f"Após definir 100°F: {temp}")

del temp.celsius # Reseta para 0

print(f"Após deleção: {temp}")

Deleters oferecem controle fino sobre a remoção de atributos. A fórmula de encapsulamento com propriedades: $E = \text{getter} + \text{setter} + \text{deleter}$ Use getter para acesso controlado ou valores calculados. Use setter para validação e transformação de dados. Use deleter para limpeza ou prevenção de deleções. Propriedades mantêm sua API limpa e seu código seguro.

Métodos Mágicos 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

Métodos mágicos são funções especiais com underscores duplos. Eles definem como objetos se comportam com operadores nativos. Primeiramente, esses métodos começam e terminam com __. Por exemplo, __init__ constrói objetos, __str__ os exibe. Além disso, __add__ define o operador + para sua classe. A voz passiva é usada aqui: “esses métodos são chamados automaticamente pelo Python”. Quando utilizar métodos mágicos? Para tornar objetos mais naturais. Também para integrar suas classes com a linguagem. Python possui dezenas desses métodos para diferentes propósitos. Vamos explorar os mais importantes com exemplos práticos. Três subtítulos guiarão você pelos principais métodos mágicos. Ao final, você criará classes que parecem tipos nativos.

Construtores, representações e chamadas

__init__ inicializa uma nova instância da classe. __new__ controla a criação do objeto (mais raro). __str__ retorna string amigável para usuários. __repr__ retorna string para depuração (deve recriar objeto). __call__ permite chamar o objeto como uma função. Quando usar cada um? __init__ em praticamente toda classe. __str__ para exibição, __repr__ para logs. __call__ para objetos que se comportam como funções. A voz passiva é aplicada: “a string é gerada automaticamente ao imprimir”. Exemplo desses métodos:

class Pessoa:
    """Demonstra __init__, __str__, __repr__ e __call__."""
    
    def __init__(self, nome, idade):
        """Construtor: inicializa o objeto."""
        self.nome = nome
        self.idade = idade
        print(f"__init__: {nome} criado")
    
    def __new__(cls, *args, **kwargs):
        """Controla criação (raro, mas útil para singletons)."""
        print(f"__new__: criando instância de {cls.__name__}")
        return super().__new__(cls)
    
    def __str__(self):
        """String amigável para usuários."""
        return f"Pessoa: {self.nome} ({self.idade} anos)"
    
    def __repr__(self):
        """String para depuração (idealmente recria o objeto)."""
        return f"Pessoa('{self.nome}', {self.idade})"
    
    def __call__(self, mensagem):
        """Permite chamar o objeto como função."""
        return f"{self.nome} diz: {mensagem}"

# Demonstração
print("=== __init__, __str__, __repr__, __call__ ===\n")
p = Pessoa("Ana", 25)

# __str__ é chamado pelo print
print(f"print(p): {p}")

# __repr__ é chamado no REPL ou com repr()
print(f"repr(p): {repr(p)}")

# __call__ permite usar o objeto como função
print(f"p('Olá!'): {p('Olá!')}")

# Exemplo com __repr__ avalável
p2 = eval(repr(p))  # Recria o objeto a partir da string
print(f"Recriado: {p2}")

# Classe com __call__ útil
class Contador:
    def __init__(self):
        self.contagem = 0
    
    def __call__(self):
        """Incrementa e retorna o valor."""
        self.contagem += 1
        return self.contagem

print("\n=== Contador com __call__ ===")
c = Contador()
print(f"c(): {c()}")
print(f"c(): {c()}")
print(f"c(): {c()}")
print(f"Contagem atual: {c.contagem}")

class Pessoa:

"""Demonstra __init__, __str__, __repr__ e __call__."""

def __init__(self, nome, idade):

"""Construtor: inicializa o objeto."""

self.nome = nome

self.idade = idade

print(f"__init__: {nome} criado")

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

"""Controla criação (raro, mas útil para singletons)."""

print(f"__new__: criando instância de {cls.__name__}")

return super().__new__(cls)

def __str__(self):

"""String amigável para usuários."""

return f"Pessoa: {self.nome} ({self.idade} anos)"

def __repr__(self):

"""String para depuração (idealmente recria o objeto)."""

return f"Pessoa('{self.nome}', {self.idade})"

def __call__(self, mensagem):

"""Permite chamar o objeto como função."""

return f"{self.nome} diz: {mensagem}"

# Demonstração

print("=== __init__, __str__, __repr__, __call__ ===\n")

p = Pessoa("Ana", 25)

# __str__ é chamado pelo print

print(f"print(p): {p}")

# __repr__ é chamado no REPL ou com repr()

print(f"repr(p): {repr(p)}")

# __call__ permite usar o objeto como função

print(f"p('Olá!'): {p('Olá!')}")

# Exemplo com __repr__ avalável

p2 = eval(repr(p)) # Recria o objeto a partir da string

print(f"Recriado: {p2}")

# Classe com __call__ útil

class Contador:

def __init__(self):

self.contagem = 0

def __call__(self):

"""Incrementa e retorna o valor."""

self.contagem += 1

return self.contagem

print("\n=== Contador com __call__ ===")

c = Contador()

print(f"c(): {c()}")

print(f"Contagem atual: {c.contagem}")

Métodos mágicos de construção tornam suas classes profissionais. __repr__ deve ser o mais explícito possível para depuração.

Operadores aritméticos e comparações

__add__ define +, __sub__ define -. __mul__ define *, __truediv__ define /. __eq__ define ==, __lt__ define <. Quando usar esses métodos? Para criar tipos numéricos personalizados. Por exemplo, vetores, matrizes, dinheiro ou frações. A voz passiva é aplicada: “as operações são sobrecarregadas pelos métodos”. Exemplo completo com operadores aritméticos:

class Vetor:
    """Vetor 2D com operadores aritméticos."""
    
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        return f"({self.x}, {self.y})"
    
    def __repr__(self):
        return f"Vetor({self.x}, {self.y})"
    
    # Operadores aritméticos
    def __add__(self, outro):
        """Vetor + Vetor ou Vetor + número."""
        if isinstance(outro, Vetor):
            return Vetor(self.x + outro.x, self.y + outro.y)
        elif isinstance(outro, (int, float)):
            return Vetor(self.x + outro, self.y + outro)
        return NotImplemented
    
    def __radd__(self, outro):
        """Número + Vetor (soma à direita)."""
        return self.__add__(outro)
    
    def __sub__(self, outro):
        """Vetor - Vetor."""
        if isinstance(outro, Vetor):
            return Vetor(self.x - outro.x, self.y - outro.y)
        return Vetor(self.x - outro, self.y - outro)
    
    def __mul__(self, escalar):
        """Vetor * escalar."""
        if isinstance(escalar, (int, float)):
            return Vetor(self.x * escalar, self.y * escalar)
        return NotImplemented
    
    def __rmul__(self, escalar):
        """Escalar * Vetor."""
        return self.__mul__(escalar)
    
    def __truediv__(self, escalar):
        """Vetor / escalar."""
        if isinstance(escalar, (int, float)):
            return Vetor(self.x / escalar, self.y / escalar)
        return NotImplemented
    
    # Operadores de comparação
    def __eq__(self, outro):
        """Vetor == Vetor."""
        if not isinstance(outro, Vetor):
            return False
        return self.x == outro.x and self.y == outro.y
    
    def __lt__(self, outro):
        """Vetor < Vetor (compara módulo)."""
        return self.modulo() < outro.modulo()
    
    def __le__(self, outro):
        """Vetor <= Vetor."""
        return self.modulo() <= outro.modulo()
    
    # Métodos auxiliares
    def modulo(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5

# Demonstração
print("=== Operadores Aritméticos ===\n")
v1 = Vetor(3, 4)
v2 = Vetor(1, 2)

print(f"v1 = {v1}")
print(f"v2 = {v2}")
print(f"v1 + v2 = {v1 + v2}")
print(f"v1 + 5 = {v1 + 5}")
print(f"3 * v1 = {3 * v1}")
print(f"v1 - v2 = {v1 - v2}")
print(f"v1 / 2 = {v1 / 2}")
print(f"v1 == Vetor(3,4)? {v1 == Vetor(3, 4)}")
print(f"v1 < v2? {v1 < v2}")

# Exemplo com frações
class Fracao:
    """Número racional com operadores."""
    
    def __init__(self, numerador, denominador):
        self.num = numerador
        self.den = denominador
        self._simplificar()
    
    def _simplificar(self):
        """Simplifica a fração usando MDC."""
        from math import gcd
        mdc = gcd(self.num, self.den)
        self.num //= mdc
        self.den //= mdc
    
    def __add__(self, outro):
        """Fração + Fração."""
        novo_num = self.num * outro.den + outro.num * self.den
        novo_den = self.den * outro.den
        return Fracao(novo_num, novo_den)
    
    def __mul__(self, outro):
        """Fração * Fração."""
        return Fracao(self.num * outro.num, self.den * outro.den)
    
    def __str__(self):
        return f"{self.num}/{self.den}"
    
    def __float__(self):
        """Converte para float."""
        return self.num / self.den

print("\n=== Frações ===")
f1 = Fracao(1, 2)
f2 = Fracao(1, 3)
print(f"1/2 + 1/3 = {f1 + f2}")
print(f"1/2 * 1/3 = {f1 * f2}")
print(f"float(1/2) = {float(f1)}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

class Vetor:

"""Vetor 2D com operadores aritméticos."""

def __init__(self, x, y):

self.x = x

self.y = y

def __str__(self):

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

def __repr__(self):

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

# Operadores aritméticos

def __add__(self, outro):

"""Vetor + Vetor ou Vetor + número."""

if isinstance(outro, Vetor):

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

elif isinstance(outro, (int, float)):

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

return NotImplemented

def __radd__(self, outro):

"""Número + Vetor (soma à direita)."""

return self.__add__(outro)

def __sub__(self, outro):

"""Vetor - Vetor."""

if isinstance(outro, Vetor):

return Vetor(self.x - outro.x, self.y - outro.y)

return Vetor(self.x - outro, self.y - outro)

def __mul__(self, escalar):

"""Vetor * escalar."""

if isinstance(escalar, (int, float)):

return Vetor(self.x * escalar, self.y * escalar)

return NotImplemented

def __rmul__(self, escalar):

"""Escalar * Vetor."""

return self.__mul__(escalar)

def __truediv__(self, escalar):

"""Vetor / escalar."""

if isinstance(escalar, (int, float)):

return Vetor(self.x / escalar, self.y / escalar)

return NotImplemented

# Operadores de comparação

def __eq__(self, outro):

"""Vetor == Vetor."""

if not isinstance(outro, Vetor):

return False

return self.x == outro.x and self.y == outro.y

def __lt__(self, outro):

"""Vetor < Vetor (compara módulo)."""

return self.modulo() < outro.modulo()

def __le__(self, outro):

"""Vetor <= Vetor."""

return self.modulo() <= outro.modulo()

# Métodos auxiliares

def modulo(self):

return (self.x ** 2 + self.y ** 2) ** 0.5

# Demonstração

print("=== Operadores Aritméticos ===\n")

v1 = Vetor(3, 4)

v2 = Vetor(1, 2)

print(f"v1 = {v1}")

print(f"v2 = {v2}")

print(f"v1 + v2 = {v1 + v2}")

print(f"v1 + 5 = {v1 + 5}")

print(f"3 * v1 = {3 * v1}")

print(f"v1 - v2 = {v1 - v2}")

print(f"v1 / 2 = {v1 / 2}")

print(f"v1 == Vetor(3,4)? {v1 == Vetor(3, 4)}")

print(f"v1 < v2? {v1 < v2}")

# Exemplo com frações

class Fracao:

"""Número racional com operadores."""

def __init__(self, numerador, denominador):

self.num = numerador

self.den = denominador

self._simplificar()

def _simplificar(self):

"""Simplifica a fração usando MDC."""

from math import gcd

mdc = gcd(self.num, self.den)

self.num //= mdc

self.den //= mdc

def __add__(self, outro):

"""Fração + Fração."""

novo_num = self.num * outro.den + outro.num * self.den

novo_den = self.den * outro.den

return Fracao(novo_num, novo_den)

def __mul__(self, outro):

"""Fração * Fração."""

return Fracao(self.num * outro.num, self.den * outro.den)

def __str__(self):

return f"{self.num}/{self.den}"

def __float__(self):

"""Converte para float."""

return self.num / self.den

print("\n=== Frações ===")

f1 = Fracao(1, 2)

f2 = Fracao(1, 3)

print(f"1/2 + 1/3 = {f1 + f2}")

print(f"1/2 * 1/3 = {f1 * f2}")

print(f"float(1/2) = {float(f1)}")

Operadores aritméticos tornam suas classes intuitivas. Use NotImplemented para operações não suportadas.

Métodos de contêiner e gerenciamento de contexto

__len__ define o tamanho (chamado por len()). __getitem__ permite acesso por índice (obj[i]). __setitem__ permite atribuição por índice. __contains__ define o operador in. __enter__ e __exit__ criam gerenciadores de contexto. Quando usar esses métodos? Para criar coleções personalizadas. Também para recursos que precisam de inicialização e limpeza. A voz passiva é aplicada: “o recurso é adquirido e liberado automaticamente”. Exemplo de contêiner e context manager:

class ListaPersonalizada:
    """Lista com métodos mágicos de contêiner."""
    
    def __init__(self, itens=None):
        self._itens = list(itens) if itens else []
    
    def __len__(self):
        """Retorna o tamanho (len())."""
        return len(self._itens)
    
    def __getitem__(self, indice):
        """Acesso por índice (lista[indice])."""
        if isinstance(indice, slice):
            return ListaPersonalizada(self._itens[indice])
        return self._itens[indice]
    
    def __setitem__(self, indice, valor):
        """Atribuição por índice (lista[indice] = valor)."""
        self._itens[indice] = valor
    
    def __delitem__(self, indice):
        """Remove por índice (del lista[indice])."""
        del self._itens[indice]
    
    def __contains__(self, item):
        """Operador 'in' (item in lista)."""
        return item in self._itens
    
    def __iter__(self):
        """Torna a classe iterável."""
        return iter(self._itens)
    
    def __add__(self, outro):
        """Concatenação com +."""
        return ListaPersonalizada(self._itens + outro._itens)
    
    def __str__(self):
        return str(self._itens)

# Demonstração de contêiner
print("=== Métodos de Contêiner ===\n")
lista = ListaPersonalizada([10, 20, 30, 40, 50])
print(f"Lista: {lista}")
print(f"Tamanho: {len(lista)}")
print(f"lista[2]: {lista[2]}")
print(f"lista[1:4]: {lista[1:4]}")
print(f"30 in lista? {30 in lista}")
print(f"60 in lista? {60 in lista}")

lista[2] = 99
print(f"Após lista[2]=99: {lista}")
del lista[0]
print(f"Após del lista[0]: {lista}")

print("Iterando:")
for item in lista:
    print(f"  {item}")

# Gerenciador de contexto
print("\n=== Gerenciador de Contexto ===")

class ArquivoGerenciado:
    """Context manager para arquivos (similar a 'with open')."""
    
    def __init__(self, nome, modo):
        self.nome = nome
        self.modo = modo
        self.arquivo = None
    
    def __enter__(self):
        """Entra no contexto (abre o arquivo)."""
        print(f"Abrindo arquivo: {self.nome}")
        self.arquivo = open(self.nome, self.modo)
        return self.arquivo
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """Sai do contexto (fecha o arquivo)."""
        print(f"Fechando arquivo: {self.nome}")
        if self.arquivo:
            self.arquivo.close()
        # Retorna False para propagar exceções
        return False

# Usando o context manager
with ArquivoGerenciado("teste_magico.txt", "w") as f:
    f.write("Conteúdo escrito via context manager\n")
    f.write("Linha 2\n")
print("Arquivo escrito com sucesso!")

# Lendo o arquivo
with ArquivoGerenciado("teste_magico.txt", "r") as f:
    conteudo = f.read()
    print(f"Conteúdo lido:\n{conteudo}")

# Exemplo com __enter__/__exit__ para timing
import time

class Temporizador:
    """Mede tempo de execução de um bloco."""
    
    def __enter__(self):
        self.inicio = time.time()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.fim = time.time()
        self.duracao = self.fim - self.inicio
        print(f"Tempo decorrido: {self.duracao:.4f}s")

print("\n=== Temporizador ===")
with Temporizador() as t:
    time.sleep(0.5)
    print("Bloco executado")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

class ListaPersonalizada:

"""Lista com métodos mágicos de contêiner."""

def __init__(self, itens=None):

self._itens = list(itens) if itens else []

def __len__(self):

"""Retorna o tamanho (len())."""

return len(self._itens)

def __getitem__(self, indice):

"""Acesso por índice (lista[indice])."""

if isinstance(indice, slice):

return ListaPersonalizada(self._itens[indice])

return self._itens[indice]

def __setitem__(self, indice, valor):

"""Atribuição por índice (lista[indice] = valor)."""

self._itens[indice] = valor

def __delitem__(self, indice):

"""Remove por índice (del lista[indice])."""

del self._itens[indice]

def __contains__(self, item):

"""Operador 'in' (item in lista)."""

return item in self._itens

def __iter__(self):

"""Torna a classe iterável."""

return iter(self._itens)

def __add__(self, outro):

"""Concatenação com +."""

return ListaPersonalizada(self._itens + outro._itens)

def __str__(self):

return str(self._itens)

# Demonstração de contêiner

print("=== Métodos de Contêiner ===\n")

lista = ListaPersonalizada([10, 20, 30, 40, 50])

print(f"Lista: {lista}")

print(f"Tamanho: {len(lista)}")

print(f"lista[2]: {lista[2]}")

print(f"lista[1:4]: {lista[1:4]}")

print(f"30 in lista? {30 in lista}")

print(f"60 in lista? {60 in lista}")

lista[2] = 99

print(f"Após lista[2]=99: {lista}")

del lista[0]

print(f"Após del lista[0]: {lista}")

print("Iterando:")

for item in lista:

print(f" {item}")

# Gerenciador de contexto

print("\n=== Gerenciador de Contexto ===")

class ArquivoGerenciado:

"""Context manager para arquivos (similar a 'with open')."""

def __init__(self, nome, modo):

self.nome = nome

self.modo = modo

self.arquivo = None

def __enter__(self):

"""Entra no contexto (abre o arquivo)."""

print(f"Abrindo arquivo: {self.nome}")

self.arquivo = open(self.nome, self.modo)

return self.arquivo

def __exit__(self, exc_type, exc_val, exc_tb):

"""Sai do contexto (fecha o arquivo)."""

print(f"Fechando arquivo: {self.nome}")

if self.arquivo:

self.arquivo.close()

# Retorna False para propagar exceções

return False

# Usando o context manager

with ArquivoGerenciado("teste_magico.txt", "w") as f:

f.write("Conteúdo escrito via context manager\n")

f.write("Linha 2\n")

print("Arquivo escrito com sucesso!")

# Lendo o arquivo

with ArquivoGerenciado("teste_magico.txt", "r") as f:

conteudo = f.read()

print(f"Conteúdo lido:\n{conteudo}")

# Exemplo com __enter__/__exit__ para timing

import time

class Temporizador:

"""Mede tempo de execução de um bloco."""

def __enter__(self):

self.inicio = time.time()

return self

def __exit__(self, exc_type, exc_val, exc_tb):

self.fim = time.time()

self.duracao = self.fim - self.inicio

print(f"Tempo decorrido: {self.duracao:.4f}s")

print("\n=== Temporizador ===")

with Temporizador() as t:

time.sleep(0.5)

print("Bloco executado")

Métodos de contêiner tornam suas coleções nativas. A fórmula de utilidade dos métodos mágicos: $U = \frac{N_{\text{métodos implementados}}}{N_{\text{comportamentos nativos}}} \times 100\%$ Quanto mais métodos mágicos, mais natural sua classe. Comece com __init__, __str__ e __repr__. Depois adicione operadores e métodos de contêiner conforme necessário. Suas classes parecerão tipos nativos da linguagem.