从内存的角度看Python中的变量

2022/1/11 7:03:48

本文主要是介绍从内存的角度看Python中的变量,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1、前言

由于笔者并未系统地学习过Python,对Python某些底层的实现细节一概不清楚,以至于在实际使用的时候会写出一些奇奇怪怪的Bug(没错,别人写代码,我写Bug),比如对象的某些属性莫名奇妙地改变。究其原因,是对Python中的变量机制存在一些误解,毕竟以前一直是用C语言居多。无奈,只能深入学习这一部分的知识,并总结成此文。

阅读本文,你可以:

  • 了解Python中变量的“储存”机制。
  • 了解Python中赋值、浅拷贝于深拷贝的区别和使用场景。
  • 了解Python中的函数传参形式。

当然,你需要一点基础的编程和面向对象的知识才能看懂本文。

2、引用式变量

相信学过Python的小伙伴都听过这样一句话:Python中一切皆是对象。这意味着,哪怕是Python中的基本数据类型,其本质上也是对象,例如对于一个int类型的变量a,你可以调用int类对象的方法来求a的绝对值:

>>> a = -1
>>> a.__abs__()
1

在这个例子中,可以说:a是int类的一个实例对象,其值是-1。当然,这句话其实说的不对,因为a并不是一个对象,而是对象的引用。这听起来很奇怪,但事实就是如此。Python中的变量都是引用式变量,他并不像C/C++中的变量,储存着具体的数据类型或对象,他像是C++中的引用。通俗的讲,Python中的变量相当于对象的别名,如果你有C语言的基础,可以把它理解为C语言中的指针,通过它你可以在内存中找到对象。话不多说,先看图:

图片来源:《流畅的Python》8.1

左边的图表示的就是C语言中的变量,变量相当于一个“盒子”,“盒子”里装着值,右边表示的就是Python中的引用式变量,a和b都是列表对象[1, 2, 3]的别名,像是贴在[1, 2, 3]上的”标签“,顺着这些”标签“,解释器可以在内存中找到他们对应的对象。你也许会问,这有啥区别,不都是变量吗。还是先看代码:

a = [1, 2, 3]
b = a
a[2] = 9
print(a)
print(b)

----运行结果----
[1, 2, 9]
[1, 2, 9]

意想不到的事情发生了,明明代码只改变了a的值,为什么b也跟着变了呢?这是因为,a、b都是列表的引用,并不是实际的列表,上述代码通过a这个”标签“改变了内存中列表[1, 2 ,3]的值,于是乎,你顺着b”标签“找到的列表,当然是改变了的。再看代码:

a = [1, 2, 3]
b = a
a = [1, 2, 9]
print(a)
print(b)

----运行结果----
[1, 2, 9]
[1, 2, 3]

在这个例程中,我们把[1, 2, 9]赋值给了a,然后再输出a和b,此时a已经发生变化,而b没有改变,a从列表[1, 2, 3]的引用变成了列表[1, 2, 9]的引用,列表[1, 2, 3]在内存中并未发生任何改变,这就是b输出的值不发生变化的原因。到这里,你应该可以理解上面说的:a是int类的一个实例对象,其值是-1为什么是错的了。这样的赋值语句在Python中的应该这样理解:创建一个int类对象-1,让a作为-1的引用。当然,右边的值是常量或是可变对象,解释器都会做出不同的反应,这将在下文进一步讲解。总之,啰啰嗦嗦说了这么多,就是希望大家都能搞明白这个问题,核心就是一句话:Python中的变量都是引用式变量,变量存储的不是值,而是引用。

3、赋值、浅拷贝与深拷贝

看完上一节,肯定有人会问,如果Python中的赋值都是引用,那我想创建一个变量的副本做备份怎么办?这在C语言中简单的一句b=a就可以实现的需求在Python中如何实现?Python中提供了三种复制的方式,即:

  • 赋值:创建对象的引用。
  • 浅拷贝:拷贝对象,但不拷贝对象内部的子对象。
  • 深拷贝:拷贝对象,并且拷贝对象内部的子对象。

一如既往地先看代码,毕竟代码最能说明问题:

import copy
a = [1, 2, [3, 3 , 3], [4, 4]]
b = a # 赋值
c = a.copy() # 浅拷贝,调用对象的copy()方法
d = copy.deepcopy(a) # 深拷贝,需要引入copy模块,使用deepcopy()方法
a[1] = -2  # 改变1
a[2] = [-3, -3, -3]  # 改变2
a[3][0] = -4  # 改变3
print(a)
print(b)
print(c)
print(d)

----运行结果----
[1, -2, [-3, -3, -3], [-4, 4]]
[1, -2, [-3, -3, -3], [-4, 4]]
[1, 2, [3, 3, 3], [-4, 4]]
[1, 2, [3, 3, 3], [4, 4]]

为了更方便阐述,这里我先给出这个例程中对象在内存中的变化情况,当然我更建议你自己去这个网站逐步可视化地运行上面的代码,甚至是本文中的所有代码,这能加深你的理解。

在这里插入图片描述

在这段代码中,首先创建了一个列表对象,这个列表的第3、4个元素也是列表对象,a是这个列表的引用,把a赋值给b,此时b也是同一个对象的引用,在内存中,它们指向同一个对象,因此可以看到无论怎么通过a改变这个对象,a和b都是相同的。c则是对a的浅拷贝,解释器新开辟了一块内存,存储了原列表的一个副本,但是由于是浅拷贝,对象内部的子对象没有被拷贝。因此,这个副本列表的后面两个元素依旧和原列表一样,是列表[3, 3 , 3]和[4, 4]的引用,在内存中指向同样的对象。代码中的改变2让原列表的第三个元素变成了另一个列表[-3, -3 , -3]的引用,但是这个副本列表的第三个元素还是[3, 3 , 3]的引用。改变3则修给了原列表第四个元素指向的列表中的一个元素,因此打印c你会发现它指向的列表对应位置的元素也改变了。而对于d,d是a的深拷贝,解释器新开辟了一块内存,完全复制了原列表对象(包括子列表对象)放在这块内存中。因此,d指向的对象和a指向的对象没有任何关系,无论怎么改变a指向的那个列表,都不会影响d指向的列表。

