Python 对象拷贝的那点事？

news2024/11/18 3:18:33

1.变量，引用和对象

变量无类型，它的作用仅仅在某个时候引用了特定的对象而已，具体在内存中就是一个指针，仅仅拥有指向对象的空间大小。

变量和对象的关系在于引用，变量引用对象后，也就对应了赋值的过程。

在 python 中一切皆为对象，具体在内存中表示一块内存空间，每一个对象都会具有 identity，type 和 value 这三个内容。

Identity, 一旦对象被创建后，Identity 的值便不会发生改变。在 Cpython 中，其值体现为内存中保存对象的地址。is 操作符，比较对象是否相等就是通过这个值。通过 id() 函数查看它的整数形式。

Type, 和 Identity 一样，在对象创建后，Type 也不会发生变化。它主要定义了一些可能支持的值和操作（如对列表来说，会有求长度的操作）。通过 type() 函数可以得到对象的类型。

Value，用于表示的某些对象的值。当对象在创建后值可以改变称为 mutable，否则的话被称为 immutable.

举个例子，比如在 C 中，int x = 4 在内存中，是先分配了一个 int 类型的内存空间，然后把 4 放进空间内。

而 Python 中，x = 4 正好相反，是为 4 分配了一块的内存空间，然后用 x 指向它。由于变量可以指向各种类型的对象，因此不需要像 C 一样声明变量。这也就是 Python 被称为动态类型的意义。

并且在 Python 中，变量可以删除，但对象是无法删除的。

2.immutable 和 mutable 对象

immutable 对象拥有一个固定的值，包括 numbers, strings, tuples. 一个新的值被保存时，一个新的对象就会被创建。这些对象在作为常量的 hash 值中有着非常重要的作用，如作为字典的 key 时。

mutable 对象可以改变自身的值，但 id() 并不会发生改变。

当一些对象包含对其他对象的一些引用时，我们称这些对象为 containers, 例如 list, tuple, dictionary 这些都是 containers. 这里需要注意的是，一个 immutable containers 可以包含对 mutable 对象的引用（如在 tuple 中包含一个 list）。 但这个对象仍然称为 immutable 对象，因为 Identity 是不变的。

3.hashable 对象

当一个对象在生命周期内（实现了__hash__()方法）hash 值不会发生改变，并可以与其他对象进行比较（实现了 __eq__() 方法），称之为hashable 对象。

在 Python 内置的 immutable 对象 大多数都是 hashable 对象。immutable containers（tuples, frozenset）在引用的对象都是 hashable 对象时，才是hashable 对象。mutable containers 容器都不是 hashable 对象。用户自定义的类都是 hashable 对象，

4.浅拷贝与深拷贝

在介绍对象的拷贝前，先介绍一下 Python 中的赋值操作，可以让我们更好的了解拷贝的过程。

赋值操作

赋值操作的右边是简单表达式:

def normal_operation():

    # immutable objects
    # int
    a = 10
    b = 10
    print('----- int')
    print("id of a:{} , id of b: {}".format(id(a), id(b)))
    # id of a:1777364320 , id of b: 1777364320
    print(a == b)  # True
    print(a is b)  # True
    # str
    str_a = '123'
    str_b = '123'
    print('----- str')
    print("id of a:{} , id of b: {}".format(id(str_a), id(str_b)))
    # id of a:1615046978224 , id of b: 1615046978224
    print(str_a == str_b)  # True
    print(str_a is str_b)  # True

    # tuple
    tuple_a = (1, 2, 3)
    tuple_b = (1, 2, 3)
    print('----- tuple')
    print("id of a:{} , id of b: {}".format(id(tuple_a), id(tuple_b)))
    # id of a:1615047009696 , id of b: 1615047024856
    print(tuple_a == tuple_b)  # True
    print(tuple_a is tuple_b)  # False

    # mutable
    # set
    set_a = {1, 2, 3}
    set_b = {1, 2, 3}
    print('----- set')
    print("id of a:{} , id of b: {}".format(id(set_a), id(set_b)))
    # id of a:1615045625000 , id of b: 1615047012872
    print(set_a == set_b)  # True
    print(set_a is set_b)  # False

    # list
    list_a = [1, 2, 3]
    list_b = [1, 2, 3]
    print('----- list')
    print("id of a:{} , id of b: {}".format(id(list_a), id(list_b)))
    # id of a:1615047017800 , id of b: 1615045537352
    print(list_a == list_b)  # True
    print(list_a is list_b)  # False

    # dict
    dict_a = {"name": "xxx", "age": "123"}
    dict_b = {"name": "xxx", "age": "123"}
    print('----- dict')
    print("id of a:{} , id of b: {}".format(id(dict_a), id(dict_b)))
    # id of a:1615045521696 , id of b: 1615045522128
    print(dict_a == dict_b)  # True
    print(dict_a is dict_b)  # False

