Design Patterns em Python: um guia para aplicar padrões de projeto

Design Patterns em Python: um guia para aplicar padrões de projeto | Alura Cursos Online

class Botao:
    def renderizar(self):
        pass
class BotaoDesktop(Botao):
    def renderizar(self):
        return "Botão de Desktop"
class BotaoWeb(Botao):
    def renderizar(self):
        return "Botão de Web"

class Fabrica:
    def criar_botao(self):
        pass
class FabricaDesktop(Fabrica):
    def criar_botao(self):
        return BotaoDesktop()
class FabricaWeb(Fabrica):
    def criar_botao(self):
        return BotaoWeb()
def cliente(fabrica: Fabrica):
    botao = fabrica.criar_botao()
    print(botao.renderizar())
cliente(FabricaDesktop())  # Saída: Botão de Desktop
cliente(FabricaWeb())      # Saída: Botão de Web

class Computador:
    def __init__(self):
        self.cpu = None
        self.memoria = None
computador = Computador()
computador.cpu = "Intel i5"
computador.memoria = 16
print(f"CPU: {computador.cpu}, Memória: {computador.memoria}GB")

class Computador:
    def __init__(self):
        self.cpu = None
        self.memoria = None
    def __str__(self):
        return f"CPU: {self.cpu}, Memória: {self.memoria}GB"
class ComputadorBuilder:
    def __init__(self):
        self.computador = Computador()
    def definir_cpu(self, cpu):
        self.computador.cpu = cpu
        return self
    def definir_memoria(self, memoria):
        self.computador.memoria = memoria
        return self
    def construir(self):
        return self.computador
# Uso do Builder
builder = ComputadorBuilder()
pc_gamer = (
    builder.definir_cpu("Intel i7")
           .definir_memoria(32)
           .construir()
)
print(pc_gamer)  # Saída: CPU: Intel i7, Memória: 32GB

class Circulo:
    def desenhar(self):
        return "Desenhando um círculo"
class Quadrado:
    def desenhar(self):
        return "Desenhando um quadrado"
forma = "circulo"
if forma == "circulo":
    circulo = Circulo()
    print(circulo.desenhar())
elif forma == "quadrado":
    quadrado = Quadrado()
    print(quadrado.desenhar())

class Forma:
    def desenhar(self):
        pass
class Circulo(Forma):
    def desenhar(self):
        return "Desenhando um círculo"
class Quadrado(Forma):
    def desenhar(self):
        return "Desenhando um quadrado"
# Fábrica de Formas
class FabricaDeFormas:
    def criar_forma(self, tipo):
        if tipo == "circulo":
            return Circulo()
        elif tipo == "quadrado":
            return Quadrado()
# Uso da Factory
fabrica = FabricaDeFormas()
forma = fabrica.criar_forma("circulo")
print(forma.desenhar())  # Saída: Desenhando um círculo
forma = fabrica.criar_forma("quadrado")
print(forma.desenhar())  # Saída: Desenhando um quadrado

class Produto:
    def __init__(self, nome, material, cor, preco):
        self.nome = nome
        self.cor = cor
        self.material = material
        self.preco = preco
# Criando um produto manualmente
produto1 = Produto("Cadeira", "Madeira", "Branca",150.00)
# Criando outro produto similar
produto2 = Produto("Sofá de Luxo", "Suede", "Azul", 2500.00)

import copy
class Produto:
    def __init__(self, nome, material, cor, preco):
        self.nome = nome
        self.material = material
        self.cor = cor
        self.preco = preco
    def clonar(self):
        return copy.deepcopy(self) # Faz uma cópia do objeto
# Criando um protótipo de produto básico
produto_prototipo = Produto(
    nome="Cadeira de Madeira",
    material="Madeira",
    cor="Branca",
    preco=150.00
)
# Clonando o protótipo
## Criando um produto com todas as características básicas do protótipo, mudando apenas o nome
produto1 = produto_prototipo.clonar()
produto1.cor = "Cadeira de Madeira Básica”
## Criando um produto com todas as características básicas do protótipo, mudando alguns detalhes de modelo
produto2 = produto_prototipo.clonar()
produto2.nome = "Cadeira de Madeira Luxo"
produto2.cor = "Marrom Escuro"
produto2.preco = 250.00
## Criando um produto com todas as características básicas do protótipo diferentes, mas com os mesmos atributos
produto3 = produto_prototipo.clonar()
produto3.nome = "Sofá Conforto"
produto3.cor = "Azul"
produto3.preco = 2500.00

class ConexaoBanco:
    def __init__(self):
        print("Conexão com o banco de dados criada!")
