Python的赋值、切片、浅拷贝与深拷贝的区别

前言
Python作为一门高级语言，与C/C++还是有很大的不同。关于赋值、切片、浅拷贝和深拷贝这一块，其实很多人对其不是很了解的，这就很容易在某些代码中出现意想不到的结果，同时也会很难找到原因。本文将讲述这几类情况的区别以及使用，尽可能通俗易懂，不会涉及到底层的实现原理。

本文所有代码的执行环境如下：

操作系统：Window10

Python版本：Python 3.7.0

执行方式：CMD窗口+Python解释器的命令交互模式

赋值、切片、拷贝
本文使用is运算符来判断对象间的唯一身份标识，也就是id是否相同，is也叫同一性运算符
is 运算符判断两个变量id是否相同，如果相同返回布尔值：Ture，反之返回False。

赋值

赋值就是我们通过赋值运算符（=）把一个变量的值赋给另一变量，相当于引用，这里的赋值又可以分为几类
赋值：不可变对象的赋值（在缓存范围内）
赋值：不可变对象的赋值（不在缓存范围内）
赋值：可变对象的赋值

解释：
不可变对象不可变对象：整形（int），字符型（string），浮点型（float），元组（tuple）
可变对象：可变对象 ：列表（list），字典（dictionary）

为了增加程序的运行效率，Python3的解析器中实现了整型数字和字符串缓存的机制。
整型数字的缓存范围为[负无穷，正无穷]，即变量值相等且在[负无穷，正无穷]范围内的所有变量都是同一个对象。
字符串默认缓存长度4096，即变量值相等且长度在4096以内的所有字符串变量是同一个对象，（这个是有争议的，很多文章说是缓存20位，但我实测是长度4096）
赋值：不可变对象的赋值（在缓存范围内）

