Python 嵌套列表

合并嵌套列表的方法

1. 使用列表推导式

nested_list = [[1, 2], [3, 4], [5, 6]]
flattened = [item for sublist in nested_list for item in sublist]
# 结果: [1, 2, 3, 4, 5, 6]

2. 使用 itertools.chain

from itertools import chain

nested_list = [[1, 2], [3, 4], [5, 6]]
flattened = list(chain.from_iterable(nested_list))
# 结果: [1, 2, 3, 4, 5, 6]

4. 递归方法（处理多层嵌套）

def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

deep_nested = [1, [2, [3, 4], 5], 6]
print(flatten(deep_nested))  # 结果: [1, 2, 3, 4, 5, 6]

5. 使用 functools.reduce

from functools import reduce
import operator

nested_list = [[1, 2], [3, 4], [5, 6]]
flattened = reduce(operator.concat, nested_list)
# 或
flattened = reduce(lambda x, y: x + y, nested_list)
# 结果: [1, 2, 3, 4, 5, 6]

对于大型列表，itertools.chain 通常是最快的方法，其次是列表推导式。sum 方法虽然简洁，但对于大型列表性能较差。

排序嵌套列表的方法

1. 按子列表的第一个元素排序（默认行为）

nested_list = [[3, 4], [1, 2], [5, 0]]
sorted_list = sorted(nested_list)
# 结果: [[1, 2], [3, 4], [5, 0]]

2. 按子列表的特定索引元素排序

# 按每个子列表的第二个元素排序
nested_list = [[3, 4], [1, 2], [5, 0]]
sorted_list = sorted(nested_list, key=lambda x: x[1])
# 结果: [[5, 0], [1, 2], [3, 4]]

3. 按子列表的长度排序

nested_list = [[3, 4, 5], [1], [5, 0, 2, 7]]
sorted_list = sorted(nested_list, key=len)
# 结果: [[1], [3, 4, 5], [5, 0, 2, 7]]

4. 按子列表的多个条件排序

# 先按第一个元素升序，再按第二个元素降序
nested_list = [[3, 4], [1, 2], [1, 3], [5, 0]]
sorted_list = sorted(nested_list, key=lambda x: (x[0], -x[1]))
# 结果: [[1, 3], [1, 2], [3, 4], [5, 0]]

5. 对嵌套列表进行原地排序

nested_list = [[3, 4], [1, 2], [5, 0]]
nested_list.sort()  # 原地修改列表
# 结果: [[1, 2], [3, 4], [5, 0]]

6. 对多层嵌套列表排序

deep_nested = [[3, [4, 1]], [1, [2, 5]], [5, [0, 3]]]
# 按内部嵌套列表的第一个元素排序
sorted_list = sorted(deep_nested, key=lambda x: x[1][0])
# 结果: [[5, [0, 3]], [1, [2, 5]], [3, [4, 1]]]

7. 自定义排序函数

def custom_sort(item):
    return sum(item)  # 按子列表元素和排序

nested_list = [[3, 4], [1, 2], [5, 0]]
sorted_list = sorted(nested_list, key=custom_sort)
# 结果: [[5, 0], [1, 2], [3, 4]]

注意事项
sorted() 函数返回一个新的排序后的列表，不改变原列表
list.sort() 方法会原地修改列表，不返回新列表
对于大型列表，key 函数的效率会影响排序性能

嵌套列表去重方法

1. 基本方法 - 子列表去重（适用于简单二维列表）

nested_list = [[1, 2], [3, 4], [1, 2], [5, 6]]

# 方法1：使用集合与元组转换
unique_list = [list(x) for x in {tuple(item) for item in nested_list}]
# 结果: [[1, 2], [3, 4], [5, 6]]

# 方法2：保持原始顺序
seen = set()
unique_list_ordered = [x for x in nested_list if tuple(x) not in seen and not seen.add(tuple(x))]

2. 多层嵌套列表去重（递归方法）

def dedupe_nested(nested):
    seen = set()
    result = []
    for item in nested:
        if isinstance(item, list):
            # 递归处理子列表
            item = dedupe_nested(item)
        hashable = tuple(item) if isinstance(item, list) else item
        if hashable not in seen:
            seen.add(hashable)
            result.append(item)
    return result

deep_nested = [[1, [2, 3]], [4, [5, 6]], [1, [2, 3]], [[7, 8], [7, 8]]]
print(dedupe_nested(deep_nested))
# 结果: [[1, [2, 3]], [4, [5, 6]], [[7, 8]]]

3. 使用 JSON 序列化方法（处理复杂嵌套结构）

import json

def dedupe_with_json(nested):
    seen = set()
    result = []
    for item in nested:
        # 转换为可排序的JSON字符串
        item_json = json.dumps(item, sort_keys=True)
        if item_json not in seen:
            seen.add(item_json)
            result.append(item)
    return result

complex_nested = [[1, {"a": 2}], [2, 3], [1, {"a": 2}], [4, [5, 6]]]
print(dedupe_with_json(complex_nested))
# 结果: [[1, {'a': 2}], [2, 3], [4, [5, 6]]]

4. 使用 pandas 处理大数据量（性能优化）

import pandas as pd

large_nested = [[...], [...], ...]  # 大数据量嵌套列表

# 转换为DataFrame去重
df = pd.DataFrame([{'data': x} for x in large_nested])
df_unique = df.drop_duplicates(subset=['data'])
unique_list = df_unique['data'].tolist()

注意事项
保持顺序：如果需要保持原始顺序，使用有序字典或记录seen集合的方法
元素类型：确保列表中的元素都是可哈希的（或可转换为可哈希形式）
性能考虑：
小数据量：使用简单集合方法
大数据量：考虑使用pandas或itertools
深度嵌套：对于非常复杂的嵌套结构，递归方法最可靠