由Python的浅拷贝(shallow copy)和深拷贝(deep copy)引发的思考

首先查看拷贝模块(copy)发现：

>>> help(copy)
Help on module copy:
NAME
    copy - Generic (shallow and deep) copying operations.
DESCRIPTION
    Interface summary:   
            import copy   
            x = copy.copy(y)        # make a shallow copy of y
            x = copy.deepcopy(y)    # make a deep copy of y   
    For module specific errors, copy.Error is raised.   
    The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or
    class instances).
    
    - A shallow copy constructs a new compound object and then (to the extent possible) inserts *the same objects* into it that the
      original contains.
    
    - A deep copy constructs a new compound object and then, recursively,  inserts *copies* into it of the objects found in the original.

    ...(here omitted 10000words)

由以上的信息可知：

    1、相同点：都拷贝出了一个新的复合对象；

    2、不同点：浅拷贝—— 在拷贝出的新的对象上插入（引用）源list对象的一切；

                    深拷贝—— 递归地拷贝源list对象中的一切。（彻头彻尾的另立门户）

 

现在出现了一个新的问题—— 拷贝

在计算机中拷贝一份数据或者拷贝一个变量，意味着系统需分配新的内存用于对拷贝数据的存放。

我们先来讨论一下变量的赋值（变量的数据结构中的内存地址域的拷贝）过程。

首先看一下变量的赋值过程：

Python 2.6.6 (r266:84292, Aug 18 2016, 15:13:37) 
[GCC 4.4.7 20120313 (Red Hat 4.4.7-17)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 3
>>> b = a
>>> id(a)
7488264
>>> id(b)
7488264
>>> a = 4
>>> id(a)
7488240
>>> id(b)               # 咦，b没有随a发生改变
7488264
>>> b
   3

要解释这个，必须要了解变量的数据结构。

当向系统申请创建一个变量时，系统先分配一块内存空间，该内存空间用于存储该变量。

变量的数据结构包括2部分：第一部分用于存储变量的名称和变量的数据类型的长度，第二部分用于存储内存地址（即索引）。

当变量未初始化时，第二部分数据为垃圾值；一旦初始化，该部分的值即为初始化值的内存地址。

例如：以上 a = 3, 其过程如下：

首先系统为常量3（int型）分配一块内存大小为4byte的空间存放常量3；然后将常量3的内存地址存储于变量a的第二部分。这样就完成了变量a的赋值过程。

b = a时，同样系统先分配一块内存空间存放变量b, 之后系统将a中的第二部分数据拷贝到b中的第二部分。

而id()的返回值正是变量的第二部分数据（内存地址）。

所以当执行a时，是根据第二部分的数据（内存地址）获取该内存的值。

当a = 4 时，变量a第二部分的数据即为常量4的存储地址，因此id(a)发生改变，而id(b)保持不变。

如下图：

 

回到浅拷贝和深拷贝的议题：

浅拷贝—— 在拷贝出的新的对象上插入（引用）源list对象的一切；                   

深拷贝—— 递归地拷贝源list对象中的一切。（彻头彻尾的另立门户）。

浅拷贝的实例：

#!/usr/bin/python                  # Python2
#
import copy

will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.copy(will)

print id(will)                     # 140337318319672
print will                         # ['Will', 28, ['Python', 'C#', 'JavaScript']]
print [id(ele) for ele in will]    # [140337318374208, 13394096, 140337318282160]
print '============================'
print id(will[2])                  # 140337318282160
print id(will[2][0])               # 140337318677600
print id(wilber[2][0])             # 140337318677600
print id(wilber)                   # 140337318386216
print wilber                       # ['Will', 28, ['Python', 'C#', 'JavaScript']]
print [id(ele) for ele in wilber]  # [140337318374208, 13394096, 140337318282160]
  
will[0] = "Wilber"
will[2].append("CSS")
print id(will)                     # 140337318319672
print will                         # ['Wilber', 28, ['Python', 'C#', 'JavaScript', 'CSS']]
print [id(ele) for ele in will]    # [140337318374448, 13394096, 140337318282160]
print id(wilber)                   # 140337318386216
print wilber                       # ['Will', 28, ['Python', 'C#', 'JavaScript', 'CSS']]
print [id(ele) for ele in wilber]  # [140337318374208, 13394096, 140337318282160]

 浅拷贝只是生成一个新的对象，数据结构以及索引关系未变。

浅拷贝时，列表will与wilber由系统分配不同的地址，系统将列表will的第一层进行拷贝即：will[0], will[1], will[2]拷贝，故wilber[0]与will[0]，wilber[1]与will[1]，wilber[2]与will[2]，指向相同的内存地址。

 如下图所示：

 

深拷贝实例：

#!/usr/bin/python
#
import copy
 
will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.deepcopy(will)

print id(will)                    # 139899797283040    
print will                        # ['Will', 28, ['Python', 'C#', 'JavaScript']]
print [id(ele) for ele in will]   # [139899797338992, 11432112, 139899797246896]
print '============='
print id(will[2])                 # 139899797246896
print id(wilber[2])               # 139899797351024
print id(will[2][0])              # 139899797642336
print id(wilber[2][0])            # 139899797642336
print id(wilber[2][1])            # 139899797339088
print id(wilber)                  # 139899797349296
print wilber                      # ['Will', 28, ['Python', 'C#', 'JavaScript']]
print [id(ele) for ele in wilber] # [139899797338992, 11432112, 139899797351024]
 
will[0] = "Wilber"
will[2].append("CSS")
print id(will)                    # 139899797283040
print will                        # ['Wilber', 28, ['Python', 'C#', 'JavaScript', 'CSS']]
print [id(ele) for ele in will]   # [139899797339280, 11432112, 139899797246896]
print id(wilber)                  # 139899797349296
print wilber                      # ['Will', 28, ['Python', 'C#', 'JavaScript']]
print [id(ele) for ele in wilber] # [139899797338992, 11432112, 139899797351024]

深拷贝会递归（逐层）拷贝list的数据结构。

深拷贝时，系统将列表will逐层进行拷贝即：列表will与wilbe，will[2]与wilber[2]由系统分配不同的地址，will[0], will[1], will[2]，will[2][0], will[2][1], will[2][2]拷贝;

故wilber[0]与will[0]，wilber[1]与will[1], will[2][0]与wilber[2][0], will[2][1]与wilber[2][0], will[2][2]与wilber[2][2]，指向相同的内存地址。

 

附注-list之间的赋值代码：

#!/usr/bin/python
#
will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = will
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]
 
will[0] = "Wilber"
will[2].append("CSS")
print id(will)
print will
print [id(ele) for ele in will]                # 发现操作的是同一对象
print id(wilber)
print wilber
print [id(ele) for ele in wilber]