在 Cpython 中，id() 反映了对象在内存中的地址。可以看到，对于 immutable 对象中的 number 和 string 来说，CPython 本身对其做了一定的优化，在创建相同的内容时，使其 指向了相同的内存地址，从而被复用。

但是，Python 不会对所有 mutable 对象执行此操作，因为实现此功能需要一定的运行时成本。对于在内存中的对象来说，必须首先在内存中搜索对象（搜索意味着时间）。对于 number 和 string 来说，搜索到它们很容易，所以才对其做了这样的优化。

对于其他类型的对象，虽然创建的内容相同，但都在内存中完全创建了一块新的区域。

赋值操作的右边是 Python 中已存在的变量:

def assignment_operation():
    # immutable objects
    # int
    a = 10
    b = a
    print('----- int')
    print("id of a:{} , id of b: {}".format(id(a), id(b)))
    # id of a:1777364320 , id of b: 1777364320
    print(a == b)  # True
    print(a is b)  # True
    # str
    str_a = '123'
    str_b = str_a
    print('----- str')
    print("id of a:{} , id of b: {}".format(id(str_a), id(str_b)))
    # id of a:2676110142128 , id of b: 2676110142128
    print(str_a == str_b)  # True
    print(str_a is str_b)  # True

    # tuple
    tuple_a = (1, 2, 3)
    tuple_b = tuple_a
    print('----- tuple')
    print("id of a:{} , id of b: {}".format(id(tuple_a), id(tuple_b)))
    # id of a:2676110191640 , id of b: 2676110191640
    print(tuple_a == tuple_b)  # True
    print(tuple_a is tuple_b)  # True

    # mutable
    # set
    set_a = {1, 2, 3}
    set_b = set_a
    print('----- set')
    print("id of a:{} , id of b: {}".format(id(set_a), id(set_b)))
    # id of a:2676108788904 , id of b: 2676108788904
    print(set_a == set_b)  # True
    print(set_a is set_b)  # True

    # list
    list_a = [1, 2, 3]
    list_b = list_a
    print('----- list')
    print("id of a:{} , id of b: {}".format(id(list_a), id(list_b)))
    # id of a:2676110181704 , id of b: 2676110181704
    print(list_a == list_b)  # True
    print(list_a is list_b)  # True

    # dict
    dict_a = {"name": "xxx", "age": "123"}
    dict_b = dict_a
    print('----- dict')
    print("id of a:{} , id of b: {}".format(id(dict_a), id(dict_b)))
    # id of a:2676079063328 , id of b: 2676079063328
    print(dict_a == dict_b)  # True
    print(dict_a is dict_b)  # True

而当赋值操作的右边是已经存在的 Python 对象时，不论是什么类型的对象，都没有在内存中创建新的内容，仅仅是声明了一个新的变量指向之前内存中已经创建的对象，就像提供了一个别名一样。

dict_a = {‘1’:1}
dict_b = dict_a
print(“id of a:{} , id of b: {}”.format(id(dict_a), id(dict_b)))
id of a:140355639151936 , id of b: 140355639151936

dict_b = {}
print(“id of a:{} , id of b: {}”.format(id(dict_a), id(dict_b)))
id of a:140355639151936 , id of b: 140355639922176

由于 dict_b = dict_a操作，让两个变量同时指向了同一块内存区域。自然 id 相等。
当对 dict_b 重新赋值时，仅让 b 指向了另外一块内存区域，并不会影响 a 的指向，由于两块内存区域不同，自然id 并不想等。
改变赋值后的对象

