每日一“酷”之copy

Copy – 复制对象

作用：提供一些函数，可以使用浅副本或深副本语义复制对象。

copy模块包括两个函数copy()和deepcopy(),用于复制现有的对象

1、  浅副本

copy()创建的浅副本（shallow copy）是一个新容器，其中填充原对象内容的引用。建立list对象的一个浅副本时，会构造一个新的list,并将原对象的元素追加到这个list。

import copy

class MyClass(object):
    def __init__(self,name):
        self.name = name
    def __cmp__(self,other):
        return cmp(self.name,other.name)
 
a = MyClass('a')
my_lt = [a]
dup = copy.copy(my_lt) 
print '             my_lt:',my_lt
print '               dup:',dup
print '      dup is my_lt:',(dup is my_lt)
print '      dup == my_lt:',(dup == my_lt)
print 'dup[0] is my_lt[0]:',(dup[0] is my_lt[0])
print 'dup[0] == my_lt[0]:',(dup[0] == my_lt[0])

运行结果：

__cmp__（） 在比较类实例时被调用

对于一个浅副本，不会复制Myclass实例，所以dup列表中的引用会指向my_lt中相同的对象

2、  深副本

deepcopy（）创建的深副本是一个新的容器,其中填充源对象内容的副本.要建立一个list的深副本，会构成一个新的list，复制原列表的元素，然后将这些副本追加到新列表。

import copy

class MyClass(object):
    def __init__(self,name):
        self.name = name
    def __cmp__(self,other):
        return cmp(self.name,other.name)
 
a = MyClass('a')
my_lt = [a]
dup = copy.deepcopy(my_lt) 
print '             my_lt:',my_lt
print '               dup:',dup
print '      dup is my_lt:',(dup is my_lt)
print '      dup == my_lt:',(dup == my_lt)
print 'dup[0] is my_lt[0]:',(dup[0] is my_lt[0])
print 'dup[0] == my_lt[0]:',(dup[0] == my_lt[0])

运行结果：
　　

3、  定制复制行为

可以使用特殊方法__copy__() 和__deepcopy__()来控制如何建立副本。

·调用__copy__()而不提供任何参数，这会返回对象的一个浅副本。

·调用__deepcopy__()，并提供一个北方字典，这回返回对象的一个深副本。所有需要深复制的成员属性都要连同备忘字典传递到copy.deepcopy()来控制递归。

例如：

import copy

class MyClass(object):
    def __init__(self,name):
        self.name = name
    def __cmp__(self,other):
        return cmp(self.name,other.name)
    def __copy__(self):
        print '__copy__()'
        return MyClass(self.name)
    def __deepcopy__(self,memo):
        print '__deepcopy__(%s)' % str(memo)
        return MyClass(copy.deepcopy(self.name, memo,))

a = MyClass('a')
sc = copy.copy(a)
dc = copy.deepcopy(a)

运行结果：

　　

备忘字典用于跟踪已复制的值，以避免无限递归

4、  深副本中的递归

为了避免复制递归数据结构可能带来的问题，deepcopy()使用一个字典来跟踪已复制的对象。将这个歌字典传入__deepcopy__() 方法，从而在该方法中也可以进行检查。

下面的例子显示了一个互连的数据结构（如图1）可以通过实现__deepcopy__()方法帮助防止递归。

                     图1

class Graph(object):
    
    def __init__(self,name,connections):
        self.name = name
        self.connections = connections
    def add_connections(self,other):
        self.connections.append(other)
    
    def __repr__(self):
        return 'Graph(name=%s,id=%s)' % (self.name,id(self))
    def __deepcopy__(self,memo):
        print '
Calling __deepcopy__ for %r' % self
        if self in memo:
            existing = memo.get(self)
            print '   Already copied to %r' % existing
            return existing
        print '   Memo dictionary'
        pprint.pprint(memo,indent=4,width=40)
        dup = Graph(copy.deepcopy(self.name, memo),[])
        print '   Copying to new object %s' % dup
        memo[self] = dup
        for c in self.connections:
            dup.add_connections(copy.deepcopy(c, memo))
        return dup

root = Graph('root',[])
a = Graph('a',[root])
b = Graph('b',[a,root])
root.add_connections(a)
root.add_connections(b)

dup = copy.deepcopy(root)

　　Graph类包含一些基本的有向图方法。基于一个名和已连接的现有节点的一个列表可以初始化一个Graph实例。add_connection()方法用于建立双向谅解deepcopy也用到了这个方法__deepcopy__()方法将打印消息来显示它如何得到调用，

并根据需要管理备忘录字典内容。它不是复制整个链接列表，而是创建一个新的列表，把各个连接的副本追加到这个列表。这样可以确保复制各个新节点时会更新备忘录字典，以免递归问题或多余的节点副本。与前面一样，完成时会返回复制的对象。

           如图1 中存在几个环，不过利用备忘录字典处理递归就可以避免遍历导致栈溢出错误。复制根节点root时，输入如下：

 　　　　

           第二次遇到root节点时，此时正在复制a节点，__deepcopy__()检测到递归，会重用备忘录字典中现有的值，而不是创建一个新对象。