🐍 Apostila: Orientação a Objeto em

Python
Para Iniciantes em Programação

📖 Sumário
1. Introdução

2. Módulo 1: Fundamentos de OOP

3. Módulo 2: Classes e Objetos

4. Módulo 3: Herança

5. Módulo 4: Encapsulamento

6. Módulo 5: Polimorfismo

7. Módulo 6: Projeto Prático

8. Atividade de Múltipla Escolha

Introdução

Bem-vindo ao mundo da Orientação a Objeto (OOP)! Esta apostila foi desenvolvida

para guiá-lo através dos conceitos essenciais de programação orientada a objetos em
Python.

O que você aprenderá?

O que é Orientação a Objeto e por que é importante

Como criar Classes e Objetos

Como usar Herança para reutilizar código

Como proteger dados com Encapsulamento

 Como usar Polimorfismo para flexibilidade

Como aplicar esses conceitos em projetos reais

Tempo estimado: 2 horas e 30 minutos

Pré-requisitos

Conhecimento básico de Python (variáveis, tipos de dados, funções)

Ambiente de desenvolvimento configurado (Python + VS Code)

Familiaridade com o terminal/prompt de comando

Módulo 1: Fundamentos de OOP

1.1 O que é Orientação a Objeto?

Orientação a Objeto (OOP) é um paradigma de programação que organiza o código

em torno de objetos e classes, em vez de apenas funções e dados separados.

Paradigmas de Programação

Paradigma Foco Exemplo

Procedural Funções e procedimentos C, Pascal

Funcional Funções puras Lisp, Haskell

Orientado a Objeto Objetos e classes Python, Java, C++

Por que Orientação a Objeto?

✅ Organização: Código mais estruturado e fácil de entender ✅ Reutilização:

Reutilizar código através de herança ✅ Manutenção: Mais fácil de manter e atualizar
✅ Escalabilidade: Funciona bem em projetos grandes ✅ Realismo: Modela o
mundo real de forma natural
1.2 Analogia do Mundo Real: A Fábrica de Carros

Imagine uma fábrica de carros. Para entender OOP, vamos usar essa analogia:

O Molde (Classe)

Uma classe é como um molde ou projeto de um carro. O molde define: - Quais peças
o carro terá (atributos) - O que o carro pode fazer (métodos)

O Carro Produzido (Objeto)

Um objeto é um carro real produzido a partir do molde. Cada carro é uma instância
única, mas segue o mesmo projeto.

Exemplo Visual

┌─────────────────────────┐
│ CLASSE (Molde) │
├─────────────────────────┤
│ Atributos: │
│ - cor │
│ - marca │
│ - velocidade │
│ │
│ Métodos: │
│ - acelerar() │
│ - frear() │
│ - buzinar() │
└─────────────────────────┘
↓ (produz)
┌─────────────────────────┐
│ OBJETO (Carro Real) │
├─────────────────────────┤
│ cor: vermelho │
│ marca: Toyota │
│ velocidade: 0 │
└─────────────────────────┘

1.3 Os 5 Pilares da Orientação a Objeto

1. Classes e Objetos

Classe: Molde ou projeto

 Objeto: Instância concreta da classe

2. Herança

Criar novas classes baseadas em classes existentes

Reutilizar código

3. Encapsulamento

Proteger dados dentro da classe

Controlar acesso aos atributos

4. Polimorfismo

Mesma interface, comportamentos diferentes

Flexibilidade no código

5. Abstração

Esconder complexidade

Mostrar apenas o necessário

Módulo 2: Classes e Objetos

2.1 O que é uma Classe?

Uma classe é um molde ou projeto que define a estrutura e o comportamento de

objetos. É como um blueprint para criar objetos.
Componentes de uma Classe

class Carro:
# Atributos (características)
cor = "vermelho"
marca = "Toyota"

# Métodos (ações)
def acelerar(self):
print("O carro está acelerando!")

def frear(self):
print("O carro está freando!")

