Padrões de Projeto em Python (Design Patterns): Prototype

✅ Artigo atualizado em Setembro 2026 Nova seção “Quando usar e quando não usar” o Prototype, incluindo a alternativa com dataclasses.replace() e copy.replace() (Python 3.13), com código testado no Python 3.13.

Salve salve Pythonista

No desenvolvimento de software, a eficiência na criação de objetos é essencial.

O Padrão de Projeto Prototype é uma solução poderosa para esse desafio em Python.

Neste artigo, exploraremos o que é o Prototype, o problema que ele resolve, sua estrutura, aplicabilidade e como implementá-lo na prática.

Entender este padrão pode melhorar significativamente a performance e a escalabilidade das suas aplicações Python.

Vá Direto ao Assunto…

• O que é o Padrão de Projeto Prototype?
• Problema que o Prototype Resolve
• Racional por trás do Prototype
• Estrutura do Padrão de Projeto Prototype
• Aplicabilidade do Padrão Prototype
• Implementando o Prototype na Prática
• Exemplos Práticos de Prototype em Python
• Quando usar e quando não usar

O que é o Padrão de Projeto Prototype?

O Prototype é um padrão de criação que permite copiar objetos existentes sem depender de suas classes.

Ele facilita a criação de novas instâncias por clonagem, evitando a necessidade de repetição de código.

Essa abordagem é especialmente útil quando a criação de um objeto é complexa ou custosa em termos de recursos.

Problema que o Prototype Resolve

Criar objetos diretamente pode ser ineficiente, especialmente quando envolve processos complexos ou demorados.

Além disso, a criação direta vincula o código à classe concreta, dificultando a manutenção e a expansão.

O Prototype resolve esses problemas permitindo a clonagem de objetos existentes, promovendo flexibilidade e reutilização.

Racional por trás do Prototype

A ideia central do Prototype é utilizar objetos existentes como “protótipos” para criar novos objetos.

Isso elimina a necessidade de instanciar objetos do zero, reduzindo a sobrecarga de criação.

Além disso, promove o desacoplamento entre o código cliente e as classes concretas, facilitando futuras modificações.

Estrutura do Padrão de Projeto Prototype

A estrutura do Prototype consiste em:

1. Prototype: Interface que declara o método de clonagem.
2. ConcretePrototype: Implementa o método de clonagem definido na interface.
3. Cliente: Cria novos objetos clonando os protótipos existentes.

Essa estrutura garante que a clonagem seja realizada de maneira consistente e controlada.

Aplicabilidade do Padrão Prototype

O Prototype é aplicável quando:

• A criação de objetos é custosa em termos de recursos.
• É necessário criar cópias de objetos existentes.
• O sistema deve ser independente das classes que precisa para criar novos objetos.
• Os ambientes de runtime do programa devem permitir a criação dinâmica de novos objetos.

Aproveita a pausa: Estou construindo o Ebookr.ai, uma plataforma que gera ebooks profissionais sobre qualquer tema usando IA. Imagina transformar seu conhecimento sobre Design Patterns em um ebook com capa, infográficos e tudo mais - em minutos! Vale conferir.

Implementando o Prototype na Prática

Vamos implementar o Prototype em Python.

Primeiro, definimos a interface Prototype com o método clone:

1
2
3
4
5
6
7

from abc import ABC, abstractmethod
import copy

class Prototype(ABC):
    @abstractmethod
    def clone(self):
        pass

Explicação do código:

1. Importações: Importamos ABC e abstractmethod para definir classes abstratas, e copy para clonagem.
2. Classe Abstrata: Prototype é uma classe abstrata que declara o método clone.
3. Método Abstrato: clone será implementado pelas classes concretas.

Exemplos Práticos de Prototype em Python

Agora, criamos uma classe concreta que implementa Prototype:

1
2
3
4
5
6
7
8
9
10

class Documento(Prototype):
    def __init__(self, titulo, conteudo):
        self.titulo = titulo
        self.conteudo = conteudo

    def clone(self):
        return copy.deepcopy(self)

    def __str__(self):
        return f"Documento: {self.titulo}\nConteúdo: {self.conteudo}"

Explicação do código:

