捐助郴维网
感谢您对郴维网的支持,你的支持将是郴维网持续发展的动力!
二维码
×
当前位置:郴维电脑服务中心 >扩展阅读 > 正文
13 2019.11

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

本文使用is运算符来判断对象间的唯一身份标识,也就是id是否相同,is也叫同一性运算符

 

赋值

赋值就是我们通过=把一个变量的值赋给另一变量,相当于引用,这里的赋值又可以分为几类

    1、赋值:不可变对象的赋值(在缓存范围内)

    为了增加程序的运行效率,Python3的解析器中实现了整型数字和字符串缓存的机制。

          整型数字的缓存范围为__[-5, 256]__,即变量值相等且在[-5, 20]范围内的所有变量都是同一个对象(这个是有争议的,有文章说是[-5, 无穷大],但我实测是[-5, 256])

          字符串默认缓存长度__4096__,即变量值相等且长度在4096以内的所有字符串变量是同一个对象,(这个是有争议的,很多文章说是缓存20位,但我实测是长度4096)

# 字符串赋值
str_a = str_b = 'hello' # 相当于 str_a = 'hello' 和 str_b = str_a 这两条语句
str_c = 'hello'
print(str_b is str_a) # 输出: True
print(str_c is str_a) # 输出:True,这里输出True就是因为缓存机制,str_c和str_a的值相等,都是'hello',且长度在20以内

# 整型赋值
int_a = int_b = 100 # 相当于 int_a = 100 和 int_b = int_a 这两条语句
int_c = 10 * 10
print(int_b is int_a) # 输出True
print(int_c is int_a) # 输出True,这里输出True就是缓存机制,因为int_c和int_a的值相等,都为100,且在[-5, 256]范围内

    2、赋值:不可变对象的赋值(不在缓存范围内)

# 字符串赋值
str_a = str_b = 'a' * 4097 # 相当于 str_a = 'a' * 4097 和 str_b = str_a 这两条语句
str_c = 'a' * 4097
print(str_b is str_a) # 输出: True
print(str_c is str_a) # 输出:False,这里输出False是因为虽然str_c和str_a的值相等,但长度在为4097,超过了缓存最大长度4096

# 整型赋值
int_a = int_b = 1000 # 相当于 int_a = 100 和 int_b = int_a 这两条语句
int_c = 10 * 10 * 10
print(int_b is int_a) # 输出True
print(int_c is int_a) # 输出False,这里输出False是因为虽然int_c和int_a的值相等,都为1000,但超出了缓存]范围[-5, 256]

    3、赋值:可变对象的赋值

    这种情况相当于完全引用,“比浅拷贝还要浅拷贝”,这里举个例,假定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 = list_b = [1, 2, 3] # 相当于 list_a = [1, 2, 3] 和 list_b = list_a 这两条语句
list_c = [1, 2, 3]
print(list_b is list_a) # 输出True,修改list_a会影响list_b,反之亦然
print(list_c is list_a) # 输出False,所以修改list_a不会影响到list_c,反之亦然
# 说明,这里所说的“比浅拷贝还浅拷贝”是针对浅拷贝而说的,也可以说完全没拷贝,只是引用
# 浅拷贝中对本身的修改不会影响另一个(对可变子元素本身的操作才会影响),而赋值无论哪种情况的修改都会影响另一个,(这里的赋值和浅拷贝是针对可变对象来说的)

 

切片

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

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

list_a = [1, 2, 3, 4]
list_b = list_a[:] # 完全切片
print(list_b is list_a) # 输出False,list_a和list_b是不同的对象
list_a.append(5) # 对对象list_a进行追加元素操作
# list_a[0] = 11 # 对对象list_a进行修改子元素操作
# del list_a[-1] # 对对象list_a进行删除子元素操作
print(list_a) # 输出[1, 2, 3, 4, 5]
print(list_b) # 输出[1, 2, 3, 4]
print(list_a is list_b) # 输出False,不是同一个对象

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