Anatomia de uma Classe

Parte Função Exemplo

Nome da Classe Identificar a classe Carro

Atributos Características cor , marca

Métodos Ações/comportamentos acelerar() , frear()

2.2 O que é um Objeto?

Um objeto é uma instância concreta de uma classe. É como um carro real produzido a
partir do molde.

Criando um Objeto

# Criar um objeto da classe Carro

meu_carro = Carro()

# Acessar atributos
print(meu_carro.cor) # Saída: vermelho
print(meu_carro.marca) # Saída: Toyota

# Chamar métodos
meu_carro.acelerar() # Saída: O carro está acelerando!
meu_carro.frear() # Saída: O carro está freando!
Múltiplos Objetos da Mesma Classe

carro1 = Carro()
carro2 = Carro()

# Cada objeto é independente

carro1.cor = "azul"
carro2.cor = "preto"

print(carro1.cor) # Saída: azul

print(carro2.cor) # Saída: preto

2.3 Construtores e Inicialização

Um construtor é um método especial que é chamado quando você cria um objeto. Em

Python, o construtor é __init__() .

Exemplo com Construtor

class Carro:
def __init__(self, cor, marca, velocidade_maxima):
self.cor = cor
self.marca = marca
self.velocidade_maxima = velocidade_maxima
self.velocidade_atual = 0

def acelerar(self):
if self.velocidade_atual < self.velocidade_maxima:
self.velocidade_atual += 10
print(f"Velocidade: {self.velocidade_atual} km/h")

def frear(self):
if self.velocidade_atual > 0:
self.velocidade_atual -= 10
print(f"Velocidade: {self.velocidade_atual} km/h")

# Criar objetos com valores iniciais

carro1 = Carro("vermelho", "Toyota", 200)
carro2 = Carro("azul", "Honda", 220)

# Cada objeto tem seus próprios valores

carro1.acelerar() # Saída: Velocidade: 10 km/h
carro2.acelerar() # Saída: Velocidade: 10 km/h

O que é self ?

self é uma referência ao objeto atual. Permite que cada objeto tenha seus próprios
atributos.
 class Pessoa:
def __init__(self, nome):
self.nome = nome # self.nome = atributo do objeto

def saudacao(self):
print(f"Olá, meu nome é {self.nome}")

pessoa1 = Pessoa("João")
pessoa2 = Pessoa("Maria")

pessoa1.saudacao() # Saída: Olá, meu nome é João

pessoa2.saudacao() # Saída: Olá, meu nome é Maria

2.4 Atributos e Métodos

Atributos

Atributos são características ou propriedades de um objeto.

class Livro:
def __init__(self, titulo, autor, paginas):
self.titulo = titulo # Atributo
self.autor = autor # Atributo
self.paginas = paginas # Atributo

Métodos

Métodos são ações que um objeto pode realizar.

class Livro:
def __init__(self, titulo, autor, paginas):
self.titulo = titulo
self.autor = autor
self.paginas = paginas
self.pagina_atual = 1

def ler(self, num_paginas):

self.pagina_atual += num_paginas
print(f"Lendo... Página {self.pagina_atual}")

def info(self):
print(f"{self.titulo} por {self.autor}")
print(f"Total de páginas: {self.paginas}")
Módulo 3: Herança

3.1 O que é Herança?

Herança é um mecanismo que permite que uma classe herde características e

comportamentos de outra classe. É como um filho herdar características dos pais.

Analogia: Família

┌─────────────────────┐
│ Classe: Animal │
├─────────────────────┤
│ Atributos: │
│ - nome │
│ - idade │
│ │
│ Métodos: │
│ - fazer_som() │
└─────────────────────┘
↑ (herda)
┌────┴────┐
↓ ↓
┌────────┐ ┌────────┐
│ Cão │ │ Gato │
├────────┤ ├────────┤
│ latir()│ │ miar() │
└────────┘ └────────┘

3.2 Classe Base e Classe Derivada

