列表的常用操作，这十张图把它说的明明白白！

列表( list)作为Python中最常用的数据类型之一，是一个可增加、删除元素的可变(mutable)容器。

基本操作

创建 list 的方法非常简单，只使用一对中括号[]

如下创建三个list:

empty = []
lst = [1,'xiaoming',29.5,'17312662388']
lst2 = ['001','2019-11-11',['三文鱼','电烤箱']]

empty在内存中的示意图：

empty内存示意图

lst在内存中的示意图：

lst 内存示意图

lst2在内存中的示意图：

lst2 内存示意图

使用python的内置函数len求list内元素个数：

len(empty) # 0
len(lst) # 4
len(lst2) # 3

依次遍历lst内每个元素并求对应类型，使用for in对遍历，内置函数type得到类型：

for _ in lst:
    print(f'{_}的类型为{type(_)}')

打印结果如下，列表 lst 内元素类型有3种：

1的类型为<class 'int'>
xiaoming的类型为<class 'str'>
29.5的类型为<class 'float'>
17312662388的类型为<class 'str'>

因此，Python的列表不要求元素类型一致。

如何向 lst2 的第三个元素['三文鱼','电烤箱']内再增加一个元素'烤鸭'。

首先，使用整数索引取出这个元素：

sku = lst2[2] # sku又是一个列表

sku变量位于栈帧中，同时指向lst22：

然后，使用列表的append方法增加元素，append默认增加到 sku列表尾部：

sku.append('烤鸭')
print(sku) # ['三文鱼', '电烤箱', '烤鸭']

sku变量示意图

此时想在sku指定索引1处插入牛腱子，使用列表的insert方法：

sku.insert(1,'牛腱子')
print(sku) # ['三文鱼', '牛腱子', '电烤箱', '烤鸭']

sku变量示意图

在购买烤鸭和牛腱子后，发现超出双十一的预算，不得不放弃购买烤鸭，使用pop方法可直接移除列表尾部元素：

item = sku.pop() # 返回烤鸭
print(sku) # ['三文鱼', '牛腱子', '电烤箱']

1574822687219

发现还是超出预算，干脆移除三文鱼，pop因为只能移除表尾元素，幸好列表有remove方法：

sku.remove('三文鱼') # 更好用：sku.remove(sku[0])
print(sku) # ['牛腱子', '电烤箱']

sku变量示意图

深浅拷贝

打印 lst2，发现第三个元素也对应改变，因为 sku 引用 lst2 的第三个元素，sku 指向的内存区域改变，所以 lst2 也会相应改变。

print(lst2) # ['001', '2019-11-11', ['牛腱子', '电烤箱']]

如果不想改变 lst2 的第三个元素，就需要复制出 lst2 这个元素，列表上有 copy 方法可实现复制：

lst2 = ['001','2019-11-11',['三文鱼','电烤箱']] # 这是lst2的初始值

可视化此行代码，lst2 位于全局帧栈中，其中三个元素内存中的可视化图如下所示：

lst2变量示意图

sku_deep = lst2[2].copy() 

注意，copy 函数，仅仅实现对内嵌对象的一层拷贝，属于 shallow copy.

此时可视化图为如下，因为拷贝 lst22，所以 sku_deep 位于栈帧中指向一块新的内存空间：

sku_deep 示意图

此时，再对 sku_deep 操作，便不会影响 lst22 的值。

如下修改 sku_deep 的第一个元素( Python 的列表索引从 0 开始编号), lst2 未受到任何影响。

sku_deep[0] = '腱子'
print(lst2[2]) # ['三文鱼','电烤箱']

修改 sku_deep 时，不会影响 lst22.

因为它们位于不同的内存空间中，如图所示，lst22 中的第一个元素依然是 三文鱼，而不是腱子.

浅拷贝示意图

至此，仅仅使用 shallow copy.

那么，它与深拷贝 ，英文叫 deepcopy，又有什么不同？

请看下面例子， a 是内嵌一层 list 的列表，对其浅拷贝生成列表 ac，修改 ac 的第三个元素，也就是列表 3,4,5 中的第二个元素为 40

a = [1,2,[3,4,5]]
ac = a.copy()
ac[0] = 10
ac[2][1] = 40

修改后，分别测试两个值的相等性。

print(a[0] == ac[0])

返回 False ，证明实现拷贝。

而 ac[2][1]是否与原数组 a 的对应位置元素相等：

print(a[2][1] == ac[2][1])

返回 True，进一步证明是浅拷贝，不是深拷贝。

如下图所示：copy 只完成了一层 copy，即 [1,2, id(3,4,5)] 复制一份，而复制后，仍然指向 3,4,5 所在的内存空间：

要想实现深度拷贝，需要使用 copy 模块的 deepcopy 函数：

from copy import deepcopy

a = [1,2,[3,4,5]]
ac = deepcopy(a)
ac[0] = 10
ac[2][1] = 40
print(a[0] == ac[0])
print(a[2][1] == ac[2][1])

打印结果，都为 False，结合下图，也能看出内嵌的 list 全部完成复制，都指向了不同的内存区域。