在之前的文章中我们介绍了Python中List列表的一些简单的用法，下面我们来看看在Python中关于List的一些高级操作用法。

切片（Slicing）

在Python中使用切片操作可以从列表中获取子列表。语法为list[start:end:step]，其中start是起始索引，end是结束索引（不包括），step是步长。如下所示。

my_list = [1, 2, 3, 4, 5]
sub_list = my_list[1:4]  # 获取索引1到索引3的子列表，即[2, 3, 4]
print(sub_list)

表示从索引位置1开始，到索引位置4结束，总共是三个数。没有设置步长所以将切片中的元素全部打印出来，如果设置了步长如下所示。

my_list = [1, 2, 3, 4, 5]
sub_list = my_list[1:4:2] # [2, 4]
print(sub_list)

输出的结果为[2, 4]，也就是从切片的第一个元素开始，按照每两个元素进行切片。就会输出[2, 4]结果。

列表切片的反向索引，切片中可以使用负数索引来从列表末尾开始索引，方便获取最后几个元素。如下所示

my_list = [1, 2, 3, 4, 5]
last_three = my_list[-3:]  # 获取列表中的最后三个元素，即[3, 4, 5]
print(last_three)

列表解析

列表解析操作主要的作用就是在单行中对列表进行条件过滤转换去创建新的列表操作。如下所示。

numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]  # 创建一个包含 numbers 中每个元素的平方的新列表
print(squares)

代码中表示将列表中所有元素进行平方之后，产生一个新的列表。最终输出结果如下所示。

[1, 4, 9, 16, 25]

列表合并

在Python中使用加法运算符或者是使用extend函数来实现将两个列表合并成一个新的列表的操作，如下所示。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = list1 + list2  # [1, 2, 3, 4, 5, 6]
list1.extend(list2)
print(merged_list)
print(list1)

通过加法运算符和extend函数都可以实现两个列表的合并操作，如上面所示，在使用的时候extend不会创建新的列表而是将list2中的数据添加到list1中。

列表排序

在Python中提供了sort()函数对列表对象进行排序操作，当然也可以使用sorted()函数直接返回一个已经排好序的列表，如下所示。

my_list = [3, 1, 4, 1, 5, 9, 2, 6]
my_list.sort()  # 对列表进行原地排序
sorted_list = sorted(my_list)  # 返回一个新的已排序列表
print(my_list)
print(sorted_list)

通过sort函数表示对列表进行原地的排序，也就是说不会产生新的列表。而使用sorted()函数操作会产生一个已经排好序的新的列表。

列表迭代

通过for循环操作可以迭代打印出列表中的每个元素操作，如下所示。

my_list = [1, 2, 3, 4, 5]
for item in my_list:
    print(item)

会发现这个代码有点类似于，Java代码中的foreach循环操作。

列表映射

使用map函数可以对列表中的每个元素都应用一个函数操作，然后得到一个新的列表，有点类似于列表的解析操作。

my_list = [1, 2, 3, 4, 5]
squared_list = list(map(lambda x: x**2, my_list))  # 对列表中的每个元素进行平方操作
print(squared_list)

上面这个例子中使用了一个匿名的lambda函数，当然在实际操作的时候，这个地方我们还可以通过def定义新的其他处理函数传入，效果是一样的。都是对列表中的每个元素都应用该函数进行处理。

列表过滤

使用filter()函数可以根据指定的过滤条件对列表中的元素进行过滤，最终产生一个新的列表。

my_list = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, my_list))  # 过滤出列表中的偶数
print(even_numbers)

通过lambda函数来过滤出列表中的所有的偶数操作，与map函数的操作是类似的。

列表压缩操作

使用zip()函数可以将多个列表中的对应位置的数据打包成一个元组，也就是说是一个元组列表，如下所示。

list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]
zipped_list = list(zip(list1, list2))  # [('a', 1), ('b', 2), ('c', 3)]
print(zipped_list)

通过zip函数将list1和list2的对应位置的数据压缩成了一个元组最终返回了一个元组的列表操作。

与之相反的操作是列表的解压缩。使用 zip() 的返回结果可以通过 zip() 和 * 操作符进行解压缩。如下所示

list3,list4 = zip(*zipped_list)
print(list3)
print(list4)

('a', 'b', 'c')
(1, 2, 3)

