Python备忘录模式：实现对象状态保存与恢复-代码聚汇网

Python备忘录模式：实现对象状态保存与恢复

备忘录模式Python设计模式对象状态管理

|难度：普通|阅读约 17 分钟

1. 备忘录模式（Memento Pattern）是什么？

备忘录模式是一种行为设计模式，它允许在不破坏封装性的前提下，捕获并外部化一个对象的内部状态，以便稍后可以将该对象恢复到此状态。简单来说，就是给对象提供一个"后悔药"机制。

在Python中实现备忘录模式特别有用，因为Python的动态特性使得保存和恢复对象状态变得相对容易。想象一下你在使用文本编辑器时的"撤销"功能，或者游戏中的"存档/读档"功能，这些都是备忘录模式的典型应用场景。

备忘录模式的核心在于：在不违反封装原则的情况下，获取并保存对象的内部状态，并在需要时恢复该状态。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 备忘录模式的三大角色解析

2.1 Originator（发起人）

Originator是需要被保存状态的对象。它负责：

创建备忘录，记录当前时刻的内部状态
使用备忘录恢复内部状态

python复制class TextEditor:
    def __init__(self):
        self._content = ""
    
    def write(self, text):
        self._content += text
    
    def save(self):
        return TextEditorMemento(self._content)
    
    def restore(self, memento):
        self._content = memento.get_saved_content()
    
    def show_content(self):
        print(f"当前内容: {self._content}")

2.2 Memento（备忘录)

备忘录是存储Originator内部状态的对象。它通常有：

获取状态的接口（但通常只对Originator开放）
严格的访问控制，防止外部随意修改

python复制class TextEditorMemento:
    def __init__(self, content):
        self._saved_content = content
    
    def get_saved_content(self):
        return self._saved_content

2.3 Caretaker（管理者）

Caretaker负责保存备忘录，但它不能对备忘录的内容进行操作或检查。它只负责：

保存备忘录
提供备忘录给Originator用于恢复

python复制class History:
    def __init__(self):
        self._states = []
    
    def push(self, memento):
        self._states.append(memento)
    
    def pop(self):
        return self._states.pop()

3. Python实现备忘录模式的完整示例

下面是一个完整的文本编辑器示例，演示了备忘录模式的实际应用：

python复制# 备忘录
class TextEditorMemento:
    def __init__(self, content):
        self._content = content
    
    @property
    def content(self):
        return self._content

# 发起人
class TextEditor:
    def __init__(self):
        self._content = ""
    
    def type(self, text):
        self._content += text
    
    def save(self):
        return TextEditorMemento(self._content)
    
    def restore(self, memento):
        self._content = memento.content
    
    def __str__(self):
        return f"当前内容: {self._content}"

# 管理者
class History:
    def __init__(self):
        self._mementos = []
    
    def push(self, memento):
        self._mementos.append(memento)
    
    def pop(self):
        if not self._mementos:
            raise ValueError("没有可恢复的状态")
        return self._mementos.pop()

# 使用示例
if __name__ == "__main__":
    editor = TextEditor()
    history = History()
    
    editor.type("Hello, ")
    history.push(editor.save())
    print(editor)  # 输出: 当前内容: Hello, 
    
    editor.type("World!")
    print(editor)  # 输出: 当前内容: Hello, World!
    
    editor.restore(history.pop())
    print(editor)  # 输出: 当前内容: Hello,

4. 备忘录模式的进阶应用与优化

4.1 增量式备忘录

对于大型对象，完整保存所有状态可能效率低下。我们可以实现增量式备忘录，只保存变化的部分：

python复制class IncrementalMemento:
    def __init__(self, changes):
        self._changes = changes
    
    @property
    def changes(self):
        return self._changes

class DocumentEditor:
    def __init__(self):
        self._content = []
        self._version = 0
    
    def add_line(self, line):
        self._content.append(line)
        self._version += 1
    
    def save(self):
        return IncrementalMemento({
            'version': self._version,
            'last_line': self._content[-1] if self._content else None
        })
    
    def restore(self, memento):
        if memento.changes['version'] < self._version:
            self._content = self._content[:memento.changes['version']]
            self._version = memento.changes['version']

4.2 使用dict实现通用备忘录

Python的__dict__属性可以让我们创建一个通用的备忘录实现：

python复制class GenericMemento:
    def __init__(self, obj):
        self._state = obj.__dict__.copy()
    
    def restore(self, obj):
        obj.__dict__.update(self._state)

class AnyClass:
    def save(self):
        return GenericMemento(self)
    
    def restore(self, memento):
        memento.restore(self)

