【十八】深拷贝与浅拷贝

已于 2023-02-21 19:40:12 修改
阅读量25 收藏
点赞数 1
分类专栏： 从零入门玩转python 文章标签： python 开发语言
于 2023-02-21 19:39:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46395534/article/details/129148689
版权

赋值与深拷贝与浅拷贝

文章目录

前言

id(object)

  • 返回 object 的唯一标识符（内存地址）

赋值

  • Python中, 变量定义和赋值必须是同时进行的，比如当执行程序 a = 999 是先在内存中开辟一块空间来存放数据999，然后定义变量名a来 指向这块空间的内存地址，方便我们使用变量值，所以变量名和值其实是一种引用的关联关系
  • 严格来说，变量名本身没有类型，通常我们所说的变量类型指的是值的数据类型
var1 = 999
print(type(var1)) # <class 'int'>
var1 = "999"
print(type(var1)) # <class 'str'>
  • 通过内置函数id()获取变量地址时，实际是返回了值的地址
var1 = 256
print(id(256))
print(id(var1))  # 同上
# 140705904571168
# 140705904571168

var2 = -5
print(id(-5))
print(id(var2))  # 同上
# 140705904562816
# 140705904562816

var3 = 257
print(id(257))
print(id(var3))  # 不一样
# 1684355280240
# 1684355278256

var4 = -6
print(id(-6))
print(id(var4))  # 不一样
# 1684355280624
# 1684355280272
  • 为了节省内存空间，解释器做了优化，如果直接执行程序文件，相同 值的变量会引用自同一个对象，而在交互式窗口运行则可以看到区别 小整数对象池：Python 为了优化速度，避免整数频繁申请和销毁内存 空间，把范围在 [-5, 256] 之间的数字放在提前建立好的小整数对象池 里面，不会被垃圾回收，在这范围内的数值如果相等，地址也就相 同，因为使用的都是同一个对象
a = 257
b = 257
print(id(a))
print(id(b))
# 1684355279312
# 1684355279280

a = 256
b = 256
print(id(a))
print(id(b))
# 140705904571168
# 140705904571168

a = -5
b = -5
print(id(a))
print(id(b))
# 140705904562816
# 140705904562816

a = -6
b = -6
print(id(a))
print(id(b))
# 1684355278768
# 1684355280304
  • 一个值可以被多个变量名引用，当变量值的引用计数（即值被关联的 次数）为0时，可认定为该值不可用，那么Python的垃圾回收机制会收 回所占用的内存空间
a = 999  # a = [1, 2, 3]
b = 999  # b = [1, 2, 3]
c = a

# 变量a、c都指向第一个999, 引用计数为2
print(id(a))
print(id(c))
# 1684355278704
# 1684355278704
# 变量b指向第二个999, 引用计数为1
print(id(b)) # 1684355278416
del a  # 解除a的引用, 第一个999的引用计数为-1, 为1
print(id(c))  # c还是指向第一个999 # 1684355278704

c = b  # 解除c的引用, 重新指向第二个999, 则第一个999的引用计数再 - 1, 为0, 被回收
# b、c都指向第二个999, 引用计数+1, 为2
print(id(b))
print(id(c))
# 1684355278416
# 1684355278416
  • 当一个可变类型的数据被多个变量名引用时，如果对该原数据进行修 改，那么它所有引用都会改变
a = [1, 2, 3]
b = [1, 2, 3]
c = a

# 变量a、c都指向第一个[1, 2, 3], 引用计数为2
print(id(a))
print(id(c))
# 1684355286920
# 1684355286920
# 变量b指向第二个[1, 2, 3], 引用计数为1
print(id(b))  # 1684355622984

a.append(4)
print(a)  # [1, 2, 3, 4]
print(c)  # [1, 2, 3, 4]
print(b)  # [1, 2, 3]

浅拷贝 & 深拷贝

Python 中的赋值语句不复制对象，只是建立引用关联，对于可变数据，有时 我们不希望直接对它进行修改，因为这可能会导致一些意外的情况发生，所以 我们就可以把它copy一份，对它的副本进行操作

