一文彻底理解python浅拷贝和深拷贝

这篇具有很好参考价值的文章主要介绍了一文彻底理解python浅拷贝和深拷贝。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、必备知识

  • 万物皆对象:在学习python的深浅拷贝之前我们必须要知道一个事情,就是python对象的引用,在python里面,万物皆对象,万物皆对象,万物皆对象,不管什么数据类型都是对象。我们定义一个变量并给这个变量赋值的时候赋的并不是这个对象值,而是这个对象引用,并不是一直值,如a = 1,这个时候并不是把1这个值赋给了a,而是把1这个对象的引用赋值给了a
  • 可变序列和不可变序列:可变序列就是可以直接对这个序列直接在原地址上进行数据修改,如果是不可变序列进行数据修改则会创建一个新的对象,让我这个变量重新指向新的对象。关于这部分不不懂的小伙伴可以参考下这篇博文:Python的可变类型与不可变类型,如果看完还是有不明白的地方可以评论区留言。

二、基本概念

  • 浅拷贝:浅拷贝会创建一个新的对象,但这个新对象的内可能是院对象的引用或者复制(视具体数据类型而言)。具体来说,如果原对象的元素是可变的(比如列表,字典,集合),浅拷贝会复制这些元素的引用,而不是元素本身。这意味着新对象和原对象会共享这些可变元素。如果对这些共享的元素进行修改,会影响到原对象。如果原对象的元素是不可变的(比如元组或字符串),浅拷贝则会复制这些元素的值,因为它们是不可变的,不会影响到原对象。浅拷贝通常有三种方式:自身构造器切片copy.copy()函数,不同数据类型(列表,元组,字典,集合 ,字符串)的浅拷贝会有差异,下面会逐一介绍。

  • 深拷贝:重新分配一块新的内存,创建一个新的对象,并将原对象中的元素以递归的方式通过创建新的子对象拷贝到新的对象中。新的对象和原对象之间没有任何关系。深拷贝使用copy.deepcopy()函数实现

  • python自带数据类型: 列表,元组,字典,集合,字符串

  • 必备工具网站:pythontutor

三、列表,元组,集合,字符串,字典浅拷贝

3.1 列表

  • 自身构造器:
>>> list1 = [1,2,3,4]
>>> list2 = list(list1)
>>> list2
[1, 2, 3, 4]
>>> id(list1)
140495553055488
>>> id(list2)
140495553080256
>>> list1==list2
True
  • 切片
>>> list1 = [1,2,3,4]
>>> list2 = list1[:]
>>> list2
[1, 2, 3, 4]
>>> list1 is list2
False
>>> list1 == list2
True
  • copy()函数
>>> import copy
>>> list1 = [1,2,3,4]
>>> list2 = copy.copy(list1)
>>> list1
[1, 2, 3, 4]
>>> list2
[1, 2, 3, 4]
>>> list1 is list2
False
>>> list1 == list2
True

注:python中的可变序列有自己的copy()方法,即对于列表和字典这种的对象可以使用list.copy()或者dict.copy()跟copy.copy()函数是等价的。

  • 总结:python列表可以使用三种方式进行浅拷贝:自身构造器,切片,copy()函数。浅拷贝之后两个变量的地址不一样,但是数值是一样的,

3.2 元组

  • 自身构造器
>>> a = (1,2,3,4)
>>> b = tuple(a)
>>> a
(1, 2, 3, 4)
>>> b
(1, 2, 3, 4)
>>> a is b
True
>>> a == b
True
  • 切片
>>> a = (1,2,3,4)
>>> b = a[:]
>>> a is b
True
>>> a == b
True
>>> a
(1, 2, 3, 4)
>>> b
(1, 2, 3, 4)
  • copy函数
>>> import copy
>>> a = (1,2,3,4)
>>> b = copy.copy(a)
>>> a
(1, 2, 3, 4)
>>> b
(1, 2, 3, 4)
>>> a is b
True
>>> a == b
True

3.3 集合

  • 自身构造器
>>> a = {1,2,3,4}
>>> b = set(a)
>>> a
{1, 2, 3, 4}
>>> b
{1, 2, 3, 4}
>>> a is b
False
>>> a == b
True
  • copy函数()
>>> import copy
>>> a = {1,2,3,4}
>>> b = copy.copy(a)
>>> a
{1, 2, 3, 4}
>>> b
{1, 2, 3, 4}
>>> a is b
False
>>> a ==b
True

3.4 字符串

  • 自身构造器
>>> a = "1234"
>>> b = str(a)
>>> a
'1234'
>>> b
'1234'
>>> a is b
True
>>> a == b
True
  • 切片
>>> a = "1234"
>>> b = a[:]
>>> a
'1234'
>>> b
'1234'
>>> a is b
True
>>> a == b
True
  • copy()