def assignment_operation_change():
    # immutable objects
    # int
    a = 10
    print("id of a:{}".format(id(a)))  
    # id of a:1994633728
    b = a 
    a = a + 10
    print('----- int')
    print("id of a:{} , id of b: {}".format(id(a), id(b)))
    # id of a:1994634048 , id of b: 1994633728
    print(a == b)  # False
    print(a is b)  # False

    # mutable objects
    # list
    list_a = [1, 2, 3]
    list_b = list_a
    list_a.append(4)
    print('----- list')
    print("id of a:{} , id of b: {}".format(id(list_a), id(list_b)))
    # id of a:2676110181704 , id of b: 2676110181704
    print(list_a == list_b)  # True
    print(list_a is list_b)  # True

当修改 imutable 对象时，由于其本身不可改变，只能在内存中新申请一块新的空间，用于存储修改后的内容。对应上面 a=20 的操作，这时再判断 a 和 b 时，由于指向了内存的不同位置，所以 a，b不在相等。a 原来指向的内存区域不会被回收，因为现在由 b 指向。可以看到 b 指向的内存地址和 a 之前的指向的内存地址是一致的。

当修改 mutable 对象时，由于都指向相同的内存地址，所以对变量 list_a 修改的操作，也会映射到变量 list_b。

总结一下：

  • 指向 imutable 的不同变量，当其中一个变量被修改时，其他变量不受影响，因为被修改后的变量会指向一个新创建的对象。

  • 指向 mutable 对象的不同变量，当其中一个变量修改这个对象时，会影响到指向这个对象的所有变量。

浅拷贝

浅拷贝创建了一个对象，这个对象包含了对被拷贝元素的参考。 所以当使用浅拷贝来复制 conainters 对象时，仅仅拷贝了那些嵌套元素的引用。

def shallow_copy():
    # immutable objects
    # int
    a = 10
    b = copy(a)
    print('----- int')
    print("id of a:{} , id of b: {}".format(id(a), id(b)))
    # id of a:1777364320 , id of b: 1777364320
    print(a == b)  # True
    print(a is b)  # True
    # str
    str_a = '123'
    str_b = copy(str_a)
    print('----- str')
    print("id of a:{} , id of b: {}".format(id(str_a), id(str_b)))
    # id of a:2676110142128 , id of b: 2676110142128
    print(str_a == str_b)  # True
    print(str_a is str_b)  # True

    # tuple
    tuple_a = (1, 2, 3)
    # Three methods of shallow copy
    # tuple_b = tuple_a[:]
    # tuple_b = tuple(tuple_a)
    tuple_b = copy(tuple_a)
    print(id(tuple_b))
    print('----- tuple')
    print("id of a:{} , id of b: {}".format(id(tuple_a), id(tuple_b)))
    # id of a:2676110191640 , id of b: 2676110191640
    print(tuple_a == tuple_b)  # True
    print(tuple_a is tuple_b)  # True

    # mutable
    # set
    set_a = {1, 2, 3}
    # Two methods of shallow copy
    # set_b = set(set_a)
    set_b = copy(set_a)
    print('----- set')
    print("id of a:{} , id of b: {}".format(id(set_a), id(set_b)))
    # id of a:2099885540520 , id of b: 2099888490984
    print(set_a == set_b)  # True
    print(set_a is set_b)  # False

    # list
    list_a = [1, 2, 3]
    # Three methods of shallow copy
    # list_b = list_a[:]
    # list_b = list(list_b)
    list_b = copy(list_a)
    print('----- list')
    print("id of a:{} , id of b: {}".format(id(list_a), id(list_b)))
    # id of a:2099888478280 , id of b: 2099888478472
    print(list_a == list_b)  # True
    print(list_a is list_b)  # False

    # dict
    dict_a = {"name": "xxx", "age": "123"}
    # Two methods of shallow copy
    # dict_b = dict(dict_a)
    dict_b = copy(dict_a)
    print('----- dict')
    print("id of a:{} , id of b: {}".format(id(dict_a), id(dict_b)))
    # id of a:2099855880480 , id of b: 2099886881024
    print(dict_a == dict_b)  # True
    print(dict_a is dict_b)  # False