这种copy操作又分为浅层copy和深层copy，我们所学的 list.copy()、 dict.copy()、set.copy() 和切片都属于浅层copy。在copy模块中，提供了通用 的浅层和深层copy操作

浅拷贝

  • 浅层拷贝只考虑最外层的数据类型
  • 如果最外层的数据类型是可变的，则（最外层）发生拷贝
  • 如果最外层的数据类型是不可变的，则不发生拷贝
import copy

tup1 = (991, "abc")
tup2 = copy.copy(tup1)  # 浅拷贝
# tup2 = tup1
print(tup1)
print(tup2)
# (991, 'abc')
# (991, 'abc')
print(id(tup1))
print(id(tup2))
# 1684355563592
# 1684355563592

tup3 = (991, "abc", [])
tup4 = copy.copy(tup3)  # 浅拷贝
print(tup3)
print(tup4)
# (991, 'abc', [])
# (991, 'abc', [])
print(id(tup3))
print(id(tup4))
# 1684355544480
# 1684355544480
print(id(tup3[-1]))
print(id(tup4[-1]))
# 1684355633096
# 1684355633096


import copy

lis1 = [991, "abc", (9, 993), [994, 995], [888, 887],
        {"name": "Tom"}, (996, [997, 998]), (888, (886, 886))]
lis2 = copy.copy(lis1)  # 浅拷贝
print(id(lis1))
print(id(lis2))
# 1684355862600
# 1684355731272
lis1.append(9)
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994, 995], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886))]
print("索引0对应的id", id(lis1[0]))
print("索引0对应的id", id(lis2[0]))
# 索引0对应的id 1684355278704
# 索引0对应的id 1684355278704
print("索引1对应的id", id(lis1[1]))
print("索引1对应的id", id(lis2[1]))
# 索引1对应的id 1684252072792
# 索引1对应的id 1684252072792
print("索引2对应的id", id(lis1[2]))
print("索引2对应的id", id(lis2[2]))
# 索引2对应的id 1684355540744
# 索引2对应的id 1684355540744
print("索引3对应的id", id(lis1[3]))
print("索引3对应的id", id(lis2[3]))
# 索引3对应的id 1684355731208
# 索引3对应的id 1684355731208
print("索引4对应的id", id(lis1[4]))
print("索引4对应的id", id(lis2[4]))
# 索引4对应的id 1684355731336
# 索引4对应的id 1684355731336
print("索引5对应的id", id(lis1[5]))
print("索引5对应的id", id(lis2[5]))
# 索引5对应的id 1684355618352
# 索引5对应的id 1684355618352
print("索引6对应的id", id(lis1[6]))
print("索引6对应的id", id(lis2[6]))
# 索引6对应的id 1684355540680
# 索引6对应的id 1684355540680
print("索引7对应的id", id(lis1[7]))
print("索引7对应的id", id(lis2[7]))
# 索引7对应的id 1684355557640
# 索引7对应的id 1684355557640
print(id(lis1[6][-1]))
print(id(lis2[6][-1]))
# 1684355731400
# 1684355731400
print(id(lis1[7][-1]))
print(id(lis2[7][-1]))
# 1684355542216
# 1684355542216
lis1[3] = [994]
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886))]


lis1[3].append(999)
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994, 999], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886))]


lis1[4].append(886)
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994, 999], [888, 887, 886], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887, 886], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886))]

lis1[5].update(age=18)
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994, 999], [888, 887, 886], {'name': 'Tom', 'age': 18}, (996, [997, 998]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887, 886], {'name': 'Tom', 'age': 18}, (996, [997, 998]), (888, (886, 886))]

lis1[6][-1].pop()
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994, 999], [888, 887, 886], {'name': 'Tom', 'age': 18}, (996, [997]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887, 886], {'name': 'Tom', 'age': 18}, (996, [997]), (888, (886, 886))]

