1. 列表与 * 操作
Python
中,*
操作符与 list
结合使用,实现元素复制。
复制 5 个空列表:
In [1]: [[]] * 5
Out[1]: [[], [], [], [], []]
In [2]: a = [[]] * 5
In [3]: a
Out[3]: [[], [], [], [], []]
In [4]:
填充两个元素:
In [4]: a[0].extend([1,2,3])
In [5]: a[1].extend([4,5,6])
期望应该为:
[[1,3,5],[2,4,6],[],[]]
实际为:
In [6]: a
Out[6]:
[[1, 2, 3, 4, 5, 6],
[1, 2, 3, 4, 5, 6],
[1, 2, 3, 4, 5, 6],
[1, 2, 3, 4, 5, 6],
[1, 2, 3, 4, 5, 6]]
原来 *
操作复制出的 a[0]
、a[1]
、...
、a[5]
,在内存中标识符是相等的,实现的仅仅是浅复制。
In [7]: id(a[0])
Out[7]: 1641831703560
In [8]: id(a[1])
Out[8]: 1641831703560
In [9]: id(a[2])
Out[9]: 1641831703560
In [10]: id(a[3])
Out[10]: 1641831703560
在这种场景下,希望实现 id[0]
、 id[1]
不相等,修改 a[1]
不会影响 a[0]
。
不使用 *
,使用列表生成式,复制出 5 个不同 id
的内嵌列表,这样就能避免赋值互不干扰的问题。
In [12]: b = [[] for _ in range(5)]
In [13]: b
Out[13]: [[], [], [], [], []]
In [14]: id(b[0])
Out[14]: 1641875609928
In [15]: id(b[1])
Out[15]: 1641875595080
In [16]: id(b[2])
Out[16]: 1641875822344
In [17]: b[0].extend([1,2,3])
In [18]: b[1].extend([4,5,6])
In [19]: b
Out[19]: [[1, 2, 3], [4, 5, 6], [], [], []]
In [20]:
2. 删除列表元素
假设列表有重复元素,要删除列表中指定的元素,看下面代码:
In [20]: def del_list(a, x):
...: for i in a:
...: if i == x:
...: a.remove(i)
...: return a
...:
In [21]: a = [1,2,3,2,4]
In [22]: del_list(a, 2)
Out[22]: [1, 3, 4]
In [23]: del_list([1,2,3,4,3,4,3], 2)
Out[23]: [1, 3, 4, 3, 4, 3]
In [24]: del_list([1,2,3,4,3,4,3], 3)
Out[24]: [1, 2, 4, 4]
In [25]: del_list([1,3,5,3,2], 3)
Out[25]: [1, 5, 2]
可以看到上面的删除都是正确的,再来看下面的代码
In [26]: del_list([1,3,3,3,3,5], 3)
Out[26]: [1, 3, 3, 5]
可以看出,删除结果仍然是包含 3 , 为什么呢?
遍历列表 a
、 remove
一次,移掉位置 i
后的所有元素索引都要减一。所以,一旦删除的元素,重复出现在列表中,就总会漏掉一个该删除的元素。
正确做法,找到被删除元素后,删除,同时下次遍历索引不加一;若未找到,遍历索引加一。
一般来讲,尽量避免在列表迭代的过程中对列表进行删除、更新操作。
3. 函数默认参数为空
Python
函数的参数可设为默认值。如果一个默认参数类型为 list
,默认值为设置为 []
。
有下面函数:
In [27]: def add_list(value, volume=[]):
...: if volume is None:
...: volume = []
...: length = len(volume)
...: for i in range(length):
...: volumn[i] = i + value
...: return volume
...:
调用 add_list
函数, val
值为 10, volume
默认值,函数返回 ret
为空列表。
In [28]: ret = add_list(10)
In [29]: ret
Out[29]: []
In [30]:
然后,我们向空列表 ret
中,分别添加值 1、2,打印 ret
,结果符合预期
In [30]: ret.append(1)
In [31]: ret.append(2)
In [32]: ret
Out[32]: [1, 2]
同样方法,再次调用 add_list
函数,第二个参数还是取默认值。预期返回值 ret
还是空列表,但是结果却出人意料!
In [41]: ret = add_list(10)
In [42]: ret
Out[42]: [10, 11]
为什么返回值为 [10,11] 呢? 按照出现的结果,我们猜测 [1, 2] + 10 后,不正是 [11,12]。
原来调用函数 add_list
时,默认参数 volume
取值为默认值时,并且 volume
作为函数的返回值。再在函数外面做一些操作,再次按照默认值调用,并返回。整个过程,默认参数 volume
的 id
始终未变。
通过增加打印我们可以看到,确实是默认参数 volume
的 id
始终未变。
In [45]: ret = add_list(10)
volume id is 1641863237000
In [46]: ret.append(1)
In [47]: ret.append(2)
In [48]: ret
Out[48]: [1, 2]
In [49]: ret = add_list(10)
volume id is 1641863237000
In [50]: ret
Out[50]: [10, 11]
为了避免这个隐藏的坑,函数的默认参数值切记不能设置为 []
,而是为 None
。这样即便按照默认值调用多次,也会规避此风险。
In [53]: def add_list(value, volume=None):
...: print("volume id is {}".format(id(volume)))
...: if volume is None:
...: volume = []
...: length = len(volume)
...: for i in range(length):
...: volume[i] = i + value
...: return volume
...:
In [58]: ret = add_list(10)
volume id is 1929553104
In [59]: ret
Out[59]: []
In [60]: ret.append(1)
In [61]: ret.append(2)
In [62]: ret
Out[62]: [1, 2]
In [63]: ret = add_list(10)
volume id is 1929553104
In [64]: ret
Out[64]: []
4. {} 和 ()
单个元素要被识别为元组,必须在括号后面加个逗号 ,
详见如下代码:
In [65]: a = (10)
In [66]: type(a)
Out[66]: int
In [67]: b = (10,)
In [68]: type(b)
Out[68]: tuple
创建集合与字典,它们都用一对 {}
,但是默认返回字典,而不是集合。要想创建空集合,可使用内置函数 set()
In [69]: d = {}
In [70]: type(d)
Out[70]: dict
In [71]: s = set()
In [72]: type(s)
Out[72]: set
5. 多值赋值顺序
多值赋值是先计算出等号右侧的所有变量值后,再赋值给等号左侧变量。
In [73]: a, b = 1, 2
In [74]: a, b = b+1, a+b
In [75]: a, b
Out[75]: (3, 3)