>>> import copy
>>> a = "1234"
>>> b = copy.copy(a)
>>> a
'1234'
>>> b
'1234'
>>> a is b
True
>>> a ==b
True

3.5 字典

  • 自身构造器
>>> dict1 = {"a":1, 1:2}
>>> dict2 = dict(dict1)
>>> dict1
{'a': 1, 1: 2}
>>> dict2
{'a': 1, 1: 2}
>>> dict1 is dict2
False
>>> dict1 == dict2
True
  • copy函数
>>> import copy
>>> dict1 = {"a":1, 1:2}
>>> dict2 = copy.copy(dict1)
>>> dict1
{'a': 1, 1: 2}
>>> dict2
{'a': 1, 1: 2}
>>> dict1 is dict2
False
>>> dict1 == dict2
True

3.6 特别注意

>>> list1 = [[1, 2], (30, 40)]
>>> list2 = list(list1)
>>> list1.append(100)
>>> list1
[[1, 2], (30, 40), 100]
>>> list2
[[1, 2], (30, 40)]
>>> list1[0].append(3)
>>> list1
[[1, 2, 3], (30, 40), 100]
>>> list2
[[1, 2, 3], (30, 40)]
>>> list1[1] += (50,60)
>>> list1
[[1, 2, 3], (30, 40, 50, 60), 100]
>>> list2
[[1, 2, 3], (30, 40)]
  • 如果是可变类型,浅拷贝之后一个变量改变不会影响到另一个,但是如果是不可变类型,一个改变了会影响到另一个同时改变。

可视化展示

  • 可变类型
list1 = [1,2,[3,4,[5,6]]]
list2 = list(list1)

dict1 = {"a":111, "b":{"c":222, "d":{"e":333}}}
dict2 = dict(dict1)

set1 = {1,2,3,4}
set2 = set(set1)

内存指向:
一文彻底理解python浅拷贝和深拷贝,Python,python,算法

  • 可变和不可变
list1 = [1,2,[3,4, [5,6]]]
list2 = list1
list3 = list(list1)
print(id(list1))
print(id(list2))
print(id(list3))


tuple1 = (1,2,(3,4,(5,6)))
tuple2 = tuple(tuple1)
tuple3 = tuple1 + (7,8)
tuple4 = tuple1
tuple5 = tuple1[1:3]
print(id(tuple1))
print(id(tuple2))
print(id(tuple3))


str1 = "12'34'56''"
str2 = str1[1:5]
str3 = str1
str4 = str1[:]
print(id(str1))
print(id(str2))
print(id(str3))
print(id(str4))

a = 135346347458484
b = int(a)
b = 123

输出:

140007835258880
140007835258880
140007835581440
140007674106368
140007674106368
140007674089280
140007835585072
140007660015344
140007835585072
140007835585072

内存指向
一文彻底理解python浅拷贝和深拷贝,Python,python,算法

浅拷贝总结

  • 可变数据类型的浅拷贝就是为新的变量重新分配一块内存空间,和原来变量的内存不一样,但是变量的值是一样的
  • 不可变数据类型不会发生浅拷贝,只是开辟了内存存储原对象的引用,而不是存储原对象的子对象的引用。
  • 要与赋值操作区分,赋值只是把原对象的引用赋值给了新的变量,相当于这两个变量指向同一个对象
  • 浅拷贝只改改变最外面一层的元素不会影响到原始数据(也就是最外层的数据是复制),改变内层元素则会影响原始数据(内层数据是引用)。
  • 可变类型会重新开辟一段内存,最外层元素互不影响,内层元素会指向原始的数据。不可变类型的数据发生完全浅拷贝(这里为了方便介绍理解成浅拷贝,实际上不可变类型不是浅拷贝,数据全部复制)时,新的变量和原始的变量的地址是一模一样的,如果是发生部分数据的复制或者增加数据的时候,则会新开辟一段空间。
  • 我们重点关注可变类型,因为不可变类型即使发生了浅拷贝或者赋值对我们后续使用没有任何影响,因为不可变类型数据不能被修改,一旦修改就重新开辟了一个新的内存来存储。

四、列表,元组,集合,字符串,字典深拷贝

可视化展示

  • 代码
import copy
list1 = [1,2,[3,4, [5,6]]]
list2 = copy.deepcopy(list1)
print(id(list1))
print(id(list2))


tuple1 = (1,2,(3,4,(5,6)))
tuple2 = copy.deepcopy(tuple1)
print(id(tuple1))
print(id(tuple2))

tuple3 = (1,2,[3,4], {"a":1})
tuple4 = tuple(tuple3)
tuple4[2].append(5)
tuple4[3]["a"] = 2