会看到最终返回的结果是两个元组，然后通过迭代的方式将元组转换成列表就可以了。

列表翻转

在上面我们介绍了关于列表的排序，使用reverse()方法可以原地翻转列表。如下所示

my_list = [1, 2, 3, 4, 5]
my_list.reverse()  # [5, 4, 3, 2, 1]

列表翻转的意思就是将原来第一个元素与最后一个元素的位置进行调转。依次递归。

列表表扁平化

想必我们都见过这样的一个数组[[1, 2], [3, 4], [5, 6]]，在概念上我们可以将其理解为一个二维的数组。那么如何将这个二维数组处理成一维数组，也就是一个扁平化的过程，如下所示。

nested_list = [[1, 2], [3, 4], [5, 6]]
flat_list = [item for sublist in nested_list for item in sublist]  # [1, 2, 3, 4, 5, 6]

通过上面的操作，可以将二维的列表也就是嵌套的列表解析成一个一维的数组。

列表条件切分

切分与切片的操作类似，只不过切分的时候可以按照指定的条件来进行操作，而切片只是按照固定的条件来进行操作。如下是一个列表切分的小例子。

my_list = [1, 2, 3, 4, 5]
lower = [x for x in my_list if x < 3]  # [1, 2]
upper = [x for x in my_list if x >= 3]  # [3, 4, 5]
print(lower)
print(upper)

中间的条件我们可以根据需求来自定义实现。如下所示

my_list = [1, 2, 3, 4, 5, 6, 7, 8]
chunk_size = 3
chunks = [my_list[i:i+chunk_size] for i in range(0, len(my_list), chunk_size)]
# [[1, 2, 3], [4, 5, 6], [7, 8]]
print(chunks)

列表合并但没有重复元素

在上面我们介绍了通过加法和extend函数来进行列表的合并操作，但是合并之后列表中是会存在重复的元素，那么如何保证在合并的时候列表中没有重复元素。可以通过如下的操作来实现。

list1 = [1, 2, 3]
list2 = [3, 4, 5]
merged_list = list(set(list1 + list2))  # [1, 2, 3, 4, 5]
print(merged_list)

上述操作完成之后，两个列表中都有元素3，在合并之后只会存在一个3。

统计列表长度以及元素出现次数

通过len()函数可以获取到列表的长度，然后通过count()函数可以获取到元素在列表中的存在次数。

my_list = [1, 2, 2, 3, 3, 3]
length = len(my_list)  # 6
count_of_3 = my_list.count(3)  # 3
print(length)
print(count_of_3)

列表的组合操作

列表的组合操作，其实就是对两个列表求笛卡尔积，也就是也就是每个列表的中的元素都进行组合一遍，如下所示。

list1 = ['a', 'b']
list2 = [1, 2]
cartesian_product = [(x, y) for x in list1 for y in list2]
# [('a', 1), ('a', 2), ('b', 1), ('b', 2)]

print(cartesian_product)

将list1中的每一个元素与list2中的每一个元素都进行组合最终形成一个新的元组列表。

列表元素去重

如果你想要从列表中去除重复的元素，可以使用集合（Set）来实现，然后再转回列表。如下所示

my_list = [1, 2, 2, 3, 3, 4]
unique_list = list(set(my_list))  # [1, 2, 3, 4]
print(unique_list)

列表查找

可以通过in关键字对列表中的元素进行快速的查找，来判断列表中是否包含某个元素。

my_list = [1, 2, 3, 4, 5]
is_present = 3 in my_list  # True
print(is_present)

列表的复制

使用切片操作 [:] 或者 copy() 方法可以创建列表的副本，而不是引用原始列表。

original_list = [1, 2, 3]
copied_list = original_list[:]  # 或者 copied_list = original_list.copy()
print(copied_list)

列表的删除

使用 del 关键字或者 remove() 方法可以删除列表中的元素。

my_list = [1, 2, 3, 4, 5]
del my_list[2]  # 删除索引为2的元素，即[1, 2, 4, 5]
my_list.remove(4)  # 删除值为4的元素，即[1, 2, 5]
print(my_list)

通过上面的操作我们就可以完成对于数组中的列表元素的删除操作。

总结

以上就是一些常用的Python中List的高级操作，当然在实际使用场景中用到List操作的地方还有很多。我们可以通过这些操作来实现一些复杂的列表处理需求，能够让你更有效地处理和操作列表数据。