背景
写 Python 四年有余了,常见的坑和奇淫巧技也都知道一些。今天在 Python 连续赋值上遇到了一个新的知识点,学习记录一下。
Python 连续赋值容易导致错误的情况有两个知识点:
相同的引用
赋值的顺序(本次探讨的重点)
相同的引用
这个有点 Python 经验的同学都知道或者很好理解,对可变对象的赋值,其实赋的是可变对象的引用。
在下面的代码中,因为['hello']是一个列表,即可变对象,变量a和b都是这个同一个列表的引用。因此,对b修改时,a的值也变了,因为它们本来就指向同一个对象。
1
2
3
4
5
6
7
8s1 = s2 = 'hello'
s2 += 'world'
print(s1)
a = b = ['hello']
b.append('world')
print(a) # Output: ['hello', 'world']
print(id(a) == id(b)) # Output: True
赋值的顺序
通常我们并不是太关心在使用连续赋值过程中赋值的顺序,就像下面这两行代码,赋值的先后次序并不影响结果。
1
2s1 = s2 = 'hello'
a = b = ['hello']
但到底是:
是先把'hello'赋值给s2,然后把s2赋值给s1吗?
还是把'hello'赋值给s2,然后'hello'赋值给s1呢?
又或者是把'hello'赋值给s1,然后'hello'赋值给s2呢?
在下面这个例子中让我犯了难。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22class :
def __init__(self, x):
self.val = x
self.next = None
def __repr__(self):
return '->'.join(map(str, ([self.val, self.next.val] if self.next else [self.val])))
def main():
a = ListNode(0)
a = a.next = ListNode(1)
print(a)
b = ListNode(0)
b.next = ListNode(1)
b = b.next
print(b)
if __name__ == '__main__':
main()
Output:
1->1
1
我本期望赋值操作可以从右向左进行赋值,让上面代码中的变量a和b有相同的结果。即:
1a = a.next = ListNode(1)
我期望上面的语句等同于
1
2a.next = ListNode(1)
a = a.next
事与愿违,解释器总是很忠实的按照原有的设计去执行代码。那么它到底是怎么做的呢?
我们可以import dis,把 python 代码反汇编来看一下。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import dis
class :
def __init__(self, x):
self.val = x
self.next = None
def __repr__(self):
return '->'.join(map(str, ([self.val, self.next.val] if self.next else [self.val])))
def main():
a = ListNode(0)
a = a.next = ListNode(1)
print(a)
b = ListNode(0)
b.next = ListNode(1)
b = b.next
print(b)
if __name__ == '__main__':
dis.dis(main)
下面看看 Line 14, 18, 19 翻译过来的汇编码:
汇编语言我并不了解,下面的注释是我根据命令名称的猜测,如有错误恳请指出。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23...
14 8 LOAD_GLOBAL 0 (ListNode) // 加载ListNode
10 LOAD_CONST 2 (1) // 加载常量 1
12 CALL_FUNCTION 1 // 调用函数(可能是ListNode的构造函数)
14 DUP_TOP
16 STORE_FAST 0 (a) // 赋值给变量 a
18 LOAD_FAST 0 (a) // 加载变量 a
20 STORE_ATTR 1 (next) // 赋值给属性 next
...
18 38 LOAD_GLOBAL 0 (ListNode) // 加载ListNode
40 LOAD_CONST 2 (1) // 加载常量 1
42 CALL_FUNCTION 1 // 调用函数(可能是ListNode的构造函数)
44 LOAD_FAST 1 (b) // 加载变量 b
46 STORE_ATTR 1 (next) // 赋值给属性 next
19 48 LOAD_FAST 1 (b) // 加载变量 b
50 LOAD_ATTR 1 (next) // 加载变量 b 的属性 next
52 STORE_FAST 1 (b) // 赋值给变量 b
...
由汇编码就很容易看出,在 Python 中类似a = b = 'hello'的连续赋值过程,实际上是将最右侧的常量或变量,对其左侧=前的各变量从左至右依次赋值。
即:1a = b = 'hello'
等同于1
2a = 'hello'
b = 'hello'
回到上面让我犯难的例子中:
1a = a.next = ListNode(1)
等同于
1
2
3
4_ = ListNode(1)
a = _
a.next = _
# 注意:这里我用_暂存了对象,整个过程中只创建了一个对象
而不是
1
2a.next = ListNode(1)
a = a.next
了解了原理,要想实现我期望的效果,其实只要调换一下顺序就行,像下面这样:1a.next = a = ListNode(1)
不过这样降低了可读性,不利于理解,最好还是不要这样写!
总结这种错误隐秘难调,最好不要使用连续赋值(Chained Assignment)。
对基础知识点要加强学习。
连续赋值在其他编程语言中似乎不是这样的,Python 是个特例,这点有待考证!!!