Python多层嵌套的dict递归解析

已于 2024-02-24 17:24:47 修改
阅读量472 收藏 8
点赞数 7
分类专栏： Python pandas 文章标签： python 算法
于 2024-02-24 15:59:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39065491/article/details/136272654
版权

Python多层嵌套的dict递归解析

1.问题

遇到多层嵌套的dict ，如何能解析为只有一维的dict ，方便后续数据处理。
一个嵌套的dict ：

AutoOrderedDict([('total',
                  AutoOrderedDict([('total', 9), ('open', 1), ('closed', 8)])),
                 ('streak',
                  AutoOrderedDict([('won',
                                    AutoOrderedDict([('current', 0),
                                                     ('longest', 2)])),
                                   ('lost',
                                    AutoOrderedDict([('current', 2),
                                                     ('longest', 2)]))])),
                 ('pnl',
                  AutoOrderedDict([('gross',
                                    AutoOrderedDict([('total', 8391.0),
                                                     ('average', 1048.875)])),
                                   ('net',
                                    AutoOrderedDict([('total',
                                                      8153.050000000002),
                                                     ('average',
                                                      1019.1312500000003)]))])),
                 ('won',
                  AutoOrderedDict([('total', 4),
                                   ('pnl',
                                    AutoOrderedDict([('total',
                                                      11173.952000000001),
                                                     ('average',
                                                      2793.4880000000003),
                                                     ('max', 7333.14)]))])),
                 ('lost',
                  AutoOrderedDict([('total', 4),
                                   ('pnl',
                                    AutoOrderedDict([('total',
                                                      -3020.9019999999987),
                                                     ('average',
                                                      -755.2254999999997),
                                                     ('max',
                                                      -1576.6519999999991)]))])),
                 ('long',
                  AutoOrderedDict([('total', 8),
                                   ('pnl',
                                    AutoOrderedDict([('total',
                                                      8153.050000000002),
                                                     ('average',
                                                      1019.1312500000003),
                                                     ('won',
                                                      AutoOrderedDict([('total',
                                                                        11173.952000000001),
                                                                       ('average',
                                                                        2793.4880000000003),
                                                                       ('max',
                                                                        7333.14)])),
                                                     ('lost',
                                                      AutoOrderedDict([('total',
                                                                        -3020.9019999999987),
                                                                       ('average',
                                                                        -755.2254999999997),
                                                                       ('max',
                                                                        -1576.6519999999991)]))])),
                                   ('won', 4),
                                   ('lost', 4)])),
                 ('short',
                  AutoOrderedDict([('total', 0),
                                   ('pnl',
                                    AutoOrderedDict([('total', 0.0),
                                                     ('average', 0.0),
                                                     ('won',
                                                      AutoOrderedDict([('total',
                                                                        0.0),
                                                                       ('average',
                                                                        0.0),
                                                                       ('max',
                                                                        0.0)])),
                                                     ('lost',
                                                      AutoOrderedDict([('total',
                                                                        0.0),
                                                                       ('average',
                                                                        0.0),
                                                                       ('max',
                                                                        0.0)]))])),
                                   ('won', 0),
                                   ('lost', 0)])),
                 ('len',
                  AutoOrderedDict([('total', 668),
                                   ('average', 83.5),
                                   ('max', 177),
                                   ('min', 12),
                                   ('won',
                                    AutoOrderedDict([('total', 556),
                                                     ('average', 139.0),
                                                     ('max', 177),
                                                     ('min', 94)])),
                                   ('lost',
                                    AutoOrderedDict([('total', 112),
                                                     ('average', 28.0),
                                                     ('max', 45),
                                                     ('min', 12)])),
                                   ('long',
                                    AutoOrderedDict([('total', 668),
                                                     ('average', 83.5),
                                                     ('max', 177),
                                                     ('min', 12),
                                                     ('won',
                                                      AutoOrderedDict([('total',
                                                                        556),
                                                                       ('average',
                                                                        139.0),
                                                                       ('max',
                                                                        177),
                                                                       ('min',
                                                                        94)])),
                                                     ('lost',
                                                      AutoOrderedDict([('total',
                                                                        112),
                                                                       ('average',
                                                                        28.0),
                                                                       ('max',
                                                                        45),
                                                                       ('min',
                                                                        12)]))])),
                                   ('short',
                                    AutoOrderedDict([('total', 0),
                                                     ('average', 0.0),
                                                     ('max', 0),
                                                     ('min',
                                                      9223372036854775807),
                                                     ('won',
                                                      AutoOrderedDict([('total',
                                                                        0),
                                                                       ('average',
                                                                        0.0),
                                                                       ('max',
                                                                        0),
                                                                       ('min',
                                                                        9223372036854775807)])),
                                                     ('lost',
                                                      AutoOrderedDict([('total',
                                                                        0),
                                                                       ('average',
                                                                        0.0),
                                                                       ('max',
                                                                        0),
                                                                       ('min',
                                                                        9223372036854775807)]))]))]))])

