展开全文

与浅拷贝对应的就是深拷贝，我们可以看到，当 a[2] 当中插入元素的时候，深度拷贝出来的 b 并不会发生对应的变化。

memento

利用拷贝，我们可以实现 memento 函数。 它的作用是给对象做备份。在Python 当中，对于一个对象 obj 来说，它所有的成员以及函数等信息全是储存在obj.__dict__这个dict 当中的。也就是说如果我们将一个对象的__dict__拷贝一份的话，其实就相当于我们把对象拷贝了一份。

通过使用拷贝，我们可以很容易实现 memento 函数，先来看代码：

defmemento(obj, deep=False): state = deepcopy(obj.__dict__) ifdeep elsecopy(obj.__dict__)

defrestore: obj.__dict__.clearobj.__dict__.update(state)returnrestore

memento 是一个高阶函数，它返回的结果是执行函数，而不是具体的执行结果。如果对高阶函数不太熟悉的同学，可以去回顾一下 Python 当中高阶函数的相关内容。

这里面的逻辑不难理解，传入的参数是一个 obj 的对象和一个 bool 型的flag。flag 表示使用深拷贝或浅拷贝， obj 就是我们需要做对应快照或者是存档的对象。我们希望在对象框架不变的基础上恢复其中的内容，所以我们拷贝的范围很明确，就是 obj.__dict__，这当中存储了对象的所有关键信息。

我们看下 restore 这个函数，当中的内容其实很简单，只有两行。

第一行是清空 obj 目前__dict__当中的内容，第二步是用之前保存的 state 来还原。其实 restore 执行的是一个回滚 obj 的功能，我们捋一下整个过程。

我们运行 memento 函数会得到 restore 这个函数，当我们执行这个函数的时候，obj 当中的内容会回滚到上次执行 memento 时的状态。

理解了 memento 当中的逻辑之后，距离我们实现事务就不远了。关于事务我们有两种实现方法， 一种是通过对象，一种是通过装饰器，我们一个一个来说吧。

Transaction对象

面向对象实现的方式比较简单，它和我们平时使用事务的过程也比较近似。Transaction 对象当中应该提供两个函数，一个是 commit 一个是rollback。也就是说当我们执行成功之后我们执行 commit，对执行的结果进行快照。如果执行失败则 rollback，将对象的结果回滚到上一次 commit时的状态。

我们理解了 memento 函数之后，会发现 commit 和 rollback 刚好对应执行 memento 函数以及执行 restore 函数。这样我们不难写出代码：

deep = Falsestates = []

def__init__( self, deep, *targets) : self.deep = deep self.targets = targets self.commit

defcommit( self) : self.states = [memento(target, self.deep) fortarget inself.targets]

defrollback( self) : fora_state inself. states:a_state

由于我们需要事务的对象可能不止一个，所以这里的 targets 设计成了数组的形式。

Transaction装饰器

我们也可以把事务实现成装饰器，这样我们可以 通过注解的方式来使用。

这里的代码原理也是一样的，只不过实现逻辑基于装饰器而已。如果对装饰器熟悉的同学，其实也不难理解。这里的 args[0] 其实就是某一个类的实例，也就是我们需要保证事务的主体。

deftransactional(func): @wraps(func)defwrapper(*args, **kwargs): # args[0] is objstate = memento(args[ 0]) try: func(*args, **kwargs)exceptException ase: stateraisee returnwrapper

这是常规装饰器的写法，当然我们也可以用类来实现装饰器，其实原理差不多，只是有一些细节不太一样。

def__init__(self, method): self.method = method

def__get__(self, obj, cls): deftransaction(*args, **kwargs): state = memento(obj)try: returnself.method(*args, **kwargs) exceptException ase: stateraisee returntransaction

当我们将这个注解加在某一个类方法上，当我们执行 obj.xxx 的时候，就会执行 Transactional 这个类中的__get__方法，而不是获得 Transactional 这个类。并且把 obj 以及 obj 对应的类型作为参数传入，也就是这里的 obj 和 cls 的含义。这个是用类来实现装饰器的常规做法，我们贴一下常规的代码，来比较学习一下。

def__call__( self, *args, **kwargs) : returnself.__wrapped_ _(*args, **kwargs)

def__get__( self, instance, cls) : ifinstance is None:returnselfelse:returntypes.MethodType( self, instance)

这是一个用类来实现装饰器的 case，我们可以看到在__get__这个函数当中返回的是 self，也就是返回了 Wrapper 这个类。类通常是不能直接执行的，为了让它能够执行，这里给它实现了一个__call__函数。用类实现装饰器也不常见，我们熟悉高阶函数的方法就可以了。

实战

最后我们来看一个实际应用的例子，我们实现了一个 NumObj 的类，兼容了上面两种事务的使用，可以对比一下看看区别。

def__repr__(self): return‘<%s, %r>’% (self.__class__.__name__, self.value)

defincrement(self): self.value += 1

@transactionaldefdo_stuff(self): self.value += ‘111’self.incrementif__name__ == ‘__main__’: num_obj = NumObj( -1)

a_transaction = Transaction( True, num_obj) # 使用Transactiontry: fori inrange( 3): num_obj.incrementprint(num_obj)

a_transaction.commitprint( ‘—-committed’) fori inrange( 3): num_obj.incrementprint(num_obj)num_obj.value += ‘x’print(num_obj)exceptException: a_transaction.rollbackprint( ‘—-rollback’)

print(num_obj)# 使用Transactionalprint( ‘– now doing stuff’) num_obj.increment

try: num_obj.do_stuffexceptException: print( ‘-> doing stuff failed’) importsys importtraceback traceback.print_exc(file=sys.stdout)

print(num_obj)

从代码当中，我们不难发现对于 Transaction 也就是面向对象实现的，我们需要额外创建一个 Transaction 的实例来在 try catch 当中控制是否执行回滚。而使用注解的方式更加灵活，它执行失败会自动执行回滚，不需要太多的额外操作。

一般来说我们更加喜欢使用注解的方式，因为这样的方式更加 简洁干净，更加 pythonic，能够体现出 Python 的强大。第一种方法显得有些中规中矩，不过好处是 可读性强一些， 代码实现难度也低一些。

大家如果在实际工作当中有需要用到，可以根据自己的实际情况去进行选择，两种都是不错的方法。

今天的文章就到这里，衷心祝愿大家每天都有所收获。