精华内容
下载资源
问答
  • 一、== 、is的比较区别 总结 is 是比较两个引用是否指向了同一个对象(地址比较)。 == 是比较两个对象的值是否相等。...二、深拷贝、浅拷贝的区别 ... 浅拷贝对不可变类型可变类型的copy不同 ...

    一、== 、is的比较区别

    总结

    • is 是比较两个引用是否指向了同一个对象(地址比较)。
    • == 是比较两个对象的值是否相等。

    二、深拷贝、浅拷贝的区别

    1. 浅拷贝是对于一个对象的顶层拷贝。通俗的理解是:拷贝了引用,并没有拷贝内容
    2. 深拷贝是对于一个对象所有层次的拷贝(递归)
    3. 浅拷贝对不可变类型和可变类型的copy不同

     

    展开全文
  • python的复制,深拷贝和浅拷贝的区别 在python中,对象赋值实际上是对象的引用。当创建一个对象,然后把它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 一般有三种方法, alist=[1,...

    python的复制,深拷贝和浅拷贝的区别
    在python中,对象赋值实际上是对象的引用。当创建一个对象,然后把它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用

    一般有三种方法,

    alist=[1,2,3,[“a”,“b”]]

    (1)直接赋值,传递对象的引用而已,原始列表改变,被赋值的b也会做相同的改变

    b=list
    print b
    [1, 2, 3, [‘a’, ‘b’]]

    list.append(5)
    alist=[1,2,3,[“a”,“b”]]
    b=alist
    print b
    [1, 2, 3, [‘a’, ‘b’]]

    alist.append(5)
    print alist;print b
    [1, 2, 3, [‘a’, ‘b’], 5]
    [1, 2, 3, [‘a’, ‘b’], 5]
    (2)copy浅拷贝,没有拷贝子对象,所以原始数据改变,子对象会改变

    import copy

    c=copy.copy(alist)
    print alist;print c
    [1, 2, 3, [‘a’, ‘b’]]
    [1, 2, 3, [‘a’, ‘b’]]

    alist.append(5)
    print alist;print c
    [1, 2, 3, [‘a’, ‘b’], 5]
    [1, 2, 3, [‘a’, ‘b’]]

    alist[3]
    [‘a’, ‘b’]

    alist[3].append(‘cccc’)
    print alist;print c
    [1, 2, 3, [‘a’, ‘b’, ‘cccc’], 5]
    [1, 2, 3, [‘a’, ‘b’, ‘cccc’]] 里面的子对象被改变了
    (3)深拷贝,包含对象里面的自对象的拷贝,所以原始对象的改变不会造成深拷贝里任何子元素的改变

    import copy

    d=copy.deepcopy(alist)
    print alist;print d
    [1, 2, 3, [‘a’, ‘b’]]
    [1, 2, 3, [‘a’, ‘b’]]始终没有改变

    alist.append(5)
    print alist;print d
    [1, 2, 3, [‘a’, ‘b’], 5]
    [1, 2, 3, [‘a’, ‘b’]]始终没有改变

    alist[3]
    [‘a’, ‘b’]

    alist[3].append(“ccccc”)
    print alist;print d
    [1, 2, 3, [‘a’, ‘b’, ‘ccccc’], 5]
    [1, 2, 3, [‘a’, ‘b’]] 始终没有改变

    展开全文
  • 拷贝和浅拷贝 浅拷贝是对一个对象的顶层(外层)拷贝,只是拷贝了引用,并没有拷贝内容。 变量的赋值是地址的引用,也算是一种浅拷贝。 copy.copy() 深拷贝则是对一个对象深层(递归)的拷贝,保证了数据的...

    深拷贝和浅拷贝

    浅拷贝是对一个对象的顶层(外层)拷贝,只是拷贝了引用,并没有拷贝内容。

    变量的赋值是地址的引用,也算是一种浅拷贝。

    copy.copy()

    深拷贝则是对一个对象深层(递归)的拷贝,保证了数据的独立性。

    copy.deepcopy()

    可变类型:列表、字典

    不可变类型:数字类型、字符串型、元组

    如果是可变类型,浅拷贝只拷贝外层,而深拷贝是完全拷贝

    如果是纯的不可变类型,那么无论是浅拷贝还是深拷贝,都只是指向同一个地址。如果不可变类型里面还存在可变类型,则浅拷贝是指向,而深拷贝则为完全拷贝。

    列表切片、字典的copy方法均属于浅拷贝

    展开全文
  • 关于python浅拷贝和深拷贝的自我总结 1.引用 a = ["value1", "value2"] b = a id(a) id(b) 这里内存分配了一块地址为这个列表,然后a指向这块地址,第二行代码意思是 让b也指向创建的列表,此时,a和b指向同一块...

    关于python中浅拷贝和深拷贝的自我总结

    1.引用

    a = ["value1", "value2"]
    b = a
    id(a)
    id(b)
    
    这里内存分配了一块地址为这个列表,然后a指向这块地址,第二行代码意思是
    让b也指向创建的列表,此时,a和b指向同一块内存空间,所以id(a)=id(b)。
    

    2.浅拷贝

    import copy
    a = [1, 2]
    b = [a, 3, 4]
    c = copy.copy(b)
    print(id(a))
    print(id(b))
    print(id(c))
    print(id(b[0]))
    print(id(c[0]))
    a.append(5)
    print(b)
    print(c)
    # 输出结果
    # id(a)
    # 1362057885768
    # id(b)
    # 1362057885640
    # id(c)
    # 1362057823560
    # id(b[0])
    # 1362057885768
    # id(c[0])
    # 1362057885768
    # print(b)
    # [[1, 2, 5], 3, 4]
    # print(c)
    # [[1, 2, 5], 3, 4]
    
    从结果可以看出,b和c的id地址不一样,c重新指向了一块空间,但是比较b[0]和
    c[0]的时候,却发现指向同一块内存地址,再次通过调用a.append方法,向a中追
    加值,发现输出来的b,c也随着变化了,这就是浅拷贝,拷贝的不够彻底。
    

    3.深拷贝

    import copy
    a = [1, 2]
    b = [a, 3, 4]
    c = copy.deepcopy(b)
    print(id(a))
    print(id(b))
    print(id(c))
    print(id(b[0]))
    print(id(c[0]))
    a.append(5)
    print(b)
    print(c)
    # 输出结果
    # id(a)
    # 1317602461064
    # id(b)
    # 1317602515208
    # id(c)
    # 1317602515272
    # id(b[0])
    # 1317602461064
    # id(c[0])
    # 1317602514824
    # print(b)
    # [[1, 2, 5], 3, 4]
    # print(c)
    # [[1, 2], 3, 4]
    
    通过观察代码发现,id(a)和id(b[0])指向同一块内存地址,但是id(c[0])却和
    它们不一样了,c[0]重新指向了新的一块地址,所以无论a怎么变化,都不会影响到
    c,也可以这么说,c与a,b没有了任何关系。于是深拷贝就是比浅拷贝更加彻底。
    

    4.注意

    对于像元组这样的不可变类型进行深浅拷贝的时候需注意,废话不多说,上代码:
    
    import copy
    a = (1, 2)
    b = copy.copy(a)
    c = copy.deepcopy(a)
    print(id(a))
    print(id(b))
    print(id(c))
    # 输出结果
    # id(a)
    # 2579250860296
    # id(b)
    # 2579250860296
    # id(c)
    # 2579250860296
    
    可见结果中三个地址一样,所以说明对于元组这种不可变类型,它不会重新再在内存
    中创建一个元组对象,深浅拷贝就相当于让b,c指向a所指向的内存地址。
    需要我们注意的是,此时,元组中的元素是不可变类型。那要是把一些可变类型当作
    元组的元素呢?代码如下:
    
    import copy
    a = [1, 2]
    b = [3, 4]
    c = (a, b)
    d = copy.copy(c)
    e = copy.deepcopy(c)
    print(id(a))
    print(id(b))
    print(id(c))
    print(id(d))
    print(id(e))
    a.append(5)
    print(a)
    print(c)
    print(d)
    print(e)
    # 输出结果
    # print(id(a))
    # 1522131609608
    # print(id(b))
    # 1522131609480
    # print(id(c))
    # 1522131610952
    # print(id(d))
    # 1522131610952
    # print(id(e))
    # 1522131631560
    # a
    # [1, 2, 5]
    # c
    # ([1, 2, 5], [3, 4])
    # d
    # ([1, 2, 5], [3, 4])
    # e
    # ([1, 2], [3, 4])
    
    结果可以看到,当元组的元素变为不可变类型之后,浅拷贝相当于引用,让c和d指
    向同一块内存地址,深拷贝的话,就是彻底拷贝了。e和前面的变量就没有关联了。
    

    作为一名以后的python从业者,这是我第一个博客,以后每天我也会坚持写一个博客,加油。

    展开全文
  • Python中,对象的赋值,拷贝(深/浅拷贝)之间是有差异的,如果使用的时候不注意,就可能产生意外的结果。 下面本文就通过简单的例子介绍一下这些概念之间的差别。 对象赋值 直接看一段代码: ...
  • 第五种情况,外层可变,内层可变----真正体现浅拷贝和深拷贝的差距,a[:]是一种浅拷贝。深浅拷贝都重新开辟了内存空间,浅拷贝的内层元素只是引用了内存地址,深拷贝的内层元素也重新开辟了内存空间。 """ e =...
  • 浅拷贝的意思就是只拷贝外面的一层,深拷贝就是拷贝的里面的所有。 看两段代码: 元组: #!/usr/bin/env/python # -*-coding:utf-8-*- # authour:xiapmin_pei import copy #定义一个元组,元组里面有一个...
  • 深浅拷贝在python中经常使用,其区别的外在表现是:使用浅拷贝,当原容器对象中可变对象中有元素发生变化,拷贝得到的对象也会变化。而使用深拷贝时,不会有这种问题。听起来有一点难理解,看例子比较直观:浅拷贝&...
  • 假设 B 复制了 A,当修改 A 时,看 B 是否会发生变化,如果 B 也跟着变了,说明这是浅拷贝,拿人手短,如果 B 没变,那就是深拷贝,自食其力。 在python中,对象赋值实际上是对象的引用。 当创建一个对象,然后把它...

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

python中深拷贝和浅拷贝

python 订阅