2.递归解析

result_dict = {}  
  
def parse_nested_dict(nested_dict, indent=0, pre_key=''):  
    for key, value in nested_dict.items():  
        # 如果是第一级，前缀恢复空值  
        if indent == 0:  
            pre_key = ''  
  
        # 增加前缀  
        new_key = pre_key + key if pre_key else key  
  
        if isinstance(value, dict):  
            # 递归调用  
            parse_nested_dict(value, indent + 1, new_key + '_')  
        else:  
            # 叶子节点，赋值到dict  
            result_dict[new_key] = value  
  
# 解析嵌套字典  
parse_nested_dict(TradeAnalyzer)

优雅。

3.效果

{'total_total': 9,
 'total_open': 1,
 'total_closed': 8,
 'streak_won_current': 0,
 'streak_won_longest': 2,
 'streak_lost_current': 2,
 'streak_lost_longest': 2,
 'pnl_gross_total': 8391.0,
 'pnl_gross_average': 1048.875,
 'pnl_net_total': 8153.050000000002,
 'pnl_net_average': 1019.1312500000003,
 'won_total': 4,
 'won_pnl_total': 11173.952000000001,
 'won_pnl_average': 2793.4880000000003,
 'won_pnl_max': 7333.14,
 'lost_total': 4,
 'lost_pnl_total': -3020.9019999999987,
 'lost_pnl_average': -755.2254999999997,
 'lost_pnl_max': -1576.6519999999991,
 'long_total': 8,
 'long_pnl_total': 8153.050000000002,
 'long_pnl_average': 1019.1312500000003,
 'long_pnl_won_total': 11173.952000000001,
 'long_pnl_won_average': 2793.4880000000003,
 'long_pnl_won_max': 7333.14,
 'long_pnl_lost_total': -3020.9019999999987,
 'long_pnl_lost_average': -755.2254999999997,
 'long_pnl_lost_max': -1576.6519999999991,
 'long_won': 4,
 'long_lost': 4,
 'short_total': 0,
 'short_pnl_total': 0.0,
 'short_pnl_average': 0.0,
 'short_pnl_won_total': 0.0,
 'short_pnl_won_average': 0.0,
 'short_pnl_won_max': 0.0,
 'short_pnl_lost_total': 0.0,
 'short_pnl_lost_average': 0.0,
 'short_pnl_lost_max': 0.0,
 'short_won': 0,
 'short_lost': 0,
 'len_total': 668,
 'len_average': 83.5,
 'len_max': 177,
 'len_min': 12,
 'len_won_total': 556,
 'len_won_average': 139.0,
 'len_won_max': 177,
 'len_won_min': 94,
 'len_lost_total': 112,
 'len_lost_average': 28.0,
 'len_lost_max': 45,
 'len_lost_min': 12,
 'len_long_total': 668,
 'len_long_average': 83.5,
 'len_long_max': 177,
 'len_long_min': 12,
 'len_long_won_total': 556,
 'len_long_won_average': 139.0,
 'len_long_won_max': 177,
 'len_long_won_min': 94,
 'len_long_lost_total': 112,
 'len_long_lost_average': 28.0,
 'len_long_lost_max': 45,
 'len_long_lost_min': 12,
 'len_short_total': 0,
 'len_short_average': 0.0,
 'len_short_max': 0,
 'len_short_min': 9223372036854775807,
 'len_short_won_total': 0,
 'len_short_won_average': 0.0,
 'len_short_won_max': 0,
 'len_short_won_min': 9223372036854775807,
 'len_short_lost_total': 0,
 'len_short_lost_average': 0.0,
 'len_short_lost_max': 0,
 'len_short_lost_min': 9223372036854775807}

