为了1%情形，牺牲99%情形下的性能:蜗牛般的Python深拷贝

最近使用 Python 一个项目，发现 Python 的深拷贝 copy.deepcopy 实在是太慢了。

创新互联建站提供网站设计制作、成都网站建设、网页设计，成都品牌网站建设，广告投放等致力于企业网站建设与公司网站制作，十载的网站开发和建站经验,助力企业信息化建设，成功案例突破上1000+,是您实现网站建设的好选择.

相关背景

在 Python 中, 我们有两种拷贝对象的方式：浅拷贝和深拷贝。浅拷贝和深拷贝都可以在 copy 模块中找到, 其中 copy.copy() 进行浅拷贝操作, copy.deepcopy() 进行深拷贝操作。浅拷贝是在另一块地址中创建一个新的对象，但是新对象内的子对象引用指向源对象的子对象。如果这时候我们修改源对象的子对象的属性, 新对象中子对象的属性也会改变。为了获取一个和源对象没有任何关系的全新对象，我们需要深拷贝。深拷贝是在另一块地址中创建一个新的对象，同时对象内的子对象也是新开辟的，和源对象对比仅仅是值相同。

下面用一个例子说明浅拷贝和深拷贝的区别，下面的代码将输出 "b [2,2,3]" 和 "c [1,2,3]"。

 
 
 
 
    
  
  
  
  
  1. import copyclass A: 
    2. 
  
  
  
  
  2.    def __init__(self): 
    3. 
  
  
  
  
  3.     array = [1,2,3] 
    4. 
  
  
  
  
  4. a = A() 
    5. 
  
  
  
  
  5. b = copy.copy(a) 
    6. 
  
  
  
  
  6. c = copy.deepcopy(a) 
    7. 
  
  
  
  
  7. a.array[0] = 2 
    8. 
  
  
  
  
  8. print "b",b.array 
    9. 
  
  
  
  
  9. print "c",c.array 
    10.

b 是由 a 浅拷贝而来，c 是由 a 深拷贝而来。修改 a.array 之后， b.array 也随之发生变化。其实 a.array 和 b.array 指向同一个对象。而 c.array 则保持原样。

深拷贝比浅拷贝符合人类的直觉，代价就是深拷贝实在是太慢了。下面代码中，case1 和 case2 是等价的。在我的机器上测试，case1 不到一秒，而 case2 则达到了 十秒。那么深拷贝为什么那么慢呢?

 
 
 
 
    
  
  
  
  
  1. import copyclass A: 
    2. 
  
  
  
  
  2.    def __init__(self): 
    3. 
  
  
  
  
  3.        array = [1,2,3] 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. a = [A() for i in xrange(100000)] 
    6. 
  
  
  
  
  6. a[10].array[0] = 100 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8. ### case1 
    9. 
  
  
  
  
  9. b = [A() for i in xrange(100000)] 
    10. 
  
  
  
  
  10. for i in xrange(100000): 
    11. 
  
  
  
  
  11.     for j in xrange(3): 
    12. 
  
  
  
  
  12.        b[i].array[j] = a[i].array[j] 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. ### case2 
    15. 
  
  
  
  
  15. c = copy.deepcopy(a) 
    16.

深拷贝分析

为了搞清楚为什么 Python 深拷贝这么慢，我阅读了下 Python 2.7 版本的 copy.deepcopy 的实现: https://github.com/python/cpython/blob/2.7/Lib/copy.py。其大体结构为:

 
 
 
 
    
  
  
  
  
  1. def deepcopy(x, memo=None, _nil=[]): 
    2. 
  
  
  
  
  2.     if memo is None: 
    3. 
  
  
  
  
  3.         memo = {} 
    4. 
  
  
  
  
  4.     d = id(x) 
    5. 
  
  
  
  
  5.     y = memo.get(d, _nil) 
    6. 
  
  
  
  
  6.     if y is not _nil: 
    7. 
  
  
  
  
  7.         return y 
    8. 
  
  
  
  
  8.   
    9. 
  
  
  
  
  9.     cls = type(x) 
    10. 
  
  
  
  
  10.   
    11. 
  
  
  
  
  11.     copier = _deepcopy_dispatch.get(cls) 
    12. 
  
  
  
  
  12.     if copier: 
    13. 
  
  
  
  
  13.         y = copier(x, memo) 
    14. 
  
  
  
  
  14.     else: 
    15. 
  
  
  
  
  15.         ... ## 其他特殊的拷贝方式 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.     memo[d] = y 
    18. 
  
  
  
  
  18.     return y 
    19.