# Criando várias instâncias da classe
conexao1 = ConexaoBanco()
conexao2 = ConexaoBanco()

class ConexaoBanco:
    _instancia = None
    def __new__(cls):
        if cls._instancia is None:
            cls._instancia = super().__new__(cls)
            print("Conexão com o banco de dados criada!")
        return cls._instancia
# Criando as conexões
conexao1 = ConexaoBanco()
conexao2 = ConexaoBanco()
# Verificando se as instâncias são as mesmas
print(conexao1 is conexao2)  # Saída: True

class PayPal:
    def pagar(self, valor):
        return f"Pagamento de ${valor} realizado com PayPal"
class Stripe:
    def processar_pagamento(self, valor):
        return f"Pagamento de ${valor} processado com Stripe"
# Uso direto e inconsistente
metodo = "paypal"
if metodo == "paypal":
    paypal = PayPal()
    print(paypal.pagar(100))
elif metodo == "stripe":
    stripe = Stripe()
    print(stripe.processar_pagamento(200))

# Classes existentes
class PayPal:
    def pagar(self, valor):
        return f"Pagamento de ${valor} realizado com PayPal"
class Stripe:
    def processar_pagamento(self, valor):
        return f"Pagamento de ${valor} processado com Stripe"
# Adapter para unificar as interfaces
class PagamentoAdapter:
    def __init__(self, metodo):
        self.metodo = metodo
    def realizar_pagamento(self, valor):
        if isinstance(self.metodo, PayPal):
            return self.metodo.pagar(valor)
        elif isinstance(self.metodo, Stripe):
            return self.metodo.processar_pagamento(valor)
# Uso do Adapter
paypal_adapter = PagamentoAdapter(PayPal())
print(paypal_adapter.realizar_pagamento(100))  # Saída: Pagamento de $100 realizado com PayPal
stripe_adapter = PagamentoAdapter(Stripe())
print(stripe_adapter.realizar_pagamento(200))  # Saída: Pagamento de $200 processado com Stripe

class Arquivo:
    def __init__(self, nome, tamanho):
        self.nome = nome
        self.tamanho = tamanho
    def obter_tamanho(self):
        return self.tamanho
class Pasta:
    def __init__(self, nome):
        self.nome = nome
        self.conteudo = []
    def adicionar(self, item):
        self.conteudo.append(item)
    def obter_tamanho(self):
        tamanho_total = 0
        for item in self.conteudo:
            if isinstance(item, Arquivo):
                tamanho_total += item.obter_tamanho()
            elif isinstance(item, Pasta):
                tamanho_total += item.obter_tamanho()
        return tamanho_total
# Estrutura manual para calcular tamanho
pasta_raiz = Pasta("Raiz")
pasta_documentos = Pasta("Documentos")
pasta_imagens = Pasta("Imagens")
arquivo1 = Arquivo("doc1.txt", 100)
arquivo2 = Arquivo("img1.jpg", 500)
pasta_documentos.adicionar(arquivo1)
pasta_imagens.adicionar(arquivo2)
pasta_raiz.adicionar(pasta_documentos)
pasta_raiz.adicionar(pasta_imagens)
print(f"Tamanho total: {pasta_raiz.obter_tamanho()}")  # Saída: Tamanho total: 600

# Interface comum para Componentes
class Componente:
    def obter_tamanho(self):
        pass
# Classe Arquivo
class Arquivo(Componente):
    def __init__(self, nome, tamanho):
        self.nome = nome
        self.tamanho = tamanho
    def obter_tamanho(self):
        return self.tamanho
# Classe Pasta
class Pasta(Componente):
    def __init__(self, nome):
        self.nome = nome
        self.conteudo = []
    def adicionar(self, item):
        self.conteudo.append(item)
    def obter_tamanho(self):
        return sum(item.obter_tamanho() for item in self.conteudo)
# Uso do Composite
pasta_raiz = Pasta("Raiz")
pasta_documentos = Pasta("Documentos")
pasta_imagens = Pasta("Imagens")
arquivo1 = Arquivo("doc1.txt", 100)
arquivo2 = Arquivo("img1.jpg", 500)
pasta_documentos.adicionar(arquivo1)
pasta_imagens.adicionar(arquivo2)
pasta_raiz.adicionar(pasta_documentos)
pasta_raiz.adicionar(pasta_imagens)
print(f"Tamanho total: {pasta_raiz.obter_tamanho()}")  # Saída: Tamanho total: 600

class NotificacaoEmail:
    def enviar(self, mensagem):
        return f"Enviando e-mail: {mensagem}"
class NotificacaoSMS:
    def enviar(self, mensagem):
        return f"Enviando SMS: {mensagem}"
