2

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

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 库。

4

2 回答 2

3

代码.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()

备注：

  • 正如所料，使用了递归
  • 一般而言，它也适用于我在第二条评论中提到的情况（对于一个输入 dict 具有多个键，其值由具有多个元素的列表组成），可以通过对“d "键入all_objs。此外，理论上它应该支持任何深度
  • flatten_dict：接受输入字典并输出字典列表（因为输入字典可能会产生多个输出字典）：
    • 每个具有“简单”（非列表）值的键，都进入输出字典（y/ies）不变
    • 至此，一个基本的输出字典就完成了（如果输入字典会生成多个输出字典，那么所有字典都会有基本字典的键/值，如果只生成一个输出字典，那就是基本字典）
    • 接下来，处理具有“有问题”值的键——可能生成的不仅仅是输出字典——（如果有的话）：
      • 具有单个元素的列表（“有问题”）的键 - 每个都可能生成多个输出字典：
        • 每个值都将被展平（可能会产生多个输出字典）；过程中会用到对应的key
        • 然后，将在所有展平的字典列表上计算笛卡尔积（对于当前输入，将只有一个包含一个元素的列表）
        • 现在，每个产品项都需要位于不同的输出字典中，因此基础字典被复制并使用产品项中每个元素的键/值进行更新（对于当前输入，每个产品项将只有一个元素）
        • 新字典附加到列表中
      • 此时基本字典列表（可能只有一个）是完整的，如果不存在由具有多个元素的列表组成的值，则这是返回列表，否则必须为每个 基本字典完成以下所有操作列表
      • 具有包含更多元素的列表的键（“非常有问题”） - 每个都会​​生成多个输出字典：
        • 首先，将针对所有值（具有多个元素的列表）计算笛卡尔积。在当前情况下，由于它只是一个这样的列表，因此每个产品项将仅包含该列表中的一个元素
        • 然后，对于每个产品项元素，需要根据列表顺序建立它的键（对于当前输入，产品项将只包含一个元素，并且也将只有一个键）
        • 同样，每个产品项都需要位于不同的输出字典中，因此基本字典被复制并使用展平产品项的键/值进行更新
      • 新字典附加到输出字典列表
  • 适用于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：

  • 使它更通用（虽然它对当前输入不可见）：仅包含一个元素的值可以产生比输出字典更多的值（当展平时），解决了这种情况（在我只考虑第一个输出字典之前，只是忽略了其余的)
  • 更正了与笛卡尔积相结合的元组拆包被掩盖的逻辑错误：if not complex_items ...part

@EDIT1：

  • 修改代码以匹配需求更改：展平字典中的键必须具有输入字典中的完整嵌套路径
于 2017-09-21T19:03:06.887 回答
0

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

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 )

请让我知道这对你有没有用。

于 2017-09-21T12:49:53.780 回答