Programação Orientada a Objetos

(POO)

Conceitos e Pilares
 Paradigmas de Programação

Forma de estruturar o pensamento para construir programas

Exemplos:
Programação Estruturada
Programação Funcional
Programação Orientada a Objetos

Programação Estruturada Programação Funcional

Sequência de instruções Baseada em expressões matemáticas

Uso de variáveis e funções Programas compostos por funções
Comunicação entre funções por parâmetros e Uso de composição de funções
retornos Linguagens: Lisp, Haskell, Prolog, Python
Linguagens: C, C++, Pascal, Python, PHP, Ruby
 Programação Orientada a Objetos

Programa é estruturado em objetos

Objetos interagem entre si por meio de mensagens
Objetos representam entidades do mundo real
Linguagens: Java, Python, C#, Javascript, Scala

Conceitos Fundamentais Atributos e Métodos

Classe Atributos
Modelo para criação de objetos Características do objeto (ex: nome,
Define os atributos e métodos de seus objetos idade)

Objeto Métodos
Instância de uma classe Ações ou comportamentos (ex:
Representa uma entidade com estado andar, comer)
(atributos) e comportamento (métodos)
 Representação Gráfica (UML)

Retângulo dividido em três seções:

Nome da classe

Atributos

Métodos
 Pilares da Programação Orientada a Objetos

POO é sustentada por 4 pilares fundamentais que tornam o desenvolvimento mais

organizado, reutilizável e próximo da realidade.

Abstração

Definição:
Processo de representar entidades do mundo real, focando apenas nas características
essenciais, e omitindo os detalhes irrelevantes.

Exemplo:
Classe Cachorro com atributos como nome, idade, peso, e métodos como latir(),
comer(), dormir().

Benefício:
Simplifica a complexidade, permitindo lidar com objetos de forma conceitual.
 Encapsulamento

Definição:
Esconde os detalhes internos de implementação de um objeto, expondo apenas o
necessário por meio de interfaces públicas (métodos).

Exemplo:
Atributos privados: __saldo
Métodos públicos: consultar_saldo(), depositar(valor)

Benefício:
Protege os dados
Garante integridade
Facilita manutenção e refatoração
 Herança

Definição:
Permite que uma classe herde atributos e métodos de outra classe, formando uma
hierarquia.

Exemplo:

Classe Animal
↳ Classe Cachorro
↳ Classe Gato

Benefício:
Reutilização de código
Facilita expansão e especialização
 Polimorfismo

Definição:
Capacidade de objetos de diferentes classes responderem de forma diferente à mesma
mensagem (método).

Exemplo:

[Link]()
Pode exibir "Au au" para Cachorro, "Miau" para Gato

Benefício:
Código mais flexível e genérico
Facilita uso de herança e interfaces
 Criação de Classes em Python

Boas Práticas de Nomeação

Usar letra maiúscula no início e nomes no singular

Ex: Livro, Pessoa, Carro

Para nomes compostos, usar o padrão CamelCase

Ex: ContaCorrente, ConversorDeTemperatura
Estrutura Básica de uma Classe

A palavra-chave class é usada para declarar uma classe

Toda classe deve conter o método especial __init__, chamado de
construtor
O construtor é executado na criação (instanciação) do objeto

class Professor:
def __init__(self):
código do construtor
 O que é o self?

Obrigatório em todos os métodos da classe (primeiro parâmetro)

Representa a própria instância do objeto
Usado para acessar atributos e métodos da classe

Criando Atributos com self Instanciando um Objeto

class Professor: p1 = Professor()

def __init__(self): print([Link])
[Link] = 'Vitor' print([Link])
[Link] = '12345'
[Link] = '01/01/2024' A classe serve como molde; o objeto é a "cópia viva".
[Link] = 'Adjunto'
[Link] = 'POO'
[Link] = 20
 Construtor com Parâmetros

Em vez de dados fixos, podemos enviar os valores na hora da criação do objeto:

class Professor:
def __init__(self, nome, mat, contratacao, status, disciplina, cargaMax):
[Link] = nome
[Link] = mat
[Link] = contratacao
[Link] = status
[Link] = disciplina Adicionando Métodos à Classe
[Link] = cargaMax
def setDisciplina(self, disciplina):
[Link] = disciplina

def setCargaMaxima(self, cargaMax):

[Link] = cargaMax

Métodos modificam ou acessam os dados internos da instância.

 Adicionando Métodos à Classe

def setDisciplina(self, disciplina):

