Python 对象拷贝的详细教程

Python热爱者 Python热爱者 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 600+累计阅读 676平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄7年
关注
原创 最新推荐文章于 2026-05-18 14:08:57 发布 676 阅读 AI 写同款· GEO 优化 ›
Python对象复制竟然有这么多种方式，赶紧学起来！ 在Python中，对象的复制是一个常见需求，尤其是在处理复杂数据结构时。浅拷贝通过copy模块的copy()函数实现，它创建原始对象的一个新实例，但这个新实例内部的子对象仍然是对原对象子对象的引用。这节将深入探讨浅拷贝的工作原理，并通过实战示例展示其在列表与字典中的应用，同时指出使用过程中需要注意的共享引用问题。 阅读详情

在本篇文章中，会先介绍 Python 中对象的基础概念，之后会提到对象的深浅拷贝以及区别。在阅读后，应该掌握如下的内容：

  • 理解变量、引用和对象的关系

  • 理解 Python 对象中 identity,type 和 value 的概念

  • 什么是 mutable 和 immutable 对象？以及它们和 hashable 的关系

  • 深浅拷贝的过程以及区别

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 中的赋值操作，可以让我们更好的了解拷贝的过程。

5.赋值操作

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

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 来说，搜索到它们很容易，所以才对其做了这样的优化。

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

6. 赋值操作的右边是 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 并不想等。

7.改变赋值后的对象

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 对象的不同变量，当其中一个变量修改这个对象时，会影响到指向这个对象的所有变量。

8.浅拷贝

浅拷贝创建了一个对象，这个对象包含了对被拷贝元素的参考。 所以当使用浅拷贝来复制 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
	# Python小白学习交流群：711312441
    # 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
    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 浅拷贝的图解：

执行浅拷贝操作：

72a62de32295d24a41f15aecb2f65eac

在 list_b 执行浅拷贝后，创建一个新的对象，新对象中的 list_a[0] 指向 1.

修改 list_a 操作：

f82e60e92a6c04ab94146965ee4e985e

当执行 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] 也会收到影响。

9.深拷贝

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

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

下面是对应图解过程：

执行深拷贝操作：

4a050f660c31f509ecde59eb8b589c38

修改 list_a 操作：

cd944895e4e8cb41278113baa1906af9

这里 list_a 和 list_b 已经是完全的不同的两个对象。

总结

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

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

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

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

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

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

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

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

标签
#python #开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
python：对象复制 1、Python中一切皆对象 ⑴在Python中，无论是定义的数值、字符串、列表、元组、集合、字典还是函数、类等都看作是一种对象 ⑵列表、元组、集合、字典属于复合对象，它们可以包含数值、字符串，也可以互相嵌套 ⑶对象都是可以赋值给变量的2、列表、字典、集合为可变对象，这些对象的有些方法是在对象本身上操作的 ⑴直接在对象本身上进行修改：改变的是对象本身，而不是生成一个修改后的新对象 ⑵如append()、remove()方法等等。这类方法都是在对象本身上进行修改，返回值 阅读详情

相关推荐

Python 对象拷贝的完整指南

对象拷贝在 Python 后端开发中非常重要，能够确保我们在处理对象时不会意外地修改原始数据。本文介绍了浅拷贝和深拷贝的实现方法，并提供了相应的示例代码。浅拷贝适用于大多数情况，它可以节省内存，并在需要时共享数据。另一方面，深拷贝则更适用于需要完全独立对象的情况。无论是浅拷贝还是深拷贝，都可以使用copy模块中的相应函数进行实现，即和。希望本文对你在 Python 后端开发中理解和使用对象拷贝提供了帮助。如果你对此还有任何疑问，请随时提问！

JoplCommon的博客 214

python 中的六种“复制”方法，Python零基础入门

python 中的六种“复制”方法，Python零基础入门

一名正义的白帽黑客 1万+

python进阶教程2：python变量引用、深拷贝和浅拷贝

Python变量引用与对象拷贝机制 摘要：本文系统阐述了Python变量的引用机制及对象拷贝特性。首先指出Python变量必须绑定对象才能存在，变量实质是内存数据的引用标识。通过内存示意图详细解析了变量指向、多引用、引用计数变化等核心概念。其次区分了可变与不可变对象的本质差异：可变对象（如列表）内容可修改而内存地址不变，不可变对象（如数字）修改会创建新对象。最后剖析拷贝机制：浅拷贝仅复制外层可变对象结构，不复制内部元素；深拷贝则递归复制整个对象结构。文章通过id()函数、内存示意图等工具，直观展示了变量引用