其中 memo 保存着所有拷贝过的对象。为什么要设置 memo 呢?在某些特殊情况下，一个对象的相关对象可以指向它自己，比如双向链表。如果不将拷贝过的对象存着，那程序将陷入死循环。另外一个值得注意的点是 _deepcopy_dispatch，这行代码根据待拷贝对象的类型，选择相应的拷贝函数。可选的拷贝函数有：用于拷贝基本数据类型的 _deepcopy_atomic, 用于拷贝列表的 _deepcopy_list，用于拷贝元组 _deepcopy_tuple，用于拷贝字典 的 _deepcopy_dict，用于拷贝自定义对象的 _deepcopy_inst 等等。其中比较重要的拷贝函数 __deepcopy_inst 代码如下所示：如果对象有 _ _ deepcopy _ _ 函数，则使用该函数进行拷贝;如果没有，那么先拷贝初始构造参数，然后构造一个对象，再拷贝对象状态。

 
 
 
 
    
  
  
  
  
  1. def _deepcopy_inst(x, memo): 
    2. 
  
  
  
  
  2.     if hasattr(x,'__deepcopy__'): 
    3. 
  
  
  
  
  3.         return x.__deepcopy__(memo) 
    4. 
  
  
  
  
  4.     if hasattr(x,'__getinitargs__'): 
    5. 
  
  
  
  
  5.         args = x.__getinitargs__() 
    6. 
  
  
  
  
  6.         args = deepcopy(args, memo) 
    7. 
  
  
  
  
  7.         y = x.__class__(*args) 
    8. 
  
  
  
  
  8.     else: 
    9. 
  
  
  
  
  9.         y = _EmptyClass() 
    10. 
  
  
  
  
  10.         y.__class__ = x.__class__ 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.     memo[id(x)] = y     
    13. 
  
  
  
  
  13.     if hasattr(x, '__getstate__'): 
    14. 
  
  
  
  
  14.         state = x.__getstate__() 
    15. 
  
  
  
  
  15.     else: 
    16. 
  
  
  
  
  16.         state = x.__dict__ 
    17. 
  
  
  
  
  17.     state = deepcopy(state, memo) 
    18. 
  
  
  
  
  18.     if hasattr(y, '__setstate__'): 
    19. 
  
  
  
  
  19.         y.__setstate__(state) 
    20. 
  
  
  
  
  20.     else: 
    21. 
  
  
  
  
  21.         y.__dict__.update(state) 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.     return y 
    24.

深拷贝需要维护一个 memo 用于记录已经拷贝的对象，这是它比较慢的原因。在绝大多数情况下，程序里都不存在相互引用。但作为一个通用的模块，Python 深拷贝必须为了这 1% 情形，牺牲 99% 情形下的性能。

一个场景

上面给出了深拷贝效率对比的结果，已经可以看出深拷贝很慢了，但没有办法直观感受深拷贝拖累整个程序的运行速度。下面给一个实际项目的例子，最近在写的一些游戏环境。玩家程序获得游戏环境给出的信息，当前玩家程序选择合适的动作，游戏环境根据该动作推进游戏逻辑;重复上述过程，直到分出胜负;整个过程如下所示。给玩家程序的信息必须从游戏环境深拷贝出来。如果给玩家的信息是从游戏环境浅拷贝出来的，那么玩家程序有可能通过信息获取游戏秘密或者操纵游戏。

我们已经知道默认的深拷贝很慢。为了改进深拷贝的效率，我们在信息类以及相关类都添加了 _ _ deepcopy _ _ 函数，下面是信息类示例。

 
 
 
 
    
  
  
  
  
  1. class FiveCardStudInfo(roomai.abstract.AbstractInfo): 
    2. 
  
  
  
  
  2.     public_state  = None 
    3. 
  
  
  
  
  3.     person_state  = None 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.     def __deepcopy__(self, memodict={}): 
    6. 
  
  
  
  
  6.         info = FiveCardStudInfo() 
    7. 
  
  
  
  
  7.         info.public_state = self.public_state.__deepcopy__() 
    8. 
  
  
  
  
  8.         info.public_state = self.person_state.__deepcopy__() 
    9. 
  
  
  
  
  9.         return info 
    10.

简单做了一个效率对比实验：让随机玩法玩家打一千局梭哈，统计耗时。实验结果如下所示。

使用原始深拷贝，程序运行时间为 143 秒，其中深拷贝时间 134 秒，深拷贝时间占整个程序时间的 94%。使用了改进深拷贝，程序运行时间是 23 秒，其中深拷贝时间 16 秒，占比为 69 %。虽然深拷贝依然占到了 69%，相比之间 94 % 已经下降很多。整个程序运行时间也从 134 秒减少到 23 秒了。

总结

Python 的深拷贝很慢，原因在于深拷贝需要维护一个 memo 用于记录已经拷贝的对象。而维护这个 memo 的原因是为了避免相互引用造成的死循环。但作为一个通用的模块，Python 深拷贝必须为了这 1% 情形，牺牲 99% 情形下的性能。我们可以通过自己实现 _ _ deepcopy _ _ 函数来改进其效率。

【本文为专栏作者“李立”的原创稿件，转载请通过获取联系和授权】

当前名称：为了1%情形，牺牲99%情形下的性能:蜗牛般的Python深拷贝
当前URL：http://www.shufengxianlan.com/qtweb/news9/17859.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

电子商务知识

分类信息网

高端网站设计　　 　四川航空文化　　 　成都网站维护　　 　达州做网站　　 　公路打桩机　　 　成都谷歌推广　　 　成都木托盘　　 　成都商城开发　　 　四川雅安服务器托管　　 　合江网站建设　　 　平城网站运维　　 　小谭网创广告　　 　名片　　 　大英泰恒网站　　 　自贡主机托管　　 　泸州网站建设　　 　雪茄烟品牌　　 　服务器托管　　 　证企宝　　 　成都茶叶销售