利用flatten()函数处理复杂嵌套结构的技巧总结

复杂嵌套结构是指在一个数据结构中存在多层嵌套，如列表中嵌套列表，字典中嵌套字典等等。处理这种复杂嵌套结构时，我们可以使用Python的flatten()函数来展开结构，使之变得简单易用。下面是一些利用flatten()函数处理复杂嵌套结构的技巧总结，并附带使用例子。

1. 将嵌套列表展开成一维列表

flatten()函数可以将多层嵌套的列表展开成一维列表。例如，我们有一个嵌套列表：[[1, 2, 3], [4, 5, 6], [7, 8, 9]]，使用flatten()函数后，会得到：[1, 2, 3, 4, 5, 6, 7, 8, 9]。

def flatten(nested_list):
    return [item for sublist in nested_list for item in sublist]

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_list = flatten(nested_list)
print(flattened_list)

2. 将嵌套字典展开成一级字典

flatten()函数可以将嵌套字典展开成一级字典。例如，我们有一个嵌套字典：{'A': {'B': {'C': 1, 'D': 2}}, 'E': {'F': 3}}，使用flatten()函数后，会得到：{'A.B.C': 1, 'A.B.D': 2, 'E.F': 3}。

def flatten(nested_dict, parent_key='', sep='.'):
    flattened_dict = {}
    for k, v in nested_dict.items():
        new_key = parent_key + sep + k if parent_key else k
        if isinstance(v, dict):
            flattened_dict.update(flatten(v, new_key, sep))
        else:
            flattened_dict[new_key] = v
    return flattened_dict

nested_dict = {'A': {'B': {'C': 1, 'D': 2}}, 'E': {'F': 3}}
flattened_dict = flatten(nested_dict)
print(flattened_dict)

3. 将嵌套列表和字典展开成一维字典

flatten()函数还可以将同时包含嵌套列表和嵌套字典的结构展开成一维字典。例如，我们有一个嵌套列表和嵌套字典的结构：[{'A': [1, 2]}, {'B': {'C': [3, 4]}}]，使用flatten()函数后，会得到：{'A': [1, 2], 'B.C': [3, 4]}。

def flatten(nested_structure, parent_key='', sep='.'):
    flattened_dict = {}
    for item in nested_structure:
        if isinstance(item, dict):
            for k, v in item.items():
                new_key = parent_key + sep + k if parent_key else k
                if isinstance(v, (list, dict)):
                    flattened_dict.update(flatten(v, new_key, sep))
                else:
                    flattened_dict[new_key] = v
        else:
            flattened_dict[parent_key] = item
    return flattened_dict

nested_structure = [{'A': [1, 2]}, {'B': {'C': [3, 4]}}]
flattened_dict = flatten(nested_structure)
print(flattened_dict)

除了上述例子中的技巧，flatten()函数还可以用于其他各种复杂嵌套结构的处理，例如嵌套元组、嵌套集合等等。总体来说，flatten()函数是处理复杂嵌套结构的利器，在数据处理和分析中起到很大的作用。