4.3 备忘录与序列化结合

对于需要持久化保存的状态，可以将备忘录与Python的序列化模块结合：

python复制import pickle

class SerializableMemento:
    def __init__(self, state):
        self._state = pickle.dumps(state)
    
    @property
    def state(self):
        return pickle.loads(self._state)

class GameCharacter:
    def __init__(self):
        self.level = 1
        self.health = 100
    
    def save(self):
        return SerializableMemento({
            'level': self.level,
            'health': self.health
        })
    
    def restore(self, memento):
        state = memento.state
        self.level = state['level']
        self.health = state['health']

5. 备忘录模式的优缺点与适用场景

5.1 优点

封装性保护：不暴露对象实现细节就能保存和恢复状态
简化Originator：将状态保存逻辑从业务逻辑中分离出来
可扩展性：可以轻松实现多级撤销/重做功能
状态快照：可以保存对象在任意时刻的状态

5.2 缺点

内存消耗：如果需要保存大量状态或频繁保存，可能消耗大量内存
性能考虑：大对象的序列化和反序列化可能影响性能
管理复杂性：需要仔细管理备忘录的生命周期

5.3 适用场景

需要撤销/重做功能：如文本编辑器、图形编辑器等
需要保存对象状态快照：如游戏存档、系统备份等
需要回滚操作：如事务处理系统
需要外部化对象状态：如检查点系统、持久化机制

6. 备忘录模式与其他设计模式的关系

6.1 与命令模式(Command Pattern)的关系

备忘录模式常与命令模式一起使用，实现可撤销的操作：

python复制class Command:
    def execute(self):
        pass
    
    def undo(self):
        pass

class AddTextCommand(Command):
    def __init__(self, editor, text):
        self._editor = editor
        self._text = text
        self._memento = None
    
    def execute(self):
        self._memento = self._editor.save()
        self._editor.type(self._text)
    
    def undo(self):
        self._editor.restore(self._memento)

6.2 与原型模式(Prototype Pattern)的关系

原型模式也可以用于保存对象状态，但它是通过克隆整个对象实现的：

python复制import copy

class PrototypeMemento:
    def __init__(self, obj):
        self._obj = copy.deepcopy(obj)
    
    def restore(self):
        return copy.deepcopy(self._obj)

6.3 与状态模式(State Pattern)的区别

状态模式关注的是对象行为的改变，而备忘录模式关注的是对象状态的保存和恢复。

7. Python中的备忘录模式最佳实践

7.1 使用装饰器简化备忘录实现

我们可以创建一个装饰器来自动为方法添加备忘录功能：

python复制def memento_method(func):
    def wrapper(self, *args, **kwargs):
        if not hasattr(self, '_mementos'):
            self._mementos = []
        self._mementos.append(self.save())
        result = func(self, *args, **kwargs)
        return result
    return wrapper

class Account:
    def __init__(self, balance=0):
        self.balance = balance
    
    def save(self):
        return AccountMemento(self.balance)
    
    def restore(self, memento):
        self.balance = memento.balance
    
    @memento_method
    def deposit(self, amount):
        self.balance += amount
    
    @memento_method
    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
        else:
            raise ValueError("余额不足")

7.2 使用上下文管理器管理备忘录

Python的上下文管理器非常适合用来管理备忘录的保存和恢复：

python复制class MementoContext:
    def __init__(self, originator):
        self.originator = originator
        self.memento = None
    
    def __enter__(self):
        self.memento = self.originator.save()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is not None:  # 如果发生异常，恢复状态
            self.originator.restore(self.memento)
        return False

# 使用示例
editor = TextEditor()
editor.type("Initial text")

try:
    with MementoContext(editor):
        editor.type(" - new text")
        raise ValueError("模拟异常")
except ValueError:
    print(editor)  # 输出: 当前内容: Initial text

7.3 使用weakref避免内存泄漏

当保存大量备忘录时，可以使用weakref来避免内存泄漏：

python复制import weakref

class WeakMemento:
    def __init__(self, state):
        self._state = weakref.ref(state) if hasattr(state, '__dict__') else state
    
    @property
    def state(self):
        return self._state() if callable(self._state) else self._state

8. 备忘录模式在实际项目中的应用案例

8.1 文本编辑器的撤销/重做功能

python复制class AdvancedTextEditor:
    def __init__(self):
        self._content = ""
        self._history = []
        self._redo_stack = []
    
    def write(self, text):
        self._history.append(self._content)
        self._content += text
        self._redo_stack.clear()
    
    def undo(self):
        if self._history:
            self._redo_stack.append(self._content)
            self._content = self._history.pop()
            return True
        return False
    
    def redo(self):
        if self._redo_stack:
            self._history.append(self._content)
            self._content = self._redo_stack.pop()
            return True
        return False

