Python 列表解析式从入门到精通：一行搞定数据处理的高效技巧

class 卑微码农:
    def __init__(self):
        self.技能 = ['能读懂十年前祖传代码', '擅长用Ctrl+C/V搭建世界', '信奉"能跑就别动"的玄学']
        self.发量 = 100  # 初始发量
        self.咖啡因耐受度 = '极限'
        
    def 修Bug(self, bug):
        try:
            # 试图用玄学解决问题
            if bug.严重程度 == '离谱':
                print("这一定是环境问题！")
            else:
                print("让我看看是谁又没写注释...哦，是我自己。")
        except Exception as e:
            # 如果try块都救不了，那就...
            print("重启一下试试？")
            self.发量 -= 1  # 每解决一个bug，头发-1
 
 
# 实例化一个我
我 = 卑微码农()

引言：为什么列表解析式是 Python 开发者的 "效率神器"？

在 Python 编程中，你是否经常遇到这样的场景：

想生成一个包含特定规则的列表，用普通for循环写了好几行代码，显得繁琐又冗余；
想对列表数据进行筛选、转换，嵌套多层循环后，代码可读性直线下降；
处理大量数据时，for循环执行速度慢，影响程序性能。

这时候，列表解析式就能派上大用场！它作为 Python 中最具特色的语法糖之一，以简洁高效、代码紧凑、执行快速的特点，成为处理列表数据的 "效率神器"。一行代码就能完成循环 + 筛选 + 转换的复杂逻辑，不仅让代码更优雅，执行速度还比普通for循环快 30%~50%。

列表解析式的应用远不止这些：数据清洗、数据转换、复杂列表生成、嵌套数据处理等场景都能看到它的身影。无论是处理日常小脚本，还是开发大型项目中的数据处理模块，列表解析式都能帮你提升开发效率，优化程序性能。

本文将从 "零基础理解" 到 "高级实战"，用通俗的语言 + 可运行的示例，系统拆解 Python 列表解析式的核心原理与应用技巧。全程无晦涩概念堆砌，让你从 "会用" 到 "吃透"，真正掌握这个 Python 开发者必备的高效工具。

一、基础铺垫：列表解析式的 "前世今生"

在学习列表解析式之前，我们先回顾 Python 中列表生成的基础方式，理解列表解析式出现的意义和价值。

1.1 什么是列表解析式？

列表解析式（List Comprehension）是 Python 中一种简洁的列表生成方式，它将for循环、条件判断和表达式整合在一行代码中，能够快速生成新的列表。

简单来说，列表解析式就是用一行代码实现原本需要多行for循环才能完成的列表生成逻辑。

示例：列表解析式与普通 for 循环的对比

# 需求：生成1~10的平方组成的列表

# 方式1：普通for循环
square_list = []
for i in range(1, 11):
    square_list.append(i ** 2)
print(square_list)  # 输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 方式2：列表解析式
square_list = [i ** 2 for i in range(1, 11)]
print(square_list)  # 输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

可以看到，列表解析式用一行代码实现了与普通for循环完全相同的功能，代码更简洁，可读性更强。

1.2 列表解析式的语法规则

列表解析式的核心语法格式如下：

[表达式 for 变量 in 可迭代对象 [if 条件判断]]

语法解析：

[]：列表解析式的标志，最终结果为一个新列表；
表达式：对每个变量进行处理的逻辑，结果作为新列表的元素；
for 变量 in 可迭代对象：遍历可迭代对象（如列表、元组、字符串、range 等），将每个元素赋值给变量；
[if 条件判断]：可选部分，只有满足条件的元素才会被处理并加入新列表。

语法变形：多层循环的列表解析式

当需要多层循环时，列表解析式的语法可扩展为：

[表达式 for 变量1 in 可迭代对象1 for 变量2 in 可迭代对象2 ... [if 条件判断]]

等价于多层嵌套的for循环。

1.3 列表解析式的核心优势

与普通for循环相比，列表解析式具有以下核心优势：

代码简洁：一行代码替代多行循环，减少冗余代码；
执行高效：底层由 C 语言实现，执行速度比普通for循环快；
可读性强：逻辑清晰，一眼就能看出列表生成的规则；
功能强大：可整合循环、条件判断、表达式，实现复杂逻辑。

示例：列表解析式的执行效率对比

我们通过生成 100 万条数据，对比列表解析式和普通for循环的执行速度：

import time

# 方式1：普通for循环
start_time = time.time()
normal_list = []
for i in range(1000000):
    normal_list.append(i * 2)
end_time = time.time()
print(f"普通for循环耗时：{end_time - start_time:.4f}秒")

# 方式2：列表解析式
start_time = time.time()
comp_list = [i * 2 for i in range(1000000)]
end_time = time.time()
print(f"列表解析式耗时：{end_time - start_time:.4f}秒")

运行结果（不同设备可能有差异）：

普通for循环耗时：0.0821秒
列表解析式耗时：0.0357秒

可以看到，列表解析式的执行速度是普通for循环的 2 倍左右，数据量越大，优势越明显。

二、列表解析式基础用法：一行搞定简单列表生成

列表解析式的基础用法主要包括 "简单循环生成"、"条件筛选生成" 和 "多层循环生成"，掌握这些用法能解决 80% 的日常列表处理场景。

2.1 简单循环生成：无条件的列表生成

当不需要筛选元素，仅需对可迭代对象中的每个元素进行处理并生成新列表时，使用简单循环的列表解析式。

示例：简单循环生成列表

# 示例1：生成1~10的整数列表
num_list = [i for i in range(1, 11)]
print(num_list)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 示例2：生成字符串中每个字符的大写形式
str_list = [c.upper() for c in "python"]
print(str_list)  # 输出：['P', 'Y', 'T', 'H', 'O', 'N']

# 示例3：将列表中的每个元素乘以2
original_list = [1, 2, 3, 4, 5]
double_list = [x * 2 for x in original_list]
print(double_list)  # 输出：[2, 4, 6, 8, 10]

# 示例4：计算列表中每个元素的绝对值
num_list = [-1, 2, -3, 4, -5]
abs_list = [abs(x) for x in num_list]
print(abs_list)  # 输出：[1, 2, 3, 4, 5]

# 示例5：将元组列表转换为字符串列表
tuple_list = [(1, "a"), (2, "b"), (3, "c")]
str_list = [str(x[0]) + x[1] for x in tuple_list]
print(str_list)  # 输出：['1a', '2b', '3c']

2.2 条件筛选生成：带条件的列表过滤与处理

当需要对可迭代对象中的元素进行筛选，只保留满足条件的元素并生成新列表时，使用带条件的列表解析式。

示例：条件筛选生成列表

# 示例1：筛选列表中的偶数
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_list = [x for x in num_list if x % 2 == 0]
print(even_list)  # 输出：[2, 4, 6, 8, 10]

# 示例2：筛选列表中的奇数并计算平方
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
odd_square_list = [x ** 2 for x in num_list if x % 2 != 0]
print(odd_square_list)  # 输出：[1, 9, 25, 49, 81]

# 示例3：筛选字符串列表中长度大于3的元素
str_list = ["a", "ab", "abc", "abcd", "abcde"]
long_str_list = [s for s in str_list if len(s) > 3]
print(long_str_list)  # 输出：['abcd', 'abcde']

# 示例4：筛选字典列表中满足条件的元素
users = [
    {"name": "张三", "age": 20},
    {"name": "李四", "age": 30},
    {"name": "王五", "age": 25}
]
# 筛选年龄大于25的用户姓名
adult_names = [user["name"] for user in users if user["age"] > 25]
print(adult_names)  # 输出：['李四']

# 示例5：处理列表中的空值，筛选非空元素并去重
data = ["a", "", "b", None, "c", "", "a"]
clean_data = [x for x in data if x and x.strip()]
print(clean_data)  # 输出：['a', 'b', 'c']

2.3 多层循环生成：嵌套循环的列表处理

当需要处理嵌套的可迭代对象（如列表嵌套列表）时，使用多层循环的列表解析式，等价于嵌套的for循环。

示例：多层循环生成列表

# 示例1：二维列表扁平化（将嵌套列表转换为一维列表）
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = [x for sublist in nested_list for x in sublist]
print(flat_list)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

# 等价于普通嵌套for循环
flat_list = []
for sublist in nested_list:
    for x in sublist:
        flat_list.append(x)

# 示例2：两个列表元素的笛卡尔积
list1 = [1, 2, 3]
list2 = ["a", "b"]
cartesian_product = [(x, y) for x in list1 for y in list2]
print(cartesian_product)  # 输出：[(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b'), (3, 'a'), (3, 'b')]

# 示例3：筛选嵌套列表中的特定元素
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 筛选所有大于5的元素
greater_than_5 = [x for sublist in nested_list for x in sublist if x > 5]
print(greater_than_5)  # 输出：[6, 7, 8, 9]

# 示例4：处理嵌套字典列表
nested_dict = [
    {"name": "张三", "hobbies": ["篮球", "游戏"]},
    {"name": "李四", "hobbies": ["读书", "跑步"]}
]
# 提取所有用户的爱好
all_hobbies = [hobby for user in nested_dict for hobby in user["hobbies"]]
print(all_hobbies)  # 输出：['篮球', '游戏', '读书', '跑步']

# 示例5：三层嵌套列表扁平化
three_nested = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
flat_three = [x for sub1 in three_nested for sub2 in sub1 for x in sub2]
print(flat_three)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8]

三、列表解析式进阶用法：处理复杂场景

基础用法只能发挥列表解析式的部分价值，结合 Python 的其他特性，列表解析式可以处理更复杂的场景。本节将介绍列表解析式的进阶用法，提升你的代码效率。

3.1 与条件表达式结合：实现复杂分支逻辑

列表解析式中的 "表达式" 部分可以结合条件表达式（三元运算符），实现复杂的分支逻辑处理。

示例：列表解析式 + 条件表达式

# 示例1：根据条件对元素进行不同处理
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 偶数乘以2，奇数加1
processed_list = [x * 2 if x % 2 == 0 else x + 1 for x in num_list]
print(processed_list)  # 输出：[2, 4, 4, 8, 6, 12, 8, 16, 10, 20]

# 示例2：根据分数评级
scores = [85, 92, 78, 60, 55, 95, 88]
grades = ["优秀" if s >= 90 else "良好" if s >= 80 else "及格" if s >= 60 else "不及格" for s in scores]
print(grades)  # 输出：['良好', '优秀', '良好', '及格', '不及格', '优秀', '良好']

# 示例3：处理字符串，空字符串替换为默认值
str_list = ["hello", "", "world", None, "python"]
processed_str = [s if s and s.strip() else "默认值" for s in str_list]
print(processed_str)  # 输出：['hello', '默认值', 'world', '默认值', 'python']

# 示例4：根据数值范围分类
nums = [10, 25, 30, 45, 50, 65, 70, 85, 90]
categories = ["低" if x < 30 else "中" if x < 60 else "高" for x in nums]
print(categories)  # 输出：['低', '低', '中', '中', '中', '高', '高', '高', '高']

# 示例5：处理字典列表，根据条件修改字段值
users = [
    {"name": "张三", "age": 20, "status": "active"},
    {"name": "李四", "age": 17, "status": "active"},
    {"name": "王五", "age": 30, "status": "inactive"}
]
# 未成年人状态改为"restricted"
updated_users = [
    {**user, "status": "restricted"} if user["age"] < 18 else user
    for user in users
]
print(updated_users)
# 输出：
# [{'name': '张三', 'age': 20, 'status': 'active'},
#  {'name': '李四', 'age': 17, 'status': 'restricted'},
#  {'name': '王五', 'age': 30, 'status': 'inactive'}]

3.2 与函数结合：增强列表处理能力

列表解析式中的 "表达式" 或 "条件判断" 部分可以调用函数，实现更复杂的逻辑处理。

示例：列表解析式 + 函数

# 示例1：调用内置函数处理元素
str_list = ["hello", "world", "python", "code"]
# 计算每个字符串的长度
len_list = [len(s) for s in str_list]
print(len_list)  # 输出：[5, 5, 6, 4]

# 示例2：调用自定义函数处理元素
def process_num(x):
    """对数字进行处理：偶数返回平方，奇数返回立方"""
    if x % 2 == 0:
        return x ** 2
    else:
        return x ** 3

num_list = [1, 2, 3, 4, 5]
processed_num = [process_num(x) for x in num_list]
print(processed_num)  # 输出：[1, 4, 27, 16, 125]

# 示例3：函数作为条件判断
def is_valid_email(email):
    """验证邮箱是否有效（简单验证）"""
    return "@" in email and "." in email

emails = ["test@example.com", "invalid-email", "user@domain", "another@example.org"]
valid_emails = [email for email in emails if is_valid_email(email)]
print(valid_emails)  # 输出：['test@example.com', 'another@example.org']

# 示例4：处理日期字符串，转换为datetime对象
from datetime import datetime

date_strings = ["2023-01-01", "2023-02-01", "invalid-date", "2023-03-01"]
def parse_date(date_str):
    try:
        return datetime.strptime(date_str, "%Y-%m-%d")
    except ValueError:
        return None

dates = [parse_date(s) for s in date_strings if parse_date(s)]
print(dates)  # 输出：[datetime.datetime(2023, 1, 1, 0, 0), datetime.datetime(2023, 2, 1, 0, 0), datetime.datetime(2023, 3, 1, 0, 0)]

# 示例5：批量处理文件路径，提取文件名
import os

file_paths = [
    "/home/user/file1.txt",
    "/home/user/file2.jpg",
    "/home/user/dir/file3.py"
]
file_names = [os.path.basename(path) for path in file_paths]
print(file_names)  # 输出：['file1.txt', 'file2.jpg', 'file3.py']

3.3 嵌套列表解析式：处理复杂嵌套结构

当需要处理多层嵌套的数据结构（如三维列表、嵌套字典）时，使用嵌套的列表解析式，逻辑更清晰。

示例：嵌套列表解析式

# 示例1：三维列表扁平化
three_d_list = [
    [[1, 2], [3, 4]],
    [[5, 6], [7, 8]],
    [[9, 10], [11, 12]]
]
# 嵌套列表解析式实现三维转一维
flat_list = [x for sub1 in three_d_list for sub2 in sub1 for x in sub2]
print(flat_list)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

# 示例2：对嵌套列表中的元素进行条件筛选和处理
nested_list = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]
# 筛选每个子列表中的偶数，并乘以2
processed_nested = [[x * 2 for x in sublist if x % 2 == 0] for sublist in nested_list]
print(processed_nested)  # 输出：[[4, 8], [12, 16], [20, 24]]

# 示例3：嵌套字典列表的复杂处理
users = [
    {
        "name": "张三",
        "age": 20,
        "orders": [
            {"id": 1, "amount": 100},
            {"id": 2, "amount": 200}
        ]
    },
    {
        "name": "李四",
        "age": 30,
        "orders": [
            {"id": 3, "amount": 150},
            {"id": 4, "amount": 300}
        ]
    }
]
# 提取每个用户的订单金额大于150的订单ID
high_amount_orders = [
    order["id"]
    for user in users
    for order in user["orders"]
    if order["amount"] > 150
]
print(high_amount_orders)  # 输出：[2, 4]

# 示例4：生成嵌套的乘法表
multiplication_table = [[i * j for j in range(1, 10)] for i in range(1, 10)]
# 打印乘法表
for row in multiplication_table:
    print(row)
# 输出：
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
# [2, 4, 6, 8, 10, 12, 14, 16, 18]
# ...
# [9, 18, 27, 36, 45, 54, 63, 72, 81]

# 示例5：处理嵌套列表，生成新的嵌套结构
data = [
    ["a", "b", "c"],
    ["d", "e", "f"],
    ["g", "h", "i"]
]
# 将每个子列表的元素转换为大写，并添加索引
processed_data = [
    [(index, char.upper()) for index, char in enumerate(sublist)]
    for sublist in data
]
print(processed_data)
# 输出：
# [[(0, 'A'), (1, 'B'), (2, 'C')],
#  [(0, 'D'), (1, 'E'), (2, 'F')],
#  [(0, 'G'), (1, 'H'), (2, 'I')]]

3.4 列表解析式与其他解析式的关联

Python 中除了列表解析式，还有字典解析式、集合解析式和生成器表达式，它们的语法类似，都是基于列表解析式的扩展。了解它们的区别和联系，能让你更灵活地处理数据。

3.4.1 字典解析式（Dictionary Comprehension）

语法：{键表达式: 值表达式 for 变量 in 可迭代对象 [if 条件判断]}，用于快速生成字典。

示例：字典解析式

# 示例1：生成键为1~5，值为键的平方的字典
square_dict = {i: i ** 2 for i in range(1, 6)}
print(square_dict)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 示例2：将两个列表转换为字典（键值对）
keys = ["name", "age", "gender"]
values = ["张三", 20, "男"]
user_dict = {k: v for k, v in zip(keys, values)}
print(user_dict)  # 输出：{'name': '张三', 'age': 20, 'gender': '男'}

# 示例3：筛选字典中的特定键值对
original_dict = {"a": 1, "b": 2, "c": 3, "d": 4}
# 筛选值为偶数的键值对
even_dict = {k: v for k, v in original_dict.items() if v % 2 == 0}
print(even_dict)  # 输出：{'b': 2, 'd': 4}

3.4.2 集合解析式（Set Comprehension）

语法：{表达式 for 变量 in 可迭代对象 [if 条件判断]}，用于快速生成集合（自动去重）。

示例：集合解析式

# 示例1：生成1~10的平方组成的集合
square_set = {i ** 2 for i in range(1, 11)}
print(square_set)  # 输出：{1, 4, 9, 16, 25, 36, 49, 64, 81, 100}

# 示例2：对列表去重并转换为大写
str_list = ["a", "b", "a", "c", "b", "A"]
unique_str = {s.upper() for s in str_list}
print(unique_str)  # 输出：{'A', 'B', 'C'}

# 示例3：筛选集合中的偶数
num_set = {1, 2, 3, 4, 5, 6, 7, 8}
even_set = {x for x in num_set if x % 2 == 0}
print(even_set)  # 输出：{2, 4, 6, 8}

3.4.3 生成器表达式（Generator Expression）

语法：(表达式 for 变量 in 可迭代对象 [if 条件判断])，用于生成生成器（惰性求值，节省内存）。

示例：生成器表达式

# 示例1：生成1~10的平方组成的生成器
square_generator = (i ** 2 for i in range(1, 11))
print(square_generator)  # 输出：<generator object <genexpr> at 0x0000023F7A8D3F90>

# 遍历生成器
for num in square_generator:
    print(num, end=" ")  # 输出：1 4 9 16 25 36 49 64 81 100

# 示例2：生成器表达式与列表解析式的内存对比
import sys

# 列表解析式：占用大量内存
list_expr = [i for i in range(1000000)]
print(f"列表解析式占用内存：{sys.getsizeof(list_expr)} 字节")

# 生成器表达式：占用少量内存（仅存储生成逻辑）
gen_expr = (i for i in range(1000000))
print(f"生成器表达式占用内存：{sys.getsizeof(gen_expr)} 字节")

运行结果：

列表解析式占用内存：8448728 字节
生成器表达式占用内存：112 字节

四种解析式对比总结

类型	语法标志	核心特点	适用场景
列表解析式	`[]`	生成列表，立即求值	需快速生成列表并直接使用
字典解析式	`{}`（键值对）	生成字典，立即求值	需快速生成字典并直接使用
集合解析式	`{}`（单元素）	生成集合，自动去重，立即求值	需快速生成集合并去重
生成器表达式	`()`	生成生成器，惰性求值	处理大量数据，节省内存

四、实战场景：列表解析式的 10 个经典应用案例

列表解析式的价值在于解决实际问题。本节将结合企业开发中的高频场景，提供 10 个可直接复用的列表解析式实战案例。

4.1 场景 1：数据清洗与预处理

在数据处理中，数据清洗是第一步，列表解析式可以快速实现数据去重、空值处理、格式标准化等功能。

示例：数据清洗与预处理

# 原始数据（包含脏数据）
raw_data = [
    " 张三 ", "李四", "", "王五", None, "张三", "赵六", " 钱七  "
]

# 步骤1：去除空值和空白字符串
clean_data1 = [x for x in raw_data if x and x.strip()]
print("去除空值后：", clean_data1)  # 输出：[' 张三 ', '李四', '王五', '张三', '赵六', ' 钱七  ']

# 步骤2：去除前后空格
clean_data2 = [x.strip() for x in clean_data1]
print("去除空格后：", clean_data2)  # 输出：['张三', '李四', '王五', '张三', '赵六', '钱七']

# 步骤3：去重（使用列表解析式+集合）
clean_data3 = list({x: None for x in clean_data2}.keys())  # 保持插入顺序（Python 3.7+）
print("去重后：", clean_data3)  # 输出：['张三', '李四', '王五', '赵六', '钱七']

# 步骤4：格式标准化（首字母大写）
clean_data4 = [x.capitalize() for x in clean_data3]
print("标准化后：", clean_data4)  # 输出：['张三', '李四', '王五', '赵六', '钱七']

# 完整流程：一行代码实现全量清洗
final_clean_data = [
    x.strip().capitalize()
    for x in raw_data
    if x and x.strip()
]
# 去重（保持顺序）
final_clean_data = list(dict.fromkeys(final_clean_data))
print("最终清洗结果：", final_clean_data)  # 输出：['张三', '李四', '王五', '赵六', '钱七']

4.2 场景 2：数据转换与格式处理

将原始数据转换为目标格式是常见需求，列表解析式可以快速实现类型转换、字段提取、格式转换等功能。

示例：数据转换与格式处理

# 示例1：字符串列表转换为整数列表
str_nums = ["1", "2", "3", "4", "5"]
int_nums = [int(x) for x in str_nums]
print("字符串转整数：", int_nums)  # 输出：[1, 2, 3, 4, 5]

# 示例2：提取字典列表中的特定字段
users = [
    {"name": "张三", "age": 20, "email": "zhangsan@example.com"},
    {"name": "李四", "age": 30, "email": "lisi@example.com"},
    {"name": "王五", "age": 25, "email": "wangwu@example.com"}
]
# 提取所有用户的邮箱
emails = [user["email"] for user in users]
print("提取邮箱：", emails)  # 输出：['zhangsan@example.com', 'lisi@example.com', 'wangwu@example.com']

# 示例3：日期格式转换
date_strings = ["2023-01-01", "2023-02-01", "2023-03-01"]
from datetime import datetime
formatted_dates = [
    datetime.strptime(date, "%Y-%m-%d").strftime("%Y年%m月%d日")
    for date in date_strings
]
print("日期格式转换：", formatted_dates)  # 输出：['2023年01月01日', '2023年02月01日', '2023年03月01日']

# 示例4：处理嵌套数据，提取层级字段
orders = [
    {
        "order_id": 1,
        "items": [{"product": "手机", "price": 5000}, {"product": "耳机", "price": 500}]
    },
    {
        "order_id": 2,
        "items": [{"product": "电脑", "price": 8000}, {"product": "键盘", "price": 300}]
    }
]
# 提取所有商品名称和对应的订单ID
product_order = [
    (order["order_id"], item["product"])
    for order in orders
    for item in order["items"]
]
print("商品与订单ID：", product_order)  # 输出：[(1, '手机'), (1, '耳机'), (2, '电脑'), (2, '键盘')]

4.3 场景 3：数据筛选与过滤

根据业务条件筛选数据是核心需求，列表解析式可以快速实现多条件筛选、复杂逻辑过滤等功能。

示例：数据筛选与过滤

# 示例1：筛选成绩在80~90分之间的学生
students = [
    {"name": "张三", "score": 75},
    {"name": "李四", "score": 85},
    {"name": "王五", "score": 92},
    {"name": "赵六", "score": 88},
    {"name": "钱七", "score": 78}
]
# 筛选80~90分的学生姓名
target_students = [
    student["name"]
    for student in students
    if 80 <= student["score"] <= 90
]
print("80~90分的学生：", target_students)  # 输出：['李四', '赵六']

# 示例2：筛选同时满足多个条件的数据
products = [
    {"name": "手机", "price": 5000, "stock": 100, "category": "电子"},
    {"name": "电脑", "price": 8000, "stock": 50, "category": "电子"},
    {"name": "衬衫", "price": 200, "stock": 200, "category": "服装"},
    {"name": "裤子", "price": 150, "stock": 150, "category": "服装"},
    {"name": "耳机", "price": 500, "stock": 300, "category": "电子"}
]
# 筛选电子类、价格低于1000且库存大于100的商品
target_products = [
    product["name"]
    for product in products
    if product["category"] == "电子"
    and product["price"] < 1000
    and product["stock"] > 100
]
print("目标商品：", target_products)  # 输出：['耳机']

# 示例3：筛选嵌套数据中的特定元素
nested_data = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]
# 筛选每个子列表中大于5且为偶数的元素
target_elements = [
    x for sublist in nested_data for x in sublist if x > 5 and x % 2 == 0
]
print("目标元素：", target_elements)  # 输出：[6, 8, 10, 12]

4.4 场景 4：生成复杂数据结构

列表解析式可以快速生成复杂的列表、嵌套列表、字典列表等数据结构，满足各种业务需求。

示例：生成复杂数据结构

# 示例1：生成嵌套的乘法表（9x9）
multiplication_table = [[i * j for j in range(1, 10)] for i in range(1, 10)]
print("9x9乘法表：")
for row in multiplication_table[:3]:  # 只打印前3行
    print(row)

# 示例2：生成字典列表（模拟用户数据）
user_data = [
    {"user_id": i, "username": f"user{i}", "age": 20 + i}
    for i in range(1, 6)
]
print("生成用户数据：", user_data)
# 输出：
# [{'user_id': 1, 'username': 'user1', 'age': 21},
#  {'user_id': 2, 'username': 'user2', 'age': 22},
#  ...]

# 示例3：生成带条件的嵌套数据
# 生成1~5的列表，每个元素是该数字的平方和立方组成的元组
nested_tuples = [(i, i ** 2, i ** 3) for i in range(1, 6)]
print("生成嵌套元组：", nested_tuples)  # 输出：[(1, 1, 1), (2, 4, 8), (3, 9, 27), (4, 16, 64), (5, 25, 125)]

# 示例4：生成符合特定规则的字符串列表
# 生成所有长度为3的小写字母组合（前10个）
import string
letters = string.ascii_lowercase
three_letter_combinations = [
    a + b + c for a in letters for b in letters for c in letters
][:10]  # 只取前10个
print("3字母组合：", three_letter_combinations)  # 输出：['aaa', 'aab', 'aac', 'aad', 'aae', 'aaf', 'aag', 'aah', 'aai', 'aaj']

4.5 场景 5：文本处理与分析

在文本处理中，列表解析式可以快速实现字符提取、单词统计、文本过滤等功能。

示例：文本处理与分析

# 示例1：提取文本中的所有单词（去除标点符号）
text = "Hello, world! This is a Python tutorial. It's very useful."
import re
# 提取所有单词（不区分大小写）
words = [
    word.lower()
    for word in re.findall(r"\b\w+\b", text)
]
print("提取单词：", words)
# 输出：['hello', 'world', 'this', 'is', 'a', 'python', 'tutorial', 'it', 's', 'very', 'useful']

# 示例2：统计单词出现频率（使用列表解析式+字典）
word_freq = {}
for word in words:
    word_freq[word] = word_freq.get(word, 0) + 1
# 或使用字典解析式
word_freq = {word: words.count(word) for word in set(words)}
print("单词频率：", word_freq)
# 输出：{'hello': 1, 'world': 1, 'this': 1, 'is': 1, 'a': 1, 'python': 1, 'tutorial': 1, 'it': 1, 's': 1, 'very': 1, 'useful': 1}

# 示例3：过滤文本中的停用词
stop_words = ["is", "a", "it", "s", "very"]
filtered_words = [word for word in words if word not in stop_words]
print("过滤停用词后：", filtered_words)  # 输出：['hello', 'world', 'this', 'python', 'tutorial', 'useful']

# 示例4：文本格式转换（首字母大写，其他小写）
text = "HELLO world! THIS IS PYTHON."
formatted_text = " ".join([word.capitalize() for word in text.split()])
print("格式转换后：", formatted_text)  # 输出：'Hello World! This Is Python.'

4.6 场景 6：数学计算与数据处理

列表解析式可以快速实现数学运算、数据统计、序列生成等功能，比普通循环更高效。

示例：数学计算与数据处理

# 示例1：生成斐波那契数列的前10项
fibonacci = [0, 1]
[fibonacci.append(fibonacci[i-1] + fibonacci[i-2]) for i in range(2, 10)]
print("斐波那契数列：", fibonacci)  # 输出：[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# 示例2：计算列表中所有元素的均值、方差和标准差
import math
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 均值
mean = sum(nums) / len(nums)
# 方差
variance = sum([(x - mean) ** 2 for x in nums]) / len(nums)
# 标准差
std_dev = math.sqrt(variance)
print(f"均值：{mean}, 方差：{variance:.2f}, 标准差：{std_dev:.2f}")
# 输出：均值：5.5, 方差：8.25, 标准差：2.87

# 示例3：生成素数列表（1~100）
def is_prime(n):
    """判断一个数是否为素数"""
    if n < 2:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True

primes = [n for n in range(1, 101) if is_prime(n)]
print("1~100的素数：", primes)
# 输出：[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

# 示例4：计算矩阵的转置（使用列表解析式）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
transposed_matrix = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print("矩阵转置：")
for row in transposed_matrix:
    print(row)
# 输出：
# [1, 4, 7]
# [2, 5, 8]
# [3, 6, 9]

4.7 场景 7：文件处理与数据读取

在文件处理中，列表解析式可以快速读取文件内容、筛选文件行、提取文件信息等。

示例：文件处理与数据读取

# 示例1：读取文件内容，筛选包含特定关键词的行
# 先创建测试文件
test_file = "test.txt"
with open(test_file, "w", encoding="utf-8") as f:
    f.write("Hello Python\n")
    f.write("List comprehension is powerful\n")
    f.write("Python is easy to learn\n")
    f.write("Data processing with Python\n")

# 读取文件，筛选包含"Python"的行
with open(test_file, "r", encoding="utf-8") as f:
    python_lines = [line.strip() for line in f if "Python" in line]
print("包含Python的行：", python_lines)
# 输出：['Hello Python', 'Python is easy to learn', 'Data processing with Python']

# 示例2：读取CSV文件，转换为字典列表
import csv
csv_file = "users.csv"
# 创建测试CSV文件
with open(csv_file, "w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "age", "email"])
    writer.writeheader()
    writer.writerows([
        {"name": "张三", "age": "20", "email": "zhangsan@example.com"},
        {"name": "李四", "age": "30", "email": "lisi@example.com"}
    ])

# 读取CSV文件
with open(csv_file, "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    users = [row for row in reader]
    # 转换age字段为整数
    users = [{**user, "age": int(user["age"])} for user in users]
print("读取CSV数据：", users)
# 输出：
# [{'name': '张三', 'age': 20, 'email': 'zhangsan@example.com'},
#  {'name': '李四', 'age': 30, 'email': 'lisi@example.com'}]

# 示例3：遍历目录，筛选特定类型的文件
import os
# 筛选当前目录下的所有.py文件
py_files = [
    file for file in os.listdir(".")
    if os.path.isfile(file) and file.endswith(".py")
]
print("当前目录下的.py文件：", py_files)

4.8 场景 8：列表数据的批量操作

对列表进行批量修改、批量计算、批量过滤是日常开发中的常见需求，列表解析式可以高效实现。

示例：列表数据的批量操作

# 示例1：批量修改列表中的元素
original_list = [1, 2, 3, 4, 5]
# 所有元素加10
modified_list1 = [x + 10 for x in original_list]
print("元素加10：", modified_list1)  # 输出：[11, 12, 13, 14, 15]

# 示例2：批量计算列表中元素的函数值
import math
nums = [1, 4, 9, 16, 25]
# 计算每个元素的平方根
sqrt_list = [math.sqrt(x) for x in nums]
print("平方根列表：", sqrt_list)  # 输出：[1.0, 2.0, 3.0, 4.0, 5.0]

# 示例3：批量过滤并转换列表元素
mixed_list = [1, "2", 3.0, "4", 5, "six"]
# 筛选出可以转换为整数的元素，并转换为整数
int_list = [
    int(x) for x in mixed_list
    if isinstance(x, (int, float)) or (isinstance(x, str) and x.isdigit())
]
print("转换为整数列表：", int_list)  # 输出：[1, 2, 3, 4, 5]

# 示例4：批量合并两个列表的元素
list1 = ["a", "b", "c"]
list2 = [1, 2, 3]
# 合并为元组列表
merged_list = [(list1[i], list2[i]) for i in range(len(list1))]
print("合并列表：", merged_list)  # 输出：[('a', 1), ('b', 2), ('c', 3)]

4.9 场景 9：嵌套数据结构的扁平化处理

处理嵌套数据结构时，扁平化是常见操作，列表解析式可以快速实现多层嵌套数据的扁平化。

示例：嵌套数据结构的扁平化处理

# 示例1：二维列表扁平化
two_d_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list1 = [x for sublist in two_d_list for x in sublist]
print("二维列表扁平化：", flat_list1)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

# 示例2：三维列表扁平化
three_d_list = [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]
flat_list2 = [x for sub1 in three_d_list for sub2 in sub1 for x in sub2]
print("三维列表扁平化：", flat_list2)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

# 示例3：嵌套字典列表扁平化
nested_dict_list = [
    {
        "name": "张三",
        "hobbies": ["篮球", "游戏"]
    },
    {
        "name": "李四",
        "hobbies": ["读书", "跑步"]
    }
]
# 提取所有爱好，扁平化为一维列表
hobbies_flat = [hobby for user in nested_dict_list for hobby in user["hobbies"]]
print("爱好列表扁平化：", hobbies_flat)  # 输出：['篮球', '游戏', '读书', '跑步']

# 示例4：不规则嵌套数据扁平化（包含不同层级的嵌套）
irregular_nested = [1, [2, [3, 4], 5], 6, [7, 8]]
def flatten_irregular(data):
    """递归扁平化不规则嵌套数据"""
    return [
        item for sublist in (
            flatten_irregular(data) if isinstance(data, list) else [data]
        )
        for item in sublist
    ] if isinstance(data, list) else [data]

flat_irregular = flatten_irregular(irregular_nested)
print("不规则嵌套数据扁平化：", flat_irregular)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8]

4.10 场景 10：与 Pandas 结合处理数据分析

在数据分析中，Pandas 是常用工具，列表解析式可以与 Pandas 结合，快速处理 DataFrame 中的数据。

示例：与 Pandas 结合处理数据分析

import pandas as pd

# 创建DataFrame
df = pd.DataFrame({
    "name": ["张三", "李四", "王五", "赵六", "钱七"],
    "age": [20, 30, 25, 35, 22],
    "score": [85, 90, 80, 95, 75]
})

print("原始DataFrame：")
print(df)

# 示例1：使用列表解析式处理DataFrame列
# 新增等级列（基于score）
df["grade"] = ["优秀" if s >= 90 else "良好" if s >= 80 else "及格" for s in df["score"]]
print("\n新增等级列后：")
print(df)

# 示例2：使用列表解析式筛选DataFrame行
# 筛选年龄>25且等级为优秀的行
filtered_df = df[[x and y for x, y in zip(df["age"] > 25, df["grade"] == "优秀")]]
print("\n筛选后的DataFrame：")
print(filtered_df)

# 示例3：使用列表解析式处理DataFrame中的缺失值
# 模拟缺失值
df.loc[2, "age"] = None
df.loc[3, "score"] = None
print("\n含缺失值的DataFrame：")
print(df)

# 填充缺失值（age用均值，score用0）
age_mean = df["age"].mean()
df["age"] = [age_mean if pd.isna(x) else x for x in df["age"]]
df["score"] = [0 if pd.isna(x) else x for x in df["score"]]
print("\n填充缺失值后：")
print(df)

# 示例4：使用列表解析式转换DataFrame数据类型
# 将age转换为整数，score转换为浮点数
df["age"] = [int(x) for x in df["age"]]
df["score"] = [float(x) for x in df["score"]]
print("\n转换数据类型后：")
print(df.dtypes)

五、避坑指南：列表解析式使用的 10 个常见错误

列表解析式虽然简洁高效，但如果使用不当，容易出现问题。本节将总结列表解析式使用中的常见错误及解决方案。

5.1 错误 1：逻辑过于复杂，可读性差

问题：为了追求 "一行代码解决所有问题"，将复杂逻辑全部写入列表解析式，导致代码难以理解和维护。示例：

# 错误示例：逻辑过于复杂的列表解析式
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = [
    x * 2 if x % 2 == 0 else (x + 1 if x % 3 == 0 else x)
    for x in data
    if x > 2 and (x % 2 == 0 or x % 3 == 0)
]
print(result)  # 输出：[4, 4, 8, 6, 10, 12]

解决方案：将复杂逻辑拆分为函数或多个步骤，平衡简洁性和可读性。

# 正确示例：拆分复杂逻辑
def process_num(x):
    if x % 2 == 0:
        return x * 2
    elif x % 3 == 0:
        return x + 1
    return x

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered_data = [x for x in data if x > 2 and (x % 2 == 0 or x % 3 == 0)]
result = [process_num(x) for x in filtered_data]
print(result)  # 输出：[4, 4, 8, 6, 10, 12]

5.2 错误 2：过度嵌套，逻辑混乱

问题：多层嵌套的列表解析式逻辑混乱，难以调试和维护。示例：

# 错误示例：过度嵌套的列表解析式
nested_data = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
result = [
    x * 2 for sub1 in nested_data
    for sub2 in sub1
    for x in sub2
    if x % 2 == 0
]
print(result)  # 输出：[4, 8, 12, 16]

解决方案：对于三层及以上的嵌套，考虑使用循环或辅助函数，或拆分嵌套逻辑。

# 正确示例：拆分嵌套逻辑
nested_data = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
# 第一步：扁平化到二维
two_d_data = [sub2 for sub1 in nested_data for sub2 in sub1]
# 第二步：筛选并处理
result = [x * 2 for sub in two_d_data for x in sub if x % 2 == 0]
print(result)  # 输出：[4, 8, 12, 16]

5.3 错误 3：忽视内存占用，处理大量数据

问题：列表解析式会立即生成完整列表，处理大量数据时占用过多内存，导致程序卡顿。示例：

# 错误示例：处理大量数据时使用列表解析式
large_list = [i for i in range(10000000)]  # 生成1000万条数据，占用大量内存

解决方案：使用生成器表达式（惰性求值），节省内存。

# 正确示例：使用生成器表达式处理大量数据
large_generator = (i for i in range(10000000))  # 仅占用少量内存
# 遍历生成器
for i, num in enumerate(large_generator):
    if i >= 10:
        break
    print(num, end=" ")  # 输出：0 1 2 3 4 5 6 7 8 9

5.4 错误 4：条件判断位置错误

问题：将条件判断写在表达式部分，而非筛选部分，导致逻辑错误。示例：

# 错误示例：条件判断位置错误
num_list = [1, 2, 3, 4, 5]
# 意图：筛选偶数并乘以2，实际：所有元素都处理，奇数返回None
result = [x * 2 if x % 2 == 0 for x in num_list]  # 语法错误

解决方案：明确条件判断的用途，筛选条件写在if子句，分支逻辑写在表达式部分。

# 正确示例1：筛选偶数并乘以2（筛选条件）
result1 = [x * 2 for x in num_list if x % 2 == 0]
print(result1)  # 输出：[4, 8]

# 正确示例2：所有元素处理，偶数乘以2，奇数加1（分支逻辑）
result2 = [x * 2 if x % 2 == 0 else x + 1 for x in num_list]
print(result2)  # 输出：[2, 4, 4, 8, 6]

5.5 错误 5：循环变量泄漏

问题：在 Python 2 中，列表解析式的循环变量会泄漏到全局作用域；Python 3 中已修复，但仍需注意局部作用域泄漏。示例：

# 示例：Python 2中的循环变量泄漏（Python 3中无此问题）
# Python 2运行结果：
i = 10
result = [i for i in range(5)]
print(i)  # 输出：4（变量i被覆盖）

解决方案：避免在列表解析式中使用与全局 / 局部变量同名的循环变量，或在使用后重新赋值。

# 正确示例：避免变量同名
i = 10
result = [x for x in range(5)]
print(i)  # 输出：10（变量i未被覆盖）

5.6 错误 6：对不可变对象进行修改

问题：试图在列表解析式中修改不可变对象（如字符串、元组），导致错误。示例：

# 错误示例：试图修改字符串（不可变对象）
str_list = ["hello", "world"]
# 意图：将每个字符串的第一个字符改为大写，实际：字符串不可修改
result = [s[0].upper() + s[1:] for s in str_list]  # 语法正确，但并非修改原对象
print(result)  # 输出：['Hello', 'World']

解决方案：不可变对象无法修改，需生成新的对象替代。

# 正确示例：生成新的字符串对象
str_list = ["hello", "world"]
result = [s.capitalize() for s in str_list]
print(result)  # 输出：['Hello', 'World']

5.7 错误 7：嵌套循环顺序错误

问题：多层循环的顺序错误，导致生成的列表不符合预期。示例：

# 错误示例：嵌套循环顺序错误
list1 = [1, 2, 3]
list2 = ["a", "b"]
# 意图：生成[(1,'a'), (1,'b'), (2,'a'), ...]，实际顺序错误
result = [(y, x) for x in list1 for y in list2]
print(result)  # 输出：[('a', 1), ('b', 1), ('a', 2), ('b', 2), ('a', 3), ('b', 3)]

解决方案：明确嵌套循环的顺序，外层循环在前，内层循环在后。

# 正确示例：嵌套循环顺序正确
result = [(x, y) for x in list1 for y in list2]
print(result)  # 输出：[(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b'), (3, 'a'), (3, 'b')]

5.8 错误 8：表达式部分包含副作用

问题：列表解析式的表达式部分包含副作用（如修改全局变量、文件写入），导致逻辑混乱。示例：

# 错误示例：表达式包含副作用（修改全局变量）
count = 0
num_list = [1, 2, 3, 4, 5]
result = [x + (count := count + 1) for x in num_list]  # Python 3.8+支持海象运算符
print(result)  # 输出：[2, 4, 6, 8, 10]
print(count)  # 输出：5（全局变量被修改）

解决方案：列表解析式应尽量保持纯函数特性，避免副作用，如需修改状态，使用普通循环。

# 正确示例：使用普通循环修改状态
count = 0
num_list = [1, 2, 3, 4, 5]
result = []
for x in num_list:
    count += 1
    result.append(x + count)
print(result)  # 输出：[2, 4, 6, 8, 10]
print(count)  # 输出：5

5.9 错误 9：数据类型不匹配导致错误

问题：列表解析式中处理的数据类型不匹配，导致运行时错误。示例：

# 错误示例：数据类型不匹配
mixed_list = [1, "2", 3, "4", 5]
# 意图：所有元素加1，实际：字符串无法与整数相加
result = [x + 1 for x in mixed_list]  # 报错：TypeError: can only concatenate str (not "int") to str

解决方案：先统一数据类型，再进行处理。

# 正确示例：统一数据类型后处理
mixed_list = [1, "2", 3, "4", 5]
# 转换为整数（筛选可转换的元素）
int_list = [
    int(x) for x in mixed_list
    if isinstance(x, (int, float)) or (isinstance(x, str) and x.isdigit())
]
result = [x + 1 for x in int_list]
print(result)  # 输出：[2, 3, 4, 5, 6]

5.10 错误 10：过度使用列表解析式

问题：为了使用列表解析式而使用，忽视了代码的可读性和维护性。示例：

# 错误示例：过度使用列表解析式（简单逻辑无需复杂语法）
# 意图：生成[0, 1, 2, 3, 4]，实际：range更简洁
result = [i for i in range(5)]
print(result)  # 输出：[0, 1, 2, 3, 4]

解决方案：根据场景选择合适的方式，简单的列表生成可直接使用range、list等内置函数。

# 正确示例：使用内置函数更简洁
result = list(range(5))
print(result)  # 输出：[0, 1, 2, 3, 4]

六、实战项目：用列表解析式打造简易数据处理工具

结合前面的知识点，我们用列表解析式开发一个简易的数据处理工具，支持数据加载、清洗、转换、筛选、排序和导出功能，展示列表解析式在实际项目中的应用。

6.1 项目需求分析

支持加载 CSV 格式的数据文件；
提供数据清洗功能（去除空值、去重、格式标准化）；
提供数据转换功能（类型转换、字段计算、格式转换）；
提供数据筛选功能（多条件筛选）；
提供数据排序功能（按指定字段排序）；
支持将处理后的数据导出为 CSV 文件。

6.2 项目结构设计

simple_data_processor/
└── main.py  # 工具核心代码

6.3 完整代码实现

import csv
import os
from datetime import datetime

class SimpleDataProcessor:
    def __init__(self):
        self.data = []  # 存储原始数据
        self.processed_data = []  # 存储处理后的数据

    def load_csv(self, file_path):
        """加载CSV文件"""
        if not os.path.exists(file_path):
            print(f"错误：文件 {file_path} 不存在")
            return False
        
        try:
            with open(file_path, "r", encoding="utf-8") as f:
                reader = csv.DictReader(f)
                self.data = [row for row in reader]
                self.processed_data = self.data.copy()
            print(f"成功加载 {len(self.data)} 条数据")
            return True
        except Exception as e:
            print(f"加载CSV文件失败：{str(e)}")
            return False

    def clean_data(self):
        """数据清洗：去除空值、去重、格式标准化"""
        if not self.processed_data:
            print("错误：未加载数据")
            return False
        
        try:
            # 步骤1：去除空值和空白字段
            self.processed_data = [
                row for row in self.processed_data
                if all(value and value.strip() for value in row.values())
            ]
            
            # 步骤2：格式标准化（去除字符串前后空格）
            self.processed_data = [
                {key: value.strip() for key, value in row.items()}
                for row in self.processed_data
            ]
            
            # 步骤3：去重（保持插入顺序）
            self.processed_data = list(dict.fromkeys(tuple(row.items()) for row in self.processed_data))
            self.processed_data = [dict(row) for row in self.processed_data]
            
            print(f"数据清洗完成，剩余 {len(self.processed_data)} 条数据")
            return True
        except Exception as e:
            print(f"数据清洗失败：{str(e)}")
            return False

    def transform_data(self, transform_rules):
        """数据转换：根据规则转换字段"""
        if not self.processed_data:
            print("错误：未加载数据")
            return False
        
        try:
            self.processed_data = [
                {
                    key: transform_rules[key](value) if key in transform_rules else value
                    for key, value in row.items()
                }
                for row in self.processed_data
            ]
            print("数据转换完成")
            return True
        except Exception as e:
            print(f"数据转换失败：{str(e)}")
            return False

    def filter_data(self, filter_func):
        """数据筛选：根据条件筛选数据"""
        if not self.processed_data:
            print("错误：未加载数据")
            return False
        
        try:
            self.processed_data = [row for row in self.processed_data if filter_func(row)]
            print(f"数据筛选完成，剩余 {len(self.processed_data)} 条数据")
            return True
        except Exception as e:
            print(f"数据筛选失败：{str(e)}")
            return False

    def sort_data(self, sort_key, reverse=False):
        """数据排序：根据指定字段排序"""
        if not self.processed_data:
            print("错误：未加载数据")
            return False
        
        try:
            self.processed_data = sorted(self.processed_data, key=lambda x: x[sort_key], reverse=reverse)
            print("数据排序完成")
            return True
        except Exception as e:
            print(f"数据排序失败：{str(e)}")
            return False

    def export_csv(self, file_path):
        """导出处理后的数据为CSV文件"""
        if not self.processed_data:
            print("错误：无处理后的数据")
            return False
        
        try:
            fieldnames = self.processed_data[0].keys() if self.processed_data else []
            with open(file_path, "w", encoding="utf-8", newline="") as f:
                writer = csv.Dict

您可能感兴趣的与本文相关的镜像