深拷贝

  1. 如果判断的该数据本身不可变且包含的所有数据都不可变, 则该数据不 发生拷贝
  2. 如果判断的该数据本身可变或者包含的数据存在可变, 则该数据发生拷贝
  • 对于其中需要判断的元素分别递归的去适用前两点规则
import copy


tup1 = (991, "abc")
tup2 = copy.deepcopy(tup1)  # 深拷贝
# tup2 = tup1
print(tup1)
print(tup2)
print(id(tup1))
print(id(tup2))
# (991, 'abc')
# (991, 'abc')
# 1684355549832
# 1684355549832

tup3 = (991, "abc", [])
tup4 = copy.deepcopy(tup3) # 深拷贝
print(tup3)
print(tup4)
# (991, 'abc', [])
# (991, 'abc', [])
print(id(tup3))
print(id(tup4))
# 1684355543400
# 1684355376976
print(id(tup3[0]))
print(id(tup4[0]))
#
# 1684355280144
# 1684355280144
print(id(tup3[1]))
print(id(tup4[1]))
# 1684252072792
# 1684252072792

print(id(tup3[-1]))
print(id(tup4[-1]))
# 1684355731016
# 1684355731144

import copy

lis1 = [991, "abc", (9, 993), [994, 995], [888, 887],
        {"name": "Tom"}, (996, [997, 998]), (888, (886, 886))]
lis2 = copy.deepcopy(lis1)  # 深拷贝
print(id(lis1))
print(id(lis2))
# 1684355865480
# 1684355865288
lis1.append(9)
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994, 995], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886))]

print("索引0对应的id", id(lis1[0]))
print("索引0对应的id", id(lis2[0]))
# 索引0对应的id 1684355278352
# 索引0对应的id 1684355278352
print("索引1对应的id", id(lis1[1]))
print("索引1对应的id", id(lis2[1]))
# 索引1对应的id 1684252072792
# 索引1对应的id 1684252072792
print("索引2对应的id", id(lis1[2]))
print("索引2对应的id", id(lis2[2]))
# 索引2对应的id 1684355568328
# 索引2对应的id 1684355568328
print("索引3对应的id", id(lis1[3]))
print("索引3对应的id", id(lis2[3]))
# 索引3对应的id 1684355865224
# 索引3对应的id 1684355862728
print("索引4对应的id", id(lis1[4]))
print("索引4对应的id", id(lis2[4]))
# 索引4对应的id 1684355865352
# 索引4对应的id 1684355865736
print("索引5对应的id", id(lis1[5]))
print("索引5对应的id", id(lis2[5]))
# 索引5对应的id 1684355271704
# 索引5对应的id 1684355805976
print("索引6对应的id", id(lis1[6]))
print("索引6对应的id", id(lis2[6]))
# 索引6对应的id 1684355563976
# 索引6对应的id 1684355623496
print("索引7对应的id", id(lis1[7]))
print("索引7对应的id", id(lis2[7]))
# 索引7对应的id 1684355557896
# 索引7对应的id 1684355557896
print(id(lis1[6][-1]))
print(id(lis2[6][-1]))
# 1684355865416
# 1684355865800
print(id(lis1[7][-1]))
print(id(lis2[7][-1]))
# 1684355607176
# 1684355607176

lis1[3].append(999)
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994, 995, 999], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886))]


lis1[5].update(age=18)
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994, 995, 999], [888, 887], {'name': 'Tom', 'age': 18}, (996, [997, 998]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886))]