# 字符串
str_a='phyton'
str_b=str_a
str_c='phyton'
print(str_a is str_b)#返回值是ture
print(str_b is str_c)#返回值是ture
""输出：True，这里输出True就是因为缓存机制，str_c和str_a的值相等，都是'phyton'，且长度在20以内
# int
int_a=int_b=-1000000000000000
int_c=-1000000000000000
print(int_a is int_b)#返回值是ture
print(int_c is int_b)#返回值是ture
# int
int_a=int_b=1000000000000000#int_a=int_b是两个语句分别是int_a=100000000000和int_a=int_b
int_c=1000000000000000
print(int_a is int_b)#返回值是ture
print(int_c is int_b)#返回值是ture
"""True，这里输出True就是缓存机制，因为int_c和int_a的值相等，都为100000000，且在[无穷]范围内

赋值：不可变对象的赋值（不在缓存范围内）

str_a='phyton'*4097
str_b=str_a
str_c='phyton'*4097
print(str_a is str_b)#返回值是ture
print(str_b is str_c)#返回值是false输出，是因为虽然str_c和str_a的值相等，但长度在为4097，超过了缓存最大长度409

赋值：可变对象的赋值
这种情况相当于完全引用，“比浅拷贝还要浅拷贝”，这里举个例，假定list_a为列表，把list_a赋值给list_b，只要不是重新赋值list_a或list_b（list_a=xxx或list_b=yyy）操作，无论是通过list_a还是通过list_b来操作列表（增、删、改…），另一个对象也会随之改变（即list_a和list_b在没有重新执行赋值操作时，将一直是同一个对象）

list_a=[1,2,3,4]
list_b=list_a
list_c=[1,2,3,4]
print(list_a is list_b)
print(list_c is list_a)

第一个返回值是Ture 说明list_a与list_b是同一个id同一个内存值
第二个返回值是Flase所以修改list_a不会影响到list_c，反之亦然。

说明，这里所说的“比浅拷贝还浅拷贝”是针对浅拷贝而说的，也可以说完全没拷贝，只是用
浅拷贝中对本身的修改不会影响另一个（对可变子元素本身的操作才会影响），而赋值无论哪种情况的修改都会影响另一个，（这里的赋值和浅拷贝是针对可变对象来说的）

list_a=[1,2,3,4]
list_b=list_a
list_a.append(5)    #对list_a末端加入5这个元素
list_b[0]=9         #对list_b第一号元素进行修改
del list_b[1]       #对list_b第二号元素进行删除
print(list_a)
print(list_b)

返回值

[9, 3, 4, 5]
[9, 3, 4, 5]
说明了：假定list_a为列表，把list_a赋值给list_b，只要不是重新赋值list_a或list_b（list_a=xxx或list_b=yyy）操作，无论是通过list_a还是通过list_b来操作列表（增、删、改…），另一个对象也会随之改变（即list_a和list_b在没有重新执行赋值操作时，将一直是同一个对象）

切片

切片就是从某个对象中抽取部分的操作，切片操作得到的对象和原对象是不同的对象，但其子元素有可能是同一对象，这里分为几种情况说明，切片相当于浅拷贝

切片：对“是不可变对象的子元素“的修改或增删操作不会影响另一对象

int_a=[1,2,3,4]
int_b=int_a[:]		#完全切片
int_a.append(5)		#对int_a的末尾追加元素
int_b[0]=9			#对int_b的第一号元素进行修改
del int_a[2]		#删除int_a的第三个元素
print(int_a is int_b)	#  输出False，list_a和list_b是不同的对象
print(id(int_a))		#输出的int_a的地址
print(id(int_b))
print(int_a)
print(int_b)
print(int_a[1] is int_b[1])

False
1395930845768
1395930846280
[1, 2, 4, 5]
[9, 2, 3, 4]
返回的值说明了：
切片：对“是不可变对象的子元素“的修改或增删操作不会影响另一对象
Ture
返回值说明了
可变对象的同一个元素的内存地址相同

切片：对“是可变对象的子元素“的操作会影响另一对象

int_a=[1,2,[3],4]       # 和上面不同的是第二号元素是可变的对象
int_b=int_a[:]          #对lint_a完全切片
int_a[2].append(5)      # 对可变子元素进行追加子元素操作，注意是对子元素本身进行追加操作
int_a[2][0] = 33
""" # 对可变子元素进行修改子元素操作，注意是对子元素本身的子元素进行修改操作，而不是修改int_a的子元素"""
int_b[0]=9
print(int_a is int_b)   # 输出False，list_a和list_b是不同的对象
print(id(int_a))
print(id(int_b))
print(int_a)
print(int_b)
print(int_a[2] is int_b[2])
"""输出True，在切片操作中，可变子元素是相当于赋值操作的，即list_a[2]和list_b[2]是同一个对象"""

False
2527716725832
2527717280072
[1, 2, [33, 5], 4]
[9, 2, [33, 5], 4]
True
说明：这种情况是不区分完全切片和不完全切片的，只要切片得到的子元素是可变对象的，都满足这种情况,

以下代码就是不完全切片的例子，和完全切片的情况一样的

int_a=[1,2,[3],4]       # 和上面不同的是第二号元素是可变的对象
int_b=int_a[:3]          #对lint_a不完全切片，但切片得到的int_b[2]是一个可变对象
int_a[2].append(5)      # 对可变子元素进行追加子元素操作，注意是对子元素本身进行追加操作
int_a[2][0] = 33
""" # 对可变子元素进行修改子元素操作，注意是对子元素本身的子元素进行修改操作，而不是修改int_a的子元素"""
int_b[0]=9
print(int_a is int_b)   # 输出False，list_a和list_b是不同的对象
print(id(int_a))
print(id(int_b))
print(int_a)
print(int_b)
print(int_a[1] is int_b[1])
"""输出True，在切片操作中，可变子元素是相当于赋值操作的，即list_a[2]和list_b[2]是同一个对象"""

