Python - 对象赋值、浅拷贝、深拷贝的区别

致伟發表於 2021-8-1 13:37:00

Python - 对象赋值、浅拷贝、深拷贝的区别

<h3>前言</h3>
<ul>
<li>Python 中不存在值传递，一切传递的都是对象的引用，也可以认为是传址</li>
<li>这里会讲三个概念：对象赋值、浅拷贝、深拷贝</li>
</ul>
 
<h3>名词解释</h3>
<ul>
<li>变量：存储对象的引用</li>
<li>对象：会被分配一块内存，存储实际的数据，比如字符串、数字、列表</li>
<li>引用：变量指向对象，可以理解为指针</li>
</ul>
<img src="https://img2020.cnblogs.com/blog/1896874/202107/1896874-20210731194409686-1313532978.png" alt="" loading="lazy">
  
<h3>实际的一种应用场景</h3>
<ul>
<li>有一个变量 a，存储了一个值</li>
<li>此时想用另一个变量 b 暂时存储变量 a 的值，以便后续使用</li>
<li>然后继续修改变量 a 的值，但修改的时候并不想同步更改变量 b 的值</li>
</ul>
<div class="cnblogs_code">
<pre>a=1
b=a
a=2</pre>
</div>
  
<h3>对象赋值</h3>
<ul>
<li>赋值运算符详解：https://www.cnblogs.com/poloyy/p/15083012.html</li>
<li>Python 的赋值语句并不是创建一个新对象，只是创建了一个共享原始对象引用的新变量</li>
</ul>
 
<h3>不可变对象的赋值</h3>
<div class="cnblogs_code">
<pre>a = 1
b = a

print(a, b)

a += 2
print(a, b)

print("a id:", id(a))
print("b id:", id(b))

# 输出结果
1 1
3 1
a id: 4564097808
b id: 4564097776</pre>
</div>
<ul>
<li>修改变量 a 的值，不会同步修改变量 b 的值</li>
<li>因为赋值操作 a += 2 后，变量 a 存储的对象引用已经改变了</li>
<li>至于具体的原理，可以看看不可变对象、可变对象的详解 https://www.cnblogs.com/poloyy/p/15073168.html</li>
</ul>
 
<h3>可变对象的赋值</h3>
<div class="cnblogs_code">
<pre>a =
b = a

print(a, b)

a[1] = 22
print(a, b)

print("a id:", id(a))
print("b id:", id(b))

# 输出结果

[1, 22, 3]
a id: 4567683136
b id: 4567683136</pre>
</div>
<ul>
<li>修改 a 变量的值，会同步修改变量 b 的值，这不符合上面的说的实际应用场景</li>
<li>因为变量 a、b 指向的对象是可变对象，所以它们保存的对象引用都是一样的</li>
</ul>
 
<h4>拷贝的诞生</h4>
<ul>
<li>那如果要让可变对象也能满足上述实际应用场景，要怎么做呢？</li>
<li>当然就是拷贝</li>
<li>而拷贝又分为浅拷贝、深拷贝，接下来会具体聊一聊两种拷贝的区别</li>
</ul>
 
<h3>第一个重点总结</h3>
<ul>
<li>对于不可变对象来说，赋值操作其实就可以满足上面说的实际应用场景</li>
<li>所以！后面要讲的浅拷贝、深拷贝对于不可变对象来说，和赋值操作是一样的效果！</li>
<li>记住！浅拷贝、深拷贝只针对可变对象，即列表、集合、字典！</li>
</ul>
 
<h3>copy 模块</h3>
Python 提供了 copy 模块，包含了浅拷贝、深拷贝函数
<div class="cnblogs_code">
<pre>from copy import copy, deepcopy

# 浅拷贝
copy(x)

# 深拷贝
deepcopy(x)</pre>
</div>
 
<h3>浅拷贝</h3>
一句话概括：浅拷贝会创建一个新对象，该新对象存储原始元素的引用
 
<h4>浅拷贝后的值是相同的</h4>
<ul>
<li>将列表赋值给变量 old_list</li>
<li>通过 copy() 方法对 old_list 变量指向的对象进行浅拷贝，并赋值给新变量 new_list</li>
<li>因为是对象进行拷贝，所以 new_list 和 old_list 存储的值是相同的</li>
</ul>
<div class="cnblogs_code">
<pre>import copy

old_list = [, , ]
new_list = copy.copy(old_list)

print("Old list:", old_list)
print("New list:", new_list)

# 输出结果
Old list: [, , ]
New list: [[1, 2, 3], , ]</pre>
</div>
 
<h4>浅拷贝后的会产生一个新的对象</h4>
<ul>
<li>虽然 old_list 和 new_list 存储的值是相同的，但浅拷贝的操作是产生了一个新的对象</li>
<li>所以 old_list 和 new_list 指向的对象并不是同一个</li>
</ul>
<div class="cnblogs_code">
<pre>import copy

old_list = [, ]
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: [, , ] id is : 4366240704
New list: [[1, 2], ] id is : 4366246720</pre>
</div>
可以看到内存地址是不同的，所以给 old_list 新增一个元素并不会同步让 new_list 也新增
 