class NotificacaoEmailComPrioridade:
    def __init__(self, prioridade):
        self.prioridade = prioridade
    def enviar(self, mensagem):
        mensagem_com_prioridade = f"[Prioridade {self.prioridade}] {mensagem}"
        return f"Enviando e-mail: {mensagem_com_prioridade}"
# Combinação de outros tipos de notificações e funcionalidades…

# Componente base
class Notificacao:
    def enviar(self, mensagem):
        pass
# Componente concreto
class NotificacaoEmail(Notificacao):
    def enviar(self, mensagem):
        return f"Enviando e-mail: {mensagem}"
class NotificacaoSMS(Notificacao):
    def enviar(self, mensagem):
        return f"Enviando SMS: {mensagem}"
# Decorator base
class NotificacaoDecorator(Notificacao):
    def __init__(self, notificacao):
        self.notificacao = notificacao
    def enviar(self, mensagem):
        return self.notificacao.enviar(mensagem)
# Decorator para registrar log
class LogDecorator(NotificacaoDecorator):
    def enviar(self, mensagem):
        log = "Registrando log..."
        return f"{log}\n{self.notificacao.enviar(mensagem)}"
# Decorator para prioridade
class PrioridadeDecorator(NotificacaoDecorator):
    def enviar(self, mensagem):
        mensagem_prioritaria = f"[PRIORITÁRIO] {mensagem}"
        return self.notificacao.enviar(mensagem_prioritaria)
# Uso do Decorator
notificacao = NotificacaoEmail()
notificacao_com_log = LogDecorator(notificacao)
notificacao_prioritaria = PrioridadeDecorator(notificacao_com_log)
mensagem = "Sistema fora do ar!"
print(notificacao_prioritaria.enviar(mensagem))

class Estoque:
    def verificar_estoque(self, produto):
        return f"Estoque do produto {produto} verificado."
class Pagamento:
    def processar_pagamento(self, valor):
        return f"Pagamento de R${valor:.2f} processado."
class Notificacao:
    def enviar_notificacao(self, mensagem):
        return f"Notificação enviada: {mensagem}"
# Uso direto dos subsistemas
estoque = Estoque()
pagamento = Pagamento()
notificacao = Notificacao()
produto = "Notebook"
valor = 3000.00
print(estoque.verificar_estoque(produto))
print(pagamento.processar_pagamento(valor))
print(notificacao.enviar_notificacao(f"Pedido do produto {produto} realizado com sucesso!"))

# Subsystems
class Estoque:
    def verificar_estoque(self, produto):
        return f"Estoque do produto {produto} verificado."
class Pagamento:
    def processar_pagamento(self, valor):
        return f"Pagamento de R${valor:.2f} processado."
class Notificacao:
    def enviar_notificacao(self, mensagem):
        return f"Notificação enviada: {mensagem}"
# Facade
class GerenciadorDePedidos:
    def __init__(self):
        self.estoque = Estoque()
        self.pagamento = Pagamento()
        self.notificacao = Notificacao()
    def realizar_pedido(self, produto, valor):
        resultado_estoque = self.estoque.verificar_estoque(produto)
        resultado_pagamento = self.pagamento.processar_pagamento(valor)
        resultado_notificacao = self.notificacao.enviar_notificacao(
            f"Pedido do produto {produto} realizado com sucesso!"
        )
        return f"{resultado_estoque}\n{resultado_pagamento}\n{resultado_notificacao}"
# Uso do Facade
gerenciador = GerenciadorDePedidos()
resultado = gerenciador.realizar_pedido("Notebook", 3000.00)
print(resultado)

class EditorDeTexto:
    def __init__(self):
        self.conteudo = ""
    def copiar(self):
        return self.conteudo
    def colar(self, texto):
        self.conteudo += texto
# Uso direto e acoplado
editor = EditorDeTexto()
editor.colar("Olá, mundo!")
print(editor.copiar())  # Saída: Olá, mundo!

# Comando abstrato
class Comando:
    def executar(self):
        pass
# Implementações de comandos
class ComandoColar(Comando):
    def __init__(self, editor, texto):
        self.editor = editor
        self.texto = texto
    def executar(self):
        self.editor.conteudo += self.texto
class ComandoCopiar(Comando):
    def __init__(self, editor):
        self.editor = editor
    def executar(self):
        return self.editor.conteudo
# Classe principal
class EditorDeTexto:
    def __init__(self):
        self.conteudo = ""
        self.historico = []
    def executar_comando(self, comando):
        resultado = comando.executar()
        self.historico.append(comando)
        return resultado
