17.列表类型数据的增删改查及运算 - 数据类型（八）

列表（list）是Python中非常重要且相当常用的数据类型，我们经常需要对列表中的元素进行增、删、改、查及进行相关运算。

1 list元素的增加

1.1 L.append(newItem)

在列表L末尾添加一个新的元素newItem（可以是数字类型、字符串类型，甚至列表类型）。

L1 = list(range(3))
print('最初的L1：', L1)
# 在列表L1末尾添加一个新的元素10
L1.append(10)
print('后来的L1：', L1)

L2 = list('我爱学')
print('最初的L2：', L2)
# 在列表L2末尾添加一个新的元素'Python'
L2.append('Python')
print('后来的L2：', L2)

# 把列表L2整体作为一个元素添加到L1末尾
L1.append(L2)
print('把L2添加到L1：', L1)

# 需要注意的是：因为列表是可变的数据类型（以后我们会专门讲到），
# 前面append进去的其实是对L2的引用，
# 所以，我们修改L2，同样会影响到L1。
L2[0] = '我们'
print('修改L2同时也影响L1：', L1)

# 运行结果如下所示：

最初的L1： [0, 1, 2]
后来的L1： [0, 1, 2, 10]
最初的L2： ['我', '爱', '学']
后来的L2： ['我', '爱', '学', 'Python']
把L2添加到L1： [0, 1, 2, 10, ['我', '爱', '学', 'Python']]
修改L2同时也影响L1： [0, 1, 2, 10, ['我们', '爱', '学', 'Python']]

1.2 L.insert(index, newItem)

在列表L索引值为index的位置插入一个新的元素newItem（可以是数字类型、字符串类型，甚至列表类型）。

L = list(range(3)) # [0, 1, 2]
print('最初的L：', L)
# 在列表L索引值为2的位置插入一个数字3
L.insert(2, 3) # [0, 1, 3, 2]
print('2的位置插入3：', L)

# 在列表L索引值为-1的位置插入一个数字4
L.insert(-1, 4) # [0, 1, 3, 4, 2]
print('-1的位置插入4：', L)

# 运行结果如下所示：

最初的L： [0, 1, 2]
2的位置插入3： [0, 1, 3, 2]
-1的位置插入4： [0, 1, 3, 4, 2]

1.3 L.extend(seq)

参数seq本身是一个列表（严格讲，应该是一个可迭代的对象，关于迭代，以后再细讲），通过该函数调用，把seq中的所有元素一一取出来，作为新元素，批量追加到列表L末尾。

L1 = list('Py')
print('原L1：', L1)
L2 = list('thon')
print('原L2：', L2)
L1.extend(L2)
L1.extend(range(1, 4))
print('最终的L1：', L1)

# 运行结果如下所示：

原L1： ['P', 'y']
原L2： ['t', 'h', 'o', 'n']
最终的L1： ['P', 'y', 't', 'h', 'o', 'n', 1, 2, 3]

1.4 L[len(L):] = newList

采用切片的方法， 把列表newList中的所有元素一一取出来，作为新元素，批量追加到切片处。该用法与上面的extend方法的实现完全类似。其中len函数，用于求列表长度。

L1 = list('Py')
print('原L1：', L1)
L2 = list('thon')
print('原L2：', L2)
L1[2:] = L2 # “=”左侧为L1列表结尾处的切片，2为L1的长度，即len(l1)。
L1[len(L1):] = range(1, 4)
print('最终的L1：', L1)

# 运行结果如下所示：

原L1： ['P', 'y']
原L2： ['t', 'h', 'o', 'n']
最终的L1： ['P', 'y', 't', 'h', 'o', 'n', 1, 2, 3]

2 list及其元素的删除

2.1 del L[index]

删除列表L中索引值为index的元素。

L = list(range(3))
print('原L：', L)
del L[1]
print('删除索引1处元素后的L：', L)
del L[-1]
print('删除索引-1处元素后的L：', L)
del L[0]
print('删除索引0处元素后的L：', L)

# 运行结果如下所示：

