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

Herança 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

Herança permite criar uma nova classe a partir de uma existente. A classe filha herda atributos e métodos da classe mãe. Primeiramente, isso promove reutilização de código e hierarquias. Por exemplo, Caminhao e Moto herdam de Veiculo. Além disso, a classe filha pode sobrescrever ou adicionar novos métodos. A voz passiva é usada aqui: “os métodos são herdados automaticamente”. Quando utilizar herança? Quando há uma relação “é um” entre conceitos. Por exemplo, “Gato é um Animal” e “Cachorro é um Animal”. Python suporta herança simples (uma mãe) e múltipla (várias mães). Vamos explorar ambos os tipos com exemplos práticos. Três subtítulos guiarão você pelo universo da herança. Ao final, você dominará hierarquias de classes em Python.

Herança simples: estendendo classes

Herança simples envolve apenas uma classe mãe. Use class Filha(Mae): para declarar herança. O método super() chama o construtor da classe mãe. Quando usar herança simples? Em hierarquias lineares claras. Por exemplo, sistemas de funcionários ou formas geométricas. A voz passiva é aplicada: “os atributos são inicializados pela mãe”. Exemplo de herança simples:

# Classe base (mãe)
class Animal:
    """Classe base para todos os animais."""
    
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
    
    def fazer_som(self):
        return "Som genérico de animal"
    
    def mover(self):
        return f"{self.nome} está se movendo"
    
    def __str__(self):
        return f"Animal: {self.nome}, {self.idade} anos"

# Classe filha (herda de Animal)
class Cachorro(Animal):
    """Cachorro herda de Animal e adiciona comportamentos específicos."""
    
    def __init__(self, nome, idade, raca):
        # Chama o construtor da classe mãe
        super().__init__(nome, idade)
        self.raca = raca
    
    # Sobrescrevendo o método da mãe (override)
    def fazer_som(self):
        return "Au au au!"
    
    # Método exclusivo da classe filha
    def abanar_rabo(self):
        return f"{self.nome} está abanando o rabo"
    
    def __str__(self):
        return f"Cachorro: {self.nome} ({self.raca}), {self.idade} anos"

class Gato(Animal):
    """Gato herda de Animal."""
    
    def __init__(self, nome, idade, cor):
        super().__init__(nome, idade)
        self.cor = cor
    
    def fazer_som(self):
        return "Miau miau!"
    
    def arranhar(self):
        return f"{self.nome} está arranhando o sofá"
    
    def __str__(self):
        return f"Gato: {self.nome} ({self.cor}), {self.idade} anos"

# Demonstração
print("=== Herança Simples ===\n")

animal = Animal("Bicho", 5)
cachorro = Cachorro("Rex", 3, "Labrador")
gato = Gato("Mimi", 2, "Branco")

print(f"Animal: {animal.fazer_som()}")
print(f"Cachorro: {cachorro.fazer_som()}")
print(f"Gato: {gato.fazer_som()}")

print(f"\n{cachorro.abanar_rabo()}")
print(f"{gato.arranhar()}")
print(f"{cachorro.mover()}")  # Método herdado

print(f"\n{animal}")
print(cachorro)
print(gato)

# Verificando tipos
print(f"\nCachorro é Animal? {isinstance(cachorro, Animal)}")
print(f"Animal é Cachorro? {isinstance(animal, Cachorro)}")
print(f"Cachorro é subclasse de Animal? {issubclass(Cachorro, Animal)}")

# Exemplo com métodos da mãe ainda disponíveis
class Passaro(Animal):
    def __init__(self, nome, idade, envergadura):
        super().__init__(nome, idade)
        self.envergadura = envergadura
    
    # Não sobrescreve fazer_som, usa o da mãe
    def voar(self):
        return f"{self.nome} está voando com envergadura de {self.envergadura}cm"

passaro = Passaro("Piu", 1, 25)
print(f"\nPássaro: {passaro.fazer_som()}")  # Usa método da mãe
print(passaro.voar())

# Classe base (mãe)

class Animal:

"""Classe base para todos os animais."""

def __init__(self, nome, idade):

self.nome = nome

self.idade = idade

def fazer_som(self):

return "Som genérico de animal"

def mover(self):

return f"{self.nome} está se movendo"

def __str__(self):

return f"Animal: {self.nome}, {self.idade} anos"

# Classe filha (herda de Animal)

class Cachorro(Animal):

"""Cachorro herda de Animal e adiciona comportamentos específicos."""

def __init__(self, nome, idade, raca):