输出:

140347510384064
140347510378496
140347334201984
140347334201984
  • 可视化
    一文彻底理解python浅拷贝和深拷贝,Python,python,算法

结论

  • 可变类型深拷贝之后新旧变量地址不一样,不可变类型不变

  • 元组类型比较特殊, 元组内部如果嵌套了 可变类型(list, dict)浅拷贝之后, 内部的值修改, 会影响拷贝之后的结果

  • 补充:函数传参的时候不可变类型是值传递,可变类型是传引用文章来源地址https://www.toymoban.com/news/detail-733908.html

到了这里,关于一文彻底理解python浅拷贝和深拷贝的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 简单理解Python中的深拷贝与浅拷贝

    I. 简介 深拷贝会递归的创建一个完全独立的对象副本, 包括所有嵌套的对象 ,而浅拷贝只 复制嵌套对象的引用 ,不复制嵌套对象本身。 简单来说就是两者都对原对象进行了复制,因此使用is运算符来比较新旧对象时,返回的都是False(都开辟了新的内存);两者区别在于 对嵌

    2024年02月12日
    浏览(41)
  • 原型模式和深拷贝,浅拷贝

    案例引入 克隆羊问题 有一只羊,姓名为tom,年龄为1,颜色为白色,编写程序创建和tom羊属性完全相同的羊。 传统方式解决 代码实现 传统实现方式分析 1.优点是好理解,简单易操作。 2.缺点进行新对象创建时,总是需要重新获取原始对象的属性,如果创建的对象复杂时,效

    2024年02月09日
    浏览(37)
  • 浅拷贝和深拷贝的区别

    1、浅拷贝,指的是重新分配一块内存,创建一个新的对象,但里面的元素是原对象中各个子对象的引用。 2、深拷贝,是指重新分配一块内存,创建一个新的对象,并且将原对象中的元素,以递归的方式,通过创建新的子对象拷贝到新对象中。因此,新对象和原对象没有任何

    2024年02月15日
    浏览(36)
  • 如何实现浅拷贝和深拷贝

    1.Object.assign方法 结果为:  2.直接赋值 1.递归 输出结果为:  2.json 输出结果为:  

    2024年02月13日
    浏览(39)
  • 什么是浅拷贝和深拷贝

    javascript 中有不同的方法来复制对象,那么我们怎样才能正确地复制一个对象呢? 本文来介绍一下浅拷贝和深拷贝。 一、什么是浅拷贝(Shallow Copy) 浅拷贝是创建一个新对象,新对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型,拷贝的就是基本类型的值,如果属性

    2024年02月08日
    浏览(38)
  • python基础(5):深入理解 python 中的赋值、引用、拷贝、作用域

    目录 python基础(5):深入理解 python 中的赋值、引用、拷贝、作用域 1、先来看个问题吧: 2、引用 VS 拷贝: 3、增强赋值以及共享引用:

    2024年02月08日
    浏览(47)
  • js中浅拷贝和深拷贝的区别

    在JavaScript中,浅拷贝(Shallow Copy)和深拷贝(Deep Copy)是两种不同的复制对象的方法,它们之间存在一些重要的区别。 浅拷贝(Shallow Copy): 浅拷贝只复制对象的顶层属性,如果属性是对象或数组,则复制的是引用,而不是实际的对象。这意味着,如果更改了复制后的对象

    2024年01月20日
    浏览(34)
  • 【Python常用函数】一文让你彻底掌握Python中的pivot_table函数

    任何事情都是由量变到质变的过程,学习Python也不例外。只有把一个语言中的常用函数了如指掌了,才能在处理问题的过程中得心应手,快速地找到最优方案。本文和你一起来探索Python中的pivot_table函数,让你以最短的时间明白这个函数的原理。也可以利用碎片化的时间巩固

    2024年02月12日
    浏览(47)
  • 【嵌入式系列】一文彻底理解DMA

    DMA用于在 外设 与 存储器 之间以及 存储器 与 存储器 之间提供高速数据传输。可以在无需任何 CPU 操作的情况下通过 DMA 快速移动数据。这样节省的 CPU 资源可供其它操作使用。 我们用一个现实例子来做个类比。有一家冶炼公司,每天要不断的从矿场拉矿石进入厂区冶炼,以

    2023年04月19日
    浏览(96)
  • java八股文面试[java基础]——浅拷贝和深拷贝

      自验证:创建Class Student两个类, Student中含有Class对象 测试代码: 输出: 可以看到不同的Student对象,但是有相同的Class对象 修改Student clone方法: 可以看到不同的class对象,不同的值: 知识来源: 【23版面试突击】什么是浅拷贝和深拷贝_哔哩哔哩_bilibili 强引用、弱引用介

    2024年02月11日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包