'''
本文,将通过对Python中可变类型和不可变类型内容的整理,来引出类型之间的互相转换,传递,以及深拷贝和浅拷贝等内容。
不可变类型(unmutable):数字,字符串,元组,bool,None
可变类型(mutable):列表,字典
'''
'''
不可变类型(unmutable):数字,字符串,元组,bool,None
这里以数字为例进行解释:
a = 10
a = 20
计算机在内存里会有一个内存空间,这个空间会专门存储一个为10的值。
每一个内存空间都一个内存地址,计算机通过该地址来访问这个内存空间,从而读取10。
同理,若要调用20这个值,那么就到存有20这个值的内存空间来读取20。
a = 10
代表的意思是 a这个变量指向了一个存有10的内存空间。
a = 20
代表的意思是 a由原来指向存值10的空间改成指向另一个存了20的的内存空间。
更改的仅仅只是a这个变量的指向,而并非修改了内存空间里的数值。
所以,数字是不可变类型。
举个例子:
有两个房间。
门牌号分别为100和102。
100号房间,里存放了电视机;102号房间里存放了电脑。
工作人员a被要求专门负责带领老板去100号房间使用电视。
后来工作人员a被更换了工作,改让他负责领老板去102号房间去使用电脑。
代换一下就可以理解。
门牌号就是内存地址;
房间是内存空间;
电视和电脑分别为存储的值;
工作人员a就是一个名为a的变量;
给a的部署工作就是给a变量赋值的过程;
老板就是计算机,通过变量a的指向,访问到内存地址为100的内存空间,调用电视(10)这个值;
房间和房间里的东西互不影响,电脑本身也不会变成电视,电视本身也不会变成电脑。
'''
# 代码验证:
a = 10
print(a)
print(id(10))#查询10这个值的内存地址
print(id(a))#查询变量a指向的内存地址
a = 20
print(a)
print(id(20))#查询20这个值的内存地址
print(id(a))#查询变量a指向的内存地址
print('= '*25)
# 运行结果:
# ========================
# 10
# 1675437040
# 1675437040
# 20
# 1675437360
# 1675437360
# ========================
#可以看出,10这个值的内存地址跟a是一样的;而当a = 20时,20这个值的内存地址跟a是一样的。
#如果是数字这个值自身发生了改变,那10和20的内存地址应该相同的才对。
#所以,由此可知数字本身是不可变的,改变只是a的指向。
"""
可变类型(mutable):列表,字典
以列表为例进行解释:
首先,要明白
列表跟“10,20”这些常用值不同。
“10,20”这类常用值,计算机一般一开始就提前开辟好的固定的空间专门存这些常用值。
而列表,它里面的内容是有变化的,专门预先开辟空间来存储它并没有什么意义。
所以列表都是等到调用时,才会去开辟一个内存空间。
(这就是为啥开关机以后列表内存地址会发生变化的原因。)
(也不是所有数字都是有专门不变的内存空间,例如20000000这种不常用数字在赋值调用时,也是重新开辟内存空间。)
ls = [233,333,666,888]
开辟一个内存空间,类型为列表,并用变量ls通过内存地址指向这个内存空间。
该空间里面存储了(233,333,666,888)四个值的内存地址,
通过这个四个地址可以分别找到存储相应数字的内存空间。
举个例子:
有一个门牌号101的房间,
有四个对讲机,可以分别联系到另外4个不同的房间
这四个房间分别有名为233,333,666,888的几个人
有天,从101房间拿走一个对讲机
那么101房间就少了一个对讲机
但是101房间还是101房间,不会变成其他房间
代换一下就可以理解。
拿走一个对讲机,就相当于是列表里面的内容发生了改变
这操作的发生都还在同一个内存空间里
发生变化的是这个列表本身
内存空间没有变化。
"""
# 代码验证:
ls = [233,333,666,888]
print(ls)
print(id(ls))
ls.pop(0)
print(ls)
print(id(ls))
print('= '*25)
# 运行结果:
# ========================
# [233, 333, 666, 888]
# 6630472
# [333, 666, 888]
# 6630472
# ========================
#参照之前对数字这一不可变类型的总结,可知,什么是可变类型了。
#内存空间地址没有变化,说明变化的是列表这个值的本身。所以列表是可变的类型。
传递
不可变类型的传递:
首先,看一段代码。
a = '波斯猫'
print(id(a))
b = a
print(id(b))
a = '哈士奇'
print(id(a))
print('a=%s,b=%s'%(a,b))
print('= '*25)
# 运行结果:
# ========================
# 7440304
# 7440304
# 7440384
# a=哈士奇,b=波斯猫
# ========================
可以看出,本来波斯猫是变量a的值,b = a 以后,此时b的值也是波斯猫了。
而且此时a和b的内存空间地址都为7440304,说明a和b都指向了同一个内存空间,这个空间里存着“波斯猫”这个值。
然后给a重新赋值,计算机重新开辟一个内存空间存了“哈士奇”并用a指向它。
“哈士奇”空间和“波斯猫”空间是两个不同的内存空间所以内存地址也不相同。
但是a的波斯猫传给了b,a之后发生了改变,对b没有影响。
这就是,传递,而且是不可变类型的传递。
可变类型的传递:
首先,看一段代码。
a = [1,2,3]
print(id(a))
b = a
print(id(b))
print('a=%s,b=%s'%(a,b))
a.append(4)
print(id(a))
print('a=%s,b=%s'%(a,b))
print('= '*25)
# 运行结果:
# ========================
# 17763080
# 17763080
# a=[1, 2, 3],b=[1, 2, 3]
# 17763080
# a=[1, 2, 3, 4],b=[1, 2, 3, 4]
# ========================
可以看出,内存地址都没有发生变化,a和b都指向了同一个内存空间。
这个内存空间里面的值“[1,2,3]”本身发生了改变。
并不是开辟了新的内存空间。
由于是值的改变,而a和b都指向它
通过用a的指向修改了值本身,b指向的该值时,肯定也有相应的变化。
宏观角度讲,a变了,那么b也一起变了。a的变化能影响到b。
这就是,可变类型的传递。
拷贝
拷贝分为:深拷贝和浅拷贝
属于Python中的copy模块的方法
# 浅拷贝:
拷贝的是地址引用。可以找到共同的内容
一方修改了,另一方受影响
a = [1,2,3,4]
b = a
print(id(a))
print(id(b))
a.append(5)
print(a)
print(b)
print('= '*25)
# 运行结果:
# ========================
# 17957960
# 17957960
# [1, 2, 3, 4, 5]
# [1, 2, 3, 4, 5]
# ========================
某种角度来说,浅拷贝就是简单的传递
拷贝的是地址引用。可以找到共同的内容
一方修改了,另一方受影响
符合以上两个条件的传递就可定义为浅拷贝。
只拷贝了内存地址
# 深拷贝:
深拷贝的是内容一样。地址不一样。
一方修改了,另一方不受影响
b = copy.deepcopy(a)
b得到的内容与a的内容完全一样,地址不一样。
就算a中有对象引用,b中对应的引用的对象依然是内容一样,地址不一样。
递归拷贝
import copy
a = [1,2,3,4]
b = copy.deepcopy(a)
print(id(a))
print(id(b))
print(a)
print(b)
print('= '*25)
# 运行结果:
# ========================
# 18508936
# 18507144
# [1, 2, 3, 4]
# [1, 2, 3, 4]
# ========================
前文中,已经介绍了列表这一种可变类型的传递的特性。
本来内存地址是不会变化的,
但是在使用了深拷贝方法以后,又重新开辟了另一个内存空间
哪怕这两个空间里面所存的值是一样的,但是实际上两个毫不相干的内存空间
把空间里的内容完全复制到了另一个不同空间,
这就是,深拷贝
总结
1、值分为两种
1、可变的值 list
如果这个变量存储的是可变的值,然后传递给另外一个变量
此时,二者变量指向同一块内存空间
然后,任何一方做了修改,会影响另一个变量
住酒店:
比如你和老王去住酒店,住了一个房间,只有一台电视。
老王喜欢看中央一套,你喜欢看中央五套。
任何一人换台,影响另外一个人
引用传递:传递的是一个地址,二者指向同一个内容,任何一个修改,会影响另一个
2、不可变的值 数字、字符串、bool、None、元组
a = 10
a = 20
如果这个变量存储的是不可变的值,然后传递给另外一个变量
此时,二者变量指向同一块内存空间
然后,任何一方做了修改,会被重新赋值,不会影响另一个变量
住酒店:
比如你和老王去住酒店,住了两个房间,设施一样,有各自台电视。
老王喜欢看中央一套,你喜欢看中央五套。
任何一人换台,不影响另外一个人
值传递,传递的就是一个值,有一个修改了,并不影响另一个。
浅拷贝:
拷贝的是地址引用。可以找到共同的内容
一方修改了,另一方受影响
深拷贝:
深拷贝的是内容一样。地址不一样。
一方修改了,另一方不受影响
b = copy.deepcopy(a)
b得到的内容与a的内容完全一样,地址不一样。
就算a中有对象引用,b中对应的引用的对象依然是内容一样,地址不一样。
递归拷贝
网友评论