python模块 - copy模块

落日映苍穹つ 2022-08-08 12:58 359阅读 0赞

http://[blog.csdn.net/pipisorry/article/details/45830941][blog.csdn.net_pipisorry_article_details_45830941]

## copy模块之浅拷贝与深拷贝 ##

copy模块用于对象的拷贝操作。该模块只提供了两个主要的方法：copy.copy与copy.deepcopy，分别表示浅复制与深复制。

### 直接赋值，深拷贝和浅拷贝的区别 ###

直接赋值：简单地拷贝对象的引用，两个对象的id相同。就是对象的引用（别名），就是给当前内存中的对象增加一个“标签”而已。通过使用内置函数 id() ，可以看出指向内存中同一个对象。

浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。即浅复制只复制对象本身，没有复制该对象所引用的对象。A *shallow copy* constructs a new compound object and then (to the extentpossible) inserts *references* into it to the objects found in the original.

深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。即创建一个新的组合对象，同时递归地拷贝所有子对象，新的组合对象与原对象没有任何关联。虽然实际上会共享不可变的子对象，但不影响它们的相互独立性。A deep copy constructs a new compound object and then, recursively, insertscopies into it of the objects found in the original.

浅拷贝和深拷贝的不同仅仅是对组合对象来说，所谓的组合对象就是包含了其它对象的对象，如列表，类实例。而对于数字、字符串以及其它“原子”类型，没有拷贝一说，产生的都是原对象的引用，所以两者就是一样的结果了。

### 直接赋值 ###

直接赋值既不是浅拷贝也不是深拷贝！

>>> a = 3

>>> b = a

>>> b = 4

>>> a

>>> b

>>>

对组合对象来说，赋值后两者完全一样，相当于视图（numpy），没有copy到额外的空间中。

a = [1, 2, [3, 4]]
    b = a
    b[2][0] = 100
    b[1] = 22
    print(a)
    print(b)

\[1, 22, \[100, 4\]\]

两个列表就是同一个列表，没有任何copy。

[皮皮blog][blog]

# 浅拷贝和深拷贝示例 #

## 浅拷贝shallow copy ##

字典的浅拷贝dict.copy()。

列表list的浅拷贝 assigning a slice of the entire list, copied\_list = original\_list\[:\]；或者直接list1.copy()。

### 示例1 ###

\#coding=gbk  
import copy  
l1 = \[1, 2, \[3, 4\]\]  
l2 = copy.copy(l1)  
print l1  
print l2  
l2\[2\]\[0\] = 50  
print l1  
print l2  
\#---- 结果 ----  
\[1, 2, \[3, 4\]\]  
\[1, 2, \[3, 4\]\]  
\[1, 2, \[50, 4\]\]  
\[1, 2, \[50, 4\]\]

### 示例2 ###

如果list中没有引用其它对象，那么浅拷贝就和深拷贝一样一样了。

a = [1, 2, 3]
    b = a.copy()
    b[0] = 333
    print(b)
    print(a)

\[333, 2, 3\]  
\[1, 2, 3\]

### 示例3 ###

真正了解浅拷贝/深拷贝的示例。

a = [1, 3, [2, 3]]
    b = a[:]
    b[2][0] = 1999
    b[1] = 2
    print(b)
    print(a)

\[1, 2, \[1999, 3\]\]  
\[1, 3, \[1999, 3\]\]

## 深拷贝deep copy ##

深复制，不仅复制对象本身，同时也复制该对象所引用的对象。

### 示例1 ###

import copy  
l1 = \[1, 2, \[3, 4\]\]  
l2 = copy.deepcopy(l1)  
print l1  
print l2  
l2\[2\]\[0\] = 50  
print l1  
print l2  
\#---- 结果 ----  
\[1, 2, \[3, 4\]\]  
\[1, 2, \[3, 4\]\]  
\[1, 2, \[3, 4\]\]  
\[1, 2, \[50, 4\]\]

[皮皮blog][blog]

## 字典浅拷贝实例 ##

**浅拷贝：**

>>>a = \{1: \[1,2,3\]\}  
>>> b = a.copy()  
>>> a, b  
(\{1: \[1, 2, 3\]\}, \{1: \[1, 2, 3\]\})  
>>> a\[1\].append(4)  
>>> a, b  
(\{1: \[1, 2, 3, 4\]\}, \{1: \[1, 2, 3, 4\]\})

**深度拷贝：**

>>>import copy  
>>> c = copy.deepcopy(a)  
>>> a, c  
(\{1: \[1, 2, 3, 4\]\}, \{1: \[1, 2, 3, 4\]\})  
>>> a\[1\].append(5)  
>>> a, c  
(\{1: \[1, 2, 3, 4, 5\]\}, \{1: \[1, 2, 3, 4\]\})

### 解析 ###

1、**b = a:** 赋值引用，a 和 b 都指向同一个对象。

![1489720931-7116-4AQC6.png][]

**2、b = a.copy():** 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。

![1489720930-6827-Vtk4m.png][]

**b = copy.deepcopy(a):** 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

![1489720930-5882-BO4qO.png][]

[皮皮blog][blog]

## 改变copy的默认行为 ##

在定义类的时候，通过定义\_\_copy\_\_和\_\_deepcopy\_\_方法，可以改变copy的默认行为。下面是一个简单的例子:

class CopyObj(object):  
    def \_\_repr\_\_(self):  
        return "CopyObj"  
      
    def \_\_copy\_\_(self):  
        return "Hello"  
obj = CopyObj()  
obj1 = copy.copy(obj)  
print obj  
print obj1  
\#---- 结果 ----  
CopyObj  
Hello

from:[http://blog.csdn.net/pipisorry/article/details/45830941][blog.csdn.net_pipisorry_article_details_45830941]

ref: \[[`copy`][copy] — Shallow and deep copy operations\]

[blog.csdn.net_pipisorry_article_details_45830941]: http://blog.csdn.net/pipisorry/article/details/45830941
[blog]: http://blog.csdn.net/pipisorry
[1489720931-7116-4AQC6.png]: /images/20220805/7a9ed5e0eeb84f3dafb5c7a193141111.png
[1489720930-6827-Vtk4m.png]: /images/20220805/671b883f8c4d42f5a4f89669e89509fa.png
[1489720930-5882-BO4qO.png]: /images/20220805/4488b8c9405d4c6a9d1c46c55cc5190f.png
[copy]: https://docs.python.org/3/library/copy.html#module-copy