Cachel Wood的博客 188

Python 中变量的多种复制方法（常规拷贝，浅拷贝，深拷贝）

常规拷贝 大家常用的变量复制方法，用“=”就行。 但是！但是！但是！ 在我们复制字典和列表时会和我们预想的不一致 接下来，做个小实验 常规拷贝在原始变量 x 的改变后，因为共用同一个内存地址，因此会直接放到被复制的变量 y 上，导致“不知情”的情况下导致 y 变量在没有操作的情况下改变。 浅拷贝 解决办法就是使用浅拷贝 浅拷贝会将两个变量分别放在不同的内存地址，解决了常规拷贝的缺点。 深拷贝 但是，对于字典或列表中有嵌套的情况，浅拷贝同样不会生效。 这时候就需要用的深拷贝。 可以看到，深拷贝可以解决

Baimoc 1万+

逆向实战：手把手教你用Frida绕过Flutter App的SSL Pinning（附脚本修改指南）

本文详细介绍了如何利用Frida工具绕过Flutter应用的SSL Pinning保护机制，包括静态分析定位关键函数、定制Frida Hook脚本以及流量捕获的完整解决方案。通过实战案例和脚本修改指南，帮助安全研究人员有效应对Flutter应用的安全挑战，特别适用于安卓平台的逆向工程和抓包需求。

weixin_28723171的博客 404

Moveit Servo学习

MoveIt Servo功能与配置指南 摘要：本文介绍了MoveIt Servo的功能特性，包括支持关节速度、末端执行器速度和位置控制，以及安全功能如奇点检查、碰撞检测等。通过示例展示了如何运行伺服控制demo，详细解析了关键节点和话题。最后以睿尔曼rml_63机器人为例，讲解了如何自定义伺服配置文件，包括环境设置、输入输出参数配置、平滑滤波器和规划场景监控等关键配置项。文章提供了从基础使用到自定义机器人配置的完整指导，帮助开发者实现高效的实时运动控制。

Fisher的博客 1177

python 实例对象 浅拷贝_Python3 入门教程——浅拷贝&深拷贝差别

前言在 Python 中提供了一个用于拷贝操作的 copy 模块，该模块中提供 浅拷贝 和 深拷贝 两种操作，其中：浅拷贝：只是将对象管理地址进行打包复制，其内部的元素的并未进行复制，而是使用旧的存储地址。深拷贝 ：是将对象中的所有元素进行复制，然后重新开辟空间来存储。对象和内存对象和内存中的值是映射的关系，当需要取内存中的值的时候，需要通过其变量名去获取。内存中的值是单一的，但其映射的对象可以...

weixin_31421613的博客 111

从零构建AI辅助逆向分析环境：JADX-MCP与LLM的实战集成指南

本文详细介绍了如何从零构建AI辅助逆向分析环境，通过集成JADX-MCP与LLM技术，提升Android应用逆向工程效率。文章涵盖环境搭建、插件安装、MCP服务器配置及实战案例分析，帮助开发者快速掌握AI在代码理解、漏洞挖掘和自动化文档生成中的应用。

weixin_27875131的博客 840

Python对象的浅拷贝与深拷贝，不愧是阿里P8

赋值： b = a 拷贝： b = a.copy() 上面的两行代码究竟有什么不同呢？带着这个问题，继续 看了上面这张图，相信大家已经对直接赋值和拷贝有了一个比较清楚的认识。 直接赋值：复制一个对象的引用给新变量 拷贝：复制一个对象到新的内存地址空间，并且将新变量引用到复制后的对象 我们的深浅拷贝只是对于可变对象来讨论的。 不熟悉的朋友需要自己去了解可变对象与不可变对象哦。 1. 对象的嵌套引用 a = { “list”: [1,2,3] } 上面的代码，在内存中是什么样子的呢？请看下图： 原来，在我

rrrrrwhwyh的博客 221

Zotero+Obsidian+Bookxnote联动让文献阅读丝滑般体验

摘录文字或图片到Obsidian