# Uso do Command
editor = EditorDeTexto()
colar = ComandoColar(editor, "Olá, mundo!")
editor.executar_comando(colar)
print(editor.conteudo)  # Saída: Olá, mundo!
copiar = ComandoCopiar(editor)
print(editor.executar_comando(copiar))  # Saída: Olá, mundo!

class ListaDeProdutos:
    def __init__(self, produtos):
        self.produtos = produtos
# Percorrendo diretamente a estrutura de dados
produtos = ListaDeProdutos(["Produto A", "Produto B", "Produto C"])
for i in range(len(produtos.produtos)):
    print(produtos.produtos[i])

# Classe de coleção
class ListaDeProdutos:
    def __init__(self, produtos):
        self.produtos = produtos
    def __iter__(self):
        return IteradorLista(self.produtos)
# Implementação do iterador
class IteradorLista:
    def __init__(self, produtos):
        self.produtos = produtos
        self.indice = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.indice < len(self.produtos):
            produto = self.produtos[self.indice]
            self.indice += 1
            return produto
        raise StopIteration
# Uso do Iterator
produtos = ListaDeProdutos(["Produto A", "Produto B", "Produto C"])
for produto in produtos:
    print(produto)  # Saídas: Produto A, Produto B, Produto C

class Termometro:
    def __init__(self):
        self.temperatura = 0
        self.display = None
        self.alarme = None
    def registrar_display(self, display):
        self.display = display
    def registrar_alarme(self, alarme):
        self.alarme = alarme
    def set_temperatura(self, temperatura):
        self.temperatura = temperatura
        if self.display:
            self.display.atualizar(self.temperatura)
        if self.alarme:
            self.alarme.verificar_alarme(self.temperatura)
class Display:
    def atualizar(self, temperatura):
        print(f"Temperatura atual: {temperatura}°C")
class Alarme:
    def verificar_alarme(self, temperatura):
        if temperatura > 30:
            print("Alerta! Temperatura alta!")
# Uso direto e acoplado
termometro = Termometro()
display = Display()
alarme = Alarme()
termometro.registrar_display(display)
termometro.registrar_alarme(alarme)
termometro.set_temperatura(32)  # Saída: Temperatura atual: 32°C \n Alerta! Temperatura alta!

# Observador
class Observador:
    def atualizar(self, temperatura):
        pass
# Sujeito
class Termometro:
    def __init__(self):
        self.temperatura = 0
        self.observadores = []
    def adicionar_observador(self, observador):
        self.observadores.append(observador)
    def remover_observador(self, observador):
        self.observadores.remove(observador)
    def notificar_observadores(self):
        for observador in self.observadores:
            observador.atualizar(self.temperatura)
    def set_temperatura(self, temperatura):
        self.temperatura = temperatura
        self.notificar_observadores()
# Observadores concretos
class Display(Observador):
    def atualizar(self, temperatura):
        print(f"Temperatura atual: {temperatura}°C")
class Alarme(Observador):
    def atualizar(self, temperatura):
        if temperatura > 30:
            print("Alerta! Temperatura alta!")
# Uso do Observer
termometro = Termometro()
display = Display()
alarme = Alarme()
termometro.adicionar_observador(display)
termometro.adicionar_observador(alarme)
termometro.set_temperatura(32)  # Saída: Temperatura atual: 32°C \n Alerta! Temperatura alta!

class Reprodutor:
    def __init__(self):
        self.estado = "parado"
    def pressionar_botao(self):
        if self.estado == "parado":
            self.estado = "reproduzindo"
            print("Iniciando reprodução...")
        elif self.estado == "reproduzindo":
            self.estado = "pausado"
            print("Reprodução pausada.")
        elif self.estado == "pausado":
            self.estado = "reproduzindo"
            print("Retomando reprodução.")
# Uso direto e com lógica condicional
reprodutor = Reprodutor()
reprodutor.pressionar_botao()  # Saída: Iniciando reprodução...
reprodutor.pressionar_botao()  # Saída: Reprodução pausada.
reprodutor.pressionar_botao()  # Saída: Retomando reprodução...

# Estados concretos
class Estado:
    def pressionar_botao(self, reprodutor):
        pass
class Parado(Estado):
    def pressionar_botao(self, reprodutor):
        reprodutor.estado = Reproduzindo()
        print("Iniciando reprodução...")
class Reproduzindo(Estado):
    def pressionar_botao(self, reprodutor):
        reprodutor.estado = Pausado()
        print("Reprodução pausada.")
class Pausado(Estado):
    def pressionar_botao(self, reprodutor):
        reprodutor.estado = Reproduzindo()
        print("Retomando reprodução...")