这里有一点需要注意，对于 string 和 number 来说，正如上面提到的 Cpython 做了相应的优化，让不同的变量指向了相同的内存地址，进而 id 的值是相等的。

但对于元组这个 immutable 元素来说，执行 浅拷贝时，也不会创建一个内存区域，只是返回一个老元组的引用。

对于其他的 mutable 对象，在浅拷贝后都会创建一个新的内存区域，包含了被拷贝元素的引用。

浅拷贝正如它的名字那样，当拷贝嵌套的 mutable 元素时，就会出现问题：

def shallow_copy_change_value():
    # list
    # Python小白学习交流群：711312441
    list_a = [1, 2, 3, [4, 5, 6]]
    list_b = copy(list_a)
    list_a[0] = 10
    list_a[3].append(7)
    print('----- list')
    print("ia:{} ,b: {}".format(list_a, list_b))
    print("id of a:{} , id of b: {}".format(id(list_a), id(list_b)))
    # a:[10, 2, 3, [4, 5, 6, 7]] ,b: [1, 2, 3, [4, 5, 6, 7]]
    # id of a:1698595158472 , id of b: 1698595159752
    print(list_a == list_b)  # False
    print(list_a is list_b)  # False

下面是对上面 list 浅拷贝的图解：

执行浅拷贝操作：

在这里插入图片描述
在 list_b 执行浅拷贝后，创建一个新的对象，新对象中的 list_a[0] 指向 1.

修改 list_a 操作：
在这里插入图片描述
当执行 list_a[0] = 10 操作时，由于 list_a[0] 本身是 number 类型，会重新创建一块区域，用于保存新的值 10. 而新创建的 list_b[0] 并不会受到影响，还会指向之前的内存区域。

当修改list_a[3] 操作时，由于list_a[3] 在浅拷贝后，新创建的对象中不会 嵌套创建 一个新的 list_a[3] 对象，仅仅是指向了之前的 list_a[3] 对象。所以当修改 list_a[3] 时, list_b[3] 也会收到影响。

深拷贝

对于深拷贝操作来说，除了会创建一个新的对象外，会还递归的遍历老对象的中的嵌套元素，并形成新的副本。

def shallow_deepcopy_change_value():
    # list
    list_a = [1, 2, 3, [4, 5, 6]]
    list_b = deepcopy(list_a)
    list_a[0] = 10
    list_a[3].append(7)
    print('----- list')
    print("a:{} ,b: {}".format(list_a, list_b))
    print("id of a:{} , id of b: {}".format(id(list_a), id(list_b)))
    # id of a:2099888478280 , id of b: 2099888478472
    print(list_a == list_b)  # False
    print(list_a is list_b)  # False

下面是对应图解过程：

执行深拷贝操作：
在这里插入图片描述
修改 list_a 操作：
在这里插入图片描述
这里 list_a 和 list_b 已经是完全的不同的两个对象。

总结

在这篇文章中，主要介绍了 Python 中对象，以及对象的拷贝过程，主要有下面几个重要的内容：

  • Python 中变量没有类型，仅仅可看做一个指针，通过引用指向对象。变量可以删除，但对象不行。

  • Python 对象被创建后，会拥有 identity，type 和 value 三个属性。

  • immutable 和 mutable，主要在于 value 在其生命周期内是否能发生变化。

  • 修改 mutable 对象时，所有指向它的变量都会受到影响。修改 immutable 对象时，指向它的其他变量没有影响。

  • immutable 的大多数对象都是 hashable，但要考虑 immutable containers 的特殊情况。

  • 浅拷贝会创建一个新的内存区域（对象），但其内部是对原对象内部引用的拷贝，在使用 mutable 对象时，存在一定的风险。

  • 深拷贝不但会创建一个新的内存区域（对象），还会递归的创建原对象的所有嵌套对象，但也带来了一些效率的问题。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/707054.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

VBA快速合并数据

VBA快速合并数据