完美！

六月闻君
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python 处理json多层嵌套_python解析多层嵌套json
weixin_39879651的博客
11-28 5569
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！这样多层json结构已完成。 补充拓展：python 读取多层嵌套的json数据模块名称：jsonpath主要特点 支持路径及*模糊匹配 支持索引和类似切片功能 支持表达式筛选jsonpath安装 pip install jsonpath jsonpath基本语法? jsonpath...
python嵌套字典读取_python3 如何解析多层嵌套字典，具体内容打开看
weixin_39637723的博客
11-23 381
展开全部# 见 代码 ，代码粘贴上不带格式，按照图片用tab键调整一下，图片是核心部分simple_dict = {'Large_dict' : {'middle_dict1' : {'small_dict1' : 1 ,'small_dict2' : 2},'middle_dict2' : {'small_dict3' : 3 ,'small_dict4' : 4,'small_dict5'...
python字典dict-创建&嵌套&查找&修改&多种遍历
12-21
字典 dict 用的好闪电提速 优点 通过哈希Hash算法，提高搜索能力。因此明显优于for循环 顺序？ 每个键值对存储在hash值，地址里。没有顺序。 因此无法使用下标访问 但是可通过dict_name[key_name]访问对应的value dict操作 操作语法 功能 dict_name = dict(key1 = value1,key2 = value2,...) 创建字典 dict_name[key]=value 往dict添加key-value dict_name[key] 返回key对应的value del dict_name[key] 删除字典中的k
Python的字典/字典多层（2层/3层）嵌套操作
热门推荐
钱多多先森
12-01 3万+
1.一个采用2层嵌套字典dict的项目实操 2.python读取txt格式文件来填写字典 3.关于字典dict的一些常用操作
Python秘诀：xmltodict，处理XML数据的终极利器
涛哥聊Python
11-14 614
xmltodict是一个Python库，用于将XML数据解析为易于处理的Python字典。这个库的主要目的是简化XML数据的解析过程，从而使XML数据的操作更加方便。它可以将XML数据转换为Python字典，这样就可以像操作字典一样轻松访问和修改XML数据。这对于处理从Web服务或文件中获取的XML数据特别有用。以下是使用xmltodict将XML数据解析为Python字典。使用Python字典来访问和处理XML数据。将Python字典转换回XML数据（如果需要）。
python多层嵌套字典（dict）数据查询操作实践
肖永威的专栏
05-21 624
文中代码和主体文字内容是由”文言一心“辅助完成，在此表示感谢AI提高工作效率。 我的三句问话如下，供参考： 问一：dict中，如何判断关键字存不在？ 问二：如果my_dict = {'a': 1, 'b': 2, 'c': {’d‘:66}} ，如何判断关键字’d'是否存在？ 问三：如果是3层，或者，更多层嵌套呢？ 问四：如果要求有级联嵌套顺序的关键字怎么处理？ 问五：如何快速查询嵌套字典中的值？
python 合并多层嵌套字典的方法——递归函数
大海的博客
08-19 1653
本函数只对dict类型的值进行合并，其他类型（str, int, list, tuple等）仅仅进行覆盖。个人认为，这样也符合大多数场景的需求。作者本人是因为要合并深度学习框架的配置文件而写的这个函数，在此场景是不需要合并list，tuple的。此函数利用递归函数，实现了任意层级value问字典的合并功能，相同的键值（非dict）以dict_2优先。在很多场景中，需要用到合并复杂字典的功能，即字典的某些value是字典，此字典的某些value还是字典。输出结果如下，正确。暂未进行更多测试用例测试。...
python 多层嵌套字典读取_python3 如何解析多层嵌套字典，具体内容打开看
weixin_39789370的博客
03-01 2867
# 见 代码 ，代码粘贴上不带格式，按照图片用tab键调整一下，图片是核心部分simple_dict={'Large_dict':{'middle_dict1':{'small_dict1':1,'small_dict2':2},'middle_dict2':{'small_dict3':3,'small_dict4':4,'small_dict5':{'s...
python中，字典列表多层嵌套，递归方式找值
lzanze的专栏
04-19 2312
Li = [1, 2, [11, 22, [111, 222, [1111, 2222, {"x": "xxx", "y": "yyy", "z": [5566, 7788, {"keyA": 888,...
Python装饰器结合递归原理解析
12-17
known = dict() @functools.wraps(fn) def memoizer(*args): if args not in known: print('memorize %s'%args) # known[args] = fn(*args) for k in known.keys(): print('%s : %s'%(k, known[k]), end = '...
Python dict和defaultdict使用实例解析
09-17
主要介绍了Python dict和defaultdict使用实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Python按照list dict key进行排序过程解析
09-17
主要介绍了Python按照list dict key进行排序过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
python DataFrame转dict字典过程详解
09-18
主要介绍了python DataFrame转dict字典过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
如何mysql数据导入到mongdb
codemami的博客
05-30 774
由于MySQL和MongoDB的数据模型不同（例如，MySQL使用关系模型，而MongoDB使用文档模型），你可能需要转换数据的格式。使用MongoDB驱动程序：你也可以使用MongoDB的官方驱动程序（如Python的pymongo）来编写脚本，将数据直接插入到MongoDB中。注意：如果你的JSON文件包含多个文档，并且它们不是作为数组的一部分（即每个文档都在其自己的行上），则需要使用--jsonArray选项。手动转换：对于小型数据集，你可以手动编辑SQL或CSV文件，将其转换为JSON格式。
学 Python 具体能干什么？
猿小白的博客
05-26 1241
Python 是一种功能强大、用途广泛的编程语言，因其简洁易读的语法和丰富的库生态系统而备受欢迎。
在linux服务器上使用tensorboard，错误记录
最新发布
wwwwzm的博客
05-30 481
1. 使用tensorboard命令时，不是从虚拟环境中找tensorboard，而是从（全局路径）中找（/home/ljx/.local/lib/python3.9/site-packages/tensorboard）是一个在 Unix-like 系统（包括 Linux 和 macOS）的命令行界面（如 Bash shell）中使用的命令。2.使用which命令， 查看使用的tensorboard的路径，发现使用的是全局路径，不是虚拟环境路径。是一个特殊的变量，它定义了操作系统搜索可执行文件的目录。
Pandas03
Bianca427的博客
05-27 1227
聚合计算时新增一列计算最大值与平均值的差值df.groupby('district').agg(最低工资=('salary', 'min'), 最高工资=('salary', 'max'), 平均工资=('salary', 'mean'), 最大值与均值差值=('salary', myfunc)).rename_axis(["行政区"])
深入理解Python中None和““的区别
m0_54701273的博客
05-27 788
在Python的世界里，None和空字符串""经常被用作默认值或用于表示缺省值的情况。尽管它们在某些语境下似乎可互换，但实际上None和""在Python中有着根本的区别。
python多层嵌套字典遍历
10-31
Python多层嵌套字典遍历可以使用嵌套的for循环或递归函数来实现。下面是两种方法的示例代码： 方法一：使用嵌套的for循环 ``` dict1 = {'a': {'nn': 'kk', 'pp': 'yy', 'uu': {'b': 'a'}}, 'c': {'b': {'a': {'b': 'c'}}}} for key1 in dict1: if isinstance(dict1[key1], dict): for key2 in dict1[key1]: if isinstance(dict1[key1][key2], dict): for key3 in dict1[key1][key2]: print(key1, key2, key3, dict1[key1][key2][key3]) else: print(key1, key2, dict1[key1][key2]) else: print(key1, dict1[key1]) ``` 方法二：使用递归函数 ``` def traverse_dict(dict_obj): for key in dict_obj: if isinstance(dict_obj[key], dict): traverse_dict(dict_obj[key]) else: print(key, dict_obj[key]) dict1 = {'a': {'nn': 'kk', 'pp': 'yy', 'uu': {'b': 'a'}}, 'c': {'b': {'a': {'b': 'c'}}}} traverse_dict(dict1) ``` 以上两种方法都可以实现多层嵌套字典的遍历，具体使用哪种方法取决于具体情况和个人喜好。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值