检查一个实例的状态变化

使用情景：

　　一个实例在上次“保存”操作之后又被修改了，需要检查它的状态变化以便有选择的保存此实例。

解决方案：

　　一个有效的解决方案是创建一个mixin类，这个类可以从多个类继承并能对一个实例的状态进行快照操作，这样就可以用此实例的当前状态和上次的快照做比较了，来判断是否被修改过了。

import copy
class ChangeCheckerMixin:
    containerItems = {dict: dict.iteritems, list: enumerate}
    immutable = False
    def snapshot(self):
                '''创建self状态的快照',就像浅拷贝，但只对容器的类型进行递归。。''
        if self.immutable:
            return
        self._snapshot = self._copy_container(self.__dict__)
    def makeImmutable(self):
                '''实例状态无法被修改 设置.immutable'''
        self.immutable = True
        try:
            del sekf._snapshot
        except AttributeError:
            pass
    def _copy_container(self, container):
                '''对容器类型拷贝'''
        new_container = copy.copy(container)
        for k, v in self.containerItems[type(new_container)](new_container):
            if type(v) in self.containerItems:
                new_container[k] = self._copy_container(v)
            elif hasattr(v, 'snapshot'):
                v.snapshot()
        return new_container
    def isChanged(self):
        if self.immutable:
            return False
        snap = self.__dict__.pop('_snapshot', None)
        if snap is None:
            return True
        try:
            return self._checkContainer(self.__dict__, snap)
        finally:
            self._snapshot = snap
    def _checkContainer(self, container, snapshot):
        if len(container) != len(snapshot):
            return True
        for k, v in self.containerItems[type(container)](container):
            try:
                ov = snapshot[k]
            except LookUpError:
                return True
            if self._checkItem(v, ov):
                return True
        return False
    def _checkItem(self, newitem, olditem):
                '''比较新旧元素，如果它们是容器类型，递归调用self._checkContainer'''
        if type(newitem) != type(olditem):
            return True
        if type(newitem) in self.containerItems:
            return self._checkContainer(newitem, olditem)
        if newitem is olditem:
            method_isChanged = getattr(newitem, 'isChanged', None)
            if method_isChanged is None:
                return False
            return method_isChanged
        return newitem != olditem
        
        
if __name__ == '__main__':
    class eg(ChangeCheckerMixin):
        def __init__(self, *arg, **kwargs):
            self.L = list(*arg, **kwargs)
        def __str__(self):
            return 'eg(%s)' % str(self.L)
        def __getattr__(self, a):
            return getattr(self.L, a)
    X = eg('ciao')
    print 'x =',X,'is changed =', X.isChanged()
    X.snapshot()
    print 'x =',X,'is changed =', X.isChanged()
    X.append('x')
    print 'x =',X,'is changed =', X.isChanged()                

最后输入结果如下图：

　　

在eg类中只是从ChangeCheckerMixin派生，因为不需要其他基类。即使从list派生也没什么用处，因为状态检查功能只能被用于那些保存在实例的字典里的状态。所以必须将一个list对象放在实例的字典中，并根据情况将某些任务委托给它，（上述示例中通过__getattr__委托了所有的非特殊方法），这样就可以看到isChanged方法能够敏锐反映出任何细微的改变。