前言

Python 的所有变量其实都是指向内存中的对象的一个指针，这确实和之前学过的强类型语言（Java）是有不同的。在Java中基本数据类型数据直接存储在栈(stack)中，引用数据类型数据存储的是该对象在栈中引用，真实的数据存放在堆内存里，引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。

而在Python中因为变量是指针，所以所有的变量无类型限制，可以指向任意对象。指针的内存空间大小是与类型无关的，其内存空间只是保存了所指向数据的内存地址。

对象还分两类：一类是可修改的，一类是不可修改的。可修改(mutable)的类型叫做值类型，不可修改(immutable)类型叫做引用类型。

不可变(immutable)对象类型

int，float，decimal，complex，bool，str，tuple，range，frozenset，bytes

可变(mutable)对象类型

list，dict，set，bytearray，user-defined classes (unless specifically made immutable)

为了探索对象在内存的存储，我们可以求助于Python的内置函数id()。它用于返回对象的身份(唯一标识符，标识符是一个整数）其实，这里所谓的身份，就是该对象的内存地址。

a = 1
print(id(a))
print(hex(id(a)))
在我的计算机上，它们返回的是:
11246696 ‘0xab9c68’
分别为内存地址的十进制和十六进制表示。

1. 浅拷贝和深拷贝的概念

以下分别是百度百科对浅拷贝和深拷贝的定义：

浅拷贝：

浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制资源。

深拷贝：

深拷贝会拷贝所有的属性，并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。深拷贝相比于浅拷贝速度较慢并且花销较大。

简单说就是：

浅拷贝只复制某个对象的引用，而不复制对象本身，新旧对象还是共享同一块内存。

深拷贝会创造一个一模一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对对象。

在python中

浅拷贝(copy())：拷贝父对象，不会拷贝对象内部的子对象。

深拷贝(deepcopy())：是copy模块中的方法，完全拷贝了子对象和父对象

2. is和==的区别

python是一种面向对象的语言，python中对象包含三种基本要素：id(返回的是对象的地址)、type(返回的是对象的数据类型)及value(对象的值)。

is和==都可以对两个对象进行比较，而且它们的返回值都是布尔类型。但是它们比较的内容是不同的，不然两个函数的作用就重复了。首先我们来看下例子，从实际操作中来看下二者的区别。
彻底理解Python中浅拷贝和深拷贝的区别

从上面的例子可以得出，is和==比较的对象的内容时不同的，即：is比较的是两个对象的地址值，也就是说两个对象是否为同一个实例对象；而==比较的是对象的值是否相等，其调用了对象的__eq__()方法。

那么怎么才能让两个对象的地址值相等呢，如果想让一个对象ls2 is ls1返回True应该怎么操作呢，我们可以把ls1赋值给ls2，这样ls1和ls2指向的就是同一个内存地址，ls1 == ls2和ls1 is ls2返回的都是True。如下图所示：
彻底理解Python中浅拷贝和深拷贝的区别

3. 赋值操作

在上面提到了赋值操作，在python中对象赋值实际上是对象的引用。当创建一个对象，然后把它赋值给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。彻底理解Python中浅拷贝和深拷贝的区别

ls1 = ls赋值引用，ls1和ls都指向同一个对象。内存图如下所示：

彻底理解Python中浅拷贝和深拷贝的区别

综上，赋值操作只是浅拷贝传递对象的引用而已，原始列表改变，被赋值的变量也会做相同的改变，所以属于浅拷贝。

前面讲到python中分为可变类型和不可变类型，下面分别按照这2种类型介绍浅拷贝和深拷贝。

4. copy模块里面的copy()方法

可变类型和不可变类型在浅拷贝中的区别

# coding=utf-8

import copy

'''
不可变类型Number String Tuple
'''
num1 = 17
num2 = copy.copy(num1)

print("num1:" + str(id(num1)))
print("num2:" + str(id(num1)))
# num1和num2的地址都相同


str1 = "hello"
str2 = copy.copy(str1)
print("str1:" + str(id(str1)))
print("str2:" + str(id(str2)))
# str1和str2的地址都相同

tup1 = (18, "tom")
tup2 = copy.copy(tup1)
print("tup1:" + str(id(tup1)))
print("tup2:" + str(id(tup2)))
# tup1和tup2的地址都相同


'''
可变类型List、Dictionary、Set
'''
list1 = [11,12]
list2 = copy.copy(list1)
print("list1:" + str(id(list1)))
print("list2:" + str(id(list2)))
# list1和list2的地址不相同


dic1 = {"key": "hello", "num": 18}
dic2 = copy.copy(dic1)
print("dic1:" + str(id(dic1)))
print("dic2:" + str(id(dic2)))
# dic1和dic2的地址不相同

set1 = {"AA","BB"}
set2 = copy.copy(set1)
print("set1:" + str(id(set1)))
print("set2:" + str(id(set2)))
# set1和set2的地址不相同



输出结果：
num1:58549080
num2:58549080
str1:60653712
str2:60653712
tup1:60127112
tup2:60127112
list1:60101000
list2:60190344
dic1:60203624
dic2:60205528
set1:60064936
set2:60064712

从以上输出结果可以看到：

对于不可变类型 Number String Tuple，浅复制仅仅是地址指向，不会开辟新空间拷贝值
对于可变类型 List、Dictionary、Set，浅复制会开辟新的空间地址，进行浅拷贝

那如果对对象作出修改操作呢？

1）最外层的数据类型是不可变的，内层数据是可变的

import copy

'''
最外层的数据类型是不可变的，内层数据是可变的
'''
a=[34, 56]
b=[89, 37]
c=(a, b)
d=copy.copy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))