list_a = [1, 2, [3], 4] # 和上面不同在于list_a[2]是一个可变对象
list_b = list_a[:] # 完全切片
print(list_b is list_a) # 输出False,list_a和list_b是不同的对象
list_a[2].append(44) # 对可变子元素进行追加子元素操作,注意是对子元素本身进行追加操作
# list_a[2][0] = 33 # 对可变子元素进行修改子元素操作,注意是对子元素本身的子元素进行修改操作,而不是修改list_a的子元素
# del list_a[2][-1] # 对可变子元素进行删除子元素操作,注意是对子元素本身的子元素进行删除操作,而不是删除list_a的子元素
print(list_) # 输出[1, 2, [3, 44], 4]
print(list_b) # 输出[1, 2, [3, 44], 4]
print(list_b is list_a) # 输出False,list_a和list_b是不同的对象
print(list_a[2] is list_b[2]) # 输出True,在切片操作中,可变子元素是相当于赋值操作的,即list_a[2]和list_b[2]是同一个对象


# 说明:这种情况是不区分完全切片和不完全切片的,只要切片得到的子元素是可变对象的,都满足这种情况,以下代码就是不完全切片的例子,和完全切片的情况一样的
list_c = list_a[:3] # 不完全切片,但切片得到的list_c[2]是一个可变对象
print(list_c is list_a) # 输出False,list_a和list_c是不同的对象
list_a[2][0] = 33 # 修改可变子元素的子元素,注意是修改子元素本身的子元素,而不是修改list_a的子元素
print(list_a) # 输出[1, 2, [33, 44], 4]
print(list_c) # 输出[1, 2, [33, 44], 4]
print(list_c is list_a) # 输出False,list_a和list_c是不同的对象
print(list_a[2] is list_c[2]) # 输出True,在切片操作中,可变子元素是相当于赋值操作的,即list_a[2]和list_c[2]是同一个对象

 

拷贝

相对于上面的赋值和切片,这里所说的拷贝的是通过copy模块进行拷贝操作

    浅拷贝

    浅拷贝使用__copy.copy(source)__方法实现(某些对象本身会提供copy方法,如list.copy),拷贝出来的对象和原对象有可能是同一对象,如果拷贝的对象是可变对象,其子元素有可能是同一对象

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

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,和赋值不一样,已经超过缓存范围,但还是一样,这种情况可以类比于不设缓存范围(肯定缓存)的赋值操作

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

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)__方法实现,拷贝出来的对象和原对象有可能是同一对象,如果拷贝的对象是可变对象,其子元素也有可能是同一对象,但总的来说,这两个对象完全没关系(无论是本身还是其子对象都完全没有关联),操作一个不会影响到另一个

          1、不可变对象的深拷贝

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

           2、可变对象的深拷贝

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

 

总结

    ☛ 赋值不可变对象要看是否有缓存机制来决定是否是同一对象

    ☛ 赋值可变对象相当于引用,完全不拷贝

    ☛ 切片相当于浅拷贝

    ☛ 对不可变对象进行浅拷贝,相当于深拷贝

    ☛ 对可变对象进行浅拷贝,直接修改一个不会不会影响另一个,但对其可变子元素的修改会影响另一个

    ☛ 深拷贝得到的对象和原对象互不相干,修改一个不会影响另一个,这里指任何修改

Tips
郴维网为您提供各类专业服务:
软件开发,电脑配件销售,WIFI路由器销售,上门电脑维修,上门安装系统,系统安装,软、硬件安装,电脑除尘清灰,显示器维修,WIFI安装调试,服务器维护,数据恢复,密码破解,网络布线,网络检修,打印机维修,打印机加碳粉,苹果电脑安装系统,苹果电脑安装双系统,监控安装维护,电脑外包,笔记本电脑维修,餐饮、美容行业软件安装 等。。。。。。
点击次数:29  更新时间:2019-11-13 20:23:52  【打印此页】 【关闭

上一条:Pyinstaller打包资源文件

下一条:已经是最后一篇了

欢迎您,来自IP为:3.215.182.36( 美国康涅狄格州费尔菲尔德县费尔菲尔德镇通用电气公司) 的朋友!您是第696955位访客; 其中 电脑访客539725位,手机访客157230位.