看到这里,你应该知道如何实现本节开头的需求了。

4、is的用法和id()函数

在Python中,每个对象都有各自的编号、类型和值,一个对象被创建以后,它的编号就不会改变,可以理解为对象在内存中的地址。id()函数可以获取对象的编号,在CPython解释器中,这个编号就是对象在内存中的地址。is是一个双目运算符,运算结果是布尔变量,用来比较两个对象的编号是否相同,准确的说,可以用于比较两个变量是否是同一个对象的引用。

a = [1, 2, 3]
b = a  # 赋值
c = a.copy()  # 浅拷贝
print(id(a))
print(id(b))
print(id(c))
print(a is b)
print(a is c)

----运行结果----
2667871075272
2667871075272
2667871075208
True
False

显然,a、b是同一个对象的引用,而c是浅拷贝的副本,因此a和c引用的不是同一个对象,即使这两个对象的值相等。不知你是否还记得,第1节中还提到在赋值语句中,右边是可变对象与不可变对象,解释器会由不同的操作,比如下面的代码:

a = 5
b = 5
print(a is b)
c = [1, 2, 3]
d = [1, 2, 3]
print(c is d)

----运行结果----
True
False

对a、b分别赋值为5,但是它们却是同一个对象的引用,这是因为,5是一个常量,对应的int类对象就是不可变的对象。Python解释器认为,这样的不可变对象,只需要在内存中存在一个就可以,因此,a和b指向同一个对象。而对于列表[1, 2, 3],由于列表是可变对象,即使这两个对象的值相同,但它们不指向同一个对象。毕竟,谁也不知道后面的程序中会不会改变其中一个列表中的值。说到这里,或许能够解释Python的作者为什么要将Python的变量设计成只有引用式变量了,按照笔者粗浅的理解,这样做的优势在于可以节约内存。毕竟,Python为了能够”简洁、优雅“,为了能够用一行代码解决C语言用20行代码才能解决的问题,在性能上牺牲了不少。

5、函数传参机制

在Python中,函数传参同样传递的是对象的引用,函数参数是不可变对象时,这没有什么讨论的价值。但是,倘若传递的参数是可变对象,如果你不注意这一点,Bug可能就会默默地在凝视你,譬如:

def test1(a):
    a[-1] = 'end'

a = [1, 2, 3]
test1(a)
print(a)

----运行结果----
[1, 2, 'end']

可以看到,在运行完函数test1后,a的值改变了,如果你不想让他改变,这是Bug就来啦。

同样,还有需要注意的一点是,不要把参数的默认值设置成一个可变对象,否则Bug大概已经在和你招手了:

# 用可变对象做参数默认值带来的bug
# 例程来源于《流畅的Python》
class HauntedBus():
    def __init__(self, passengers=[]):
        self.passengers = passengers

    def pick(self, name): # 乘客上车
        self.passengers.append(name)

    def drop(self, name): # 乘客下车
        self.passengers.remove(name)

bus1 = HauntedBus(['zhang_san', 'li_si'])
bus1.pick('wang_mazi')
bus1.drop('zhang_san')
print(bus1.passengers)

bus2 = HauntedBus()
bus2.pick('zhao_wu')
print(bus2.passengers)

bus3 = HauntedBus()
print(bus3.passengers)
print(bus2.passengers is bus3.passengers)
print(bus3.passengers is bus1.passengers)

----运行结果----
['li_si', 'wang_mazi']
['zhao_wu']
['zhao_wu']
True
False

你会惊奇地发现,bus3.passengers难道不应该是空列表吗?这是因为,HauntedBus的构造函数中passengers的默认值是一个可变对象,在对bus2进行操作的时候,由于引用式变量的特性,改变了默认值指向的可变对象。于是乎,就出现了意向不到的Bug。

6、扩展阅读

讲到这里,其实本文的主要内容就基本讲完了。本节的内容,除非说你需要开发自己的Python库,否则了解与否都基本不会影响你使用Python,你完全可以跳过本节,完结撒花。

垃圾回收:在其他编程语言中都会讨论变量或对象的生存周期,会有垃圾回收机制,但在Python中好像很少谈及这个问题。实际上,Python也存在垃圾回收机制,Python中每个变量都是对象的引用,如果某个对象不再被引用,这个对象就会被销毁,这就是Python中的垃圾回收机制。del语句可以删除变量,解除变量对对象的引用,如果这是对象的最后一个引用,这个对象就会被销毁。

弱引用:弱引用不增加对象的引用数,若对象存在,通过弱引用可以获取对象。若对象已被销毁,则弱引用返回None,这常用于缓存中。

最后,本文的目的在于帮助那些像我一样从C语言转移到Python的人,或者是被Python的变量、拷贝整得晕头转向的人。为了让小白也有可能能看懂本文,我尽量写得通俗易懂。但是限于本人水平,难免会有谬误或疏漏之处,如有发现,烦请再评论区指正,over。

欢迎访问我的个人博客:https://liu-huilin.github.io/

参考资料

Python语言参考手册:https://docs.python.org/zh-cn/3/reference/datamodel.html

Luciano Ramalho:《流畅的Python》第八章,人民邮电出版社。

Python 直接赋值、浅拷贝和深度拷贝解析:https://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html



这篇关于从内存的角度看Python中的变量的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程