# Classe Contexto
class Reprodutor:
    def __init__(self):
        self.estado = Parado()
    def pressionar_botao(self):
        self.estado.pressionar_botao(self)
# Uso do State
reprodutor = Reprodutor()
reprodutor.pressionar_botao()  # Saída: Iniciando reprodução...
reprodutor.pressionar_botao()  # Saída: Reprodução pausada.
reprodutor.pressionar_botao()  # Saída: Retomando reprodução...

class Recomendacao:
    def __init__(self, tipo):
        self.tipo = tipo
    def recomendar(self, usuario):
        if self.tipo == "colaborativa":
            print("Recomendando com filtragem colaborativa...")
        elif self.tipo == "conteudo":
            print("Recomendando com filtragem baseada em conteúdo...")
        elif self.tipo == "hibrida":
            print("Recomendando com algoritmo híbrido...")
# Uso direto e com lógica condicional
recomendacao = Recomendacao("colaborativa")
recomendacao.recomendar("usuario1")  # Saída: Recomendando com filtragem colaborativa...

# Estratégias de recomendação
class RecomendacaoColaborativa:
    def recomendar(self, usuario):
        print("Recomendando com filtragem colaborativa...")
class RecomendacaoConteudo:
    def recomendar(self, usuario):
        print("Recomendando com filtragem baseada em conteúdo...")
class RecomendacaoHibrida:
    def recomendar(self, usuario):
        print("Recomendando com algoritmo híbrido...")
# Contexto de recomendação
class SistemaRecomendacao:
    def __init__(self, estrategia):
        self.estrategia = estrategia
    def recomendar(self, usuario):
        self.estrategia.recomendar(usuario)
# Uso do Strategy
recomendacao_colaborativa = SistemaRecomendacao(RecomendacaoColaborativa())
recomendacao_colaborativa.recomendar("usuario1")  # Saída: Recomendando com filtragem colaborativa...
recomendacao_conteudo = SistemaRecomendacao(RecomendacaoConteudo())
recomendacao_conteudo.recomendar("usuario2")  # Saída: Recomendando com filtragem baseada em conteúdo...
recomendacao_hibrida = SistemaRecomendacao(RecomendacaoHibrida())
recomendacao_hibrida.recomendar("usuario3")  # Saída: Recomendando com algoritmo híbrido...

class ValidarRG:
    def validar(self, documento):
        print(f"Verificando formato do RG {documento}...")
        print(f"Validando número do RG {documento}...")
class ValidarCPF:
    def validar(self, documento):
        print(f"Verificando formato do CPF {documento}...")
        print(f"Validando número do CPF {documento}...")

from abc import ABC, abstractmethod
class ValidadorDocumento(ABC):
    def validar(self, documento):
        self.verificar_formato(documento)
        self.validar_numero(documento)
    @abstractmethod
    def verificar_formato(self, documento):
        pass
    @abstractmethod
    def validar_numero(self, documento):
        pass
class ValidarRG(ValidadorDocumento):
    def verificar_formato(self, documento):
        print(f"Verificando formato do RG {documento}...")
    def validar_numero(self, documento):
        print(f"Validando número do RG {documento}...")
class ValidarCPF(ValidadorDocumento):
    def verificar_formato(self, documento):
        print(f"Verificando formato do CPF {documento}...")
    def validar_numero(self, documento):
        print(f"Validando número do CPF {documento}...")
# Uso do Template
validar_rg = ValidarRG()
validar_rg.validar("12.345.678-9")
validar_cpf = ValidarCPF()
validar_cpf.validar("123.456.789-00")

Outras empresas do Grupo Alun

Outras empresas do Grupo Alun

Outras empresas do Grupo Alun

Outras empresas do Grupo Alun

Design Patterns em Python: um guia para aplicar padrões de projeto

Laís Urano

Explore por tópico

Categorias de Design Patterns

Padrões Criacionais

Abstract Factory

Builder

Factory

Prototype

Singleton

Padrões Estruturais

Adapter

Composite

Decorator

Facade

Padrões Comportamentais

Command

Iterator

Observer

State

Strategy

Template Method

Quando utilizar Design Patterns em Python?

Conclusão

Laís Urano

Inscreva-se em nossa Newsletter

Explore por tópico

Leia também

Categorias de Design Patterns

Padrões Criacionais

Abstract Factory

Builder

Factory

Prototype

Singleton

Padrões Estruturais

Adapter

Composite

Decorator

Facade

Padrões Comportamentais

Command

Iterator

Observer

State

Strategy

Template Method

Quando utilizar Design Patterns em Python?

Conclusão