要实现 Python 列表中子列表的去重，核心在于如何将可变且不可哈希的列表转换为一种能被集合识别或能被其他数据结构（如字典）作为唯一键的形式。最直接有效的方法是将每个子列表转换为**可哈希的元组**。以下是具体的实现方法、对比和应用场景分析。 ### 核心代码实现 假设您有一个包含子列表的列表 `original_list = [[1, 2, 3], [2, 3, 4], [1, 2, 3]]`，目标是得到不重复的结果 `[[1, 2, 3], [2, 3, 4]]`，并**尽可能保留首次出现的顺序**。 #### 方法一：使用 `set` 和元组转换（推荐） 这是最简洁高效且符合 Python 风格的方法。其思路是：通过列表推导式，将每个子列表转换为元组，添加到集合中进行去重，再将结果转换回列表。为了实现顺序保留，需要使用一个 `for` 循环和辅助的 `set`。 ```python original_list = [[1, 2, 3], [2, 3, 4], [1, 2, 3]] # 【去重核心代码开始】 seen = set() result_list = [] for sublist in original_list: # 将子列表转换为元组，使其可哈希 tuple_repr = tuple(sublist) if tuple_repr not in seen: seen.add(tuple_repr) result_list.append(sublist) # 【去重核心代码结束】 print(result_list) # 输出：[[1, 2, 3], [2, 3, 4]] ``` **代码解读**： 1. `seen = set()` 创建一个空集合，用于存储已见过的子列表的元组表示。 2. `for sublist in original_list:` 遍历原始列表的每个子列表。 3. `tuple_repr = tuple(sublist)` 将子列表转换为元组，因为列表是可变的，不可哈希，不能直接存入 `set`，而元组是**不可变且可哈希**的 [ref_6]。 4. `if tuple_repr not in seen:` 检查当前子列表的元组形式是否已在集合中。 5. `seen.add(tuple_repr)` 和 `result_list.append(sublist)`：如果未见过，则将其元组形式加入集合，并将**原始子列表**加入结果列表。这保证了去重并**保留原始顺序**。 #### 方法二：使用 `dict.fromkeys()` 和元组键（简洁但依赖字典顺序） 从 Python 3.7 开始，字典会**保留键的插入顺序**。我们可以利用这一点，用子列表的元组形式作为字典的键来去重。 ```python original_list = [[1, 2, 3], [2, 3, 4], [1, 2, 3]] # 【去重核心代码开始】 # 使用字典去重，键为元组形式的子列表 temp_dict = dict.fromkeys(tuple(item) for item in original_list) # 将键（元组）转换回列表 result_list = [list(key) for key in temp_dict.keys()] # 【去重核心代码结束】 print(result_list) # 输出：[[1, 2, 3], [2, 3, 4]] ``` **代码解读**： 1. `dict.fromkeys(tuple(item) for item in original_list)`：创建一个字典，其键是由生成器表达式 `(tuple(item) for item in original_list)` 生成的元组序列。字典的键是唯一的，因此重复的元组键会被自动去重。由于字典保留了键的插入顺序，这同时保证了去重后的顺序 [ref_3]。 2. `[list(key) for key in temp_dict.keys()]`：将字典键（即去重后的元组）再转换回列表形式，得到最终结果。 #### 方法三：使用 `itertools.groupby()`（要求先排序） 如果对结果顺序没有要求，或者可以先对列表排序，可以结合 `itertools.groupby` 使用。 ```python from itertools import groupby original_list = [[1, 2, 3], [2, 3, 4], [1, 2, 3]] # 【去重核心代码开始】 # 先对列表排序，groupby才能将相邻的相同元素分组 sorted_list = sorted(original_list) result_list = [list(key) for key, _ in groupby(sorted_list)] # 【去重核心代码结束】 print(result_list) # 输出：[[1, 2, 3], [2, 3, 4]] ``` **代码解读**： 1. `sorted(original_list)`：对原始列表进行排序。`groupby` 函数只能对**已排序的迭代对象**中的连续相同元素进行分组 [ref_3]。 2. `[list(key) for key, _ in groupby(sorted_list)]`：遍历分组结果，`key` 是每个唯一的子列表（由分组产生），`_` 是组内的迭代器（此处忽略）。这提取出了排序后不重复的子列表。 **注意**：此方法会**改变元素的顺序**（因为先排序了），适用于不关心顺序或需要先排序再分组的场景。 ### 方法对比与选择建议 为了清晰对比，下表总结了三种方法的核心特性： | 方法 | 核心代码片段 | 是否保留原序 | 时间复杂度 | 推荐场景与说明 | | :--- | :--- | :--- | :--- | :--- | | **`set` + `for`循环法** | `if tuple_repr not in seen:`<br>` seen.add(tuple_repr)`<br>` result_list.append(sublist)` | **是** | O(n) | **通用首选**。逻辑清晰，顺序保留准确，适用于所有 Python 版本和场景 [ref_6]。 | | **`dict.fromkeys()`法** | `temp_dict = dict.fromkeys(tuple(item) for item in original_list)`<br>`result_list = [list(key) for key in temp_dict.keys()]` | **是** (Python 3.7+) | O(n) | **代码最简洁**。利用了现代Python字典的特性，一行生成字典实现去重 [ref_3]。 | | **`itertools.groupby()`法** | `sorted_list = sorted(original_list)`<br>`result_list = [list(key) for key, _ in groupby(sorted_list)]` | **否**（会排序） | O(n log n) | **适用于需要排序或分组操作的场景**。去重是附带功能，主要用于分组 [ref_3]。 | **结论**： 对于“去除列表中重复的子列表”这一需求，**方法一（`set` + `for`循环）是普适性最强、最推荐的做法**。它明确地将子列表转换为可哈希的元组，通过 `set` 进行存在性判断，高效地完成去重并严格保留首次出现的顺序 [ref_5][ref_6]。 **关键点在于理解为什么需要转换**：列表是**不可哈希**的，因此无法直接作为集合的元素或字典的键。而元组（只要其元素本身也是可哈希的）是**可哈希**的，这使得我们可以用它来唯一标识一个子列表的内容，从而实现去重操作 [ref_6]。 ### 扩展应用场景 假设您需要处理的子列表本身也包含不可哈希元素（如列表嵌套列表），或者您需要根据子列表的某种“特征”（例如元素之和）进行去重，上述方法稍作修改即可适用。 **场景示例1：根据子列表元素之和去重** ```python original_list = [[1, 2], [3], [2, 1], [4]] seen = set() result = [] for sublist in original_list: # 定义“特征”为元素之和 feature = sum(sublist) if feature not in seen: seen.add(feature) result.append(sublist) print(result) # 输出：[[1, 2], [3], [4]]，因为[1,2]和[2,1]的和都是3，只保留第一个。 ``` **场景示例2：处理嵌套子列表的深度去重** 如果子列表内部也包含列表（如 `[[1, [2]], [[2], 1]]`），直接转换为元组会失败，因为内部列表不可哈希。此时需要递归地转换为元组，或使用其他序列化方法（如 `json.dumps`）。