Python列表之常用内置函数、方法、技巧汇总

列表相关操作

排序

列表的方法sort()或者内置函数sorted()可以完成排序操作。

# 对lst本身进行升序排列，使用sort()方法
lst = [3, 1, 2]
# lst变为[1, 2, 3]
lst.sort()        

# 得到一个新的升序列表，lst保持不变，使用sorted()内置函数
lst = [3, 1, 2]
# lst不变，lst_sorted为[1, 2, 3]
lst_sorted = sorted(lst)

注意：无论是方法sort()或者内置函数sorted()都有两个形参，reverse和key，前者表示是否倒序排列，后者表示排序的依据，通常会涉及到lambda匿名函数的使用。关于key形参以及lambda匿名函数的使用可以详见真题【排序】2023Q1A-身高提供排序 中的进阶部分。

# 对lst本身进行降序排列，使用sort()方法
lst = [3, 1, 2]
# lst变为[3, 2, 1]
lst.sort(reverse = True)        

# 得到一个新的降序列表，lst保持不变，使用sorted()内置函数
lst = [3, 1, 2]
# lst不变，lst_sorted为[3, 2, 1]
lst_sorted = sorted(lst, reverse = True)

翻转

列表的方法reverse()或者内置函数reversed()可以完成翻转操作。

# 对lst本身进行翻转，使用reverse()方法
lst = [3, 1, 2]
lst.reverse()        

# 得到一个新的翻转列表，lst保持不变，使用reversed()内置函数
lst = [3, 1, 2]
lst_reversed = list(reversed(lst))

也可以使用列表的切片操作来完成翻转，设置步长为-1即可。

# 得到一个新的翻转列表，lst保持不变，使用切片操作
lst = [3, 1, 2]
lst_reversed = lst[::-1]

映射

如果想把一个列表里的所有元素批量地调用某一个函数，并映射得到一个新的列表（原列表中元素相对位置不变），可以使用内置函数map(func, iter)。
map(func, iter)的含义是，对可迭代对象iter（通常是一个列表）里的所有元素都调用函数func，并得到一个新的map对象。如果我们对map对象的外部再调用list()，则可以得到一个新的列表。
其具体例子如下：

lst_str = ["1", "2", "3"]
# 得到lst_num为[1, 2, 3]
lst_num = list(map(int, lst_str))

上述过程，是将lst_str = [“1”, “2”, “3”]中的每一个元素即str类型的"1"、“2”、"3"都调用了函数int()，转化为int类型的的1、2、3。
实际上等价于

lst_str = ["1", "2", "3"]
lst_num = list()
for ch in lst_str:
    lst_num.append(int(ch))
# 得到lst_num为[1, 2, 3]

或

lst_str = ["1", "2", "3"]
lst_num = list(int(ch) for ch in lst_str)
# 得到lst_num为[1, 2, 3]

在ACM模式中，map()函数通常会用于处理用例的输入。具体可见ACM模式输入输出总结中的具体例子。
另外，需要注意map(func, iter)中的参数func既可以是一个内置函数，也可以是一个自定义函数，还可以是一个lambda匿名函数（可见后续lambda匿名函数的相关内容）。

枚举

如果想在for循环中同时获得列表的索引i和元素值v，可以使用枚举内置函数enumerate(lst)，其语法如下：

lst = ["a", "b", "c"]
for i, v in enumerate(lst):
    print(i, v)

# 依次输出
# 0 a
# 1 b
# 2 c

这种写法等价于：

lst = ["a", "b", "c"]
for i in range(len(lst)):
    v = lst[i]
    print(i, v)

另外，enumerate(lst, start)支持传入第二个参数start，表示索引i的从start开始计数（但传入的整个lst还是会都会被遍历，只是i从start开始数而不是从0开始数）。譬如

lst = ["a", "b", "c"]
for i, v in enumerate(lst, 1):
    print(i, v)

# 由于i会从1而不是从0开始计数，
# 依次输出
# 1 a
# 2 b
# 3 c

合并

有两个长度相等的列表a_lst和b_lst，如果想获得由同一索引对应元素构成的二元元组列表，可以使用内置函数zip()。

a_lst = [0, 1, 2]
b_lst = ["a", "b", "c"]
# 得到二维列表[(0, 'a'), (1, 'b'), (2, 'c')]
merge_lst = list(zip(a_lst, b_lst))

更常见的使用场景是在for循环中：

a_lst = [0, 1, 2]
b_lst = ["a", "b", "c"]
for a, b in zip(a_lst, b_lst):
    print(a, b)

去重

直接使用哈希集合set()的特性，即可完成列表的去重。

lst = [1, 1, 2, 3, 3]
lst_nonrepeat = list(set(lst))

拷贝

先思考执行以下代码，为什么列表a会随着列表b的变化而变化？

a = [1,2,3]
b = a
b[0] = 0

print(b)
# 得到[0,2,3]
print(a)
# 得到[0,2,3]

这实际上涉及到Python一切皆对象的设计思想，此处的a和b是同一个列表对象的两个别名，它们表示同一个列表，因此修改b会牵连到a。这也是初学者非常容易犯的一个错误。
为了使得a和b指向两个不同的列表对象，我们在赋值操作时可以有两种操作，来让b获得a的拷贝：

1. 使用切片。即令b = a[:]

a = [1,2,3]
b = a[:]
b[0] = 0

print(b)
# 得到[0,2,3]
print(a)
# 得到[1,2,3]

2. 使用copy()方法。即令b = a.copy()

a = [1,2,3]
b = a.copy()
b[0] = 0

print(b)
# 得到[0,2,3]
print(a)
# 得到[1,2,3]

以上两种方法，都可以使得a和b表示两个不同的（但值相同的）列表对象。这个技巧在回溯算法中非常常见。