第一次遇到深拷贝和浅拷贝的问题是用python在一个for循环中对一个list赋值，使用的语句是
a = b
这个b会不断带入循环，每次计算得到，最后发现list乱七八糟的，后来才发现，python中a=b并不是创建一个a，将b的值赋给它，而是b的地址的一个复制。
后来其实在C#的另一个问题中，也是类似的错误，当然这个问题要复杂的多，因此特地重写了一篇。
我不由自主地会想，浅拷贝与深拷贝的区别是什么，在什么场景下要用到浅拷贝，而什么场景下用深拷贝呢？
1、首先明白什么是浅拷贝和深拷贝
- 可变对象、不可变对象
在了解深浅拷贝之前，先了解可变与不可变对象。
可变对象是指地址所指向的值可变的对象，相反不可变对象就是地址所指向的对象是不可变的。举个例子
a = 5
a = 6
这里a赋了两次值，但是第二次赋值时，a的地址并不改变，不同的是，执行语句后，a指向的地方存储的值从5变成了6。因此，a是可变对象。
那么，这里的‘5’呢？5是一个数字，当你在语句中输入5时，它就一定代表数字5所在的地方，你不能给5再赋值，因此，5是不可变对象。当你试图改变一个不可变对象时，它事实上新生成了一个对象并返回给你。例如，y = y+1，返回的y事实上已经不是原来y的地址了。
不可变对象包含：int,float,complex,long,str,unicode,tuple。
- 深浅拷贝语句
import copy a=[1,2,3,4,5,[‘a‘,‘b‘]] #原始对象 b=a#赋值，传对象的引用 c=copy.copy(a)#对象拷贝，浅拷贝 d=copy.deepcopy(a)#对象拷贝，深拷贝 print "a=",a," id(a)=",id(a),"id(a[5])=",id(a[5]) print "b=",b," id(b)=",id(b),"id(b[5])=",id(b[5]) print "c=",c," id(c)=",id(c),"id(c[5])=",id(c[5]) print "d=",d," id(d)=",id(d),"id(d[5])=",id(d[5]) print "*"*70 a.append(6)#修改对象a a[5].append(‘c‘)#修改对象a中的[‘a‘,‘b‘]数组对象 print "a=",a," id(a)=",id(a),"id(a[5])=",id(a[5]) print "b=",b," id(b)=",id(b),"id(b[5])=",id(b[5]) print "c=",c," id(c)=",id(c),"id(c[5])=",id(c[5]) print "d=",d," id(d)=",id(d),"id(d[5])=",id(d[5])
a = b 是赋值操作，只是复制一个地址，就是一个地址的两个引用。
copy函数是另起了一个地址，存放新对象，但是只是重新复制了可变对象，不可变对象的地址并不变，因此如果改动不可变对象，copy出的对象仍然会变。
deepcopy则是完完全全生成一个新的对象，源对象中的所有对象都生成一份放在新地址中。
2、为什么要有深浅拷贝
其实我一直在用相关的知识，但一直不自知，没有去仔细思考。例如，在一道leetcode题中：
#21.合并两个有序链表 #将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 class Solution(object): def mergeTwoLists(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ p = ListNode(0) ans = p while(l1 or l2): if(l1==None): p.next = l2 return ans.next elif(l2==None): p.next = l1 return ans.next else: if(l1.val>l2.val): p.next = l2 p = p.next l2 = l2.next else: p.next = l1 p = p.next l1 = l1.next return ans.next
标黄的一行，就是用ans记录p节点的位置，这样p就可以进行迭代，最终返回ans，即返回了头指针，在这里，很容易理解，ans = p操作就是使用ans复制了p的地址，并不是复制p的值，也不是指向p，而是，执行了将p所在的地址引用给ans。这就是浅拷贝。
- a = b赋值语句通常用来记录b的地址，如果b需要在后续进行迭代操作，a可以记录初始位置。
- copy函数进行了浅层拷贝，可以在新对象中对一些元素进行操作和修改，同时，那些常用的不可变对象还是原来的元素，这样的好处至少如下
- 时间、内存开销更小，效率更高了
- 用编程思想来类比，不可变对象可以认为类似于全局变量，可变对象可以认为是实例化对象中的局部变量，这样做的好处就显而易见了
- deepcopy就是完全全新生成了一个对象，其中所有的对象都是全新，与源对象没关系的，可以随意更改。
3、函数中的传参关系
我们常常把一个对象传入到函数中，函数中也经常对该对象进行操作。虽然有不同的赋值操作，但是其实不同操作之间的含义是不一样的。
def func1(nums): nums = set(nums) def func2(nums): nums = [1,2,3,4,5]
l = [1,1,1,1]
func1(l)
func2(l)
在这个操作中，都在定义的函数中对nums进行了赋值，但是如果实操就会发现，在函数内nums被改变了，但函数运行结束后，l还是等于[1,1,1,1]。
这是因为在函数中，nums这个对象代表的只是对l的引用，nums = set(nums)这个语句，是生成了一个set（nums）对象，并将该对象的地址赋给了nums这个引用。并没有将set（nums）的内容覆盖掉nums所在的地址的内容。
def func3(nums): for i in range(len(nums)): nums[i] = 9 def func4(nums): nums.pop(1)
nums.append(3)
l = [1,1,1,1] func3(l) func4(l)
在这个操作中，会发现l的值都被改变了。这是因为以上无论是针对index赋值还是list操作，都是针对nums这个变量所指向的list对象进行的操作，也就是实实在在地操作在了地址上，改变了元素。这事实上是python函数中传参的问题。有一篇博文写的很清楚：python函数参数传递：传值还是传引用。
所以要清楚地记得，python函数中传递的就是对象的地址。当操作针对地址所指的对象进行操作时，就会变，否则当你试图给这个传递的参数赋值时，就会失效。