# Chama o construtor da classe mãe

super().__init__(nome, idade)

self.raca = raca

# Sobrescrevendo o método da mãe (override)

def fazer_som(self):

return "Au au au!"

# Método exclusivo da classe filha

def abanar_rabo(self):

return f"{self.nome} está abanando o rabo"

def __str__(self):

return f"Cachorro: {self.nome} ({self.raca}), {self.idade} anos"

class Gato(Animal):

"""Gato herda de Animal."""

def __init__(self, nome, idade, cor):

super().__init__(nome, idade)

self.cor = cor

def fazer_som(self):

return "Miau miau!"

def arranhar(self):

return f"{self.nome} está arranhando o sofá"

def __str__(self):

return f"Gato: {self.nome} ({self.cor}), {self.idade} anos"

# Demonstração

print("=== Herança Simples ===\n")

animal = Animal("Bicho", 5)

cachorro = Cachorro("Rex", 3, "Labrador")

gato = Gato("Mimi", 2, "Branco")

print(f"Animal: {animal.fazer_som()}")

print(f"Cachorro: {cachorro.fazer_som()}")

print(f"Gato: {gato.fazer_som()}")

print(f"\n{cachorro.abanar_rabo()}")

print(f"{gato.arranhar()}")

print(f"{cachorro.mover()}") # Método herdado

print(f"\n{animal}")

print(cachorro)

print(gato)

# Verificando tipos

print(f"\nCachorro é Animal? {isinstance(cachorro, Animal)}")

print(f"Animal é Cachorro? {isinstance(animal, Cachorro)}")

print(f"Cachorro é subclasse de Animal? {issubclass(Cachorro, Animal)}")

# Exemplo com métodos da mãe ainda disponíveis

class Passaro(Animal):

def __init__(self, nome, idade, envergadura):

super().__init__(nome, idade)

self.envergadura = envergadura

# Não sobrescreve fazer_som, usa o da mãe

def voar(self):

return f"{self.nome} está voando com envergadura de {self.envergadura}cm"

passaro = Passaro("Piu", 1, 25)

print(f"\nPássaro: {passaro.fazer_som()}") # Usa método da mãe

print(passaro.voar())

A classe filha herda tudo que não foi sobrescrito. super() é essencial para inicializar corretamente a mãe.

Herança múltipla: combinando comportamentos

Herança múltipla permite uma classe herdar de várias mães. Use class Filha(Mae1, Mae2): para declarar. Python usa o MRO (Method Resolution Order) para resolver conflitos. Quando usar herança múltipla? Em mixins e interfaces. Por exemplo, combinando comportamentos como “Voador” e “Nadador”. A voz passiva é aplicada: “as classes são pesquisadas em ordem específica”. Exemplo de herança múltipla:

# Classes base (mixins)
class Voador:
    """Mixin para seres que voam."""
    
    def __init__(self, altitude_maxima=100):
        self.altitude_maxima = altitude_maxima
    
    def voar(self):
        return f"Voando até {self.altitude_maxima} metros"
    
    def planar(self):
        return "Planando suavemente"

class Nadador:
    """Mixin para seres que nadam."""
    
    def __init__(self, profundidade_maxima=50):
        self.profundidade_maxima = profundidade_maxima
    
    def nadar(self):
        return f"Nadando até {self.profundidade_maxima} metros"
    
    def mergulhar(self):
        return "Mergulhando profundamente"

class Corredor:
    """Mixin para seres que correm."""
    
    def __init__(self, velocidade_maxima=30):
        self.velocidade_maxima = velocidade_maxima
    
    def correr(self):
        return f"Correndo a {self.velocidade_maxima} km/h"
    
    def acelerar(self):
        return "Acelerando rapidamente"

# Classe que combina múltiplas habilidades
class Pato(Voador, Nadador, Corredor):
    """Pato herda de Voador, Nadador e Corredor."""
    
    def __init__(self, nome, altitude=100, profundidade=50, velocidade=20):
        # Inicializa todos os mixins
        Voador.__init__(self, altitude)
        Nadador.__init__(self, profundidade)
        Corredor.__init__(self, velocidade)
        self.nome = nome
    
    def fazer_som(self):
        return "Quack quack!"
    
    def __str__(self):
        return f"Pato: {self.nome}"

# Demonstração
print("\n=== Herança Múltipla ===\n")

pato = Pato("Donald", altitude=80, profundidade=30, velocidade=15)

