Padrões de projeto em Python

Padrão de projeto Memento em Python

Nesta lição, você vai usar o padrão Memento para salvar e restaurar o estado de um objeto, como a função desfazer (undo).

  • Avançado
  • 3 min de leitura
  • 1 exemplo executável

Introdução

O problema

Desfazer, checkpoints em jogos e "restaurar padrões" precisam salvar o estado de um objeto e trazê-lo de volta depois, sem que outro código mexa nos detalhes internos do objeto.

Pense assim

O padrão Memento é como salvar um jogo. O jogo cria um arquivo de save com o seu estado; você guarda o save sem precisar entender o que tem dentro. Depois, carregar o save põe o jogo de volta exatamente onde estava.

Do save de jogo para o código
editor.save()💾 Crie um arquivo de save
Snapshot(text)🔒 Um save lacrado que não pode ser editado
editor.text = "changed"🎮 Continue jogando e mude coisas
editor.restore(saved)⏪ Carregue o save: de volta a draft
Salve um snapshot, mude coisas, restaure o snapshot.
Em uma frase

O padrão Memento captura o estado de um objeto num objeto snapshot que depois pode restaurá-lo, sem mostrar os detalhes internos do objeto ao código que guarda o snapshot.

Pontos-chave

  1. Snapshot é uma dataclass congelada, então um snapshot salvo não pode ser mudado depois.
  2. save() cria um Snapshot com o texto atual.
  3. Depois o texto é mudado para "changed".
  4. restore(saved) põe o texto salvo de volta, então "draft" é impresso.

Quando usar?

  • Desfazer e refazer em editores e ferramentas de desenho.
  • Checkpoints e saves de jogos.
  • Voltar atrás depois de uma operação que falhou.

Quando não é preciso

  • Estados muito grandes salvos com frequência: snapshots gastam muita memória; guarde só as mudanças.
  • Valores simples: guardar uma cópia da variável basta.

Código de exemplo

Executar código →
main.py
from dataclasses import dataclass


@dataclass(frozen=True)
class Snapshot:
    # Memento: store a restorable snapshot without exposing internals.
    text: str


class Editor:
    def __init__(self): self.text = ""
    def save(self): return Snapshot(self.text)

    def restore(self, snapshot):
        # Restore state without exposing representation details.
        self.text = snapshot.text


editor = Editor()
editor.text = "draft"
saved = editor.save()
editor.text = "changed"
editor.restore(saved)
print(editor.text)
Gerar um botão Run para este exemplo

Resultado da execução

draft

Explicação do código

O método save() de Editor cria um snapshot com o conteúdo atual, draft. Depois que o conteúdo muda para changed, o método restore() recupera o conteúdo do snapshot salvo, por isso o resultado impresso é draft.

Altere os valores e execute o programa no compilador Python online CodeUtility sem instalar Python.

Exercícios práticos

Tente modificar o código seguindo as sugestões abaixo. Mudar o código e observar o resultado ajuda você a entender muito mais do que só ler.

  1. Substitua o domínio do exemplo preservando a estrutura do padrão.
  2. Compare o padrão com uma implementação mais simples e explique as diferenças.
  3. Escreva testes para cada participante antes de adicionar outra implementação.
Executar no compilador Python →

Erros comuns

Salvar uma referência a um estado mutável

Se o snapshot guarda a mesma lista que o editor continua mudando, o estado salvo muda também.

Problema
def save(self):
    return Snapshot(self.lines)  # same list
Correção
def save(self):
    return Snapshot(list(self.lines))  # a copy

Terminou esta lição?

Marque como aprendida para acompanhar seu progresso.