Classe Base (Superclasse)

A classe base é a classe original que define características comuns.

class Animal:
def __init__(self, nome, idade):
self.nome = nome
self.idade = idade

def fazer_som(self):
print(f"{self.nome} faz um som")

def info(self):
print(f"Nome: {self.nome}, Idade: {self.idade}")
Classe Derivada (Subclasse)

A classe derivada herda da classe base e pode adicionar novos comportamentos.

class Cão(Animal):
def fazer_som(self):
print(f"{self.nome} late: Au au!")

def buscar(self):
print(f"{self.nome} está buscando a bola")

class Gato(Animal):
def fazer_som(self):
print(f"{self.nome} mia: Miau!")

def arranhar(self):
print(f"{self.nome} está arranhando o sofá")

Usando Herança

# Criar objetos
dog = Cão("Rex", 5)
cat = Gato("Whiskers", 3)

# Usar métodos herdados

dog.info() # Saída: Nome: Rex, Idade: 5
cat.info() # Saída: Nome: Whiskers, Idade: 3

# Usar métodos específicos

dog.fazer_som() # Saída: Rex late: Au au!
cat.fazer_som() # Saída: Whiskers mia: Miau!

# Usar métodos da subclasse

dog.buscar() # Saída: Rex está buscando a bola
cat.arranhar() # Saída: Whiskers está arranhando o sofá

3.3 Benefícios da Herança

✅ Reutilização de Código: Não precisa repetir código comum ✅ Organização:

Código mais estruturado e lógico ✅ Manutenção: Mudanças na classe base afetam
todas as subclasses ✅ Hierarquia: Modela relacionamentos do mundo real
Módulo 4: Encapsulamento

4.1 O que é Encapsulamento?

Encapsulamento é o princípio de esconder os detalhes internos de uma classe e

fornecer uma interface pública controlada. É como um carro: você não precisa saber
como funciona o motor, apenas como dirigir.

Analogia: Cápsula de Remédio

┌──────────────────────────┐
│ ENCAPSULAMENTO (Cápsula)│
├──────────────────────────┤
│ Dados Privados (dentro) │
│ - ingredientes │
│ - fórmula │
│ │
│ Interface Pública │
│ - tomar() │
│ - dosagem() │
└──────────────────────────┘

4.2 Atributos Privados e Públicos

Atributos Públicos

Podem ser acessados de fora da classe.

class Pessoa:
def __init__(self, nome):
self.nome = nome # Atributo público

Atributos Privados

Começam com _ (convenção) ou __ (mais forte). Não devem ser acessados

diretamente.
 class ContaBancaria:
def __init__(self, titular, saldo):
self.titular = titular
self.__saldo = saldo # Atributo privado

def depositar(self, valor):

if valor > 0:
self.__saldo += valor
print(f"Depósito de R${valor} realizado")

def sacar(self, valor):

if valor > 0 and valor <= self.__saldo:
self.__saldo -= valor
print(f"Saque de R${valor} realizado")
else:
print("Saque não permitido")

def get_saldo(self):
return self.__saldo

Usando Encapsulamento

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

# Acessar através de métodos públicos

conta.depositar(500) # Saída: Depósito de R$500 realizado
conta.sacar(200) # Saída: Saque de R$200 realizado
print(conta.get_saldo()) # Saída: 1300

# Tentar acessar diretamente (não recomendado)

# print(conta.__saldo) # Erro: AttributeError

4.3 Getters e Setters

Getters e Setters são métodos para acessar e modificar atributos privados de forma
controlada.
 class Temperatura:
def __init__(self, celsius):
self.__celsius = celsius

# Getter
def get_celsius(self):
return self.__celsius

# Setter com validação

def set_celsius(self, valor):
if -273.15 <= valor: # Validação
self.__celsius = valor
else:
print("Temperatura inválida!")

def get_fahrenheit(self):
return (self.__celsius * 9/5) + 32