weixin_43694742的博客 1万+

【人工智能】AI驱动值班巡检Agent（Hermes）

传统运维值班巡检场景中，存在四大核心痛点：本项目基于 Agent+Skills+浏览器自动化 架构，构建了具备自我进化能力的AI值班员，核心逻辑流如下：

奶爸的编程之路，也就一周冷个三天 178

聊一聊Python中的浅拷贝和深拷贝

往期好文推荐 学习Python不需要程基础？ 0基础不用怕，从0到1轻松教你入门Python python系统学习流线图，教你一步一步学会python 成为一名做大数据开发的女程序员，并不是二狗进入大学时的第一目标。 前言 我们知道列表是可变对象，指向他的变量都会根据他的变化而变化。 l1 = [1, 2, 3] l2 = l1 l1.append(4) print(l1, l2) # [1, 2, 3, 4] [1, 2, 3, 4] 所以我们就要用拷贝方法，这样就不会受其影响了。 l1 = [1

zihong523的博客 94

嵌入式Zephyr RTOS面试题及参考答案

在Zephyr中，为自定义外设编写Devicetree绑定（Bindings）有助于内核理解设备树中自定义外设节点的含义和属性。首先，需要创建一个.yaml格式的绑定文件，通常存放在目录下对应的子目录中，文件名应能反映外设的类型和功能。绑定文件的开头要定义基本信息，包括字段，用于简要描述外设的功能和用途；compatible字段，它是一个字符串列表，用于匹配设备树中自定义外设节点的compatible属性，设备树节点和绑定文件通过这个字段关联起来。接下来，要定义外设节点的属性。使用properties。

大模型大数据攻城狮的专栏 988

python 赋值、浅拷贝与深拷贝

直接赋值：其实就是对象的引用（别名）。 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。 深拷贝(deepcopy)：copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。 字典浅拷贝实例 实例 >>>a = {1: [1,2,3]} >>> b = a.copy() >>> ...

MISAYAONE的博客 437

【即插即用模块】注意力篇 | TGRS 2025 | SCPP：独家复现！三特征多尺度注意力融合，涨点必备！

摘要：SCPP（Scale-aware Pyramid Pooling）是一种创新的多尺度特征融合模块，专为U型网络瓶颈设计。它通过局部特征提取（1×1卷积）、多尺度膨胀卷积（1/3/5膨胀率分支）和全局特征聚合（全局平均池化）三重结构，结合SE通道注意力机制和自适应加权融合，显著提升特征表达能力。实验表明，SCPP能有效解决边缘模糊和错误检测问题，在遥感图像分割等任务中表现优异。该模块支持即插即用，适用于各类需要多尺度特征增强的视觉任务。

主要更新底层视觉（去噪、超分等）相关的科研内容，形式为【论文精读】+【论文复现】 946

【YOLOv8改进-注意力机制】LSKNet(Large Selective Kernel Network ):空间选择注意力

【YOLOv8改进-注意力机制】LSKNet(Large Selective Kernel Network ):空间选择注意力 (论文笔记+引入代码)。LSKNet能够动态调整其大的空间接收场，以更好地模拟遥感场景中各种对象的范围上下文。据我们所知，这是首次在遥感目标检测领域探索大型和选择性核机制。

专注于图像领域，主要研究内容包括计算机视觉和深度学习，特别是在图像分类、目标检测和图像生成等方面有深入的研究和实践经验。 2864

python的浅拷贝和深拷贝

1. Python如何拷贝一个对象？ 在Python中如何拷贝一个对象呢？我们很多时候会用等号赋值法，除了=赋值，实际上还有浅拷贝和深拷贝，那么赋值，浅拷贝和深拷贝到底有什么区别呢？ (1) 赋值(=)：创建了对象的一个新的引用，修改其中任意一个变量都会影响到另外一个； (2) 浅拷贝：创建一个新的对象，但是它包含的是对原始对象中包含项的引用(如果用引用的方式修改其中一个对象，另外一个也会改变)； (3) 深拷贝：创建一个新对象，并且递归的复制它所包含的对象(修改其中一个，另外一个不会改变)。 浅

Be_Nice的博客 285