print(f"{pato}")
print(f"{pato.fazer_som()}")
print(f"{pato.voar()}")
print(f"{pato.planar()}")
print(f"{pato.nadar()}")
print(f"{pato.mergulhar()}")
print(f"{pato.correr()}")
print(f"{pato.acelerar()}")

# Exemplo de mixins em sistemas de arquivos
class Serializable:
    """Mixin para serialização."""
    
    def to_dict(self):
        return {k: v for k, v in self.__dict__.items()}
    
    def to_json(self):
        import json
        return json.dumps(self.to_dict())

class Loggable:
    """Mixin para logging."""
    
    def log(self, mensagem):
        print(f"[LOG] {self.__class__.__name__}: {mensagem}")

class Personagem(Serializable, Loggable):
    """Personagem com habilidades de serialização e log."""
    
    def __init__(self, nome, nivel):
        self.nome = nome
        self.nivel = nivel
    
    def subir_nivel(self):
        self.nivel += 1
        self.log(f"Subiu para nível {self.nivel}")

print("\n=== Mixins em Ação ===")
personagem = Personagem("Aragorn", 10)
personagem.subir_nivel()
print(f"Personagem em JSON: {personagem.to_json()}")

# Demonstração do MRO (Method Resolution Order)
print(f"\nMRO do Pato: {[c.__name__ for c in Pato.__mro__]}")

100

101

102

103

# Classes base (mixins)

class Voador:

"""Mixin para seres que voam."""

def __init__(self, altitude_maxima=100):

self.altitude_maxima = altitude_maxima

def voar(self):

return f"Voando até {self.altitude_maxima} metros"

def planar(self):

return "Planando suavemente"

class Nadador:

"""Mixin para seres que nadam."""

def __init__(self, profundidade_maxima=50):

self.profundidade_maxima = profundidade_maxima

def nadar(self):

return f"Nadando até {self.profundidade_maxima} metros"

def mergulhar(self):

return "Mergulhando profundamente"

class Corredor:

"""Mixin para seres que correm."""

def __init__(self, velocidade_maxima=30):

self.velocidade_maxima = velocidade_maxima

def correr(self):

return f"Correndo a {self.velocidade_maxima} km/h"

def acelerar(self):

return "Acelerando rapidamente"

# Classe que combina múltiplas habilidades

class Pato(Voador, Nadador, Corredor):

"""Pato herda de Voador, Nadador e Corredor."""

def __init__(self, nome, altitude=100, profundidade=50, velocidade=20):

# Inicializa todos os mixins

Voador.__init__(self, altitude)

Nadador.__init__(self, profundidade)

Corredor.__init__(self, velocidade)

self.nome = nome

def fazer_som(self):

return "Quack quack!"

def __str__(self):

return f"Pato: {self.nome}"

# Demonstração

print("\n=== Herança Múltipla ===\n")

pato = Pato("Donald", altitude=80, profundidade=30, velocidade=15)

print(f"{pato}")

print(f"{pato.fazer_som()}")

print(f"{pato.voar()}")

print(f"{pato.planar()}")

print(f"{pato.nadar()}")

print(f"{pato.mergulhar()}")

print(f"{pato.correr()}")

print(f"{pato.acelerar()}")

# Exemplo de mixins em sistemas de arquivos

class Serializable:

"""Mixin para serialização."""

def to_dict(self):

return {k: v for k, v in self.__dict__.items()}

def to_json(self):

import json

return json.dumps(self.to_dict())

class Loggable:

"""Mixin para logging."""

def log(self, mensagem):

print(f"[LOG] {self.__class__.__name__}: {mensagem}")

class Personagem(Serializable, Loggable):

"""Personagem com habilidades de serialização e log."""

def __init__(self, nome, nivel):

self.nome = nome

self.nivel = nivel

def subir_nivel(self):

self.nivel += 1

self.log(f"Subiu para nível {self.nivel}")

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

personagem = Personagem("Aragorn", 10)

personagem.subir_nivel()

print(f"Personagem em JSON: {personagem.to_json()}")

# Demonstração do MRO (Method Resolution Order)

print(f"\nMRO do Pato: {[c.__name__ for c in Pato.__mro__]}")

Herança múltipla é poderosa, mas use com moderação. Mixins são classes pequenas que adicionam comportamentos específicos.

Sobrescrita e super() em herança múltipla

super() funciona de forma especial em herança múltipla. Ele segue o MRO para chamar o próximo método na hierarquia. Isso permite que todos os pais sejam inicializados corretamente. Quando usar super()? Em praticamente todos os construtores. Também em métodos que querem estender (não substituir) o comportamento. A voz passiva é aplicada: “as chamadas são delegadas ao próximo na MRO”. Exemplo de super() em herança múltipla:

