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():
        .computador.memoria = memoria
         
     ():
         .computador

builder = ComputadorBuilder()
pc_gamer = (
    builder.definir_cpu()
           .definir_memoria()
           .construir()
)
(pc_gamer)

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()

fabrica = FabricaDeFormas()
forma = fabrica.criar_forma()
(forma.desenhar())  
forma = fabrica.criar_forma()
(forma.desenhar())

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
)


produto1 = produto_prototipo.clonar()
produto1.cor = Cadeira de Madeira LuxoMarrom EscuroSofá ConfortoAzul

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):
         (.metodo, PayPal):
             .metodo.pagar(valor)
         (.metodo, Stripe):
             .metodo.processar_pagamento(valor)

paypal_adapter = PagamentoAdapter(PayPal())
(paypal_adapter.realizar_pagamento())  
stripe_adapter = PagamentoAdapter(Stripe())
(stripe_adapter.realizar_pagamento())

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)
     ():
        tamanho_total = 
         item  .conteudo:
             (item, Arquivo):
                tamanho_total += item.obter_tamanho()
             (item, Pasta):
                tamanho_total += item.obter_tamanho()
         tamanho_total

pasta_raiz = Pasta()
pasta_documentos = Pasta()
pasta_imagens = Pasta()
arquivo1 = Arquivo(, )
arquivo2 = Arquivo(, )
pasta_documentos.adicionar(arquivo1)
pasta_imagens.adicionar(arquivo2)
pasta_raiz.adicionar(pasta_documentos)
pasta_raiz.adicionar(pasta_imagens)
()

# 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):
     ():
        .nome = nome
        .conteudo = []
     ():
        .conteudo.append(item)
     ():
         (item.obter_tamanho()  item  .conteudo)

pasta_raiz = Pasta()
pasta_documentos = Pasta()
pasta_imagens = Pasta()
arquivo1 = Arquivo(, )
arquivo2 = Arquivo(, )
pasta_documentos.adicionar(arquivo1)
pasta_imagens.adicionar(arquivo2)
pasta_raiz.adicionar(pasta_documentos)
pasta_raiz.adicionar(pasta_imagens)
()

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():
         

 ():
     ():
        .notificacao = notificacao
     ():
         .notificacao.enviar(mensagem)

 ():
     ():
        log = 
         

 ():
     ():
        mensagem_prioritaria = 
         .notificacao.enviar(mensagem_prioritaria)

notificacao = NotificacaoEmail()
notificacao_com_log = LogDecorator(notificacao)
notificacao_prioritaria = PrioridadeDecorator(notificacao_com_log)
mensagem = 
(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))
(pagamento.processar_pagamento(valor))
(notificacao.enviar_notificacao())

# 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: "

 :
     ():
        .estoque = Estoque()
        .pagamento = Pagamento()
        .notificacao = Notificacao()
     ():
        resultado_estoque = .estoque.verificar_estoque(produto)
        resultado_pagamento = .pagamento.processar_pagamento(valor)
        resultado_notificacao = .notificacao.enviar_notificacao(
            
        )
         

gerenciador = GerenciadorDePedidos()
resultado = gerenciador.realizar_pedido(, )
(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 ():
        .editor = editor
     ():
         .editor.conteudo

 :
     ():
        .conteudo = 
        .historico = []
     ():
        resultado = comando.executar()
        .historico.append(comando)
         resultado

editor = EditorDeTexto()
colar = ComandoColar(editor, )
editor.executar_comando(colar)
(editor.conteudo)  
copiar = ComandoCopiar(editor)
(editor.executar_comando(copiar))

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):
         .indice < (.produtos):
            produto = .produtos[.indice]
            .indice += 
             produto
         StopIteration

produtos = ListaDeProdutos([, , ])
 produto  produtos:
    (produto)

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 .display:
            .display.atualizar(.temperatura)
         .alarme:
            .alarme.verificar_alarme(.temperatura)
 :
     ():
        ()
 :
     ():
         temperatura > :
            ()

termometro = Termometro()
display = Display()
alarme = Alarme()
termometro.registrar_display(display)
termometro.registrar_alarme(alarme)
termometro.set_temperatura()

# 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():
        .observadores.remove(observador)
     ():
         observador  .observadores:
            observador.atualizar(.temperatura)
     ():
        .temperatura = temperatura
        .notificar_observadores()

 ():
     ():
        ()
 ():
     ():
         temperatura > :
            ()

termometro = Termometro()
display = Display()
alarme = Alarme()
termometro.adicionar_observador(display)
termometro.adicionar_observador(alarme)
termometro.set_temperatura()

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"
            ()

reprodutor = Reprodutor()
reprodutor.pressionar_botao()  
reprodutor.pressionar_botao()  
reprodutor.pressionar_botao()

# 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():
     ():
        reprodutor.estado = Reproduzindo()
        ()

 :
     ():
        .estado = Parado()
     ():
        .estado.pressionar_botao()

reprodutor = Reprodutor()
reprodutor.pressionar_botao()  
reprodutor.pressionar_botao()  
reprodutor.pressionar_botao()

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...")

 :
     ():
        .estrategia = estrategia
     ():
        .estrategia.recomendar(usuario)

recomendacao_colaborativa = SistemaRecomendacao(RecomendacaoColaborativa())
recomendacao_colaborativa.recomendar()  
recomendacao_conteudo = SistemaRecomendacao(RecomendacaoConteudo())
recomendacao_conteudo.recomendar()  
recomendacao_hibrida = SistemaRecomendacao(RecomendacaoHibrida())
recomendacao_hibrida.recomendar()

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():
        ()
     ():
        ()
 ():
     ():
        ()
     ():
        ()

validar_rg = ValidarRG()
validar_rg.validar()
validar_cpf = ValidarCPF()
validar_cpf.validar()

Carreiras

Área de Interesse

Aulas ao Vivo - Skills & Go

Senioridade

Eventos Alura

Outras empresas do Grupo Alun

Outras empresas do Grupo Alun

Carreiras

Área de Interesse

Aulas ao Vivo - Skills & Go

Senioridade

Eventos Alura

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

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

Explore por tópico

Carreiras

Área de Interesse

Aulas ao Vivo - Skills & Go

Senioridade

Eventos Alura

Carreiras

Área de Interesse

Aulas ao Vivo - Skills & Go

Senioridade

Eventos Alura

Laís Urano

Inscreva-se em nossa Newsletter

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

Explore por tópico

Leia também