Python - 可变和不可变对象 - Powered by Discuz! Archiver

刘旭昕 發表於 2021-7-30 20:57:00

Python - 可变和不可变对象

<h3>前置知识</h3>
<ul>
<li>在 Python 中，一切皆为对象</li>
<li>Python 中不存在值传递，一切传递的都是对象的引用，也可以认为是传址</li>
</ul>
 
<h3 id="hid-j3rSiZ">有哪些可变对象，哪些不可变对象？</h3>
<ul>
<li>不可变对象：字符串、元组、数字（int、float）</li>
<li>可变对象：数组、字典、集合</li>
</ul>
 
<h3>不可变对象和可变对象的区别？</h3>
<ul>
<li>可变对象：改变对象内容，对象在内存中的地址不会被改变</li>
<li>不可变对象：改变对象内容，对象在内存中的地址会被改变；如果必须存储一个不同的值，则必须创建新的对象</li>
</ul>
 
<h4>不可变对象的应用场景</h4>
它们在需要常量哈希值的地方起着重要作用，例如作为字典中的键
 
<h3 id="hid-iK3G5N">从内存角度出发说下有什么区别？</h3>
<h4 id="hid-xkDzNC">不可变对象</h4>
<img src="https://img2020.cnblogs.com/blog/1896874/202103/1896874-20210301211549664-1358897679.png" alt="" class="medium-zoom-image" loading="lazy">
<ul>
<li>Python 中的变量有一个内存空间</li>
<li>具体的数据（对象）也有一个内存空间</li>
<li>而变量保存（指向）的是存储数据（对象）的内存地址，一般也叫对象引用</li>
<li>不可变对象是指对象内容本身不可变</li>
<li>变的是：改变了值，会创建新对象，然后变量改变了对象引用，指向了新对象，旧对象会被垃圾回收</li>
</ul>
 
<h4 id="hid-Y5AK5w">可变对象</h4>
<img src="https://img2020.cnblogs.com/blog/1896874/202103/1896874-20210301214710421-312061590.png" alt="" class="medium-zoom-image" loading="lazy">
变的是：原来对象的内容，不会创建新对象，而变量也还是指向原对象
 
<h3>从代码角度看看区别 </h3>
<h4>不可变对象-整型</h4>
<div class="cnblogs_code">
<pre>a = 123
b = a
print(id(a))
print(id(b))
print(a, b)

a += 2

print(id(a))
print(id(b))
print(a, b)

# 输出结果
4473956912
4473956912
123 123
4473956976
4473956912
125 123</pre>
</div>
<ul>
<li>从前两次打印可以看到，a、b 变量保存的内存地址是同一个，他们们都保存了 123 的内存地址（123 对象的引用）</li>
<li>预期情况：在 a 做了加法赋值运算之后，既然他们一开始都是指向同一个内存地址，按道理修改 123 后，他们也应该仍然指向同一个内存地址呀，但是并没有！</li>
<li>实际情况：a 指向了新的内存地址，而 b 仍然指向旧的内存地址，所以他们的值也不一样</li>
</ul>
 
<h4>可以看看下面的图</h4>
首先，这是一个内存区域
<img src="https://img2020.cnblogs.com/blog/1896874/202107/1896874-20210729230249499-1141173869.png" alt="" loading="lazy">
原理
<ul>
<li>因为数字（int、float）是不可变对象，所以不能在 123 的内存地址上直接修改数据</li>
<li>加法赋值，实际上是将原来的 123 复制了一份到新的内存地址，然后再做加法，得到一个新的值 125，最后 a 再指向新的内存地址</li>
</ul>
 
<h4>不可变对象-字符串</h4>
<div class="cnblogs_code">
<pre>a = "test"
b = a
print(id(a))
print(id(b))
print(a, b)

a += "123"

print(id(a))
print(id(b))
print(a, b)

# 输出结果
4455345392
4455345392
test test
4455818288
4455345392
test123 test</pre>
</div>
 
<h4>不可变对象-元组</h4>
<div class="cnblogs_code">
<pre>a = (1, 2, 3)
b = a
print(id(a))
print(id(b))
print(a, b)

a = a + a
print(id(a))
print(id(b))
print(a, b)

# 输出结果
4455410240
4455410240
(1, 2, 3) (1, 2, 3)
4455359200
4455410240
(1, 2, 3, 1, 2, 3) (1, 2, 3)</pre>
</div>
  
<h4>可变对象列表</h4>
<div class="cnblogs_code">
<pre># 列表
a =
b = a

print(id(a))
print(id(b))
print(a, b)

a +=

print(a, b)
print(id(a))
print(id(b))

# 输出结果
4327665856
4327665856
[1, 2, 3, 4, 5, 6]
4327665856
4327665856</pre>
</div>
能看到 a 变量修改值之后，b 的值也随之修改了
 
<h4>可以看看下面的图</h4>
<img src="https://img2020.cnblogs.com/blog/1896874/202107/1896874-20210730202130156-190699005.png" alt="" loading="lazy"> 
<ul>
<li>因为 list 是可变对象，所以并不会将原来的值复制到新的内存地址再改变，而是直接在原来的内存地址上修改数据</li>
<li>因为 a、b 都是指向原来的内存地址的，所以 a、b 变量保存的内存地址是一致的（对象引用是一致的），当然值也是一样的啦</li>
</ul>
 
<h3>Python 函数的参数传递</h3>
这里先提前讲下函数的入门，因为参数传递是个挺重要的点
 
<h4>概念</h4>
<ul>
<li>开头有讲到，Python 的一切传递都是对象的引用，函数参数传递也不例外</li>
<li>当传递给函数的是一个变量，实际上传递的是变量保存的对象引用（变量指向的内存地址）</li>
<li>在函数内部修改变量时，会根据变量指向的内存地址，去修改对应的值才对，事实真是如此吗</li>
</ul>
 
<h4>参数传递不可变对象</h4>
<div class="cnblogs_code">
<pre># 函数
def test_no_define(age, name):
age = 123
name = "poloyy"
print(age, name)

age = 1
name = "yy"
print(age, name)

test_no_define(age, name)
print(age, name)

# 输出结果
1 yy
123 poloyy
1 yy</pre>
</div>
 
<h4>参数传递可变对象</h4>
<div class="cnblogs_code">
<pre># 函数
def test_define(dicts, sets):
dicts['age'] = 24
sets.pop()
print(dicts, sets)

dicts = {"age": 123}
sets = {1, 2}
print(dicts, sets)

test_define(dicts, sets)
print(dicts, sets)

# 输出结果
1 yy
{'age': 123} {1, 2}
{'age': 24} {2}
{'age': 24} {2}</pre>
</div>
  
<h4>总结</h4>
<ul>
<li>当函数参数传递的变量是不可变对象的时候，函数内改变变量值，函数外的变量不会随之改变</li>
<li>当函数参数传递的变量是可变对象的时候，函数内改变变量值，函数外的变量会随之改变</li>
</ul>
  
来源：https://www.cnblogs.com/poloyy/p/15073168.html

頁: [1]

琼殿技术论坛's Archiver

Python - 可变和不可变对象