# Demonstração do fluxo de super()
class A:
    def __init__(self):
        print("Inicializando A")
        self.valor_a = "A"
    
    def metodo(self):
        print("Método de A")
        return "A"

class B:
    def __init__(self):
        print("Inicializando B")
        self.valor_b = "B"
    
    def metodo(self):
        print("Método de B")
        return "B"

class C(A, B):
    def __init__(self):
        print("Iniciando C")
        super().__init__()  # Chama o próximo no MRO (A)
        # A já inicializou, agora precisamos inicializar B manualmente?
        # Na verdade, A não chama B. Por isso, usamos super() em todas.
        print("C inicializado")
    
    def metodo(self):
        print("Início do método de C")
        resultado = super().metodo()  # Chama A.metodo
        print(f"Resultado de super(): {resultado}")
        return "C modificado"

# Classe bem comportada (todos usam super)
class BomA:
    def __init__(self):
        print("BomA iniciando")
        super().__init__()
        self.valor_a = "BomA"
    
    def metodo(self):
        print("BomA.metodo")
        return super().metodo() if hasattr(super(), 'metodo') else "A"

class BomB:
    def __init__(self):
        print("BomB iniciando")
        super().__init__()
        self.valor_b = "BomB"
    
    def metodo(self):
        print("BomB.metodo")
        return super().metodo() if hasattr(super(), 'metodo') else "B"

class BomC(BomA, BomB):
    def __init__(self):
        print("BomC iniciando")
        super().__init__()
        print("BomC finalizado")
    
    def metodo(self):
        print("BomC.metodo")
        return super().metodo()

print("=== Comportamento sem super() adequada ===")
c = C()
print(c.metodo())

print("\n=== Comportamento com super() adequada ===")
bom_c = BomC()
print(bom_c.metodo())
print(f"Valores: {bom_c.valor_a}, {bom_c.valor_b}")

# Exemplo prático: logger com timestamp
class TimestampMixin:
    """Adiciona timestamp às mensagens."""
    
    def log(self, mensagem):
        from datetime import datetime
        timestamp = datetime.now().strftime("%H:%M:%S")
        return super().log(f"[{timestamp}] {mensagem}") if hasattr(super(), 'log') else print(f"[{timestamp}] {mensagem}")

class FileLogger:
    """Logger que escreve em arquivo."""
    
    def __init__(self, arquivo="log.txt"):
        self.arquivo = arquivo
    
    def log(self, mensagem):
        with open(self.arquivo, "a") as f:
            f.write(f"{mensagem}\n")
        return mensagem

class ConsoleLogger:
    """Logger que escreve no console."""
    
    def log(self, mensagem):
        print(f"CONSOLE: {mensagem}")
        return mensagem

# Combinando mixins
class TimestampFileLogger(TimestampMixin, FileLogger):
    pass

class TimestampConsoleLogger(TimestampMixin, ConsoleLogger):
    pass

print("\n=== Logger com Timestamp ===")
logger = TimestampFileLogger("meu_log.txt")
logger.log("Mensagem de teste")

logger2 = TimestampConsoleLogger()
logger2.log("Mensagem no console")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

# Demonstração do fluxo de super()

class A:

def __init__(self):

print("Inicializando A")

self.valor_a = "A"

def metodo(self):

print("Método de A")

return "A"

class B:

def __init__(self):

print("Inicializando B")

self.valor_b = "B"

def metodo(self):

print("Método de B")

return "B"

class C(A, B):

def __init__(self):

print("Iniciando C")

super().__init__() # Chama o próximo no MRO (A)

# A já inicializou, agora precisamos inicializar B manualmente?

# Na verdade, A não chama B. Por isso, usamos super() em todas.

print("C inicializado")

def metodo(self):

print("Início do método de C")

resultado = super().metodo() # Chama A.metodo

print(f"Resultado de super(): {resultado}")

return "C modificado"

# Classe bem comportada (todos usam super)

class BomA:

def __init__(self):

print("BomA iniciando")

super().__init__()

self.valor_a = "BomA"

def metodo(self):

print("BomA.metodo")

return super().metodo() if hasattr(super(), 'metodo') else "A"

class BomB:

def __init__(self):

print("BomB iniciando")

super().__init__()

self.valor_b = "BomB"

def metodo(self):

print("BomB.metodo")

return super().metodo() if hasattr(super(), 'metodo') else "B"