[Link] = disciplina

def setCargaMaxima(self, cargaMax):

[Link] = cargaMax

Métodos modificam ou acessam os dados internos da instância.

Usando os Métodos

p1 = Professor('Vitor', '12345', '01/01/2024', 'Adjunto', 'POO', 20)

print([Link]) # Saída: POO

[Link]('SQL')
print([Link]) # Saída: SQL
 Relacionamentos entre Classes

Por que relacionar classes?

Objetos não existem isoladamente

Objetos são formados por outros objetos
Objetos interagem entre si
Um programa orientado a objetos é composto por vários objetos
interligados

Exemplos:
• Um Carro tem um Motor
• Uma Turma possui vários Alunos
• Um Livro possui um Autor
 Diagrama de Classes

Representa os objetos usados em um sistema

Mostra o relacionamento estrutural entre os objetos
É parte fundamental do projeto do software

Tipos de Relacionamento (UML)

Associação

Relacionamento mais genérico

Classes estão ligadas conceitualmente
Representada por uma linha simples no diagrama

Ex: Pessoa trabalha para Empresa

 Implementação de Associação

class Endereco:
def __init__(self, rua, bairro, complemento, cep):
[Link] = rua
[Link] = bairro
[Link] = complemento
[Link] = cep

class Funcionario:
def __init__(self, nome, data_nasc, sexo, salario, endereco):
[Link] = nome
[Link] = endereco # Referência a outro objeto
 Agregação

Uma classe possui outras como partes

Ciclo de vida independente: os objetos agregados existem por si só

Exemplo:
Carro possui Roda Implementação da Agregação
Mesmo sem rodas, o carro ainda é um carro
class Roda:
def __init__(self, tamanho):
[Link] = tamanho

class Carro:
def __init__(self, marca, modelo):
[Link] = []

def adicionar_roda(self, roda):

[Link](roda)
 Composição

Relacionamento mais forte

Uma classe depende de outra
Se o objeto pai for destruído, o filho também será

Exemplo:
Implementação da Composição Departamento é composto por Funcionários
Sem funcionários, não há departamento
class Departamento:
def __init__(self, nome):
[Link] = nome

class Empregado:
def __init__(self, nome, salario, departamento=None):
if departamento is None:
[Link] = Departamento("Sem Departamento")
else:
[Link] = departamento
 Multiplicidade

Multiplicidade Significado

0..1 Zero ou um
1 Um (obrigatório)
0..* Zero ou mais
1..* Um ou mais
n Exatamente n
0..n Zero até n

*Lembrando que n precisa ter o valor especificado

 Encapsulamento

Encapsulamento = ocultar detalhes internos e proteger os dados.

Controla o acesso a atributos e métodos de uma classe.
Usa modificadores de acesso: público, protegido e privado.

Modificadores de Acesso
 Convenção de Nomenclatura

Público: atributo_simples
Protegido: _atributo_protegido (um underline)
Privado: __atributo_privado (dois underlines)

Exemplo Prático - Classe Pessoa

class Pessoa:
def __init__(self, nome, idade, cpf):
[Link] = nome
[Link] = idade
self.__cpf = cpf # privado

Atributos públicos: nome, idade

Atributo privado: __cpf
 Getters e Setters Diagrama de Classes

Getters: acessam atributos privados + indica público

Setters: modificam atributos privados - indica privado
# indica protegido
def get_cpf(self):
return self.__cpf Exemplo:

def set_cpf(self, cpf): + nome: str

self.__cpf = cpf + get_cpf(): str
- __cpf: str

Autorreferência com self

self referencia a própria instância da classe

Necessário para acessar atributos e métodos da instância
 Atributos Estáticos class Pessoa:
total_pessoas = 0 #atributo estático
Compartilhados por todas as instâncias
Declarados diretamente na classe def __init__(self, nome, idade, cpf):
[Link] = nome
[Link] = idade
self.__cpf = cpf
Métodos Estáticos Pessoa.total_pessoas += 1

Não acessam self nem atributos da @staticmethod #método estático

instância def calcular_idade_em_dias(idade):
Definidos com @staticmethod return idade * 365
Usados para funções auxiliares da classe
print("Total de pessoas:", Pessoa.total_pessoas)

idade_em_dias = Pessoa.calcular_idade_em_dias(30)
print("Idade em dias:", idade_em_dias)
 Herança Conceitos-Chave

Herança = relacionamento Superclasse (classe mãe): mais genérica