C# WinForm 基于DirectShow.dll编写的程序，可边预览边保存视频，音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择（默认选中第一个）2.可录制wmv和avi两种格式的视频并且都带有音频，avi可以录制的分辨率和帧数进行选择，wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照，也可边录制视频边拍照4.添加了视频和音频的压缩功能（酌情使用）这次二次开发发现C#对DirectShow的相关信息太少，这次做完也不敢藏私共享出来，还望大家指正

SIMATIC S7-1200, S7-1500 PID 控制[手册]

SIMATIC S7-1200, S7-1500 PID 控制[手册]

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册，内含HL7和ASTM)

Python 拷贝对象（深拷贝deepcopy与浅拷贝）

Python拷贝对象（深拷贝deepcopy与浅拷贝） >>> import copy>>> a = [1,2,3,4,['a','v']]>>> b = a>>> b[1, 2, 3, 4, ['a', 'v']]>>> c = copy.copy(a)>>> c[1, 2...

weixin_34290390的博客 324

WINCC7.3破解文件

WINCC7.3硬件够破解文件，有需要的下载！WINCC7.3硬件够破解文件，有需要的下载！

python字典的复制、浅拷贝和深拷贝的区别

python字典的复制、浅拷贝和深拷贝的区别 复制：跟原字典完全一样 浅拷贝：将原字典拷贝一份，但是没有拷贝原字典中的子对象，所以当原字典中的子对象发生变化时，浅拷贝后的字典也会发生变化 深拷贝：将原字典连同其子对象一块进行了拷贝，所以深拷贝后的字典不会随着原字典的变化而改变 代码示例： #coding:utf-8 import sys import copy def main(): ...

u010569893的博客 1949

python深拷贝和浅拷贝的区别

转载自：https://www.cnblogs.com/xueli/p/4952063.html#4236955 作者：米 立 在python中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用 一般有三种方法， alist=[1,2,3,[“a”,“b”]] （1）直接赋值 默认浅拷贝传递对象的引用而已,原始列表改变，被赋值的b也会做相同的改变 >>> b=alist >>> print

BiBlioManiaa的博客 253

python深拷贝和浅拷贝理解

1. 理解名词 可变对象：列表、字典、集合 不可变对象：数字、字符串、元组 拷贝：复制一个新的对象，新增一块内存空间 引用：不会新增对象，不会开辟新的内存空间，只是多了一个引用 2. 对【不可变对象】进行拷贝，是新增一个对象，即另辟一块内存空间，内存地址不同，一个改变互不影响。 本文总结是对【可变对象】的拷贝。 2.1. 赋值 listA = [1,2,3,['a','...

hou_angela的博客 396

python的复制，深拷贝和浅拷贝的区别

在python中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用 一般有三种方法， alist=[1,2,3,["a","b"]] （1）直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变，被赋值的b也会做相同的改变 >>> b=alist >>> print b [...

Chelseady的博客 408

Python中对于浅拷贝、深拷贝的理解

浅拷贝：是对于一个对象的顶层拷贝，通俗的理解是拷贝了引用，并没有拷贝内容。 深拷贝：是对于一个对象所有层次的拷贝(递归)。 注意点： copy.copy对于可变类型，会进行浅拷贝； copy.copy对于不可变类型，不会拷贝，仅仅是指向。 In [88]: a = [11,22,33] In [89]: b = copy.copy(a) In [90]: id(a) Out[90]: 592751...

hilong 168

Python学习教程：Python列表赋值，复制，深拷贝及5种浅拷贝详解

Python学习教程：Python列表赋值，复制，深拷贝及5种浅拷贝详解 概述 在列表复制这个问题，看似简单的复制却有着许多的学问，尤其是对新手来说，理所当然的事情却并...

cpfsdzs2014的博客 218

Python中的赋值、浅拷贝和深拷贝

本章节内容涉及可变类型和不可变类型的基础知识，详见以下文章： https://blog.youkuaiyun.com/matlab2007/article/details/102831025 1. 当对不可变类型进行复制操作时 import copy a = 'hello world' b = a c = copy.copy(a) d = copy.deepcopy(a) print(id(a),id(b),...

matlab2007的博客 421
上一篇： Python迭代器的__iter__和__next__详细教程
下一篇： Python模块学习：subprocess模块详解
点赞 2
评论 0
书签 书签 2
Python热爱者
Python热爱者
博客等级 码龄7年 3056粉丝 1330原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值