class BomC(BomA, BomB):

def __init__(self):

print("BomC iniciando")

super().__init__()

print("BomC finalizado")

def metodo(self):

print("BomC.metodo")

return super().metodo()

print("=== Comportamento sem super() adequada ===")

c = C()

print(c.metodo())

print("\n=== Comportamento com super() adequada ===")

bom_c = BomC()

print(bom_c.metodo())

print(f"Valores: {bom_c.valor_a}, {bom_c.valor_b}")

# Exemplo prático: logger com timestamp

class TimestampMixin:

"""Adiciona timestamp às mensagens."""

def log(self, mensagem):

from datetime import datetime

timestamp = datetime.now().strftime("%H:%M:%S")

return super().log(f"[{timestamp}] {mensagem}") if hasattr(super(), 'log') else print(f"[{timestamp}] {mensagem}")

class FileLogger:

"""Logger que escreve em arquivo."""

def __init__(self, arquivo="log.txt"):

self.arquivo = arquivo

def log(self, mensagem):

with open(self.arquivo, "a") as f:

f.write(f"{mensagem}\n")

return mensagem

class ConsoleLogger:

"""Logger que escreve no console."""

def log(self, mensagem):

print(f"CONSOLE: {mensagem}")

return mensagem

# Combinando mixins

class TimestampFileLogger(TimestampMixin, FileLogger):

pass

class TimestampConsoleLogger(TimestampMixin, ConsoleLogger):

pass

print("\n=== Logger com Timestamp ===")

logger = TimestampFileLogger("meu_log.txt")

logger.log("Mensagem de teste")

logger2 = TimestampConsoleLogger()

logger2.log("Mensagem no console")

A fórmula do MRO para herança múltipla: $\text{MRO}(C(B_1, B_2, …, B_n)) = [C] + \text{merge}(\text{MRO}(B_1), …, \text{MRO}(B_n), [B_1, …, B_n])$ Herança é uma ferramenta poderosa quando usada com sabedoria. Prefira composição sobre herança em casos duvidosos. Use herança para relações “é um” genuínas. Seu código será mais limpo e manutenível.

Classes e Objetos 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 são plantas arquitetônicas para criar objetos. Objetos são instâncias concretas que ocupam memória. Primeiramente, uma classe define atributos (dados) e métodos (comportamentos). Por exemplo, uma classe Cachorro pode ter nome e latir(). Além disso, cada objeto tem seus próprios valores de atributos. A voz passiva é usada aqui: “os objetos são criados a partir da classe”. Quando utilizar classes e objetos? Em sistemas complexos e reutilizáveis. Também quando você precisa modelar entidades do mundo real. Python é uma linguagem orientada a objetos desde o início. Vamos explorar sintaxe, construtores e encapsulamento. Três subtítulos guiarão você pelos fundamentos da POO. Ao final, você criará suas próprias classes com confiança.

Sintaxe básica: criando classes e instâncias

Use a palavra-chave class seguida do nome da classe. O método __init__ é o construtor especial. Ele inicializa os atributos do novo objeto. O parâmetro self refere-se à própria instância. Quando usar classes? Sempre que você agrupar dados e comportamentos. A voz passiva é aplicada: “os atributos são definidos com self”. Exemplo de classe básica:

# Definindo uma classe simples
class Pessoa:
    """Classe que representa uma pessoa."""
    
    # Construtor (inicializador)
    def __init__(self, nome, idade):
        self.nome = nome  # Atributo público
        self.idade = idade
    
    # Método de instância
    def saudacao(self):
        return f"Olá, meu nome é {self.nome}"
    
    def aniversario(self):
        self.idade += 1
        return f"{self.nome} agora tem {self.idade} anos"
    
    def __str__(self):
        """Representação amigável do objeto."""
        return f"Pessoa(nome={self.nome}, idade={self.idade})"

# Criando objetos (instâncias)
pessoa1 = Pessoa("Ana", 25)
pessoa2 = Pessoa("Carlos", 30)

# Acessando atributos e métodos
print(pessoa1.saudacao())
print(f"Idade da Ana: {pessoa1.idade}")
pessoa1.aniversario()
print(f"Após aniversário: {pessoa1.idade}")

print(pessoa2.saudacao())
print(pessoa2)  # Usa __str__ automaticamente