generalização-especialização Subclasse (classe filha): mais especializada
Permite que uma subclasse herde Generalização: agrupar semelhanças
atributos e métodos de uma Especialização: definir diferenças
superclasse
Facilita:
Reutilização de código
Extensibilidade
Manutenção
 Exemplo Conceitual

Classes: Ave, Cachorro → têm coisas

em comum

Criamos a superclasse Animal

Ave e Cachorro se tornam
subclasses

Teste: "É UM"

Cachorro é um Animal = herança
apropriada
 Herança na UML

Representada por uma seta com triângulo apontando para a superclasse

Atributos e métodos públicos são herdados
Atributos e métodos privados não são acessíveis pelas subclasses
 Encapsulamento e Herança

Privado (__)→ visível apenas pela própria classe

Protegido (_)→ visível pela classe e suas herdeiras
Público → acessível em qualquer lugar

Vantagens:
Reutilização e extensibilidade
Menos código
Facilita manutenção Tipos de Herança

Desvantagens: Herança Simples:

Maior acoplamento entre classes Uma subclasse herda de uma superclasse
Pode “ferir” o encapsulamento Exemplo: Carro(Veiculo)

Herança Múltipla (Python):

Uma subclasse herda de várias superclasses
Pode gerar ambiguidade
 Sobrescrita de Métodos Uso de super()

Uma subclasse pode class Animal:

sobrescrever um método da def fazer_som(self):
superclasse print("Este animal emite o seguinte som:")
A superclasse pode ser
acessada com super() class Gato(Animal):
def fazer_som(self):
class Animal: super().fazer_som()
def fazer_som(self): print("Miau")
print("Som genérico")
gato = Gato()
class Gato(Animal): gato.fazer_som()
def fazer_som(self):
print("Miau") Evita recursão infinita
Permite complementar o comportamento da superclasse
 Classes Abstratas – Conceitos Métodos Abstratos

Classe abstrata: não pode ser instanciada. Devem ser declarados com @abstractmethod.
Serve como modelo/base para outras classes. Obrigatórios nas subclasses.
Pode conter: A classe que os contém também deve ser
Métodos abstratos (sem implementação) abstrata.
Métodos concretos (com implementação)
Usada para forçar a implementação de
métodos nas subclasses.

Regras das Classes Abstratas

Não podem gerar objetos.

Subclasses devem implementar todos os métodos abstratos.
É possível declarar construtores e métodos concretos nas abstratas.
 Subclasses implementam
calcularSalario de forma
específica:

Exemplo de Implementação

class Gerente(Funcionario):
def calcularSalario(self): return [Link]

class Vendedor(Funcionario):
def calcularSalario(self): return [Link] + ([Link] * 0.1)

class Assistente(Funcionario):
def calcularSalario(self): return [Link] * [Link]
 Interfaces – O que são?

Um contrato: define o que deve ser implementado.

Especifica métodos e constantes, mas sem implementação.
Promove baixo acoplamento.

Quando Usar?

Classes Abstratas: quando há reuso de código e estrutura comum.

Interfaces: quando o foco é flexibilidade e baixo acoplamento.
Em Python, interfaces podem ser simuladas com herança múltipla.
 Polimorfismo – Conceito

Origem: do grego "poli" (muitas) + "morfos" (formas).

Capacidade de objetos responderem de forma diferente a
uma mesma chamada de método.
Permite que objetos de classes diferentes sejam tratados
de maneira uniforme.
Como funciona em Python?

Implementado por meio de:

Tipos de Polimorfismo (Cardelli & Wegner)
Herança
Sobrescrita de métodos
Ad Hoc
Sobrecarga
Coerção

Universal
Inclusão (sobrescrita)
Paramétrico
 Polimorfismo Ad Hoc – Sobrecarga

Mesmo nome de função com diferentes parâmetros.

Não é nativamente suportado em Python.

def funcao(a): ...

def funcao(a, b): ... # Sobrescreve a anterior # Inválido em Python

Alternativas com argumentos padrão ou opcionais:

def calcular_media(*args):
quantidade = len(args)
def funcao(a, b=None): if quantidade == 0:
if b is None: return 0
print(a) total = sum(args)
else: return total / quantidade
print(a + b)
print(calcular_media(2, 4, 6)) # Saída: 4.0
funcao(2) # Saída: 2 print(calcular_media(10, 20, 30, 40, 50)) # Saída: 30.0
funcao(2, 3) # Saída: 5 print(calcular_media()) # Saída: 0
 Polimorfismo Universal – Inclusão Vantagens do Polimorfismo