# Usar
temp = Temperatura(25)
print(temp.get_celsius()) # Saída: 25
print(temp.get_fahrenheit()) # Saída: 77.0

temp.set_celsius(30)
print(temp.get_celsius()) # Saída: 30

4.4 Benefícios do Encapsulamento

✅ Proteção de Dados: Evita modificações indevidas ✅ Validação: Pode validar

dados antes de atribuir ✅ Flexibilidade: Pode mudar implementação interna sem
afetar o código externo ✅ Segurança: Controla o acesso aos dados

Módulo 5: Polimorfismo

5.1 O que é Polimorfismo?

Polimorfismo significa "muitas formas". É a capacidade de objetos diferentes

responderem ao mesmo comando de formas diferentes.
Analogia: Controle Remoto

┌─────────────────────────┐
│ Controle Remoto │
├─────────────────────────┤
│ Botão: Ligar │
└─────────────────────────┘
↓ (mesmo comando)
┌────┴────┐
↓ ↓
┌────────┐ ┌────────┐
│ TV │ │ Rádio │
├────────┤ ├────────┤
│ Liga │ │ Liga │
│ exibe │ │ toca │
│ vídeo │ │ áudio │
└────────┘ └────────┘

5.2 Polimorfismo com Herança

class Animal:
def fazer_som(self):
pass # Método vazio (será sobrescrito)

class Cão(Animal):
def fazer_som(self):
return "Au au!"

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

class Vaca(Animal):
def fazer_som(self):
return "Muuu!"

# Polimorfismo em ação
animais = [Cão(), Gato(), Vaca()]

for animal in animais:

print(animal.fazer_som())
# Saída:
# Au au!
# Miau!
# Muuu!

5.3 Polimorfismo com Duck Typing

Em Python, você não precisa herdar de uma classe para ter polimorfismo. Se um
objeto tem o método, pode ser usado.
 class Pato:
def fazer_som(self):
return "Quá quá!"

def nadar(self):
return "Nadando..."

class Pessoa:
def fazer_som(self):
return "Olá!"

def nadar(self):
return "Nadando..."

# Duck typing: Se parece um pato e faz som de pato...

def fazer_barulho(entidade):
print(entidade.fazer_som())

pato = Pato()
pessoa = Pessoa()

fazer_barulho(pato) # Saída: Quá quá!

fazer_barulho(pessoa) # Saída: Olá!

5.4 Benefícios do Polimorfismo

✅ Flexibilidade: Código mais genérico e reutilizável ✅ Extensibilidade: Fácil

adicionar novos tipos ✅ Simplicidade: Menos código duplicado ✅ Manutenção:
Mudanças em um lugar afetam todos

Módulo 6: Projeto Prático

6.1 Sistema de Biblioteca

Vamos criar um sistema de biblioteca que utiliza todos os conceitos aprendidos.

Estrutura do Projeto

Biblioteca/
├── Item (classe base)
│ ├── Livro (herança)
│ ├── Revista (herança)
│ └── DVD (herança)
├── Usuário
├── Empréstimo
└── Biblioteca
Código Completo

from datetime import datetime, timedelta

# Classe base
class Item:
def __init__(self, titulo, autor, ano):
self.titulo = titulo
self.autor = autor
self.ano = ano
self.__disponivel = True

def emprestar(self):
if self.__disponivel:
self.__disponivel = False
return True
return False

def devolver(self):
self.__disponivel = True

def esta_disponivel(self):
return self.__disponivel

def info(self):
status = "Disponível" if self.__disponivel else "Emprestado"
return f"{self.titulo} ({self.ano}) - {status}"

# Subclasses
class Livro(Item):
def __init__(self, titulo, autor, ano, paginas):
super().__init__(titulo, autor, ano)
self.paginas = paginas

def info(self):
base = super().info()
return f"{base} - {self.paginas} páginas"

class Revista(Item):
def __init__(self, titulo, autor, ano, edicao):
super().__init__(titulo, autor, ano)
self.edicao = edicao

