Question

如果我的嵌套对象是字典，那会更简单，但这些是字典列表。例如：

all_objs1 = [{
    'a': 1,
    'b': [{'ba': 2, 'bb': 3}, {'ba': 21, 'bb': 31}],
    'c': 4
}, {
    'a': 11,
    'b': [{'ba': 22, 'bb': 33, 'bc': [{'h': 1, 'e': 2}]}],
    'c': 44
}]

我希望以下列格式输出：

[
  {'a': 1, 'b.ba': 2, 'b.bb': 3, 'c': 4},
  {'a': 1, 'b.ba': 21, 'b.bb': 31, 'c': 4},
  {'a': 11, 'b.ba': 22, 'b.bb': 33, 'bc.h': 1, 'bc.e': 2, 'c': 44},
]

基本上，生成的展平对象的数量将等于（obj * depth）

使用我当前的代码：

def flatten(obj, flattened_obj, last_key=''):
  for k,v in obj.iteritems():
    if not isinstance(v, list):
      flattened_obj.update({last_key+k : v})
    else:
      last_key += k + '.'
      for nest_obj in v:
        flatten(nest_obj, flattened_obj, last_key)
        last_key = remove_last_key(last_key)

def remove_last_key(key_path):
    second_dot = key_path[:-1].rfind('.')
    if second_dot > 0:
      return key_path[:second_dot+1]
    return key_path

输出：

[
  {'a': 1, 'b.bb': 31, 'c': 4, 'b.ba': 21},
  {'a': 11, 'b.bc.e': 2, 'c': 44, 'b.bc.h': 1, 'b.bb': 33, 'b.ba': 22}
]

我能够展平对象（虽然不准确），但我无法在每个嵌套对象上创建新对象。我不能使用pandas库，因为我的应用程序部署在app引擎上。

Answer 1

code.py ：

from itertools import product
from pprint import pprint as pp


all_objs = [{
    "a": 1,
    "b": [{"ba": 2, "bb": 3}, {"ba": 21, "bb": 31}],
    "c": 4,
    #"d": [{"da": 2}, {"da": 5}],
}, {
    "a": 11,
    "b": [{"ba": 22, "bb": 33, "bc": [{"h": 1, "e": 2}]}],
    "c": 44,
}]


def flatten_dict(obj, parent_key=None):
    base_dict = dict()
    complex_items = list()
    very_complex_items = list()
    for key, val in obj.items():
        new_key = ".".join((parent_key, key)) if parent_key is not None else key
        if isinstance(val, list):
            if len(val) > 1:
                very_complex_items.append((key, val))
            else:
                complex_items.append((key, val))
        else:
            base_dict[new_key] = val
    if not complex_items and not very_complex_items:
        return [base_dict]
    base_dicts = list()
    partial_dicts = list()
    for key, val in complex_items:
        partial_dicts.append(flatten_dict(val[0], parent_key=new_key))
    for product_tuple in product(*tuple(partial_dicts)):
        new_base_dict = base_dict.copy()
        for new_dict in product_tuple:
            new_base_dict.update(new_dict)
        base_dicts.append(new_base_dict)
    if not very_complex_items:
        return base_dicts
    ret = list()
    very_complex_keys = [item[0] for item in very_complex_items]
    very_complex_vals = tuple([item[1] for item in very_complex_items])
    for product_tuple in product(*very_complex_vals):
        for base_dict in base_dicts:
            new_dict = base_dict.copy()
            new_items = zip(very_complex_keys, product_tuple)
            for key, val in new_items:
                new_key = ".".join((parent_key, key)) if parent_key is not None else key
                new_dict.update(flatten_dict(val, parent_key=new_key)[0])
            ret.append(new_dict)
    return ret


def main():
    flatten = list()
    for obj in all_objs:
        flatten.extend(flatten_dict(obj))
    pp(flatten)


if __name__ == "__main__":
    main()

备注：

正如所料，使用递归