8.2 游戏角色状态保存

python复制class GameState:
    def __init__(self, level=1, health=100, inventory=None):
        self.level = level
        self.health = health
        self.inventory = inventory or []
    
    def save(self):
        return GameStateMemento(
            level=self.level,
            health=self.health,
            inventory=self.inventory.copy()
        )
    
    def restore(self, memento):
        self.level = memento.level
        self.health = memento.health
        self.inventory = memento.inventory.copy()

class GameStateMemento:
    def __init__(self, level, health, inventory):
        self.level = level
        self.health = health
        self.inventory = inventory

8.3 表单数据的自动保存与恢复

python复制class FormData:
    def __init__(self):
        self.fields = {}
        self._history = []
        self._current = -1
    
    def update_field(self, name, value):
        if self._current < len(self._history) - 1:
            self._history = self._history[:self._current + 1]
        self._history.append((name, value, self.fields.copy()))
        self._current += 1
        self.fields[name] = value
    
    def undo(self):
        if self._current > 0:
            self._current -= 1
            _, _, state = self._history[self._current]
            self.fields = state.copy()
    
    def redo(self):
        if self._current < len(self._history) - 1:
            self._current += 1
            name, value, _ = self._history[self._current]
            self.fields[name] = value

9. 备忘录模式的性能优化策略

9.1 懒加载备忘录

对于大型对象，可以实现懒加载的备忘录：

python复制class LazyMemento:
    def __init__(self, state_getter):
        self._state_getter = state_getter
        self._state = None
    
    @property
    def state(self):
        if self._state is None:
            self._state = self._state_getter()
        return self._state

class BigObject:
    def __init__(self, data):
        self.data = data
    
    def save(self):
        return LazyMemento(lambda: {'data': self.data.copy()})
    
    def restore(self, memento):
        self.data = memento.state['data']

9.2 差分备忘录

只保存状态的变化部分，而不是整个状态：

python复制class DiffMemento:
    def __init__(self, changes):
        self._changes = changes
    
    @property
    def changes(self):
        return self._changes

class ConfigManager:
    def __init__(self):
        self.config = {}
        self._version = 0
    
    def set_value(self, key, value):
        old_value = self.config.get(key, None)
        if old_value != value:
            self._version += 1
            return DiffMemento({
                'version': self._version,
                'key': key,
                'old_value': old_value,
                'new_value': value
            })
        return None
    
    def apply_change(self, memento):
        if memento.changes['new_value'] is None:
            self.config.pop(memento.changes['key'], None)
        else:
            self.config[memento.changes['key']] = memento.changes['new_value']
    
    def revert_change(self, memento):
        if memento.changes['old_value'] is None:
            self.config.pop(memento.changes['key'], None)
        else:
            self.config[memento.changes['key']] = memento.changes['old_value']

9.3 备忘录池模式

对于频繁创建和销毁的备忘录，可以使用对象池技术：

python复制class MementoPool:
    def __init__(self, max_size=100):
        self._pool = []
        self._max_size = max_size
    
    def acquire(self, state):
        if self._pool:
            memento = self._pool.pop()
            memento._state = state
            return memento
        return SimpleMemento(state)
    
    def release(self, memento):
        if len(self._pool) < self._max_size:
            memento._state = None
            self._pool.append(memento)

class SimpleMemento:
    def __init__(self, state):
        self._state = state
    
    @property
    def state(self):
        return self._state

10. 备忘录模式的测试策略

10.1 单元测试备忘录功能

python复制import unittest

class TestMementoPattern(unittest.TestCase):
    def setUp(self):
        self.editor = TextEditor()
        self.history = History()
    
    def test_single_save_restore(self):
        self.editor.type("Hello")
        memento = self.editor.save()
        self.editor.type(", World!")
        self.editor.restore(memento)
        self.assertEqual(str(self.editor), "当前内容: Hello")
    
    def test_multiple_saves(self):
        self.editor.type("A")
        self.history.push(self.editor.save())
        self.editor.type("B")
        self.history.push(self.editor.save())
        self.editor.type("C")
        
        self.editor.restore(self.history.pop())
        self.assertEqual(str(self.editor), "当前内容: AB")
        
        self.editor.restore(self.history.pop())
        self.assertEqual(str(self.editor), "当前内容: A")
    
    def test_empty_history(self):
        with self.assertRaises(ValueError):
            self.history.pop()