def info(self):
base = super().info()
return f"{base} - Edição {self.edicao}"

class DVD(Item):
def __init__(self, titulo, diretor, ano, duracao):
super().__init__(titulo, diretor, ano)
self.duracao = duracao

def info(self):
base = super().info()
return f"{base} - {self.duracao} minutos"

# Classe Usuário
class Usuario:
def __init__(self, nome, email):
self.nome = nome
self.email = email
self.__emprestimos = []

def emprestar_item(self, item):

 if item.emprestar():
self.__emprestimos.append(item)
return True
return False

def devolver_item(self, item):

if item in self.__emprestimos:
item.devolver()
self.__emprestimos.remove(item)
return True
return False

def get_emprestimos(self):
return self.__emprestimos

# Classe Biblioteca
class Biblioteca:
def __init__(self, nome):
self.nome = nome
self.__itens = []

def adicionar_item(self, item):

self.__itens.append(item)

def listar_itens(self):
for item in self.__itens:
print(item.info())

def buscar_disponivel(self, titulo):

for item in self.__itens:
if item.titulo == titulo and item.esta_disponivel():
return item
return None

# Usando o sistema
biblioteca = Biblioteca("Biblioteca Central")

# Adicionar itens
livro1 = Livro("1984", "George Orwell", 1949, 328)
livro2 = Livro("O Hobbit", "J.R.R. Tolkien", 1937, 310)
revista1 = Revista("Veja", "Vários", 2024, 1)
dvd1 = DVD("Matrix", "Wachowski", 1999, 136)

biblioteca.adicionar_item(livro1)
biblioteca.adicionar_item(livro2)
biblioteca.adicionar_item(revista1)
biblioteca.adicionar_item(dvd1)

# Listar itens
print("=== Itens na Biblioteca ===")
biblioteca.listar_itens()

# Criar usuário
usuario = Usuario("João", "[email protected]")

# Emprestar item
print("\n=== Empréstimos ===")
livro = biblioteca.buscar_disponivel("1984")
if livro:
usuario.emprestar_item(livro)
print(f"Livro emprestado para {usuario.nome}")

# Listar itens novamente

print("\n=== Itens na Biblioteca (após empréstimo) ===")
biblioteca.listar_itens()
Atividade de Múltipla Escolha

Instruções

Responda às 20 questões abaixo para verificar seu aprendizado. Cada questão tem
apenas uma resposta correta.

Questão 1: O que é Orientação a Objeto?

Um paradigma de programação que organiza o código em torno de:

A) Apenas funções B) Objetos e classes C) Variáveis globais D) Loops e condições

Resposta Correta: B

Questão 2: Qual é a analogia mais apropriada para

uma classe?

A) Um carro real B) Um molde ou projeto C) Uma ferramenta D) Uma instrução

Resposta Correta: B

Questão 3: O que é um objeto?

A) Uma classe B) Uma função C) Uma instância de uma classe D) Um atributo

Resposta Correta: C
Questão 4: Qual é o método especial chamado quando
você cria um objeto em Python?

A) __start__() B) __init__() C) __create__() D) __new__()

Resposta Correta: B

Questão 5: O que é self em Python?

A) Uma variável global B) Uma função C) Uma referência ao objeto atual D) Uma
classe

Resposta Correta: C

Questão 6: Qual é o principal benefício da herança?

A) Aumentar a velocidade do código B) Reduzir o tamanho do arquivo C) Reutilizar

código D) Facilitar a compilação

Resposta Correta: C

Questão 7: Em Python, qual é a sintaxe para criar uma

classe que herda de outra?

A) class Filha : Mãe B) class Filha(Mãe): C) class Filha extends Mãe: D)

class Filha inherits Mãe:

Resposta Correta: B
Questão 8: O que é encapsulamento?

A) Criar múltiplas classes B) Esconder detalhes internos e fornecer interface

controlada C) Usar herança D) Criar objetos