一般情况下，它也适用于我在2 ^nd评论中提到的情况（对于一个输入字典，其中包含多个键，其值包含更多列表可以通过在 all_objs 中逐步退出 ＆＃34; <＆＃34; 键来测试。另外，理论上它应该支持任何深度

flatten_dict ：获取输入字典并输出字典列表（因为输入字典可能会产生多个输出字典）：

每个键都有一个＆＃34;简单＆＃34; （不是列表）值，进入输出字典（y / ies）不变

此时， base 输出字典已完成（如果输入字典将生成多个输出字典，则所有字体都将具有 base 字典键/值，如果它只生成一个输出字典，然后是 base one）

接下来，键有＆＃34;有问题＆＃34;值 - 可能生成超过输出字典 - （如果有）处理：

具有包含单个元素的列表的键（＆＃34;有问题＆＃34;） - 每个可能生成多个输出字典：

每个值都将被展平（可能会产生多个输出字典）;相应的密钥将在流程中使用

然后，将在所有扁平字典列表上计算笛卡尔积（对于当前输入，只有一个列表包含一个元素）

现在，每个产品项都需要在不同输出字典中，因此 base 字典会被复制并使用每个<的键/值进行更新/ strong>产品项目中的元素（对于当前输入，每个产品项目只有一个元素）

新词典附加到列表

此时 base 词典列表（可能只有一个）已完成，如果没有包含多个元素的列表的值，则返回列表，否则以下所有内容必须为列表
中的每个基础字典完成
包含更多元素的列表的键（＆＃34;非常有问题＆＃34;） - 每个将生成多个输出词典：

首先，将根据所有值（具有多个元素的列表）计算笛卡尔积。在目前的情况下，因为它只有一个这样的列表，每个产品项目只包含该列表中的元素

然后，对于每个产品项元素，需要根据列表顺序建立其密钥（对于当前输入，产品项目只包含一个元素，并且只有一个密钥）

同样，每个产品项都需要位于不同输出字典中，因此 base 字典会被展平产品项的键/值复制和更新

新词典附加到输出词典列表

使用 Python 3 和 Python 2

可能会很慢（特别是对于大输入对象），因为性能不是目标。此外，由于它是自下而上构建的（在处理新案例时添加功能），它非常扭曲（RO： intortocheated :)），可能有一个我错过的更简单的实现。

<强>输出：

c:\Work\Dev\StackOverflow\q046341856>c:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe code.py [{'a': 1, 'b.ba': 2, 'b.bb': 3, 'c': 4}, {'a': 1, 'b.ba': 21, 'b.bb': 31, 'c': 4}, {'a': 11, 'b.ba': 22, 'b.bb': 33, 'b.bc.e': 2, 'b.bc.h': 1, 'c': 44}]

<强> @ EDIT0 ：

使它更通用（虽然它对当前输入不可见）：只包含一个元素的值可以产生比输出字典更多（当展平时），解决了这种情况（在我只考虑1 <之前） sup> st 输出字典，只是忽略其余的）

更正了一个逻辑错误，该错误被屏蔽了元组拆包并结合了笛卡尔积：if not complex_items ... part

<强> @ EDIT1 ：

修改代码以匹配需求更改：展平字典中的键必须在输入字典中具有完整嵌套路径

Answer 2

使用此代码获取所需的输出。它基于递归调用生成输出。

import json
from copy import deepcopy
def flatten(final_list, all_obj, temp_dct, last_key):


    for dct in all_obj:
        deep_temp_dct = deepcopy(temp_dct)
        for k, v in dct.items():
            if isinstance(v, list):
                final_list, deep_temp_dct = flatten(final_list, v, deep_temp_dct, k)
            else:
                prefix = ""
                if last_key : prefix = last_key + "."
                key = prefix+ k
                deep_temp_dct[key] = v
        if deep_temp_dct not in final_list:
            final_list.append(deep_temp_dct)

    return final_list, deep_temp_dct

final_list, _ = flatten([], all_objs1, {}, "")
print json.dumps(final_list, indent =4 )

让我知道它是否适合你。

将嵌套对象的列表归一化/展平为点分隔的键值对

2 个答案: