python之列表的高级应用及说明

当前版本：Python 3.8.4

如果你刚开始接触 Python，那你一定绕不开一个东西——列表。在 Python 里，列表是最基础、也最常用的数据类型之一。别的语言里管它叫“数组”，但 Python 的列表更灵活，什么都能往里装：数字、字符串，甚至另一个列表。简单说，它就是那个你随手拿来存数据、做处理的容器。

这篇文章会把列表的各种处理方式和实用方法串一遍，从定义到操作，再到真正能派上用场的技巧，争取让刚上路的朋友也能一次理清。

1. 如何定义列表

定义列表其实就两种路子：

l = []        # 定义一个空列表
l = list()    # 定义一个空列表

列表用方括号 [] 来表示，左括号开头，右括号收尾。括号里的东西叫“元素”，用逗号隔开。元素的类型不限，数字、字符串、甚至另一个列表，都能往里塞。

# 定义一个列表，包含数字、字符串和列表
l = [123 ,'AAA', [10, 20]]

除了手动填入元素，你还可以用迭代的方式生成列表，这个在数据处理中很常见：

l = [x for x in range(1, 6)]

• 把函数的返回值赋给列表，也是同样的道理。

那列表到底能干嘛？

举个例子。假设你正在搭一个自动化框架，需要把任务信息写到 Excel 文件里，然后让框架去读取。这时候，列表就是一个天然的临时存储空间。你可以先把文件名存进去，再遍历操作：

# 将文件名放入列表中
file = ['file1.xlsx', 'file2.xlsx', 'file3.xlsx']

# 遍历这个列表中的文件名
for f in file:
    print(f"开始执行项目，处理文件：{f}")
    '''省略处理文件的代码'''

2. 处理列表的方式

列表的主要操作无非那么几类：增删改查、索引取值、深拷贝与浅拷贝的区别。下面一个个过。

2.1. 统计元素

在列表里，用逗号分割的每一项都算一个元素。比如：

l = [ 100, 200, 'AAA', 'BBB' ]

这里就有 4 个元素。注意，列表统计元素是按逗号分隔来算的，这点跟字符串不太一样——字符串是按单个字符统计的。

想取第 2 个元素？直接用索引就行：

l = [ 100, 200, 'AAA', 'BBB' ]
print(l[1])

关于索引的具体用法，后面会单独讲。

统计元素的常用方法：

• len：统计元素个数
• count：统计某个元素出现的次数
• max：找最大值
• min：找最小值
• sort：升序排序（直接修改原列表）
• sorted：升序或降序排序（返回新列表）
• reverse：元素反转

【方式一】统计元素个数：len

l = [ 100, 200, 'AAA', 'BBB' ]
len(l)

【方式二】统计某个元素出现的次数：count

l = [ 100, 200, 'AAA', 'BBB' ]
l.count("A")

• 注意：count 统计的是元素的个数，不是单个字符的个数。

【方式三】查询最大值：max（仅支持数字）

L = [3, 43, 2, 98]
max(L)

【方式四】查询最小值：min（仅支持数字）

L = [3, 43, 2, 98]
min(L)

【方式五】升序排序：sort、sorted（仅支持数字）

L1 = [4, 1, 9]
L1.sort()

L2 = [5, 3, 7]
L2 = sorted(L2, reverse=False)

【方式六】降序排序：sorted（仅支持数字）

L = [5, 3, 7]
L = sorted(L, reverse=True)

【方式七】元素反转：reverse

L = [ 100, 200, 'AAA', 'BBB' ]
L.reverse()

2.2. 添加元素

给列表加东西，Python 提供了几种方式：你可以指定位置插进去，也可以一股脑儿往尾巴上追加。

• insert：按索引插入
• append：在末尾追加一个元素
• extend：在末尾追加多个元素

【方式一】指定索引添加元素：insert

'''方法1'''
L = [ 100, 200, 'AAA', 'BBB' ]
L.insert(0, 500)    # 在索引为0处添加元素

'''方法2'''
L = [ 100, 200, 'AAA', 'BBB' ]
L[0:0] = [500]      # 在索引为0处添加元素

在索引为1处添加多个元素：

L = [ 100, 200, 'AAA', 'BBB' ]
L[1:1] = [500, 'EEE']      # 在索引为1处添加元素

【方式二】在列表后面追加元素：append

L = [1, 2, 3]
L.append('AAA')

append 不支持一次性追加多个元素，但你可以用 + 符号来实现类似效果：

L = [1, 2, 3]
L = L + ['AAA', 'BBB']

【方式三】追加多个元素：extend

L = [1, 2, 3]
L.extend(('a', 'b', 10))    # 需要使用一个括号

用迭代的方式添加也很方便：

L = ['A', 'B', 'C']
L.extend(range(10,15))    # 使用range迭代

2.3. 修改元素

修改列表里的元素，最直接的办法就是通过索引。

【方式一】按索引修改单个元素

L = ['A', 'B', 'C', 'D', 'E']
L[0] = 10    # 修改第1个元素
L[-1] = 20   # 修改最后1个元素

【方式二】按索引修改多个元素

L = ['A', 'B', 'C', 'D', 'E']
L[:3] = [10, 20]    # 将前3个元素修改为2个元素

【方式三】迭代修改指定的元素名

L = [100, 'BBB', 'AAA', 'BBB', 'BBB']
# 用迭代的方式将BBB修改为EEE
new_L = [elem if elem != 'BBB' else 'EEE' for elem in L]

2.4. 删除元素

删除元素也有多种方式，按索引删、按元素值删，都行。

【方式一】按索引删除元素：del、pop

L = ['A', 'B', 'C', 'D', 'E']

# del支持删除多个元素
del L[0]
del L[:3]

# pop只支持删除一个元素
L.pop(0)    # 删除第一个元素

【方式二】按元素名删除：remove

L = ['A', 'B', 'C', 'B', 'D']
L.remove('B')    # 仅支持删除1个元素

【方式三】按元素名删除多个元素（迭代）

L = ['A', 'B', 'C', 'B', 'D']
d = ['A', 'B']  # 需要删除的元素列表
new_L = [elem for elem in L if elem not in d]    # 迭代删除

【方式四】按索引删除多个元素（迭代）

del_index=[0, 1, 2]    #指定要删除的索引下标，不能使用负数(-1)
L1 = ['a', 'b', 'c', 'd', 'e']
L2=[i for num,i in enumerate(L1) if num not in del_index]

2.5. 索引取值

索引（Index）就是给每个元素一个编号，从 0 开始排。这跟排队是一个道理，第一个到的拿 0 号牌。

元素：a b c d e f
索引：0 1 2 3 4 5

• 第 1 个元素索引为 0，第 2 个元素索引为 1，依此类推。

读取对应索引的值用 变量[索引] 的方式：

L = ['a', 'b', 'c', 'd', 'e']
L[0]    # 读取第1个元素
L[3]    # 读取第4个元素
L[-1]   # 读取最后1个元素

除了取单个元素，还能用切片的方式一次性取一段：

变量[起始索引:结束索引]

L = ['a', 'b', 'c', 'd', 'e']
L[:2]    # 读取前2个元素
L[-2:]   # 读取后2个元素
L[1:3]   # 读取索引为1~2的元素

• 第 1 个元素用 0 表示，最后 1 个元素用 -1 表示。
• 切片时，冒号前面为空表示从开头取，后面为空表示取到末尾。
• 切片取值是“左闭右开”的，比如 [1:3] 取的是索引 1 和 2，不包含索引 3。

切片还支持指定步长：

变量[起始索引:结束索引:步长]    # 步长默认1

L = ['a', 'b', 'c', 'd', 'e']
L[1::1]  # 读取索引为1和后面的元素，步长为1
L[1::2]  # 读取索引为1和后面的元素，步长为2
L[::2]   # 读取全部元素，步长为2

2.6. 拷贝方式

Python 里的拷贝分为深拷贝和浅拷贝，理解这俩的区别，能帮你避免不少 bug。

• 深拷贝：复制对象及其内部所有子对象，递归地再造一份完全独立的副本。改动原始对象里的子对象，不会影响深拷贝出来的新对象。
• 浅拷贝：只复制对象的引用，不复制子对象本身。如果原始对象里的子对象是可变的，那么改动它会连累浅拷贝出来的副本。