(Sobrescrita)
Reutilização de código: lógica comum
Subclasse redefine o método herdado da reutilizável com várias classes.
superclasse.
Flexibilidade: objetos diferentes tratados
class Animal: uniformemente.
def comer(self):
print("Animal comendo") Extensibilidade: novas classes podem ser
adicionadas sem modificar o código
class Cachorro(Animal): existente.
def comer(self):
print("Cachorro comendo") Manutenção facilitada: menor impacto de
alterações.
Objetos se comportam conforme sua
classe específica, mesmo usando
referência genérica.
 Exceções – Conceito

Exceção: condição anormal que altera/interrompe o fluxo

de um programa.
Causas comuns:
Erros de hardware ou memória
Divisão por zero
Acesso a variáveis nulas
Abertura de arquivos com erro
Valores fora de faixa

Exceções em Python

Mecanismo próprio para tratamento de exceções em tempo de execução.

Sem tratamento → o programa é interrompido.
Tratamento correto torna o código mais robusto e confiável.
Uso exagerado → polui e prejudica desempenho.
 Error vs Exception

Tipo Descrição
Error Erros graves, irrecuperáveis, ex: sintaxe. Não devem ser tratados.
Exception Situações inesperadas mas recuperáveis. Devem ser tratadas.

Tratamento de Exceções em Python

Blocos principais:

try:
# código que pode gerar exceção
except:
# tratamento da exceção
else:
# executa se não houver erro (opcional)
finally:
# executa sempre, com ou sem erro (opcional)
 Lançando Exceções – raise

Utilizado para levantar uma exceção manualmente.

Exemplo:
Múltiplos Excepts
def incrementa_int(n):
Permite tratar diferentes exceções if not isinstance(n, int):
separadamente: raise TypeError("n deve ser um inteiro")
return n + 1
try:
p = Paciente(nome)
except TypeError:
print("Nome deve ser string")
except NameIsEmptyError:
print("Nome não pode ser vazio")
except Exception as e:
print("Erro inesperado:", e)
 Propagação de Exceções

Se a exceção não for tratada localmente, propaga para níveis externos.

Caso não haja tratador, o interpretador imprime o erro e finaliza.
 Criando Exceções Personalizadas

Crie uma classe que herde de Exception.

Exemplo:
Benefícios do Tratamento de Exceções

class NameIsEmptyError(Exception):
Continuidade da execução mesmo
pass
após erros.
Mensagens amigáveis ao usuário.
Uso em uma classe:
Logs úteis para diagnóstico.
Evita perda de dados, por exemplo,
class Paciente:
garantindo o fechamento de arquivos
def __init__(self, nome):
ou conexões.
if not isinstance(nome, str):
raise TypeError("nome inválido")
if nome == '':
raise NameIsEmptyError("'nome' é obrigatório")
 TDD e Testes Unitários

Conceitos Básicos TDD – Desenvolvimento Guiado por Testes

Funcionalidade: comportamentos Conceito proposto por Kent Beck (2002).

esperados da aplicação. Os requisitos viram testes antes da implementação.

Exemplos: 3 etapas principais:

App de tarefas:
adicionar/remover, definir Etapa Descrição
prioridade, ordenar por data.
Rede social: postar, comentar, RED Escreva um teste que falha
curtir, enviar mensagem. GREEN Implemente o código até o teste passar
Sistema de viagens: reservar BLUE Refatore o código para melhorar
voo/hotel, escolher assento,
pagar.
 Vantagens do TDD Limitações do TDD

Código mais simples, legível e de Não cobre testes de integração/interface

fácil manutenção Requer comprometimento da equipe
Menor acoplamento entre classes Pode gerar falsa sensação de segurança
Interface mais clara e focada Testes também precisam de manutenção
Mais confiança ao desenvolver Erros de lógica podem passar despercebidos
(menor risco de quebrar algo)
Melhor cobertura dos requisitos

Relembrando: Tipos de Erros

Tipo Descrição

Sintaxe Violação das regras da linguagem

Tempo de Execução Ocorrem durante a execução (ex: divisão por zero)
Lógica Código executa, mas produz resultado incorreto
 O que são Testes Unitários? Testes com assert

Testam unidades isoladas do código Verifica condições esperadas