原L： [0, 1, 2]
删除索引1处元素后的L： [0, 2]
删除索引-1处元素后的L： [0]
删除索引0处元素后的L： []

2.2 del L[i:j]

删除列表L中从索引i到j（不包括j）的切片。i和j所表达的范围跟列表切片中的范围完全一致。

L = list(range(7))
print('原L：', L)
del L[2:4] # 即从第2个元素开始，第4个元素截止（不包括第4个元素）
print('删除[2:4]切片后的L：', L)
del L[-2:] # 即从倒数第2个元素开始，一直到最末的元素（包括末尾的元素）
print('删除[-2:]切片后的L：', L)
del L[:1] # 即从第0个元素开始，第1个元素截止（不包括第1个元素）
print('删除[:1]切片后的L：', L)
del L[:] # 即删除所有
print('删除[:]切片后的L：', L)

# 运行结果如下所示：

原L： [0, 1, 2, 3, 4, 5, 6]
删除[2:4]切片后的L： [0, 1, 4, 5, 6]
删除[-2:]切片后的L： [0, 1, 4]
删除[:1]切片后的L： [1, 4]
删除[:]切片后的L： []

2.3 L.pop(index = -1)

“砰”的一声，从当前列表中把索引值为index的元素给毁灭（删除）了，index可以不用传入，要是不传入的话，默认删除列表中的最后一个元素。

L = list(range(5))
print('原L：', L)
L.pop()
print('删除末尾元素后的L：', L)
L.pop(-2)
print('删除索引-2处元素后的L：', L)
L.pop(1)
print('删除索引1处元素后的L：', L)

# 运行结果如下所示：

原L： [0, 1, 2, 3, 4]
删除末尾元素后的L： [0, 1, 2, 3]
删除索引-2处元素后的L： [0, 1, 3]
删除索引1处元素后的L： [0, 3]

2.4 L.remove(item)

从列表L中把元素值等于item的元素删除，若列表中有多个元素的值都等于item，仅删除排在前面的第一个。若列表中不存在元素的值等于item时，会触发ValueError错误。

L1 = list(range(1, 5)) # [1, 2, 3, 4]
print('原L1：', L1)
L1.remove(3) # [1, 2, 4]
print('删除3后的L1：', L1)
# 执行下面的语句会出错，提示：“list.remove(x): x not in list”。
# L1.remove(5)

L2 = ['apple', 'bike', 'cake', 'bike']
print('原L2：', L2)
L2.remove('bike')
print('删除"bike"后的L2（只会删除第一个"bike"）：', L2)

L3 = [1, 2, [3, 4, 5]]
print('原L3：', L3)
# 执行下面的语句会出错，对列表L3执行remove方法，
# 可删除的元素只能是三选一：1、2、[3, 4, 5]
# L3.remove(3)

L3[2].remove(3) # 注意：通过L3[2]来删除元素值为3的元素
print('删除3后的L3：', L3)
L3.remove([4, 5])
print('删除[4, 5]后的L3：', L3)

# 运行结果如下所示：

原L1： [1, 2, 3, 4]
删除3后的L1： [1, 2, 4]
原L2： ['apple', 'bike', 'cake', 'bike']
删除"bike"后的L2（只会删除第一个"bike"）： ['apple', 'cake', 'bike']
原L3： [1, 2, [3, 4, 5]]
删除3后的L3： [1, 2, [4, 5]]
删除[4, 5]后的L3： [1, 2]

2.5 L.clear()

把列表L中的所有元素都删除，L清空成空列表。

L = [0, 1, 2, [3, 4]]
print('原L：', L)
L.clear()
print('调用clear后的L：', L)

# 运行结果如下所示：

原L： [0, 1, 2, [3, 4]]
调用clear后的L： []

2.6 del L

删除列表变量L，L这个变量不能再被使用了。

L = list(range(5))
print('原L：', L)
del L
# 执行下面的语句会出错，提示：“name 'L' is not defined”。
# print('执行del后的L：', L)

# 运行结果如下所示：

原L： [0, 1, 2, 3, 4]

3 list元素的修改

3.1 L[index] = newItem