if __name__ == '__main__':
    unittest.main()

10.2 性能测试备忘录实现

python复制import timeit

def test_memento_performance():
    editor = TextEditor()
    history = History()
    
    def operation():
        editor.type("a")
        history.push(editor.save())
    
    return timeit.timeit(operation, number=1000)

print(f"1000次保存操作耗时: {test_memento_performance():.4f}秒")

10.3 内存使用测试

python复制import sys

def test_memento_memory():
    editor = TextEditor()
    history = History()
    
    editor.type("初始内容")
    for i in range(100):
        editor.type(f" 新增内容{i}")
        history.push(editor.save())
    
    return sys.getsizeof(history)

print(f"100个备忘录占用的内存: {test_memento_memory()}字节")

11. 备忘录模式在Python框架中的应用

11.1 Django中的备忘录模式

Django的migration系统实际上使用了备忘录模式的思想：

python复制# 类似Django Migration的实现
class Migration:
    def __init__(self, name):
        self.name = name
        self.operations = []
    
    def add_operation(self, operation):
        self.operations.append(operation)
    
    def apply(self, project_state):
        new_state = project_state.clone()
        for operation in self.operations:
            new_state = operation.apply(new_state)
        return new_state
    
    def unapply(self, project_state):
        new_state = project_state.clone()
        for operation in reversed(self.operations):
            new_state = operation.unapply(new_state)
        return new_state

class ProjectState:
    def __init__(self, models=None):
        self.models = models or {}
    
    def clone(self):
        return ProjectState(self.models.copy())

11.2 Flask中的上下文管理

Flask的请求上下文和应用上下文管理也体现了备忘录模式：

python复制class RequestContext:
    def __init__(self, app, environ):
        self.app = app
        self.request = Request(environ)
        self.session = None
        self._implicit_app_ctx_stack = []
    
    def push(self):
        self._preserve_context_state()
        # ... 实际push操作
    
    def pop(self):
        self._restore_context_state()
        # ... 实际pop操作
    
    def _preserve_context_state(self):
        self._saved_state = {
            'session': self.session,
            # 保存其他需要保存的状态
        }
    
    def _restore_context_state(self):
        self.session = self._saved_state['session']
        # 恢复其他状态

11.3 PyQt中的撤销框架

PyQt提供了QUndoStack和QUndoCommand类，实现了备忘录模式：

python复制from PyQt5.QtWidgets import QUndoCommand

class AddTextCommand(QUndoCommand):
    def __init__(self, document, text, parent=None):
        super().__init__(parent)
        self.document = document
        self.text = text
        self.old_text = ""
    
    def redo(self):
        self.old_text = self.document.text()
        self.document.setText(self.old_text + self.text)
    
    def undo(self):
        self.document.setText(self.old_text)

12. 备忘录模式的替代方案

12.1 使用序列化模块

Python的pickle模块可以作为一种简单的备忘录实现：

python复制import pickle

class PickleMemento:
    def __init__(self, obj):
        self._data = pickle.dumps(obj.__dict__)
    
    def restore(self, obj):
        obj.__dict__.update(pickle.loads(self._data))

class SimpleObject:
    def save(self):
        return PickleMemento(self)
    
    def restore(self, memento):
        memento.restore(self)

12.2 使用装饰器保存函数状态

对于函数式编程，可以使用装饰器保存函数调用状态：

python复制def memoize(func):
    cache = {}
    
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    
    return wrapper

@memoize
def expensive_computation(x):
    print(f"计算 {x}...")
    return x * x

12.3 使用生成器实现状态保存

Python生成器可以自动保存执行状态：

python复制def stateful_process():
    state = 0
    while True:
        new_state = yield state
        if new_state is not None:
            state = new_state

processor = stateful_process()
next(processor)  # 启动生成器
print(processor.send(10))  # 输出: 10
print(processor.send(20))  # 输出: 20

13. 备忘录模式与Python特性的结合

13.1 使用描述符实现自动备忘录

python复制class MementoDescriptor:
    def __init__(self, name):
        self.name = name
        self.history = []
    
    def __get__(self, obj, objtype):
        if obj is None:
            return self
        return getattr(obj, f"_{self.name}")
    
    def __set__(self, obj, value):
        if hasattr(obj, f"_{self.name}"):
            self.history.append(getattr(obj, f"_{self.name}"))
        setattr(obj, f"_{self.name}", value)
    
    def undo(self, obj):
        if self.history:
            setattr(obj, f"_{self.name}", self.history.pop())

class Document:
    content = MementoDescriptor('content')
    
    def __init__(self):
        self.content = ""