print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))

print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))

a.append(90)
print("c: %s" % str(c))
print("d: %s" % str(d))


输出结果：
c: ([34, 56], [89, 37])
d: ([34, 56], [89, 37])
id(a): 56627592
id(b): 56639880
id(c): 56640648
id(d): 56640648
id(c[0]): 56627592
id(c[1]): 56639880
id(d[0]): 56627592
id(d[1]): 56639880
c: ([34, 56, 90], [89, 37])
d: ([34, 56, 90], [89, 37])

从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行浅拷贝的时候，是直接引用c的地址，而不是再开辟新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，也没有开辟新的地址空间存放。当a发生变化后，d也随之发生了变更。

2）最外层的数据类型是不可变的，内层数据也是不可变的

import copy

'''
最外层的数据类型是不可变的，内层数据也是不可变的
'''
a=(34, 56)
b=(89, 37)
c=(a, b)
d=copy.copy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))

print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))

print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))


输出结果：
c: ((34, 56), (89, 37))
d: ((34, 56), (89, 37))
id(a): 59722120
id(b): 59722184
id(c): 59720840
id(d): 59720840
id(c[0]): 59722120
id(c[1]): 59722184
id(d[0]): 59722120
id(d[1]): 59722184

从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行浅拷贝的时候，是直接引用c的地址，而不是再开辟新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，也没有开辟新的地址空间存放。

3）最外层的数据类型是可变的，内层数据也是可变的

import copy

'''
最外层的数据类型是可变的，内层数据也是可变的
'''
a=[34, 56]
b=[89, 37]
c=[a, b]
d=copy.copy(c)
print("c: %s" % c)
print("d: %s" % d)

print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))

a.append(90)
print("c: %s" % c)
print("d: %s" % d)


输出结果：
c: [[34, 56], [89, 37]]
d: [[34, 56], [89, 37]]
id(a): 59249032
id(b): 59261320
id(c): 59263624
id(d): 59338568
id(d[0]): 59249032
id(d[1]): 59261320
c: [[34, 56, 90], [89, 37]]
d: [[34, 56, 90], [89, 37]]

从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行浅拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，而没有开辟新的地址空间存放。当a发生变化后，d也随之发生了变更。

4）最外层的数据类型是可变的，内层数据是不可变的

import copy

'''
浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。
最外层的数据类型是可变的，内层数据是不可变的
'''
a=(34, 56)
b=(89, 37)
c=[a, b]
d=copy.copy(c)
print("c: %s" % c)
print("d: %s" % d)

print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))


输出结果：
c: [(34, 56), (89, 37)]
d: [(34, 56), (89, 37)]
id(a): 52381896
id(b): 52381960
id(c): 52367752
id(d): 52448968
id(d[0]): 52381896
id(d[1]): 52381960

从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行浅拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，而没有开辟新的地址空间存放。

综上，可以得出结论：

浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。使用浅拷贝的时候，分为两种情况。
第一种，如果最外层的数据类型是可变的，比如说列表，字典等，浅拷贝会开启新的地址空间去存放。
第二种，如果最外层的数据类型是不可变的，比如元组，字符串等，浅拷贝对象的时候，还是引用对象的地址空间。

