前言

  • Python 中不存在值传递,一切传递的都是对象的引用,也可以认为是传址
  • 这里会讲三个概念:对象赋值、浅拷贝、深拷贝

名词解释

  • 变量:存储对象的引用
  • 对象:会被分配一块内存,存储实际的数据,比如字符串、数字、列表
  • 引用:变量指向对象,可以理解为指针

实际的一种应用场景

  • 有一个变量 a,存储了一个值
  • 此时想用另一个变量 b 暂时存储变量 a 的值,以便后续使用
  • 然后继续修改变量 a 的值,但修改的时候并不想同步更改变量 b 的值
a=1
b=a
a=2

对象赋值

不可变对象的赋值

a = 1
b = a print(a, b) a += 2
print(a, b) print("a id:", id(a))
print("b id:", id(b)) # 输出结果
1 1
2 1
a id: 4564097808
b id: 4564097776
  • 修改变量 a 的值,不会同步修改变量 b 的值
  • 因为赋值操作 a += 2 后,变量 a 存储的对象引用已经改变了
  • 至于具体的原理,可以看看不可变对象、可变对象的详解 https://www.cnblogs.com/poloyy/p/15073168.html

可变对象的赋值

a = [1, 2, 3]
b = a print(a, b) a[1] = 22
print(a, b) print("a id:", id(a))
print("b id:", id(b)) # 输出结果
[1, 2, 3] [1, 2, 3]
[1, 22, 3] [1, 22, 3]
a id: 4567683136
b id: 4567683136
  • 修改 a 变量的值,会同步修改变量 b 的值,这不符合上面的说的实际应用场景
  • 因为变量 a、b 指向的对象是可变对象,所以它们保存的对象引用都是一样的

拷贝的诞生

  • 那如果要让可变对象也能满足上述实际应用场景,要怎么做呢?
  • 当然就是拷贝
  • 而拷贝又分为浅拷贝、深拷贝,接下来会具体聊一聊两种拷贝的区别

第一个重点总结

  • 对于不可变对象来说,赋值操作其实就可以满足上面说的实际应用场景
  • 所以!后面要讲的浅拷贝、深拷贝对于不可变对象来说,和赋值操作是一样的效果!
  • 记住!浅拷贝、深拷贝只针对可变对象,即列表、集合、字典!

copy 模块

Python 提供了 copy 模块,包含了浅拷贝、深拷贝函数

from copy import copy, deepcopy

# 浅拷贝
copy(x) # 深拷贝
deepcopy(x)

浅拷贝

一句话概括:浅拷贝会创建一个新对象,该新对象存储原始元素的引用

浅拷贝后的值是相同的

  • 将列表赋值给变量 old_list
  • 通过 copy() 方法对 old_list 变量指向的对象进行浅拷贝,并赋值给新变量 new_list
  • 因为是对象进行拷贝,所以 new_list 和 old_list 存储的值是相同的
import copy

old_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
new_list = copy.copy(old_list) print("Old list:", old_list)
print("New list:", new_list) # 输出结果
Old list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
New list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

浅拷贝后的会产生一个新的对象

  • 虽然 old_list 和 new_list 存储的值是相同的,但浅拷贝的操作是产生了一个新的对象
  • 所以 old_list 和 new_list 指向的对象并不是同一个
import copy

old_list = [[1, 2], [3, 4]]
new_list = copy.copy(old_list) old_list.append([5, 6]) print("Old list:", old_list, "id is :", id(old_list))
print("New list:", new_list, "id is :", id(new_list)) # 输出结果
Old list: [[1, 2], [3, 4], [5, 6]] id is : 4366240704
New list: [[1, 2], [3, 4]] id is : 4366246720

可以看到内存地址是不同的,所以给 old_list 新增一个元素并不会同步让 new_list 也新增

原理图

  • 浅拷贝生成了一个新对象,然后赋值给 new_list
  • new_list、old_list 指向的列表对象不是同一个,但值相同
  • 重点:对于列表对象中的元素,浅拷贝产生的新对象只存储原始元素的引用(内存地址),所以两个列表对象的元素的引用都指向同一个内存地址

