序列赋值引发的Python列表陷进

开发 后端
++是指把两个序列的元素拼接在一起。通常+号两侧的序列由相同类型的数据所构成,在拼接的过程中,两个被操作的序列都不会被修改,Python会新建一个包含同样类型数据的序列作为拼接的结果。

[[384843]]

本文转载自微信公众号「dongfanger」,作者dongfanger。转载本文请联系dongfanger公众号。

序列赋值是Python默认操作,如果使用不当,有可能会掉入语法陷阱。

+

+是指把两个序列的元素拼接在一起。通常+号两侧的序列由相同类型的数据所构成,在拼接的过程中,两个被操作的序列都不会被修改,Python会新建一个包含同样类型数据的序列作为拼接的结果。比如:

  1. a = [1] 
  2. b = [2] 
  3. c = a + b 
  4. print(a, b, c) 
  5. print(id(a), id(b), id(c)) 

结果为:

  1. [1] [2] [1, 2] 
  2. 2409610524480 2409610523520 2409610523648 

*

如果想要把一个序列复制几份然后再拼接起来,更快捷的做法是把这个序列乘以一个整数。同样,这个操作会产生一个新序列:

  1. >>> l = [1] 
  2. >>> l * 5 
  3. [1, 1, 1, 1, 1] 
  4. >>> 5 * "a" 
  5. 'aaaaa' 

+和*都遵循这个规律,不修改原有的操作对象,而是构建一个全新的序列。

列表套列表的陷进

猜猜这个结果会是啥:

  1. x = ["x"
  2. my_list = [x] * 3 
  3. print(my_list)  # [['x'], ['x'], ['x']] 
  4.  
  5. x2 = my_list[2] 
  6. x2[0] = "y" 
  7. print(my_list) 

讲道理,应该是[['x'], ['x'], ['y']],但是错了,实际是:

  1. [['y'], ['y'], ['y']] 

Unbelievable!给my_list的最后一个元素的列表赋值,结果所有三个元素的列表都被赋值了!这反映出my_list这三个元素不是3个列表,而是3个列表引用,指向了同一个相同的列表。相当于:

  1. x = ["x"
  2. my_list = [] 
  3. for i in range(3): 
  4.     my_list.append(x)  # 追加相同对象 
  5.  
  6. x2 = my_list[2] 
  7. x2[0] = "y" 
  8. print(my_list)  # [['y'], ['y'], ['y']] 

每次都追加了同一个对象到my_list。如果想生成3个不同列表,那么需要在每次迭代中新建列表:

  1. my_list = [] 
  2. for i in range(3): 
  3.     x = ["x"]  # 新建列表 
  4.     my_list.append(x) 
  5.  
  6. x2 = my_list[2] 
  7. x2[0] = "y" 
  8. print(my_list)  # [['x'], ['x'], ['y']] 

这样就符合预期了。可以用列表推导简化代码:

  1. x = ["x"
  2. my_list = [x for i range(3)] 
  3.  
  4. x2 = my_list[2]   
  5. x2[0] = "y" 
  6. print(my_list)  # [['x'], ['x'], ['y']] 

教训:

新建列表中的列表,使用列表推导,不要使用*运算符。

如果a * n这个语句中,序列a里的元素是对其他可变对象的引用的话,就需要格外注意了,这可能不是你想要的效果。

+=

a += b虽然意思是a = a + b,但是它背后的特殊方法是__iadd__,如果一个类没有实现这个方法的话,Python才会退一步调用__add__。__iadd__方法会直接在原对象中追加,__add__方法会先生成新对象再赋值。

*=

+=的这些概念也适用于*=,只是后者对应的是__imul__。追加还是新对象,在作用到可变序列和不可变序列时效果明显,示例:

  1. # 可变序列,追加 
  2. >>> l = [1, 2, 3] 
  3. >>> id(l) 
  4. 2135319475136 
  5. >>> l *= 2 
  6. >>> l 
  7. [1, 2, 3, 1, 2, 3] 
  8. >>> id(l) 
  9. 2135319475136  # id一样 
  10.  
  11. # 不可变序列,新对象 
  12. >>> t = (1, 2, 3) 
  13. >>> id(t) 
  14. 2135322139520 
  15. >>> t *= 2 
  16. >>> id(t) 
  17. 2135321695424  # id不一样 

元组套列表的陷进

  1. >>> t = (1, 2, [30, 40]) 
  2. >>> t[2] += [50, 60] 

猜猜会发生下面4种情况中的哪一种?a.t变成(1, 2, [30, 40, 50, 60])b.因为tuple不支持对它的元素赋值,所以会抛出TypeError异常c.以上两个都不是d.a和b都是对的因为元组不能赋值,所以我会毫不犹豫的选择b。但实际上答案是d!a和b都是对的,既会赋值成功,也会报错:

  1. >>> t = (1, 2, [30, 40]) 
  2. >>> t[2] += [50, 60] 
  3. Traceback (most recent call last): 
  4.   File "<input>", line 1, in <module> 
  5. TypeError: 'tuple' object does not support item assignment 
  6. >>> t 
  7. (1, 2, [30, 40, 50, 60]) 

Oh No!为什么?一、赋值成功,因为t[2]指向的是一个可变对象(列表[30, 40]),可变对象是能赋值的。二、报错,因为可变对象赋值给了不可变对象(元组t),不可变对象不能赋值。

写成t[2].extend([50, 60])能避免这个异常。

教训:

  1. 不要把可变对象放在元组里面。
  2. +=不是一个原子操作,虽然抛出了异常,但还是完成了操作。

这位巴西作者说到,在他15年的Python生涯中,他还没见过谁在这个地方吃过亏。

小结

本文分别介绍了+、*和列表套列表的陷阱,+=、*=和元组套列表的陷阱,并分别得出了教训。这是动态语言的弊端,在运行后才能知道有没有类型错误,只能积累代码经验来避免。鱼与熊掌不可兼得,在享受Python语法简洁的便利同时,也得付出运行报错排查麻烦的代价。

 

参考资料:《流畅的Python》

 

责任编辑:武晓燕 来源: dongfanger
相关推荐

2022-03-03 17:06:24

序列类型新增元素Python

2021-09-02 07:52:18

算法大数据个人信息保护

2021-05-28 05:49:28

Python数据结构与算法bisect

2024-07-12 12:01:37

Python代码多重赋值

2009-06-19 08:29:36

Windows 7微软操作系统

2023-07-05 07:21:34

时间序列学习框架模型

2009-03-13 16:39:16

Linux开源改变

2010-03-15 09:47:43

Python DNA序

2017-05-24 15:50:08

PythonCPython

2021-01-11 05:30:04

Boot 单机片

2020-03-02 00:32:08

Python列表for循环

2022-05-27 07:51:07

自定义无序列表CSS

2013-04-16 10:48:04

Python序列

2011-10-17 08:29:33

Ubuntu 11.1思考

2015-02-04 14:36:07

格式串漏洞Ghost漏洞安全漏洞

2012-07-05 09:54:04

Amazon宕机

2020-11-11 10:00:13

NAT性能内核

2024-06-28 09:52:47

列表Python

2021-03-15 10:02:22

Python列表函数

2021-08-30 12:25:12

Python序列化函数
点赞
收藏

51CTO技术栈公众号