# Classe com atributo de classe (compartilhado)
class ContaBancaria:
    # Atributo de classe (compartilhado entre todas as instâncias)
    taxa_juros = 0.02
    
    def __init__(self, titular, saldo_inicial=0):
        self.titular = titular
        self.saldo = saldo_inicial
    
    def depositar(self, valor):
        self.saldo += valor
        return self.saldo
    
    def sacar(self, valor):
        if valor <= self.saldo:
            self.saldo -= valor
            return True
        return False
    
    def aplicar_juros(self):
        juros = self.saldo * ContaBancaria.taxa_juros
        self.saldo += juros
        return juros

# Criando contas
conta1 = ContaBancaria("João", 1000)
conta2 = ContaBancaria("Maria", 500)

print(f"\nConta de {conta1.titular}: saldo R${conta1.saldo}")
conta1.depositar(200)
print(f"Após depósito: R${conta1.saldo}")

print(f"Taxa de juros: {ContaBancaria.taxa_juros * 100}%")
juros = conta1.aplicar_juros()
print(f"Juros aplicados: R${juros:.2f}")
print(f"Novo saldo: R${conta1.saldo:.2f}")

# Definindo uma classe simples

class Pessoa:

"""Classe que representa uma pessoa."""

# Construtor (inicializador)

def __init__(self, nome, idade):

self.nome = nome # Atributo público

self.idade = idade

# Método de instância

def saudacao(self):

return f"Olá, meu nome é {self.nome}"

def aniversario(self):

self.idade += 1

return f"{self.nome} agora tem {self.idade} anos"

def __str__(self):

"""Representação amigável do objeto."""

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

# Criando objetos (instâncias)

pessoa1 = Pessoa("Ana", 25)

pessoa2 = Pessoa("Carlos", 30)

# Acessando atributos e métodos

print(pessoa1.saudacao())

print(f"Idade da Ana: {pessoa1.idade}")

pessoa1.aniversario()

print(f"Após aniversário: {pessoa1.idade}")

print(pessoa2.saudacao())

print(pessoa2) # Usa __str__ automaticamente

# Classe com atributo de classe (compartilhado)

class ContaBancaria:

# Atributo de classe (compartilhado entre todas as instâncias)

taxa_juros = 0.02

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

self.titular = titular

self.saldo = saldo_inicial

def depositar(self, valor):

self.saldo += valor

return self.saldo

def sacar(self, valor):

if valor <= self.saldo:

self.saldo -= valor

return True

return False

def aplicar_juros(self):

juros = self.saldo * ContaBancaria.taxa_juros

self.saldo += juros

return juros

# Criando contas

conta1 = ContaBancaria("João", 1000)

conta2 = ContaBancaria("Maria", 500)

print(f"\nConta de {conta1.titular}: saldo R${conta1.saldo}")

conta1.depositar(200)

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

print(f"Taxa de juros: {ContaBancaria.taxa_juros * 100}%")

juros = conta1.aplicar_juros()

print(f"Juros aplicados: R${juros:.2f}")

print(f"Novo saldo: R${conta1.saldo:.2f}")

Cada objeto mantém seus próprios valores de atributos. Atributos de classe são compartilhados por todas as instâncias.

Encapsulamento: protegendo dados internos

Encapsulamento esconde detalhes internos da classe. Em Python, usamos convenção de nomes para indicar proteção. Um underscore _atributo significa “protegido”. Dois underscores __atributo causam name mangling. Quando usar encapsulamento? Quando um atributo não deve ser alterado diretamente. Por exemplo, um saldo bancário só muda via métodos. A voz passiva é aplicada: “as propriedades são usadas para controle de acesso”. Exemplo de encapsulamento:

class Produto:
    """Classe com atributos encapsulados."""
    
    def __init__(self, nome, preco, estoque):
        self.nome = nome  # Público
        self._preco = preco  # Protegido (convenção)
        self.__estoque = estoque  # Privado (name mangling)
    
    # Getter para preço (propriedade)
    @property
    def preco(self):
        return self._preco
    
    # Setter com validação
    @preco.setter
    def preco(self, novo_preco):
        if novo_preco < 0:
            raise ValueError("Preço não pode ser negativo")
        self._preco = novo_preco
    
    # Getter para estoque
    @property
    def estoque(self):
        return self.__estoque
    
    # Método para alterar estoque com validação
    def remover_estoque(self, quantidade):
        if quantidade <= 0:
            raise ValueError("Quantidade deve ser positiva")
        if quantidade > self.__estoque:
            raise ValueError("Estoque insuficiente")
        self.__estoque -= quantidade
        return self.__estoque
    
    def adicionar_estoque(self, quantidade):
        if quantidade <= 0:
            raise ValueError("Quantidade deve ser positiva")
        self.__estoque += quantidade
        return self.__estoque
    
    def __str__(self):
        return f"Produto: {self.nome}, Preço: R${self.preco:.2f}, Estoque: {self.estoque}"