各自的优点

• 深拷贝的最大好处是“完全独立”，你对副本随便改，原始数据纹丝不动。适合那些需要递归操作或频繁修改子对象的场景。
• 浅拷贝速度更快，因为它只是复制引用，没有真正的数据拷贝。如果原始对象的子对象很大且不会被改动，浅拷贝能省不少内存。

各自的缺点

• 深拷贝的缺点是吃资源。对象结构越大、嵌套越深，拷贝时消耗的内存和时间就越多。
• 浅拷贝的缺点是风险。如果原始对象里的可变子对象被改了，所有浅拷贝出来的副本都会跟着变，容易出意外。

做深拷贝需要导入标准库 copy：

# 导入标准库
import copy

# 定义一个列表a
a = [1, 2, 3, [4, 5]]

# 将列表a的值深拷贝到b
b = copy.deepcopy(a)

浅拷贝可以用 copy() 函数，或者直接赋值：

# 方式一
a = [1, 2, 3, [4, 5]]
b = a.copy()

# 方式二
a = [1, 2, 3, [4, 5]]
b = [a, "BBB"]

这里有个细节值得留心：修改原始列表的顶层元素，浅拷贝的副本不会跟着变；但如果是修改子对象（比如列表中的列表），浅拷贝的副本就会同步变化。

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

简单说，浅拷贝复制的只是“外壳”，里面的“芯子”还是共用的。所以操作时要留个心眼。

3. 列表的应用方法

3.1. 迭代循环

循环遍历列表里的元素，是再常见不过的操作了：

L = [1, 2, 3, [4, 5]]
for i in L:
    print(f"当前元素为：{i}")

除了直接遍历元素，你还可以用 enumerate 同时拿到元素的索引和值：

# 定义列表
L = ['AAA', 'BBB', 'CCC']

# 遍历列表中的索引和元素
for index,element in enumerate(L):
    print(f"索引：{index}, 元素：{element}")

默认索引从 0 开始。如果业务上需要从 1 开始数，可以指定 start=1：

# 定义列表
L = ['AAA', 'BBB', 'CCC']

# 遍历列表中的索引和元素
for index,element in enumerate(L, start=1):
    print(f"索引：{index}, 元素：{element}")

3.2. 数据处理

列表在实际开发中最常见的用途之一就是存数据、做处理。排序、过滤、计算，这些都是常规操作。

【方式一】列表排序（元素仅支持数字）

L = [4, 2, 1, 3, 5]
L.sort()  # 升序
L = sorted(L, reverse=False)    # 升序
L = sorted(L, reverse=True)     # 降序
L.reverse()  # 反转

【方式二】过滤列表（筛选偶数）

# 定义一个全数字的列表
L = [1, 2, 3, 4, 5]
# 过滤偶数
L_new = list(filter(lambda x: x % 2 == 0, L))

【方式三】计算列表的值

# 定义一个全是数字的列表
L = [1, 2, 6, 8, 5, 10]

# 求和
sum_result = sum(L)

# 求最大值
max_result = max(L)

# 求最小值
min_result = min(L)

# 求平均值
a vg_result = sum(L) / len(L)

# 所有值乘以 10
multiplied_list = [x * 10 for x in L]

3.3. 实现缓存

列表的可变性让它很适合用来做缓存——存一些临时的计算结果，或者需要快速访问的数据。

# 封装一个使用列表缓存的类
class ListCache:
    def __init__(self, max_size):
        self.max_size = max_size   # 缓存的最大容量
        self.cache = []            # 定义一个空的缓存列表

    def get(self, key):
        '''检查是否有对应的缓存项'''
        for item in self.cache:
            if item['key'] == key:
                return item['value']
        return None

    def set(self, key, value):
        '''判断缓存是否已满'''
        if len(self.cache) >= self.max_size:
            self.cache.pop(0)   # FIFO方式移除最旧的缓存项

        # 使用字典的方式添加新的缓存项
        self.cache.append({'key': key, 'value': value})