<h4>原理图</h4>
<img src="https://img2020.cnblogs.com/blog/1896874/202108/1896874-20210801103442325-199330745.png" alt="" loading="lazy">
<ul>
<li>浅拷贝生成了一个新对象，然后赋值给 new_list</li>
<li>new_list、old_list 指向的列表对象不是同一个，但值相同</li>
<li>重点：对于列表对象中的元素，浅拷贝产生的新对象只存储原始元素的引用（内存地址），所以两个列表对象的元素的引用都指向同一个内存地址</li>
</ul>
 
<h3>那为什么要深拷贝呢？</h3>
<h4>修改列表内的不可变对象元素</h4>
上面的栗子是直接添加元素，来看看修改元素会怎么样
<div class="cnblogs_code">
<pre># 不可变元素
import copy

old_list =
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:
New list: [1, 2, 'string', (1, 2)]</pre>
</div>
修改 old_list 的三种不可变对象元素，均不会同步给 new_list
 
<h4>修改不可变对象的原理图</h4>
<img src="https://img2020.cnblogs.com/blog/1896874/202108/1896874-20210801105557786-1875694485.png" alt="" loading="lazy">
 
<h4>修改列表内的可变对象元素</h4>
<div class="cnblogs_code">
<pre># 可变元素
import copy

old_list = [, ]
new_list = copy.copy(old_list)

old_list += 99
old_list[1] += 97

print("Old list:", old_list, "old list id:", id(old_list), " old list id:", id(old_list))
print("new list:", new_list, "new list id:", id(new_list), " new list id:", id(new_list))

# 输出结果
Old list: [, ] old list id: 4430308096old list id: 4430302400
new list: [[100, 2], ] new list id: 4430308416new list id: 4430302400</pre>
</div>
从输出结果看到
<ul>
<li>两个变量保存了不同的对象引用</li>
<li>但是可变对象元素的内存地址仍然是同一个</li>
</ul>
 
<h4>修改可变对象的原理图</h4>
<img src="https://img2020.cnblogs.com/blog/1896874/202108/1896874-20210801110731999-1822292487.png" alt="" loading="lazy">
 
<h4>总结</h4>
<ul>
<li>修改可变对象是在原始对象上直接操作的</li>
<li>浅拷贝产生的新对象存储的仍然是原始对象的内存地址</li>
<li>所以修改可变对象的时候，新对象的值也会被同步修改，因为新旧列表对象的元素的引用是指向同一个内存地址</li>
<li>当修改可变对象的时候，不满足一开始说的实际应用场景，所以诞生了深拷贝</li>
</ul>
 
<h3>深拷贝</h3>
<ul>
<li>创建一个新对象，且存储的对象引用也是新的</li>
<li>深，意味着会把所有子元素对象也复制生成一个新对象</li>
</ul>
 
<h4>栗子一</h4>
<div class="cnblogs_code">
<pre># 深拷贝
old_list = [, ]
new_list = copy.deepcopy(old_list)

old_list += 99
old_list[1] += 97

print("Old list:", old_list, "old list id:", id(old_list), " old list id:", id(old_list))
print("new list:", new_list, "new list id:", id(new_list), " new list id:", id(new_list))

# 输出结果
Old list: [, ] old list id: 4430308480old list id: 4430211392
new list: [[1, 2], ] new list id: 4430308096new list id: 4430308864</pre>
</div>
从输出结果看到
<ul>
<li>两个变量保存了不同的对象引用</li>
<li>可变对象元素（子对象）的内存地址也是不同的</li>
</ul>
 
<h4>栗子二</h4>
假设是一个三维列表呢
<div class="cnblogs_code">
<pre># 深拷贝-三维数组
old_list = [], ]
new_list = copy.deepcopy(old_list)

old_list[1] += 90

print("Old list:", old_list)
print("New list:", new_list)

# 输出结果
Old list: [], ]
New list: [[1, ], ]</pre>
</div>
两个变量依旧是独立的
 
<h4>深拷贝原理图</h4>
<img src="https://img2020.cnblogs.com/blog/1896874/202108/1896874-20210801124730663-364174440.png" alt="" loading="lazy">
 
<h3>浅拷贝的多种实现方式</h3>
https://www.cnblogs.com/poloyy/p/15086511.html
 
<h3>面试题：浅拷贝、深拷贝的区别</h3>
<ol>
<li>浅拷贝和深拷贝只有在可变对象才会生效，不可变对象的赋值操作、浅拷贝、深拷贝的效果是一样的</li>
<li>浅拷贝会将对象复制生成一个新对象，但新对象仍然存储原始对象的引用，当原始对象是可变对象，然后修改它的值时，新旧对象会同时改变</li>
<li>深拷贝不仅会将对象复制生成一个新对象，且所有原始对象都会复制生成新对象，即使原始对象是可变对象，新对象存储的对象引用也是新的，所以改变旧对象的可变对象时，不会影响新对象</li>
</ol> 
来源：https://www.cnblogs.com/poloyy/p/15084277.html

頁: [1]

琼殿技术论坛's Archiver

Python - 对象赋值、浅拷贝、深拷贝的区别