简单粗暴从例子先看的，然后再详解深拷贝及浅拷贝两个概念~
浅拷贝：
栗子1
list1 = [1,2,3]
list2 = list(list1) #这里就是浅拷贝,也可以写作下面两种写法
#list2 = list1[:]
#list2 = copy.copy(list1)
print(list2)
print("list1==list2 ?",list1==list2)
print("list1 is list2 ?",list1 is list2)
结果1：
[1, 2, 3]
list1==list2 ? True
list1 is list2 ? False
但是有一个特殊的数据结构就是元组tuple，如果使用tuple()或者切片操作":"，或者copy.copy()，并不会创建一份浅拷贝，会创建一个指相同元组的引用：
栗子2
import copy
tuple1 = (1, 2, 3)
tuple2 = copy.copy(tuple1)
print(tuple2)
print("tuple1 == tuple2 ?",tuple1 == tuple2)
print("tuple1 is tuple2 ?",tuple1 is tuple2)
结果2
(1, 2, 3)
tuple1 == tuple2 ? True
tuple1 is tuple2 ? True
结论：
简单来讲，**浅拷贝是指重新分配一块内存，创建一个新的对象，里面的元素是原对象中各个子对象的引用。**如果数据采用浅拷贝方式，如果原来对象元素不改变，采用浅拷贝不会出现错误；如果元素可变，则会出现一些问题。
栗子3
list1 = [[1, 2], (30, 40)]
list2 = list(list1)
list1.append(100)
print("list1:",list1)
print("list2:",list2)
list1[0].append(3)
print("list1:",list1)
print("list2:",list2)
list1[1] += (50, 60)
print("list1:",list1)
print("list2:",list2)
结果3：
list1: [[1, 2], (30, 40), 100]
list2: [[1, 2], (30, 40)]
list1: [[1, 2, 3], (30, 40), 100]
list2: [[1, 2, 3], (30, 40)]
list1: [[1, 2, 3], (30, 40, 50, 60), 100]
list2: [[1, 2, 3], (30, 40)]
1）初始化list1,包含一个list[1,2]和一个元组（30,40）,list2是对list1的浅拷贝，此时与list1元素一致；
2）list1添加了元素，并没有改变其中的元素，所以list2并没有变化，因为两者为不同对象，不共享内存。
3）list1改变了第一个元素，这时list2第一个元素也改变，因为两者共同指向同一个元素;
4）list1改变了其为元组的元素，因为元组是不可变的，这里表示对 list1 中的第二个元组拼接，然后重新创建了一个新元组作为 list1 中的第二个元素，而 list2 中没有引用新元组，因此 list2 并不受影响。
深拷贝
通过栗子3，可以很清楚地看到使用浅拷贝可能带来的副作用。如果想避免这种副作用，完整地拷贝一个对象，就需要使用深拷贝。所谓深拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。
深拷贝通过copy.deepcopy()实现：
import copy
list1 = [[1, 2], (30, 40)]
list2 = copy.deepcopy(list1)
list1.append(100)
print("list1:",list1)
print("list2:",list2)
list1[0].append(3)
print("list1:",list1)
print("list2:",list2)
list1[1] += (50, 60)
print("list1:",list1)
print("list2:",list2)
结果：
list1: [[1, 2], (30, 40), 100]
list2: [[1, 2], (30, 40)]
list1: [[1, 2, 3], (30, 40), 100]
list2: [[1, 2], (30, 40)]
list1: [[1, 2, 3], (30, 40, 50, 60), 100]
list2: [[1, 2], (30, 40)]
不过深拷贝需要注意的点，如果被拷贝对象中存在指向自身的引用，那么程序很容易陷入无限循环，例如：
import copy
list1 = [1]
list1.append(list1)
print(list1)
list2 = copy.deepcopy(list1)
print(list2)
结果
[1, [...]]
[1, [...]]
此例子中，列表 x 中有指向自身的引用，因此 x 是一个无限嵌套的列表。但是当深度拷贝 x 到 y 后，程序并没有出现栈溢出的现象。这是为什么呢？
其实，这是因为深度拷贝函数 deepcopy 中会维护一个字典，记录已经拷贝的对象与其 ID。拷贝过程中，如果字典里已经存储了将要拷贝的对象，则会从字典直接返回。通过查看 deepcopy 函数实现的源码就会明白：
def deepcopy(x, memo=None, _nil=[]):
"""Deep copy operation on arbitrary Python objects.
See the module's __doc__ string for more info.
"""
if memo is None:
memo = {}
d = id(x) # 查询被拷贝对象 x 的 id
y = memo.get(d, _nil) # 查询字典里是否已经存储了该对象
if y is not _nil:
return y # 如果字典里已经存储了将要拷贝的对象，则直接返回
...
