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

    递归拷贝