Python：如何将含多字典的嵌套列表解析为基础DataFrame？

下面是几种可行的实现方案，附代码示例和适用场景：

方法1：使用pandas内置的json_normalize（推荐） #

这是处理嵌套字典/JSON结构最便捷的方式，pandas内置方法，无需手动遍历，适合大多数常规嵌套场景。

import pandas as pd

# 你的嵌套列表数据
data = [{'classification': 
 {'description': 'A registered charge', 
 'type': 'charge-description'}, 
 'charge_code': 'SC3802280001', 
 'etag': '157167f8f780f440048f4056da17784dfafe64e5', 
 'delivered_on': '2015-09-04', 
 'persons_entitled': [{'name': 'The Royal Bank of Scotland PLC'}], 
 'created_on': '2015-09-03', 
 'links': {'self': '/company/SC380228/charges/IKH-4F5A4YmihSPe9D8Mq-WAJDw'}, 
 'particulars': {'floating_charge_covers_all': True, 
 'contains_negative_pledge': True, 
 'contains_floating_charge': True}, 
 'status': 'outstanding', 
 'transactions': [{'links': {'filing': '/company/SC380228/filing-history/MzEzMDM4OTgxOGFkaXF6a2N4'}, 
 'filing_type': 'create-charge-with-deed', 
 'delivered_on': '2015-09-04'}], 
 'charge_number': 1
}]

# 1. 先展开层级字典（classification、links、particulars）
base_df = pd.json_normalize(data)

# 2. 展开列表型嵌套字段（persons_entitled、transactions）
# 展开persons_entitled并保留关联主字段
df_persons = pd.json_normalize(
    data,
    record_path='persons_entitled',
    meta=['charge_code', 'charge_number', 'status'],
    errors='ignore'
)

# 展开transactions并保留关联主字段
df_transactions = pd.json_normalize(
    data,
    record_path='transactions',
    meta=['charge_code', 'charge_number', 'status'],
    errors='ignore'
)

# 3. 合并所有数据（按共同字段关联）
final_df = pd.merge(base_df, df_persons, on=['charge_code', 'charge_number', 'status'], how='left')
final_df = pd.merge(final_df, df_transactions, on=['charge_code', 'charge_number', 'status'], how='left')

# 查看结果
print(final_df.head())

优势：代码简洁，内置方法稳定性高，支持自定义展开规则，适合快速实现需求。

方法2：手动遍历构建扁平字典（自定义场景） #

如果需要对字段展开规则做精细化控制（比如自定义字段名、过滤特定嵌套层级），可以手动递归遍历嵌套结构，将所有层级的键值对展开为扁平字典，再转成DataFrame。

import pandas as pd

def flatten_dict(d, parent_key='', sep='_'):
    """递归展开嵌套字典，用下划线拼接层级键名"""
    items = []
    for k, v in d.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten_dict(v, new_key, sep=sep).items())
        elif isinstance(v, list):
            # 处理列表：这里取第一个字典元素展开，可根据需求修改为遍历所有元素
            if v and isinstance(v[0], dict):
                items.extend(flatten_dict(v[0], new_key, sep=sep).items())
            else:
                items.append((new_key, v))
        else:
            items.append((new_key, v))
    return dict(items)

# 处理所有数据项，生成扁平字典列表
flattened_data = [flatten_dict(item) for item in data]

# 转成DataFrame
df = pd.DataFrame(flattened_data)
print(df.columns)
print(df.head())

优势：完全自定义展开逻辑，适合特殊场景（比如只展开特定嵌套层级、修改字段命名规则）。

方法3：递归展开多层级列表（深度嵌套场景） #

如果数据存在多层级嵌套列表（比如列表里嵌套字典，字典里又包含列表），可以用递归函数逐层展开所有列表，同时保留所有关联的上层字段，确保每条记录的完整性。

import pandas as pd

def flatten_dict(d, parent_key='', sep='_'):
    """辅助函数：展开嵌套字典"""
    items = []
    for k, v in d.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten_dict(v, new_key, sep=sep).items())
        else:
            items.append((new_key, v))
    return dict(items)

def expand_nested_lists(data, parent_data=None):
    """递归展开所有嵌套列表，保留上层关联字段"""
    result = []
    parent_data = parent_data or {}
    for item in data:
        # 分离字典字段和列表字段
        dict_fields = {}
        list_fields = {}
        for k, v in item.items():
            if isinstance(v, dict):
                dict_fields.update(flatten_dict(v, k))
            elif isinstance(v, list) and v and isinstance(v[0], dict):
                list_fields[k] = v
            else:
                dict_fields[k] = v
        # 合并父级数据与当前字典字段
        current_data = {**parent_data, **dict_fields}
        # 递归展开列表字段
        if list_fields:
            for k, lst in list_fields.items():
                result.extend(expand_nested_lists(lst, current_data))
        else:
            result.append(current_data)
    return result

# 展开所有嵌套列表
expanded_data = expand_nested_lists(data)

# 转成DataFrame
df = pd.DataFrame(expanded_data)
print(df.head())

优势：处理深度嵌套的列表结构，确保所有层级的列表元素都能展开为独立记录，适合复杂嵌套场景。

内容的提问来源于stack exchange，提问作者classic_unique