实例需求：原始数据保存在工作表的A列至C列，现需要根据材料编号合并交付日期和交付数量，并且交付日期的日期格式采用两位数字年份简写格式，合并后的数据保存在E列和F列，如下图所示。 示例代码如下。 Sub demo()Dim o…
阅读更多...
MSP430F249 Proteus仿真数码管秒表-0050

MSP430F249 Proteus仿真数码管秒表-0050

MSP430F249 Proteus仿真数码管秒表-0050 Proteus仿真小实验： MSP430F249 Proteus仿真数码管秒表-0050 功能： 硬件组成：MSP430F249单片机 2位数码管2个按键（清零 开始/暂停） 1.点击开始键后数码管开始秒表计时0~9…
阅读更多...
Spring Cloud - HTTP 客户端 Feign 、自定义配置、优化、最佳实践

Spring Cloud - HTTP 客户端 Feign 、自定义配置、优化、最佳实践

目录 一、Feign 是什么，有什么用呢？ 二、Feign 客户端的使用 2.1、远程调用 1.引入依赖 2.在order-service（发起远程调用的微服务）的启动类添加注解开启Feign的功能 3.编写 Feign 客户端 4.通过 Feign 客户端发起远程调用 …
阅读更多...
附件1.服务器操作系统安全加固要求及配置建议【上】

附件1.服务器操作系统安全加固要求及配置建议【上】

文章目录 加固文件说明【重启auditd服务后/etc/audit/audit.rules文件内容消失怎么处理】【用户的的本地登录和远程登录默认都会被审计； 2，可配置对chown、chmod、chcon等命令的执行进行审计；【ssh会话默认会被审计；】【可添加审计…
阅读更多...
kafka入门用这一篇就够了!

kafka入门用这一篇就够了!

目录 1，kafka简单介绍 2，kafka使用场景 3，kafka基本概念 kafka集群 数据冗余 分区的写入 读取分区数据 顺序消费 提交策略 零拷贝技术（netty） 1，kafka简单介绍 kafka是一款分布式、支持分区的、多…
阅读更多...
3.springboot开发篇

3.springboot开发篇

SpringBoot开发实用篇 ​ KF-1.热部署 热部署是不用重启项目，项目自动更新 非springboot项目热部署实现原理 ​ 开发非springboot项目时，我们要制作一个web工程并通过tomcat启动，通常需要先安装tomcat服务器到磁盘中，开发的程序…
阅读更多...
【openGauss数据库】--运维指南02-逻辑备份与恢复

【openGauss数据库】--运维指南02-逻辑备份与恢复

【openGauss数据库】--运维指南02-逻辑备份与恢复 🔻 一、 openGauss数据库备份与恢复概述🔰 1.1 备份与恢复类型🔰 1.2 类型对比 🔻 二、 配置文件的备份与恢复🔻 三、逻辑备份----gs_dump & gs_dumpall&#x1…
阅读更多...
Uipath Excel 实战01-自动生成流水号最佳方法

Uipath Excel 实战01-自动生成流水号最佳方法

Uipath RPA 自动生成流水号最佳方法，提高RPA 性能，速度毫秒级。通过本案例将学会Excel 写入单元格、Excel 自动填充公式、Excel 自动调整列范围、保存Excel 文件以及使用Excel 函数。 公式参考： Excel公式参考： Excel CONCATENAT…
阅读更多...
动态规划——地下城游戏

动态规划——地下城游戏

题目链接 leetcode在线oj题——地下城游戏 题目描述 恶魔们抓住了公主并将她关在了地下城 dungeon 的 右下角 。地下城是由 m x n 个房间组成的二维网格。我们英勇的骑士最初被安置在 左上角 的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。 骑士的初始健…
阅读更多...
chatgpt赋能python：线上免费Python教程推荐

chatgpt赋能python：线上免费Python教程推荐

线上免费Python教程推荐 Python作为一门简单易学的编程语言，在各个行业和领域都越来越受欢迎。很多人想学Python，但是可能因为费用等问题而卡住了。今天，我们来介绍一些免费的Python教程，帮助那些想要学习Python但没有预算的人。…
阅读更多...
上手vue2的学习笔记2之安装vue的踩坑经历