lis1[6][-1].pop()
print(lis1)
print(lis2)
# [991, 'abc', (9, 993), [994, 995, 999], [888, 887], {'name': 'Tom', 'age': 18}, (996, [997]), (888, (886, 886)), 9]
# [991, 'abc', (9, 993), [994, 995], [888, 887], {'name': 'Tom'}, (996, [997, 998]), (888, (886, 886))]
名字不好起的名字都有人用？
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QImage的深拷贝与浅拷贝
琅嬛福地
11-05 2399
最近在 做项目时，被QImage深深的坑过，之前也没遇到过，来看看如何构造一个QImage, 查看头文件可知，有如下几种构造方法： QImage() Q_DECL_NOEXCEPT; QImage(const QSize &size, Format format); QImage(int width, int height, Format format); QImage(uchar *data, int width, int height, For...
浅拷贝与深拷贝
weixin_45837693的博客
07-29 93
如果类中没有指针，浅拷贝完全能解决所有拷贝问题，但是如果类中存在指针，那么浅拷贝就出现了大问题： 类中的指针会指向同一块内存空间，在对象生命周期结束的时候，析构函数会释放该内存空间，由于两个指针都指向这一个空间，就会导致这块内存空间被释放两次。 如： #include <iostream> #include <string.h> using namespace std; class Person { private: char*m_name; int m_age;
深拷贝与浅拷贝的区别
05-27 7681
深拷贝与浅拷贝是针对对象属性为对象的，因为基本数据类型在进行赋值操作时（也就是深拷贝（值拷贝）），是直接将值赋给了新的变量，也就是该变量是原变量的一个副本，这时，你修改两个中的任意一个都不会影响另一个；而对于对象或引用数据在进行浅拷贝时，只是将对象的引用复制了一份，也就是内存地址，即两个不同的变量指向了同一个内存地址，那么在改变任意一个变量的值都是改变内存地址所存储的值，因此两个变量的值都会改变。 1. js中的深拷贝（值拷贝）： js 中的基本数据类型：String，Number，Boolean，Nu.
js中的浅拷贝与深拷贝
jiangjunyuan168的博客
02-10 2945
在前端开发中的过程中我们经常要接触到浅拷贝与深拷贝的问题， 下面就对浅拷贝与深拷贝的概念、区别以及其有哪种实现方法来做一个简单的说明。 概念 浅拷贝： 浅拷贝是指，一个新的对象对原始对象的属性值进行精确地拷贝，如果拷贝的是基本数据类型，拷贝的就是基本数据类型的值，如果是引用数据类型，拷贝的就是内存地址。如果其中一个对象的引用内存地址发生改变，另一个对象也会发生变化。 深拷贝： 深拷贝相对浅拷贝而言，如果遇到属性值为引用类型的时候，它新建一个引用类型并将对应的值复制给它，因此对象获得的一个新的引用类型而不是一
深拷贝与浅拷贝
wufeifan_learner的博客
04-03 795
前面说到了拷贝构造函数，但是情况并未列举完。我怕文章太长就分开写，看的舒服。 有一种情况，那就是当构造函数中有指针操作，怎么办？ #include <iostream> using namespace std; class A{ private: int *a; public: A(){ a = new int[100]; cout...
python的深拷贝与浅拷贝
12-21
python的深拷贝与浅拷贝 引言 前两天在用python写A*算法的时候，被python的深拷贝和浅拷贝恶搞了一番，实际上还是因为没搞清楚哪些是深拷贝，哪些是浅拷贝，现特意写一篇小结，加深理解。 什么是浅拷贝 所谓浅拷贝，...
详解JS深拷贝与浅拷贝
10-14
JS中的深拷贝和浅拷贝是编程中常见的概念，尤其在处理复杂数据结构如对象和数组时显得尤为重要。它们之间的主要区别在于复制对象时是否复制了对象的引用。 首先，我们需要理解JavaScript的数据类型。JavaScript有两...
深拷贝和浅拷贝一些例子
04-20
深拷贝和浅拷贝一些例子
Python 深拷贝和浅拷贝详解
03-09
1、Python 深拷贝和浅拷贝概念理解 浅拷贝，指的是重新分配一块内存，创建一个新的对象，但里面的元素是原对象中各个子对象的引用。 深拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以...
力扣第214题“最短回文串”
10年数据\经营分析经验，现任大厂数据分析负责人
06-28 678
本文详细解读了力扣第214题“最短回文串”，通过使用 KMP 算法的方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
【Python】在 VS Code 里面绘制动图不显示动画的解决办法
Suasy小易的博客
06-25 464
VS Code 中使用 matplotlib 的动画功能，需要配置适当的绘图后端。
小红书商家电话采集软件使用指南
qq_34629423的博客
06-24 501
步骤一：安装Python和相关库 首先，确保你的电脑已经安装了Python运行环境（建议安装Python3版本）。步骤三：编写代码 在你喜欢的编辑器中创建一个新的Python文件，例如"shangjia_phone_crawler.py"。步骤二：获取商家列表页面URL 在小红书App中，进入你想要采集的商家列表页面，并复制该页面的URL地址。然后，按照提示输入商家列表页面的URL地址，回车确认。使用小红书商家电话采集软件可以提高商家电话的采集效率，以下是使用指南及附带代码。
Java的异常处理体系
落日的博客
06-28 905
ControllerAdvice 注解用于定义全局控制器建议，在 Spring MVC 中，控制器建议由控制器中的 @ExceptionHandler 方法、@InitBinder 方法和 @ModelAttribute 方法组成。①、CheckedException （检查异常 必须在代码中显式处理 使用try catch捕获 或者 在方法上使用 throws 抛出 除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常 ）
Scrapy框架与其他Python爬虫库的对比分析
wx_19970108018的博客
06-28 338
如果需要爬取大量网站的数据，并且需要复杂的处理操作，那么 Scrapy 框架是比较不错的选择；对于初学者来说，建议先学习其他 Python 爬虫库，掌握爬虫的基本技术，再考虑使用 Scrapy 框架进行深入的学习和开发。Scrapy 是一个专门为爬取网站数据而设计的框架，它内置了许多常用的爬虫功能，如自动模拟 HTTP 请求、页面解析、数据提取、数据存储等。BeautifulSoup 是 Python 中非常流行的 HTML 解析库，它可以快速、灵活地解析 HTML 页面，并提取需要的数据。
数据类型 运算符
Xiao_die888的博客
06-23 747
booleantruefalsebyteshortintlongLlfloatFfdoublechar基本数据类型直接存储它们的值，当变量被声明为基本数据类型时，它们直接在栈上分配内存。StringInteger引用数据类型在Java堆上分配内存，而引用变量（在栈上）存储的是对象在堆上的内存地址。
优化｜PyOptInterface:高效且灵活的Python优化建模语言
weixin_53463894的博客
06-25 635
建模语言的效率直接影响优化模型的构建和求解时间。通过C++实现的内核直接调用优化求解器的底层C接口，构建优化模型的速度非常快，在性能测试中建模速度最接近求解器的C++接口，比Pyomo快10-20倍，比一些优化求解器的官方Python接口快2-5倍，并超越了目前速度最快的开源建模语言JuMP.jl。在统一接口的基础上，仍然提供了设置优化求解器特定参数等底层接口和高级功能，比如支持混合整数规划（MIP）中的回调函数（callback function），提供与优化求解器官方Python接口相近的完备功能。
Python布尔值：理解与应用
RetutghbxLouis的博客
06-26 238
Python中的布尔值是逻辑数据类型，用于表示真（True）或假（False）两种状态。布尔值在编程中广泛用于条件判断和逻辑运算，是程序中控制流程和逻辑判断的基础。Python的布尔值支持逻辑运算符（如and、or、not）以及与比较运算符（如==、!=、<、>等）的结合使用，使得开发者可以根据条件执行不同的代码分支，实现复杂的逻辑控制。
13017.win10安装WSL2及CUDA开发环境
写给自己的笔记
06-25 766
默认启动进入root用户，修改进入到自定义用户.进入到ubuntu.exe目录。
使用container_of宏进行类型转换
最新发布
java666668888的博客
06-28 244
本文详细介绍了。
vue的深拷贝与浅拷贝
09-14
Vue中的深拷贝和浅拷贝与JavaScript中的深拷贝和浅拷贝有些不同。在Vue中，深拷贝和浅拷贝是针对Vue实例中的响应式数据的。 1. 浅拷贝：Vue的浅拷贝是通过`Object.assign()`或展开运算符`...`来实现的。浅拷贝只会...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值