那为什么要深拷贝呢?

修改列表内的不可变对象元素

上面的栗子是直接添加元素,来看看修改元素会怎么样

# 不可变元素
import copy old_list = [1, 2, "string", (1, 2,)]
new_list = copy.copy(old_list) old_list[1] += 22
old_list[2] += "s"
old_list[3] += (3,) print("Old list:", old_list)
print("New list:", new_list) # 输出结果
Old list: [1, 24, 'strings', (1, 2, 3)]
New list: [1, 2, 'string', (1, 2)]

修改 old_list 的三种不可变对象元素,均不会同步给 new_list

修改不可变对象的原理图

修改列表内的可变对象元素

# 可变元素
import copy old_list = [[1, 2], [3, 4]]
new_list = copy.copy(old_list) old_list[0][0] += 99
old_list[1][0] += 97 print("Old list:", old_list, "old list id:", id(old_list), " old list[0] id:", id(old_list[0]))
print("new list:", new_list, "new list id:", id(new_list), " new list[0] id:", id(new_list[0])) # 输出结果
Old list: [[100, 2], [100, 4]] old list id: 4430308096 old list[0] id: 4430302400
new list: [[100, 2], [100, 4]] new list id: 4430308416 new list[0] id: 4430302400

从输出结果看到

  • 两个变量保存了不同的对象引用
  • 但是可变对象元素的内存地址仍然是同一个

修改可变对象的原理图

总结

  • 修改可变对象是在原始对象上直接操作的
  • 浅拷贝产生的新对象是存储的仍然是原始对象的内存地址
  • 所以修改可变对象的时候,新对象的值也会被同步修改,因为新旧列表对象的元素的引用是指向同一个内存地址
  • 当修改可变对象的时候,不满足一开始说的实际应用场景,所以诞生了深拷贝

深拷贝

  • 创建一个新对象,且存储的对象引用也是新的
  • 深,意味着会把所有子元素对象也复制生成一个新对象

栗子一

# 深拷贝
old_list = [[1, 2], [3, 4]]
new_list = copy.deepcopy(old_list) old_list[0][0] += 99
old_list[1][0] += 97 print("Old list:", old_list, "old list id:", id(old_list), " old list[0] id:", id(old_list[0]))
print("new list:", new_list, "new list id:", id(new_list), " new list[0] id:", id(new_list[0])) # 输出结果
Old list: [[100, 2], [100, 4]] old list id: 4430308480 old list[0] id: 4430211392
new list: [[1, 2], [3, 4]] new list id: 4430308096 new list[0] id: 4430308864

从输出结果看到

  • 两个变量保存了不同的对象引用
  • 可变对象元素(子对象)的内存地址也是不同的

栗子二

假设是一个三维列表呢

# 深拷贝-三维数组
old_list = [[1, [10, 9]], [3, 4]]
new_list = copy.deepcopy(old_list) old_list[0][1][0] += 90 print("Old list:", old_list)
print("New list:", new_list) # 输出结果
Old list: [[1, [100, 9]], [3, 4]]
New list: [[1, [10, 9]], [3, 4]]

两个变量依旧是独立的

深拷贝原理图

浅拷贝的多种实现方式

https://www.cnblogs.com/poloyy/p/15086511.html