5. copy模块里面的deepcopy()方法

1）最外层的数据类型是不可变的，内层数据是可变的

import copy

'''
最外层的数据类型是不可变的，内层数据是可变的
'''
a=[34, 56]
b=[89, 37]
c=(a, b)
d=copy.deepcopy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))

print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))

print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))

a.append(90)
print("c: %s" % str(c))
print("d: %s" % str(d))


输出结果：
c: ([34, 56], [89, 37])
d: ([34, 56], [89, 37])
id(a): 52367752
id(b): 52380040
id(c): 52380808
id(d): 52380872
id(c[0]): 52367752
id(c[1]): 52380040
id(d[0]): 52382472
id(d[1]): 52457160
c: ([34, 56, 90], [89, 37])
d: ([34, 56], [89, 37])

从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行深拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行深拷贝的时候，内层元素也开辟了新的地址空间存放。当a发生变化后，d并没有发生变更。

2）最外层的数据类型是不可变的，内层数据也是不可变的

import copy

'''
最外层的数据类型是不可变的，内层数据也是不可变的
'''
a=(34, 56)
b=(89, 37)
c=(a, b)
d=copy.deepcopy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))

print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))

print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))


输出结果：
c: ((34, 56), (89, 37))
d: ((34, 56), (89, 37))
id(a): 48187848
id(b): 48187912
id(c): 48186504
id(d): 48186504
id(c[0]): 48187848
id(c[1]): 48187912
id(d[0]): 48187848
id(d[1]): 48187912

从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行深拷贝的时候，是直接引用c的地址，而不是再开辟新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行深拷贝的时候，内层元素是引用的a和b的地址，也没有开辟新的地址空间存放。

3）最外层的数据类型是可变的，内层数据也是可变的

import copy

'''
最外层的数据类型是可变的，内层数据也是可变的
'''
a=[34, 56]
b=[89, 37]
c=[a, b]
d=copy.deepcopy(c)
print("c: %s" % c)
print("d: %s" % d)

print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))

a.append(90)
print("c: %s" % c)
print("d: %s" % d)


输出结果：
c: [[34, 56], [89, 37]]
d: [[34, 56], [89, 37]]
id(a): 59380104
id(b): 59392392
id(c): 59394696
id(d): 59394824
id(d[0]): 59469512
id(d[1]): 59469768
c: [[34, 56, 90], [89, 37]]
d: [[34, 56], [89, 37]]

从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行深拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行深拷贝的时候，内层元素也开辟了新的地址空间存放。当a发生变化后，d并没有发生变更。

4）最外层的数据类型是可变的，内层数据是不可变的

import copy

'''
浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。
最外层的数据类型是可变的，内层数据是不可变的
'''
a=(34, 56)
b=(89, 37)
c=[a, b]
d=copy.deepcopy(c)
print("c: %s" % c)
print("d: %s" % d)

print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))


输出结果：
c: [(34, 56), (89, 37)]
d: [(34, 56), (89, 37)]
id(a): 45041928
id(b): 45041992
id(c): 45027720
id(d): 45040008
id(d[0]): 45041928
id(d[1]): 45041992

从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行深拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行深拷贝的时候，内层元素是引用的a和b的地址，而没有开辟新的地址空间存放。

综上，可以得出结论：

深拷贝对一个对象是所有层次的拷贝（递归），内部和外部都会被拷贝过来。
深拷贝也分两种情况：
第一种，最外层数据类型可变。外层的会新开辟地址空间存放。如果里面是可变数据类型，内部会新开辟地址空间存放。如果内部数据类型不可变，内部则是对地址的引用。
第二种，外层数据类型不可变，如果内部数据是可变数据类型，外部和内部都会新开辟地址空间存放。如果内部数据类型不可变，外部和内部都是对地址的引用。

6.字典自带的copy方法

dict_1 = {"key1":[1,2,3,4],"key2":"val2"}
dict_2 = dict_1.copy()
dict_1["key1"].append(5)
print("id(dict_1)",id(dict_1),id(dict_1["key1"]),dict_1)
print("id(dict_2)",id(dict_2),id(dict_1["key1"]),dict_2)