上手vue2的学习笔记2之安装vue的踩坑经历

上一篇笔记 上手vue2的学习笔记1之了解前端三剑客，简单介绍了学习vue框架之前应该具备的基础知识和四个我认为非常有用的学习链接，建议大家动手实践一下，更多深刻的理解前端三剑客之间的关系。 这一篇笔记主要介绍我在安装vue过程中遇到的坑…
阅读更多...
华为FIT痩AP旁挂式隧道组网实验(一)

华为FIT痩AP旁挂式隧道组网实验(一)

拓扑图 实验设备型号ACAC6005S1S5700S2S3700APAP2050DNAP4AP2050DNAR1AR200 没有配置好之前,是没有这个AP范围圈的 配置流程 接入交换机创建VLAN,配置对应端口的链路类型,放行vlan,开启端口隔离 # 与AP连接的接口(0/0/2) [S2]vlan batch 100 101 [S2]int e0/0/2 [S2-Ethern…
阅读更多...
Android中关于SharedPreference参数的问题

Android中关于SharedPreference参数的问题

文章目录 一、前言二、问题背景三、问题定位四、问题解决 一、前言 在上周开发时遇到一个问题，记录一下： 首先描述一下应用场景： 使用sharedPreference进行存储，命名为a.xml，这里简称为a文件有两个服务，一…
阅读更多...
海思nnie 部署环境 搭建流程

海思nnie 部署环境 搭建流程

文章目录 在windows上安装 Ruyi studio 软件MinG-64 安装运行软件在windows上安装 Ruyi studio 软件 Hi3559A的资料包 链接：https://pan.baidu.com/s/1rQcXvLW6ruSxIs4C9cMSCg 提取码：zsq5 从百度网盘下载软件 有很多个版本， 这里我选择的是SVP_PC.part2的版本 解压后得到：…
阅读更多...
[爬虫]解决机票网站文本混淆问题-实战讲解

[爬虫]解决机票网站文本混淆问题-实战讲解

前言 最近有遇到很多小伙伴私信向我求助，遇到的问题基本上都是关于文本混淆或者是字体反爬的问题。今天给大家带来其中一个小伙伴的实际案例给大家讲讲解决方法 📝个人主页→数据挖掘博主ZTLJQ的主页 ​​ 个人推荐python学习系列： ☄️爬虫J…
阅读更多...
YOLOv8训练和预测

YOLOv8训练和预测

目录 1.源码下载 2.环境配置 3. 数据集准备 4.训练配置 5.训练时遇到的错误 1.源码下载 GitHub - ultralytics/ultralytics: NEW - YOLOv8 🚀 in PyTorch > ONNX > CoreML > TFLite 2.环境配置 运行环境需要的包和YOLOv5/v7一样，这里不…
阅读更多...
C语言：移位操作注意事项

C语言：移位操作注意事项

移位操作&#xff1a;因为操作符的原因&#xff0c;注意加括号。还有没必要在移位的时候进行&#xff08;uint32_t&#xff09;转换。 测试程序如下&#xff1a; #include <string.h> #include <stdlib.h> #include <stdio.h> #include <stdint.h>i…
阅读更多...
javaweb学习3

javaweb学习3

javascript入门 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Title</title><script type"text/javascript"> // <!-- 可以在head和body嵌入script执行顺序从上而…
阅读更多...
KEIL5-MDK配色方案

KEIL5-MDK配色方案

改字体 复制如下代码&#xff0c;替换原有文件内容 global.prop文件&#xff1a;D:Keil_v5\UV4\global.prop # properties for all file types indent.automatic1 virtual.space0 view.whitespace0 view.endofline0 code.page0 caretline.visible0 highlight.matchingbraces1 …
阅读更多...
【深度学习】日常笔记8

【深度学习】日常笔记8

过拟合是指模型在训练集上表现良好&#xff0c;但在验证集和测试集上表现不佳的现象。这是因为模型在训练过程中过度学习了训练数据中的噪声和细节&#xff0c;而忽略了更一般的特征和规律&#xff0c;导致模型泛化能力不足。 具体来说&#xff0c;当模型在训练集上进行训练时&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023