if __name__ == '__main__':
    # 创建一个最大容量为 2 的缓存
    LC = ListCache(2)

    # 向方法中添加两个缓存数据
    LC.set('k1', 'AAA')
    LC.set('k2', 'BBB')

    # 查看结果
    print(LC.get('k1'))     # AAA
    print(LC.get('k2'))     # BBB

    # 向方法中添加第3个缓存数据
    LC.set('k3', 'CCC')
    print(LC.get('k1'))     # 此时的k1已经被清理

3.4. 数据结构算法

列表是数据结构中最基础的一种，元素有序排列。下面列举几种常见算法。

① 线性搜索

• 线性搜索就是从列表的第一个元素开始，一个一个地比，直到找到目标或者遍历完整个列表。

代码实现：

# 定义一个列表
arr = [4, 2, 7, 1, 9, 5]
# 需要查找的值
target = 7

def linear_search(arr, target):
    # 遍历该数组的长度
    for i in range(len(arr)):
        # 通过索引来判断这个值是否为真
        if arr[i] == target:
            return i  # 返回目标元素的索引
    return -1  # 如果目标元素不存在于列表中，返回 -1

# 传入列表和需要查找的值
index = linear_search(arr, target)
print(f"元素{target}的索引为：{index}")

② 二分搜索

• 二分搜索的前提是列表必须有序。它每次把列表分成两半，拿中间的元素跟目标比，从而快速缩小范围。时间复杂度是 O(log n)，比线性搜索快不少。

代码实现：

# 定义一个列表
arr = [1, 12, 4, 6, 7, 3]
# 需要查询的值
target = 7

def binary_search(arr, target):
    arr.sort()  # 先将数组排序（升序）
    low = 0     # 定义最小索引
    high = len(arr) - 1     # 定义最大索引

    while low <= high:
        mid = (low + high) // 2 # 取中间索引的值（整数）
        if arr[mid] == target:  # 判断是否该索引的值等于target
            return mid          # 为真，返回目标元素的索引
        elif arr[mid] < target:
            low = mid + 1       # 如果结果小于target，将索引+1
        else:
            high = mid - 1      # 如果结果大于target，将索引-1

    return -1  # 如果目标元素不存在于列表中，返回 -1

# 向函数中传入列表和需要查找的值
index = binary_search(arr, target)
print("目标元素的索引：", index)

③ 排序算法

冒泡排序

arr = [4, 2, 7, 1, 9, 5]

def bubble_sort(arr):
    n = len(arr)

    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

sorted_arr = bubble_sort(arr)
print("排序后的列表：", sorted_arr)

插入排序

arr = [4, 2, 7, 1, 9, 5]

def insertion_sort(arr):
    n = len(arr)

    for i in range(1, n):
        key = arr[i]
        j = i - 1

        while j >= 0 and arr[j] > key:
            arr[j+1] = arr[j]
            j -= 1
        
        arr[j+1] = key
    
    return arr

sorted_arr = insertion_sort(arr)
print("排序后的列表：", sorted_arr)

选择排序

arr = [4, 2, 7, 1, 9, 5]

def selection_sort(arr):
    n = len(arr)

    for i in range(n-1):
        min_index = i
        for j in range(i+1, n):
            if arr[j] < arr[min_index]:
                min_index = j
            
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr

sorted_arr = selection_sort(arr)
print("排序后的列表：", sorted_arr)

快速排序

arr = [4, 2, 7, 1, 9, 5]

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[0]
    less = [x for x in arr[1:] if x <= pivot]
    greater = [x for x in arr[1:] if x > pivot]

    return quick_sort(less) + [pivot] + quick_sort(greater)

sorted_arr = quick_sort(arr)
print("排序后的列表：", sorted_arr)

归并排序

arr = [4, 2, 7, 1, 9, 5]

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left_half = arr[:mid]
    right_half = arr[mid:]

    left_half = merge_sort(left_half)
    right_half = merge_sort(right_half)

    return merge(left_half, right_half)

def merge(left, right):
    result = []
    i, j = 0, 0

    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])

    return result

sorted_arr = merge_sort(arr)

总结

列表在 Python 中的地位，差不多相当于工具箱里的螺丝刀——看着不起眼，但几乎每个项目都离不开它。从数据存储到算法实现，从简单的遍历到复杂的排序，把它玩熟了，写代码的时候会顺手很多。