Python - 对象赋值、浅拷贝、深拷贝的区别的更多相关文章

  1. python中赋值-浅拷贝-深拷贝之间的关系

    赋值: 变量的引用,没有拷贝空间 对象之间赋值本质上 是对象之间的引用传递而已.也就是多个对象指向同一个数据空间. 拷贝的对象分两种类型: . 拷贝可变类型 浅拷贝: 只拷贝第一层数据,不关心里面的第 ...

  2. Python对象赋值、浅拷贝、深拷贝

    Python中,基本数据类型,理解为常见数据类型:布尔型.整型.浮点型.字符串.列表.元组.字典.集合,随语言不同而不同,但是根据在内存中存储方式的不同,区分开原子类型和容器类型. 对象赋值 对象的赋 ...

  3. python的赋值,深拷贝和浅拷贝的区别

    原文地址https://www.cnblogs.com/xueli/p/4952063.html 赋值:a = [1,2,3,["a","b"]]  b=a,那 ...

  4. python中赋值,深拷贝,浅拷贝区别

    这三种 的区别就是 复制的变量 是否是原变量的引用. 赋值:只是原变量的引用. 浅拷贝和深拷贝的区别 需要通过 子元素 区分 浅拷贝:子元素的 引用相同 深拷贝:所以引用都不相同,完全复制一份 这三种 ...

  5. 深入理解Python中赋值、深拷贝(deepcopy)、浅拷贝(copy)

    赋值 python跟java中的变量本质是不一样的,Python的变量实质上是一个指针(int型或str型),而java的变量是一个可操作的存储空间. a = 123b = a print(id(a) ...

  6. python开发_copy(浅拷贝|深拷贝)_博主推荐

    在python中,有着深拷贝和浅拷贝,即copy模块 下面我们就来聊一下: 运行效果: ================================================== 代码部分: ...

  7. python 中的 赋值 浅拷贝 深拷贝

    1.对象的赋值 都是进行对象引用(内存地址)传递,即 b is a ,a 变 b也变 2.浅拷贝 会创建一个新的对象,对于对象中的元素,浅拷贝就只会使用原始元素的引用(内存地址) 当我们使用下面的操作 ...

  8. 搞不懂JS中赋值·浅拷贝·深拷贝的请看这里

    前言 百科定义:拷贝就是拷贝指向对象的指针,意思就是说:拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一块空间,浅拷贝只是一种简单的拷贝,让几个对象公用一个内存,然而当内存销毁的时候,指向这 ...

  9. [Python] 等号赋值, copy, deepcopy的区别

    参考链接: 1. 介绍python中的可变类型与不可变类型:https://blog.csdn.net/answer3lin/article/details/86430074 (也可以参考转载博客 P ...

随机推荐

  1. What is maven?

    Introduction Maven, a Yiddish word meaning accumulator(累加器) of knowledge, began as an attempt to sim ...

  2. 与安卓联调,调用安卓那边的方法,获取到安卓传过来的数据,再携带这些数据发送axios请求,获取到用户的信息

    第一步:js调用Android方法:接收Android传递过来的数据,并做处理 //参数一:调用java中的方法   submitFromWeb是方法名,必须和Android中注册时候的方法名称保持一 ...

  3. NOIP模拟测试17「入阵曲·将军令·星空」

    入阵曲 题解 应用了一种美妙移项思想, 我们先考虑在一维上的做法 维护前缀和$(sum[r]-sum[l-1])\%k==0$可以转化为 $sum[r]\% k==sum[l-1]\%k$开个桶维护一 ...

  4. Python变量小秘密

    变量全都是引用 跟其他编程语言不同,Python的变量不是盒子,不会存储数据,它们只是引用,就像标签一样,贴在对象上面. 比如: >>> a = [1, 2, 3] >> ...

  5. WPF添加外边框,添加外边框虚线

    <Border Background="LightBlue" BorderBrush="Black"  BorderThickness="2&q ...

  6. 安装nodejs版本模块报错notsup Unsupported platform for n

    使用npm install -g n报错 如果出现npm ERR! notsup Unsupported platform for n@6.7.0: wanted {"os":&q ...

  7. python返回列表最大值(java返回数组最大值)

    b=["3","2","1","6","5","2","1" ...

  8. golang变量与常量

    变量 变量 在程序运行中可以改变的量 枚举 var ( a3 = 1 a4 = 2 ) golang不同类型变量不能替换 func main() { var a int = 10 a = 20 a = ...

  9. Unity3D学习笔记2——绘制一个带纹理的面

    目录 1. 概述 2. 详论 2.1. 网格(Mesh) 2.1.1. 顶点 2.1.2. 顶点索引 2.2. 材质(Material) 2.2.1. 创建材质 2.2.2. 使用材质 2.3. 光照 ...

  10. 49、django工程(cookie+session)

    49.1.介绍: 1.cookie不属于http协议范围,由于http协议无法保持状态,但实际情况,我们却又需要"保持状态",因此cookie就是在这样一个场景下诞生. cooki ...