(funções, métodos, objetos) Se falso → levanta AssertionError
Verificam se a unidade faz o que se
propõe Exemplo:
Exemplo:
assert 3 == 2 + 1 # OK
def soma_2(numero): assert 3 == 2 + 2 # AssertionError
return numero * 2 # erro proposital
def test_1_numero_2():
test1 = soma_2(2) == 4 assert soma_2(2) == 4
print("Teste 1:", "sucesso" if test1 else "falha")
 Scripts em Python

Primeiro contato com Python é via interpretador interativo

Depois usamos arquivos .py, chamados scripts
Scripts contêm o código executável do programa

Módulos em Python

À medida que o código cresce, separamos em vários arquivos

Cada arquivo é chamado de módulo
Script ≈ Módulo (tecnicamente, ambos são arquivos .py)

Pacotes em Python

Conjunto de módulos organizados em pastas

Usado para facilitar a manutenção e organização
Pastas com módulos = Pacotes
Opcional: arquivo __init__.py para inicializar o pacote
 Bibliotecas em Python Analisando Módulos

Coleção de módulos e pacotes reutilizáveis Listar conteúdos disponíveis:

Três tipos: dir()

import math
Integradas: já vêm com o Python (ex: math, dir(math)
datetime)
De terceiros: instaladas via pip (ex: numpy, pandas) Localizar arquivo do módulo:
Próprias: criadas pelo próprio desenvolvedor
import turtle
Nome dos Módulos print(turtle.__file__)

O nome do módulo é o nome do arquivo .py

Podemos consultar com:

import meu_modulo
print(meu_modulo.__name__)
 Executando Módulos

Formas comuns:
Terminal: python nome_do_arquivo.py
VSCode: botão Run
IDLE: tecla F5

Ao importar, o conteúdo é executado uma única vez

Condicional __name__ == '__main__'

Usada para evitar execução direta ao importar um módulo

Exemplo:

def exibe_nome():
print(f'Nome do módulo: {__name__}')

if __name__ == '__main__':
exibe_nome()
 Importando com Apelidos (alias)
Importando Módulos
Útil para simplificar o código:
Python verifica se já foi importado (cachê)
import numpy as np
Se não, busca nos diretórios listados em:

import sys
print([Link]) Organizando Módulos em Pacotes

Criar pastas com vários módulos

(Opcional) arquivo __init__.py para inicialização

Importando Partes de um Módulo

Exemplo de estrutura:

Importar apenas o que será usado:

meu_pacote/
├── __init__.py
from math import sin, cos, pi
├── [Link]
└── [Link]
 Bibliotecas: Distribuição e Instalação

Bibliotecas disponíveis no PyPI (Python Package Index) e repositórios remotos

Você também pode criar sua própria biblioteca

Gerenciador de pacotes: pip

Comando Função
pip install <lib>==<versão> Instala versão específica
pip uninstall <lib> Desinstala biblioteca
pip show <lib> Exibe informações da biblioteca
 Biblioteca Útil: Pytest Biblioteca Útil: Pandas

Facilita a automatização de testes Usada para manipulação e análise de dados

Testes ficam em arquivos como: Ideal para dados tabulares (como planilhas)
test_*.py
*_test.py Permite:
Leitura, escrita e transformação de dados
Executa funções ou classes de teste Indexação hierárquica (multi-index)
Instalação:
Instalação:
pip install pytest
python -m pytest <[Link]> pip install pandas

Pandas – Estruturas de Dados

Estrutura Descrição
Series Dados unidimensionais (1D) — como uma coluna
DataFrame Dados bidimensionais (2D) — como uma tabela Excel
 SQLAlchemy – Exemplo ORM

from sqlalchemy import Column, Integer, String, ForeignKey

Biblioteca Útil: SQLAlchemy from [Link] import declarative_base

Biblioteca para interação com Base = declarative_base()

bancos de dados relacionais
Dois principais componentes: class Author(Base):
SQLAlchemy Core: abstração SQL __tablename__ = 'authors'
de baixo nível id = Column(Integer, primary_key=True)
SQLAlchemy ORM: mapeamento name = Column(String)
objeto-relacional (classe↔ tabela)
class Book(Base):
Instalação: __tablename__ = 'books'
id = Column(Integer, primary_key=True)
pip install sqlalchemy title = Column(String)
author_id = Column(Integer, ForeignKey([Link]))
 Persistência de Dados

Histórico

Antes dos bancos de dados, programas já manipulavam dados armazenados em arquivos