# Usando a classe
produto = Produto("Notebook", 2500.00, 10)
print(produto)

# Acessando via propriedade (getter)
print(f"Preço do {produto.nome}: R${produto.preco:.2f}")

# Alterando via setter com validação
produto.preco = 2400.00
print(f"Novo preço: R${produto.preco:.2f}")

# Tentativa de acesso direto ao atributo privado (falha)
try:
    print(produto.__estoque)
except AttributeError as e:
    print(f"Erro: {e} (name mangling)")

# Acesso correto via métodos
produto.remover_estoque(3)
print(f"Estoque após remoção: {produto.estoque}")
produto.adicionar_estoque(5)
print(f"Estoque após adição: {produto.estoque}")

# Demonstração do name mangling
print(f"\nNome real do atributo privado: {dir(produto)[-1]}")

class Produto:

"""Classe com atributos encapsulados."""

def __init__(self, nome, preco, estoque):

self.nome = nome # Público

self._preco = preco # Protegido (convenção)

self.__estoque = estoque # Privado (name mangling)

# Getter para preço (propriedade)

@property

def preco(self):

return self._preco

# Setter com validação

@preco.setter

def preco(self, novo_preco):

if novo_preco < 0:

raise ValueError("Preço não pode ser negativo")

self._preco = novo_preco

# Getter para estoque

@property

def estoque(self):

return self.__estoque

# Método para alterar estoque com validação

def remover_estoque(self, quantidade):

if quantidade <= 0:

raise ValueError("Quantidade deve ser positiva")

if quantidade > self.__estoque:

raise ValueError("Estoque insuficiente")

self.__estoque -= quantidade

return self.__estoque

def adicionar_estoque(self, quantidade):

if quantidade <= 0:

raise ValueError("Quantidade deve ser positiva")

self.__estoque += quantidade

return self.__estoque

def __str__(self):

return f"Produto: {self.nome}, Preço: R${self.preco:.2f}, Estoque: {self.estoque}"

# Usando a classe

produto = Produto("Notebook", 2500.00, 10)

print(produto)

# Acessando via propriedade (getter)

print(f"Preço do {produto.nome}: R${produto.preco:.2f}")

# Alterando via setter com validação

produto.preco = 2400.00

print(f"Novo preço: R${produto.preco:.2f}")

# Tentativa de acesso direto ao atributo privado (falha)

try:

print(produto.__estoque)

except AttributeError as e:

print(f"Erro: {e} (name mangling)")

# Acesso correto via métodos

produto.remover_estoque(3)

print(f"Estoque após remoção: {produto.estoque}")

produto.adicionar_estoque(5)

print(f"Estoque após adição: {produto.estoque}")

# Demonstração do name mangling

print(f"\nNome real do atributo privado: {dir(produto)[-1]}")

Propriedades com @property permitem getters e setters elegantes. Name mangling transforma __estoque em _Produto__estoque.

Métodos especiais e boas práticas

Python oferece métodos especiais (dunder methods) para personalização. __init__ constrói, __str__ exibe, __repr__ depura. __len__ define o tamanho, __add__ sobrecarrega +. Quando usar métodos especiais? Para tornar objetos mais “pythônicos”. Por exemplo, permitir len(obj) ou obj1 + obj2. A voz passiva é aplicada: “as operações são definidas pelos métodos mágicos”. Exemplo de classe com métodos especiais:

class Vetor:
    """Representa um vetor matemático 2D."""
    
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        """String amigável para usuários."""
        return f"Vetor({self.x}, {self.y})"
    
    def __repr__(self):
        """String para depuração (precisa recriar objeto)."""
        return f"Vetor({self.x}, {self.y})"
    
    def __add__(self, outro):
        """Soma de vetores (sobrecarga do operador +)."""
        if not isinstance(outro, Vetor):
            raise TypeError("Só é possível somar Vetor com Vetor")
        return Vetor(self.x + outro.x, self.y + outro.y)
    
    def __sub__(self, outro):
        """Subtração de vetores (sobrecarga do operador -)."""
        return Vetor(self.x - outro.x, self.y - outro.y)
    
    def __mul__(self, escalar):
        """Multiplicação por escalar."""
        if isinstance(escalar, (int, float)):
            return Vetor(self.x * escalar, self.y * escalar)
        raise TypeError("Multiplicação apenas por número")
    
    def __rmul__(self, escalar):
        """Multiplicação com escalar à esquerda (escalar * vetor)."""
        return self.__mul__(escalar)
    
    def __eq__(self, outro):
        """Comparação de igualdade."""
        if not isinstance(outro, Vetor):
            return False
        return self.x == outro.x and self.y == outro.y
    
    def __len__(self):
        """Retorna o número de componentes (sempre 2)."""
        return 2
    
    def __abs__(self):
        """Módulo (norma) do vetor."""
        return (self.x ** 2 + self.y ** 2) ** 0.5
    
    def __getitem__(self, indice):
        """Permite acesso via índice: v[0] e v[1]."""
        if indice == 0:
            return self.x
        elif indice == 1:
            return self.y
        raise IndexError("Índice inválido")
    
    def __call__(self, fator):
        """Permite chamar o objeto como função: v(2)."""
        return Vetor(self.x * fator, self.y * fator)

