Dominando Programação Orientada a Objetos em Python: Classes, Herança, Encapsulamento e Polimorfismo

Programação Orientada a Objetos em Python

Este guia percorre conceitos centrais da Programação Orientada a Objetos (POO) do Python, com exemplos práticos que ilustram como construir código robusto e reutilizável.

Vídeo: Programação Orientada a Objetos em Python

Programação Orientada a Objetos

Python é linguagem multi-paradigma que suporta vários estilos de programação. Uma das abordagens mais poderosas é modelar problemas usando objetos — abordagem conhecida como Programação Orientada a Objetos (POO).

Um objeto possui duas características essenciais:

• Atributos (dados)
• Comportamento (métodos)

Por exemplo, um papagaio é objeto com atributos como name, age e color, e comportamentos como sing() e dance().

POO em Python promove código reutilizável, aderindo ao princípio DRY (Don't Repeat Yourself).

Classe

Uma class é blueprint que define estrutura e comportamento de objetos. Pense nela como esboço detalhado de um papagaio: especifica quais propriedades e ações um papagaio pode ter.

class Parrot:
    pass

Aqui, Parrot é classe vazia. Instâncias são criadas depois.

Objeto

Um objeto (ou instância) é realização concreta de uma classe. Quando classe é definida, nenhuma memória alocada; apenas template existe. Instanciar classe cria objeto.

obj = Parrot()

No exemplo abaixo, construímos classe Parrot funcional e criamos duas instâncias, blu e woo:

class Parrot:
    # Atributo de classe
    species = "bird"
    # Atributos de instância
    def __init__(self, name, age):
        self.name = name
        self.age = age
# Instanciar classe
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)
# Acessar atributos de classe
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))
# Acessar atributos de instância
print("{} is {} years old".format(blu.name, blu.age))
print("{} is {} years old".format(woo.name, woo.age))

Saída

Blu is a bird Woo is also a bird Blu is 10 years old Woo is 15 years old

Neste snippet, species é atributo de classe compartilhado por todos papagaios, enquanto name e age são atributos de instância únicos a cada objeto.

Métodos

Métodos são funções definidas dentro de classe que descrevem comportamento do objeto. São invocados em instâncias da classe.

class Parrot:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def sing(self, song):
        return f"{self.name} sings {song}"
    def dance(self):
        return f"{self.name} is now dancing"
# Instanciar e usar métodos
blu = Parrot("Blu", 10)
print(blu.sing("'Happy'"))
print(blu.dance())

Saída

Blu sings 'Happy' Blu is now dancing

Herança

Herança permite nova classe herdar atributos e métodos de classe existente, promovendo reuso de código e hierarquia lógica.

# Classe base
class Bird:
    def __init__(self):
        print("Bird is ready")
    def whoisThis(self):
        print("Bird")
    def swim(self):
        print("Swim faster")
# Classe derivada
class Penguin(Bird):
    def __init__(self):
        super().__init__()
        print("Penguin is ready")
    def whoisThis(self):
        print("Penguin")
    def run(self):
        print("Run faster")
peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

Saída

Bird is ready Penguin is ready Penguin Swim faster Run faster

Encapsulamento

Encapsulamento restringe acesso direto ao estado interno do objeto, protegendo integridade dos dados. Em Python, atributos privados são denotados por underscore inicial (simples ou duplo).

class Computer:
    def __init__(self):
        self.__maxprice = 900
    def sell(self):
        print(f"Selling Price: {self.__maxprice}")
    def setMaxPrice(self, price):
        self.__maxprice = price
c = Computer()
c.sell()
# Tentar modificar diretamente
c.__maxprice = 1000
c.sell()
# Usar método setter
c.setMaxPrice(1000)
c.sell()

Saída

Selling Price: 900 Selling Price: 900 Selling Price: 1000

Polimorfismo

Polimorfismo permite objetos de classes diferentes serem tratados através de interface compartilhada, permitindo código flexível que opera em vários tipos de objetos.

class Parrot:
    def fly(self):
        print("Parrot can fly")
    def swim(self):
        print("Parrot can't swim")
class Penguin:
    def fly(self):
        print("Penguin can't fly")
    def swim(self):
        print("Penguin can swim")
# Interface comum
def flying_test(bird):
    bird.fly()
blu = Parrot()
peggy = Penguin()
flying_test(blu)
flying_test(peggy)

Saída

Parrot can fly Penguin can't fly

Principais Conclusões

• POO estrutura código para clareza e manutenibilidade.
• Classes permitem reuso de código através de herança.
• Encapsulamento protege dados internos.
• Polimorfismo oferece interfaces flexíveis entre tipos de objetos.