doc = Document()
doc.content = "第一版"
doc.content = "第二版"
doc.content = "第三版"

doc.content.undo(doc)  # 恢复到"第二版"

13.2 使用元类自动添加备忘录功能

python复制class MementoMeta(type):
    def __new__(cls, name, bases, namespace):
        def save(self):
            return {k: v for k, v in self.__dict__.items() if not k.startswith('_')}
        
        def restore(self, state):
            for k, v in state.items():
                setattr(self, k, v)
        
        namespace['save'] = save
        namespace['restore'] = restore
        return super().__new__(cls, name, bases, namespace)

class AutoMemento(metaclass=MementoMeta):
    pass

class Config(AutoMemento):
    def __init__(self):
        self.value = 0
        self.name = "default"

13.3 使用上下文变量保存状态

Python 3.7+的contextvars模块可以用于保存上下文状态：

python复制from contextvars import ContextVar, copy_context

editor_state = ContextVar('editor_state', default="")

def edit_text(new_text):
    token = editor_state.set(new_text)
    try:
        print(f"编辑中: {editor_state.get()}")
    finally:
        editor_state.reset(token)

ctx = copy_context()
ctx.run(edit_text, "第一版")
ctx.run(edit_text, "第二版")

14. 备忘录模式在并发环境中的注意事项

14.1 线程安全的备忘录实现

python复制import threading

class ThreadSafeMemento:
    def __init__(self, state):
        self._state = state
        self._lock = threading.Lock()
    
    @property
    def state(self):
        with self._lock:
            return self._state
    
    @state.setter
    def state(self, value):
        with self._lock:
            self._state = value

class ConcurrentEditor:
    def __init__(self):
        self._content = ""
        self._history = []
        self._lock = threading.Lock()
    
    def write(self, text):
        with self._lock:
            self._history.append(self._content)
            self._content += text
    
    def undo(self):
        with self._lock:
            if self._history:
                self._content = self._history.pop()
                return True
            return False

14.2 异步环境中的备忘录

在异步环境中，需要考虑状态的一致性问题：

python复制import asyncio

class AsyncMemento:
    def __init__(self, state):
        self._state = state
    
    async def get_state(self):
        await asyncio.sleep(0)  # 模拟异步操作
        return self._state

class AsyncEditor:
    def __init__(self):
        self._content = ""
        self._history = []
    
    async def write(self, text):
        self._history.append(self._content)
        await asyncio.sleep(0)  # 模拟异步操作
        self._content += text
    
    async def undo(self):
        if self._history:
            self._content = self._history.pop()
            return True
        return False

14.3 多进程环境中的备忘录

在多进程环境中，备忘录需要支持序列化：

python复制import multiprocessing

class ProcessSafeMemento:
    def __init__(self, state):
        self._state = state
    
    def __getstate__(self):
        return self._state
    
    def __setstate__(self, state):
        self._state = state

def worker(memento_queue):
    memento = memento_queue.get()
    print(f"工作进程恢复状态: {memento._state}")

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    memento = ProcessSafeMemento("初始状态")
    queue.put(memento)
    
    p = multiprocessing.Process(target=worker, args=(queue,))
    p.start()
    p.join()

15. 备忘录模式的高级应用：时间旅行调试

备忘录模式可以用于实现时间旅行调试功能：

python复制class TimeTravelDebugger:
    def __init__(self, target):
        self.target = target
        self._timeline = []
        self._current = -1
    
    def checkpoint(self):
        if self._current < len(self._timeline) - 1:
            self._timeline = self._timeline[:self._current + 1]
        memento = self.target.save()
        self._timeline.append(memento)
        self._current += 1
    
    def rewind(self, steps=1):
        if steps <= 0 or self._current - steps < 0:
            return False
        
        self._current -= steps
        self.target.restore(self._timeline[self._current])
        return True
    
    def forward(self, steps=1):
        if steps <= 0 or self._current + steps >= len(self._timeline):
            return False
        
        self._current += steps
        self.target.restore(self._timeline[self._current])
        return True
    
    def goto(self, index):
        if 0 <= index < len(self._timeline):
            self._current = index
            self.target.restore(self._timeline[self._current])
            return True
        return False

# 使用示例
editor = TextEditor()
debugger = TimeTravelDebugger(editor)

editor.type("A")
debugger.checkpoint()
editor.type("B")
debugger.checkpoint()
editor.type("C")
debugger.checkpoint()

debugger.rewind(2)  # 回到只有"A"的状态
debugger.forward(1)  # 前进到"AB"状态