输出结果：
('id(dict_1)', 43262840L, 48538120L, {'key2': 'val2', 'key1': [1, 2, 3, 4, 5]})
('id(dict_2)', 48598552L, 48538120L, {'key2': 'val2', 'key1': [1, 2, 3, 4, 5]})

可以看出，父对象被拷贝到了一个新内存地址，但是对于子对象只是引用了它的内存地址，并没有拷贝子对象里面可迭代的内容。如果子对象里面的内容修改后，被赋值的变量也会做相同的改变，所以字典中的copy方法属于浅拷贝。

7.切片表达式拷贝

num1 = [1, 2, 3, [4, 5]]
num2 = num1[:]
num1[0] = 0
num1.append(5)
num1[3].append(6)
print(num1, id(num1))
print(num2, id(num2))
print(num1[3], id(num1[3]))
print(num2[3], id(num2[3]))


输出结果：
([0, 2, 3, [4, 5, 6], 5], 57012616L)
([1, 2, 3, [4, 5, 6]], 57012744L)
([4, 5, 6], 57000328L)
([4, 5, 6], 57000328L)

由此可见，切片操作并没有复制可变类型的元素而是复制了可变类型的地址，相当于浅拷贝。

8.总结

首先深拷贝和浅拷贝都是对象的拷贝，都会生成一个看起来相同的对象，他们本质的区别是拷贝出来的对象的地址是否和原对象一样
(1)深拷贝：拷贝了一份与原对象不同地址的对象，修改对象中的任何值，都不会改变深拷贝的对象的值。
(2)浅拷贝：对原对象值的拷贝，地址仍然指向原对象的地址，原对象的值发生变化，拷贝对象的值也会随着改变。
(3)深拷贝和浅拷贝需要注意的地方是：可变元素的拷贝
在浅拷贝时，拷贝出来的新对象的地址和原对象是不一样的，但是新对象里面的可变元素（如列表）的地址和原对象里的地址是相同的。也就是说浅拷贝它拷贝的是浅层次的数据结构（不可变元素），对象里的可变元素作为深层次的数据结构并没有被拷贝到新地址里面去，而是和原对象里的指向同一个地址。

下面解释可变类型和不可变类型的嵌套使用：

（1）可变类型:
浅拷贝和深拷贝只要最外层是可变类型都会生成新的对象

[] 或者{}, 浅拷贝和深拷贝都会生成新的对象
[[],[]]列表的嵌套，可变类型嵌套了可变类型，浅拷贝：只拷贝最外层，会生成新的对象，内层是引用。深拷贝：外层和内层都会进行拷贝，都是全新的对象，都有独立的存储空间
[(),()] 外层可变，内层不可变，浅拷贝：只拷贝最外层，会生成新的对象，内层是引用。深拷贝：外层和内层都会进行拷贝，外层会生成新对象，但是由于内层是不可变类型，所以内层依然是引用
[(),[]] 外层可变，内层有一个是可变，浅拷贝：只拷贝最外层，会生成新的对象，内层是引用。深拷贝：外层和内层都会进行拷贝，外层会生成新对象，内层可变对象会生成新对象，内层不可变对象是引用

（2）不可变类型:
最外层是不可变类型，浅拷贝就一定是引用

Number、字符串或者(), 浅拷贝和深拷贝都是引用
([],[]), copy浅拷贝：只会拷贝最外层，内层只是引用，但是最外层是不可变，拷贝之后毫无意义，仅仅是引用关系。deepcopy：从外层到内层都会拷贝，内层是可变，为了达到和原来的数据完全隔离，会生成全新的对象
((),()) 完全不可变，拷贝了之后如果生成新的数据也无法修改，所以不管深拷贝还是浅拷贝都是引用
((),[]) 外层不可变，但是内层有一个是可变，copy依然是引用，deepcopy,会生成新的对象，内层的不可变类型是引用，可变类型会生成新的对象。

参考文章：

python之浅拷贝和深拷贝的区别_埃菲尔没有塔尖的博客-CSDN博客_python 深拷贝和浅拷贝的区别

Python之中切片是浅拷贝吗？Python怎么实现浅拷贝 – 优草派

python赋值、深拷贝和浅拷贝的区别详解_测试小白00的博客-CSDN博客_python赋值和浅拷贝

python中的is和==区别_Tonywu2018的博客-CSDN博客_python is和==的区别

python3浅拷贝与深拷贝的区别和理解 – 简书