把列表L索引值为index的元素替换成newItem。

L = list(range(5))
print('原L：', L)
L[3] = [3, 33, 333]
L[4] = '44'
print('修改后的L：', L)

# 运行结果如下所示：

原L： [0, 1, 2, 3, 4]
修改后的L： [0, 1, 2, [3, 33, 333], '44']

3.2 L[i:j] = newList

把列表L中索引从i到j（不包括j）的切片替换成newList这个列表（可迭代对象）中的元素。

L = list(range(5)) # [0, 1, 2, 3, 4]
print('原L：', L)

# 把0、1两个数字元素替换成'0'、'1'两个字符串元素。
L[0:2] = ['0', '1'] # ['0', '1', 2, 3, 4]
print('修改L[0:2]后的L：', L)

# 把2这个数字元素替换成20、[21, 22]两个元素（一个为数字，一个为列表）。
L[2:3] = [20, [21, 22]] # ['0', '1', 20, [21, 22], 3, 4]
print('修改L[2:3]后的L：', L)

# 把3这个数字元素删除掉。
L[4:5] = [] #  ['0', '1', 20, [21, 22], 4]
print('修改L[4:5]后的L：', L)

# 把4这个数字元素替换成“[4]”列表元素。
L[4:5] = [[4]] # ['0', '1', 20, [21, 22], [4]]
print('修改L[4:5]后的L：', L)

# 把“[21, 22]”这个元素替换成“[21.1, 21.2, 22]”元素。
L[3][:1] = [21.1, 21.2] # ['0', '1', 20, [21.1, 21.2, 22], [4]]
print('修改L[3][:1]后的L：', L)

# 把20及其之后的所有元素替换成5、6两个数字元素。
L[2:] = [5, 6] # ['0', '1', 5, 6]
print('修改L[2:]后的L：', L)

# 运行结果如下所示：

原L： [0, 1, 2, 3, 4]
修改L[0:2]后的L： ['0', '1', 2, 3, 4]
修改L[2:3]后的L： ['0', '1', 20, [21, 22], 3, 4]
修改L[4:5]后的L： ['0', '1', 20, [21, 22], 4]
修改L[4:5]后的L： ['0', '1', 20, [21, 22], [4]]
修改L[3][:1]后的L： ['0', '1', 20, [21.1, 21.2, 22], [4]]
修改L[2:]后的L： ['0', '1', 5, 6]

4 list的查找及运算

4.1 L.index(item)

返回列表L中元素值与item相等且第一个匹配上的元素的索引值。要是没能查找到匹配的元素，会触发ValueError错误。

L = list(range(1, 6))
print(L)
print("元素4在L列表中的索引值为：", L.index(4))
# 如下代码会触发ValueError错误，错误提示为：6 is not in list
# print(L.index(6))

# 运行结果如下所示：

[1, 2, 3, 4, 5]
元素4在L列表中的索引值为： 3

4.2 list的相关运算

• L1 + L2：将两个列表拼接起来；
• L * n：n为一个整数（若n小于0，则会当作0来处理），结果相当于列表L与自身进行n次拼接；
• x in L：若列表L中存在元素值等于x，则结果为True，否则为False；
• x not in L：若列表L中不存在元素值等于x，则结果为True，否则为False。

L1 = list(range(3))
L2 = list(range(3, 6))
print(L1, L2, L1 + L2)
print([0, 1] * 3)
print('1 in [0, 1]：', 1 in [0, 1])
print('2 not in [0, 1]：', 2 not in [0, 1])
print('1 in [0, [1]]：', 1 in [0, [1]])
print('[1] in [0, [1]]：', [1] in [0, [1]])

# 运行结果如下所示：

[0, 1, 2] [3, 4, 5] [0, 1, 2, 3, 4, 5]
[0, 1, 0, 1, 0, 1]
1 in [0, 1]： True
2 not in [0, 1]： True
1 in [0, [1]]： False
[1] in [0, [1]]： True

---

青少年、零基础、初学者Python编程从入门到精通，“老马带小马 一块学Python”编程系列。