美文网首页Python 随堂随记
Python.可变与不可变类型,传递,拷贝的整理。

Python.可变与不可变类型,传递,拷贝的整理。

作者: NataliaTsunako | 来源:发表于2017-07-13 20:19 被阅读0次

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

    相关文章

      网友评论

        本文标题:Python.可变与不可变类型,传递,拷贝的整理。

        本文链接:https://www.haomeiwen.com/subject/ltrghxtx.html