Resposta Correta: B

Questão 9: Como você marca um atributo como

privado em Python?

A) Usar private antes do nome B) Usar _ ou __ antes do nome C) Usar private_

depois do nome D) Não é possível em Python

Resposta Correta: B

Questão 10: O que é um getter?

A) Uma classe B) Um método para obter o valor de um atributo privado C) Uma função
global D) Um tipo de herança

Resposta Correta: B

Questão 11: O que é polimorfismo?

A) Usar múltiplas classes B) A capacidade de objetos diferentes responderem ao

mesmo comando de formas diferentes C) Criar herança D) Usar encapsulamento

Resposta Correta: B
Questão 12: Qual é a analogia mais apropriada para
polimorfismo?

A) Um carro B) Uma classe C) Um controle remoto que funciona com diferentes

aparelhos D) Uma função

Resposta Correta: C

Questão 13: O que é duck typing em Python?

A) Um tipo de herança B) Se parece um pato e faz som de pato, é um pato C) Uma

classe especial D) Um método privado

Resposta Correta: B

Questão 14: Qual é o método usado para chamar um

método da classe pai em Python?

A) parent() B) super() C) inherit() D) base()

Resposta Correta: B

Questão 15: O que é um atributo?

A) Uma ação que um objeto pode realizar B) Uma característica ou propriedade de um

objeto C) Uma classe D) Uma função

Resposta Correta: B
Questão 16: O que é um método?

A) Uma característica de um objeto B) Uma classe C) Uma ação que um objeto pode
realizar D) Um atributo

Resposta Correta: C

Questão 17: Qual é o principal benefício do

encapsulamento?

A) Aumentar a velocidade B) Proteger dados e permitir validação C) Reduzir o código

D) Facilitar a herança

Resposta Correta: B

Questão 18: Em uma hierarquia de classes, qual é a

classe que outras herdam?

A) Classe derivada B) Classe filha C) Classe base ou superclasse D) Classe secundária

Resposta Correta: C

Questão 19: O que acontece quando você cria

múltiplos objetos da mesma classe?

A) Todos compartilham os mesmos atributos B) Cada objeto tem seus próprios

atributos C) Os atributos são compartilhados parcialmente D) Não é possível criar
múltiplos objetos

Resposta Correta: B
Questão 20: Qual é o primeiro passo para usar
Orientação a Objeto em Python?

A) Criar um objeto B) Criar uma classe C) Usar herança D) Usar encapsulamento

Resposta Correta: B
Gabarito Completo

Questão Resposta

1 B

2 B

3 C

4 B

5 C

6 C

7 B

8 B

9 B

10 B

11 B

12 C

13 B

14 B

15 B

16 C

17 B

18 C

19 B

20 B
Como Calcular Sua Nota

Questões Corretas: 20

Valor de cada questão: 1 ponto

Nota Máxima: 20 pontos

Fórmula: (Número de acertos ÷ 20) × 10 = Sua nota

Exemplo: Se você acertou 18 questões: (18 ÷ 20) × 10 = 9.0

Interpretação da Nota

9.0 a 10.0: Excelente! Você dominou OOP

7.0 a 8.9: Muito bom! Você entendeu bem os conceitos

5.0 a 6.9: Bom! Revise os conceitos que teve dúvida

Abaixo de 5.0: Releia a apostila e tente novamente

Próximas Etapas

1. ✅ Verifique suas respostas com o gabarito

2. 📚 Releia os módulos onde teve dúvidas

3. 💻 Pratique os conceitos no seu computador

4. 🚀 Comece a criar seus próprios projetos com OOP

Parabéns por completar esta apostila! Você agora domina os conceitos

fundamentais de Orientação a Objeto em Python! 🎉
Próximos passos: Crie seus próprios projetos, explore bibliotecas Python que
usam OOP e continue aprendendo! 🚀
Apostila desenvolvida para iniciantes em programação Versão 1.0 - 2024