Os programas precisavam conhecer a estrutura do arquivo
Surgem os SGBDs como intermediários
Ainda há casos onde o acesso direto a arquivos é mais adequado

Armazenamento em Arquivos Caminhos de Arquivos

Arquivo: espaço em memória não volátil Caminho absoluto: começa na raiz (ex: C:/, /home/)
Para ler/escrever arquivos: Caminho relativo: começa do diretório atual
Saber o caminho
Conhecer a estrutura
Definir nome e local do arquivo
 Leitura e Escrita com open() Manipulação com TextIOWrapper

Modo Descrição Métodos úteis:

'r' Leitura .read(), .readline(), .readlines()
'w' Escrita (trunca o conteúdo anterior) .write(), .writelines()
'x' Criação exclusiva .tell(): posição do cursor
'a' Escrita com anexação .seek(): move o cursor
'b' Modo binário
't' Modo texto (padrão) with open('[Link]', 'r') as f:
'+' Atualização (leitura + escrita) print([Link]())
[Link](5)

with open('[Link]', 'w') as f:

[Link]("Olá Mundo")
 Arquivos CSV

Formato texto com dados tabulares

Separadores comuns: ,, ;, \t
Uso do módulo csv:

import csv
with open('[Link]', 'w', newline='', encoding='utf-8') as f:
escritor = [Link](f, delimiter=';')
[Link](['Produto', 'Qtd'])

Manipulação de CSV com Pandas

pandas oferece leitura, escrita e análise facilitada de dados CSV

import pandas as pd
dados = pd.read_csv('[Link]')
 Funcionalidades do pandas:

Leitura de CSV, Excel, SQL etc.

Seleção e indexação de dados
Limpeza, transformação e agregação
Junções e concatenação de dados
Suporte a datas, visualização e estatísticas

Arquivos JSON

Formato leve e legível para dados estruturados

Baseado em pares chave-valor
Suporte a tipos como: string, número, bool, null, array, objeto
 Manipulação de JSON em Python

Módulo json:

Função Descrição
[Link]() Serializa e salva em arquivo
[Link]() Serializa e retorna como str
[Link]() Lê de arquivo JSON e converte em objeto Python
[Link]() Converte str JSON em objeto Python

import json

dados = {"nome": "Alice", "idade": 30} # Codificação

with open('[Link]', 'w') as f:
[Link](dados, f)

with open('[Link]', 'r') as f: # Decodificação

dados_lidos = [Link](f)
 Programas x Banco de Dados

Programas modernos dependem de bancos de dados:

ERPs
Redes sociais
Aplicações financeiras
Jogos e sistemas públicos

POO vs Modelo Relacional

POO (Programação) Modelo Relacional (BD)

Classe Relação
Objeto Tupla
Atributo Atributo
Método —
 Mapeamento Objeto-Relacional (ORM)

Técnica que liga objetos em código a dados relacionais

Abstração de alto nível
Simplifica e agiliza o desenvolvimento
Exemplo de ferramenta: SQLAlchemy

SQLAlchemy: Visão Geral

Dois componentes principais:

SQLAlchemy Core: manipulação direta via SQL

SQLAlchemy ORM: usa classes Python para representar tabelas

Instalação:

pip install sqlalchemy

 Pilha (Stack)

Estrutura LIFO (Last In, First Out)

A inserção e remoção ocorrem no topo da pilha
A extremidade oposta é a base da pilha
Operações com Pilha
Exemplos práticos:
Desfazer/refazer em editores push: empilha (insere)
Navegação entre páginas da web pop: desempilha (remove do topo)
Avaliação de expressões aritméticas top/peek: consulta o topo
is_empty: verifica se está vazia
size: retorna a quantidade de elementos
Pilha em Python – Lista

pilha = []
[Link](2)
item = [Link]()
topo = pilha[-1]
Classe Stack (Pilha) Exemplo: Parênteses Balanceados
Verifica se uma expressão possui parênteses
corretamente abertos e fechados.
 Fila (Queue)
Operações com Fila
Estrutura FIFO (First In, First Out)
Entrada no final e remoção no início enqueue: insere no fim
dequeue: remove do início
Exemplos práticos: first: consulta o primeiro
Atendimento de clientes is_empty: verifica se está vazia
Processamento de tarefas size: retorna a quantidade de elementos
Filas de impressão

Fila em Python – Lista

fila = []
[Link](1)
item = [Link](0)
primeiro = fila[0]
Classe Queue (Fila) Exemplo: Impressora com Fila

Programa que gerencia impressões