'''
本文，将通过对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中对应的引用的对象依然是内容一样，地址不一样。
递归拷贝