1. Classe Documento: Herda de Prototype.
2. Construtor: Recebe titulo e conteudo.
3. Método clone: Retorna uma cópia profunda do objeto.
4. Método __str__: Define a representação em string do objeto.

Vamos testar a clonagem:

1
2
3
4
5
6
7
8

# Criando o protótipo original
doc_original = Documento("Relatório Anual", "Conteúdo do relatório anual.")

# Clonando o documento
doc_clone = doc_original.clone()

print(doc_original)
print(doc_clone)

E a saída será:

1
2
3
4

Documento: Relatório Anual
Conteúdo: Conteúdo do relatório anual.
Documento: Relatório Anual
Conteúdo: Conteúdo do relatório anual.

Explicação do código:

1. Instância Original: Criamos doc_original com título e conteúdo específicos.
2. Clonagem: doc_clone é uma cópia de doc_original criada pelo método clone.
3. Impressão: Exibimos ambos os documentos, que possuem os mesmos valores.

Saber quando vale a pena clonar um objeto em vez de recriar do zero é critério que só vem com prática de POO de verdade. Essa vivência prática é o que a Jornada Python constrói com você, do zero ao avançado:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Quando usar e quando não usar

Use o Prototype quando:

• Montar o objeto do zero é caro (carregar configuração de arquivo, fazer consultas, processar dados) e você precisa de várias variações dele.
• Você precisa copiar um objeto sem saber a classe concreta dele, por exemplo, quando recebe protótipos prontos de um registro e só quer cloná-los.

Evite quando:

• O objeto é simples e barato de criar. Chamar o construtor com os argumentos certos é mais claro do que clonar.
• O objeto guarda recursos externos, como conexões com banco de dados, arquivos abertos ou locks. O deepcopy pode falhar ou duplicar algo que não deveria ser duplicado.
• Você está criando a hierarquia só para ter um método clone. Em Python, copy.copy() e copy.deepcopy() já funcionam em praticamente qualquer objeto, sem precisar herdar de Prototype.

Para classes de dados, o jeito mais direto de “clonar trocando alguns campos” é usar uma dataclass com dataclasses.replace(), disponível em qualquer Python 3 moderno. A partir do Python 3.13 também existe copy.replace(), que faz o mesmo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import copy
from dataclasses import dataclass, field, replace


@dataclass
class Documento:
    titulo: str
    conteudo: str
    tags: list[str] = field(default_factory=list)


modelo = Documento("Relatório Anual", "Conteúdo do relatório anual.", ["financeiro"])

# Cópia trocando só o título (funciona em qualquer versão do Python 3)
rascunho = replace(modelo, titulo="Relatório Anual (rascunho)")

# A partir do Python 3.13 também existe copy.replace()
revisao = copy.replace(modelo, titulo="Relatório Anual (revisão)")

print(rascunho.titulo)
print(revisao.titulo)

# Atenção: replace() faz cópia rasa, a lista de tags é compartilhada
rascunho.tags.append("rascunho")
print(modelo.tags)

E a saída será:

1
2
3

Relatório Anual (rascunho)
Relatório Anual (revisão)
['financeiro', 'rascunho']

Repare na última linha: replace() faz uma cópia rasa, então listas e outros objetos mutáveis continuam compartilhados com o original. Quando isso for um problema, use copy.deepcopy(), como no método clone do exemplo anterior.

Antes de continuar… Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Conclusão

O Padrão de Projeto Prototype é uma ferramenta valiosa para otimizar a criação de objetos em Python.

Ele resolve problemas de eficiência e acoplamento, facilitando a clonagem de objetos existentes.

Com sua estrutura simples e aplicabilidade ampla, o Prototype pode melhorar a flexibilidade e a manutenção das suas aplicações.

Esperamos que este artigo tenha esclarecido como implementar e utilizar o Prototype em seus projetos Python.

O Prototype depende de POO bem entendida. Quer dominar classes e objetos construindo aplicações Python completas? Conheça a Jornada Python, nosso curso de Python completo.

Para continuar, veja a visão geral dos padrões de projeto em Python e outros padrões criacionais, como o Abstract Factory e o Builder.

Por Vinícius Ramos em 13/03/2025

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•