# Demonstração
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 - v2 = {v1 - v2}")
print(f"v1 * 3 = {v1 * 3}")
print(f"3 * v1 = {3 * v1}")
print(f"v1 == Vetor(3,4)? {v1 == Vetor(3,4)}")
print(f"Tamanho (len): {len(v1)}")
print(f"Módulo de v1: {abs(v1):.2f}")
print(f"v1[0] = {v1[0]}, v1[1] = {v1[1]}")
print(f"v1(2) = {v1(2)}")

# Exemplo de classe com __enter__ e __exit__ (context manager)
class ArquivoGerenciado:
    """Context manager para arquivos."""
    
    def __init__(self, nome, modo):
        self.nome = nome
        self.modo = modo
        self.arquivo = None
    
    def __enter__(self):
        self.arquivo = open(self.nome, self.modo)
        return self.arquivo
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.arquivo:
            self.arquivo.close()
        return False  # Não suprime exceções

# Uso do context manager
with ArquivoGerenciado("teste.txt", "w") as f:
    f.write("Olá, mundo!")

print("\nArquivo escrito com sucesso usando context manager")

100

class Vetor:

"""Representa um vetor matemático 2D."""

def __init__(self, x, y):

self.x = x

self.y = y

def __str__(self):

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

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

def __repr__(self):

"""String para depuração (precisa recriar objeto)."""

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

def __add__(self, outro):

"""Soma de vetores (sobrecarga do operador +)."""

if not isinstance(outro, Vetor):

raise TypeError("Só é possível somar Vetor com Vetor")

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

def __sub__(self, outro):

"""Subtração de vetores (sobrecarga do operador -)."""

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

def __mul__(self, escalar):

"""Multiplicação por escalar."""

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

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

raise TypeError("Multiplicação apenas por número")

def __rmul__(self, escalar):

"""Multiplicação com escalar à esquerda (escalar * vetor)."""

return self.__mul__(escalar)

def __eq__(self, outro):

"""Comparação de igualdade."""

if not isinstance(outro, Vetor):

return False

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

def __len__(self):

"""Retorna o número de componentes (sempre 2)."""

return 2

def __abs__(self):

"""Módulo (norma) do vetor."""

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

def __getitem__(self, indice):

"""Permite acesso via índice: v[0] e v[1]."""

if indice == 0:

return self.x

elif indice == 1:

return self.y

raise IndexError("Índice inválido")

def __call__(self, fator):

"""Permite chamar o objeto como função: v(2)."""

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

# Demonstração

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 - v2 = {v1 - v2}")

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

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

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

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

print(f"Módulo de v1: {abs(v1):.2f}")

print(f"v1[0] = {v1[0]}, v1[1] = {v1[1]}")

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

# Exemplo de classe com __enter__ e __exit__ (context manager)

class ArquivoGerenciado:

"""Context manager para arquivos."""

def __init__(self, nome, modo):

self.nome = nome

self.modo = modo

self.arquivo = None

def __enter__(self):

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

return self.arquivo

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

if self.arquivo:

self.arquivo.close()

return False # Não suprime exceções

# Uso do context manager

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

f.write("Olá, mundo!")

print("\nArquivo escrito com sucesso usando context manager")

Métodos especiais tornam suas classes mais integradas à linguagem. A fórmula da orientação a objetos é clara: $POO = \text{classes} + \text{objetos} + \text{encapsulamento} + \text{herança}$ Classes e objetos são o alicerce de qualquer sistema Python. Comece com classes simples e adicione complexidade gradualmente. Seu código será mais organizado, reutilizável e intuitivo.