False
1693617968200
1693618522440
[1, 2, [33, 5], 4]
[9, 2, [33, 5]]
返回值不同
True
返回值说明了
可变对象的同一个元素的内存地址相同

拷贝

相对于上面的赋值和切片，这里所说的拷贝的是通过copy模块进行拷贝操作
source翻译：来源
浅拷贝使用copy.copy(source)方法实现（某些对象本身会提供copy方法，如list.copy），拷贝出来的对象和原对象有可能是同一对象，如果拷贝的对象是可变对象，其子元素有可能是同一对象

一、对不可变对象进行浅拷贝，相当于深拷贝，类似于赋值操作，请参考上面的赋值说明，与赋值不同的是，这里拷贝得到的的对象和原对象是同一对象

import copy
a = 'hello'
b = copy.copy(a)
print(b is a) # 输出True，和赋值一样

c = 'a' * 4097
d = copy.copy(c)
print(d is c) # 
输出True，和赋值不一样，
已经超过缓存范围，但还是一样，这种情况可以类比于不设缓存范围（肯定缓存）的赋值操作

这一点说明了浅拷贝的作用比赋值的作用大。
赋值在不在范围值内
而浅拷贝不用考虑。

二、对可变对象进行浅拷贝，相当于完全切片，得到的对象和原对象是不同的对象，但其子元素有可能是同一对象

import copy
a = [1, [2, [3, [4]]]]
b = copy.copy(a)
print(b is a) # 输出False，浅拷贝可变对象得到的对象和原对象是不同的对象
print(b[0] is a[0]) # True，浅拷贝可变对象得到的对象的不可变子元素是同一对象，这和深拷贝是一样的
print(b[1] is a[1]) # True，浅拷贝可变对象得到的对象的可变子元素也是同一对象，这和深拷贝是不一样的
# 下面两个和上面两个是一样的情况，一一对应，只不过层级更深而已
print(b[1][0] is a[1][0]) # True
print(b[1][1] is a[1][1]) # True

b[0] = 111 # 对b[0]直接修改
b.append(3434) # 对b进行追加操作
print(a, b) # 这里a和b不一样了

b[1][0] = 22 # 对子元素b[1][0]直接修改
b[1].append(5) # 对子元素b[1]进行追加操作
print(b[1], a[1]) # 这里的b[1]和a[1]还是保持一样的

深拷贝
深拷贝使用copy.deepcopy(source)方法实现，拷贝出来的对象和原对象有可能是同一对象，如果拷贝的对象是可变对象，其子元素也有可能是同一对象，但总的来说，这两个对象完全没关系（无论是本身还是其子对象都完全没有关联），操作一个不会影响到另一个

import copy
a = 'a' * 10000
b = copy.deepcopy(a)
print(b is a) # 输出True，深拷贝不可变对象得到的对象和原对象是同一对象

可变对象的深拷贝

import copy
c = [1, [2, [3, [4]]]]
d = copy.deepcopy(c)
print(d is c) # 输出False，深拷贝可变对象得到的对象和原对象是不同的对象
print(d[0] is c[0]) # 输出True，深拷贝可变对象得到的对象的不可变子元素是同一对象
print(d[1] is c[1]) # 输出False，深拷贝可变对象得到的对象的可变子元素是不同的对象
# 下面两个和上面两个是一样的情况，一一对应，只不过层级更深而已
print(d[1][0] is c[1][0]) # 输出True
print(d[1][1] is c[1][1]) # 输出False

总结
赋值不可变对象要看是否有缓存机制来决定是否是同一对象
赋值可变对象相当于引用，完全不拷贝
切片相当于浅拷贝
对不可变对象进行浅拷贝，相当于深拷贝
对可变对象进行浅拷贝，直接修改一个不会不会影响另一个，但对其可变子元素的修改会影响另一个
深拷贝得到的对象和原对象互不相干，修改一个不会影响另一个，这里指任何修改
。