logo标签列表

使用嵌套的defaultdict重建数组

pythonarraysdefaultdict
3
这个问题是之前一个问题的延伸：rebuild python array based on common elements - 但是不同之处足以需要一个新问题：
我已经苦苦挣扎了一段时间。我的数据是来自SQL查询的字典数组。数组中的每个元素都代表一批货物，并且基于键有共同的值。
data = [
    {"CustName":"customer1", "PartNum":"part1", "delKey":"0001", "qty":"10", "memo":"blah1"},
    {"CustName":"customer1", "PartNum":"part1", "delKey":"0002", "qty":"10", "memo":"blah2"},
    {"CustName":"customer1", "PartNum":"part1", "delKey":"0003", "qty":"10", "memo":"blah3"},
    {"CustName":"customer2", "PartNum":"part3", "delKey":"0004", "qty":"20", "memo":"blah4"},
    {"CustName":"customer2", "PartNum":"part3", "delKey":"0005", "qty":"20", "memo":"blah5"},
    {"CustName":"customer3", "PartNum":"partXYZ", "delKey":"0006", "qty":"50", "memo":"blah6"},
    {"CustName":"customer3", "PartNum":"partABC", "delKey":"0007", "qty":"100", "memo":"blah7"}]

我想要的输出是按照特定键分组的。
dataOut = [
   {"CustName":"customer1", "Parts":[
        {"PartNum":"part1", "deliveries":[
            {"delKey":"0001", "qty":"10", "memo":"blah1"},
            {"delKey":"0002", "qty":"10", "memo":"blah2"},
            {"delKey":"0003", "qty":"10", "memo":"blah3"}]}]},
   {"CustName":"customer2", "Parts":[
        {"PartNum":"part3", "deliveries":[
            {"delKey":"0004", "qty":"20", "memo":"blah4"},
            {"delKey":"0005", "qty":"20", "memo":"blah5"}]}]},
   {"CustName":"customer3", "Parts":[
        {"PartNum":"partXYZ", "deliveries":[
            {"delKey":"0006", "qty":"50", "memo":"blah6"}]},
        {"PartNum":"partABC", "deliveries":[
            {"delKey":"0007", "qty":"100", "memo":"blah7"}]}]}]

我可以使用defaultdict和列表推导式来获取单层分组，就像上一个问题提供的那样，并稍作修改。

d = defaultdict(list)
for item in data:
    d[item['CustName']].append(item)
print([{'CustName': key, 'parts': value} for key, value in d.items()])

但我无法在输出数组中获得第二层，也就是通过PartNum键进行分组。通过一些研究，我认为我需要将外部`defaultdict'的类型设置为defaultdict，如下所示：

d = defaultdict(defaultdict(list))

由于defaultdict返回一个函数，所以会出现错误，因此我需要使用lambda（是吗？）

d = defaultdict(lambda:defaultdict(list))
for item in data:
    d[item['CustName']].append(item) <----this?

我的问题是如何在循环中“访问”第二级数组并告诉“内部”的defaultdict按照什么分组（PartNum）？ 数据来自数据库程序员，项目不断发展以添加更多数据（键），因此我希望此解决方案尽可能通用，以防更多数据被抛到我的面前。 我希望能够“链接”defaultdicts，具体取决于需要多少级别。 我正在学习过程中，因此正在努力理解lambda和defaultdict类型的基础知识以及从哪里开始。
1
对字典进行排序，然后应用groupby。或者如果可以的话，事先使用SQL完成。我现在无法为您提供更多帮助，因为我正在使用手机... - Pynchia
一个PartNum中是否可以有两个具有相同编号/值的delKey？ - wwii
你的实际data中有多少项？ - wwii
原始数据集中可能有数万条数据。 - guidoc
2
你是否关心输出列表中值的顺序？如果不关心，你可以轻松地摆脱这些级别，并使你的结构成为一个嵌套的字典集合。Tree = lambda: defaultdict(Tree) 就是你需要设置这种结构的全部内容。 - Blckknght
4个回答
2

根据@Pynchia的建议使用groupby，根据@hege_hegedus的建议对无序数据使用sorted：

from itertools import groupby
dataOut = []
dataSorted = sorted(data, key=lambda x: (x["CustName"], x["PartNum"]))
for cust_name, cust_group in groupby(dataSorted, lambda x: x["CustName"]):
    dataOut.append({
        "CustName": cust_name,
        "Parts": [],
    })
    for part_num, part_group in groupby(cust_group, lambda x: x["PartNum"]):
        dataOut[-1]["Parts"].append({
            "PartNum": part_num,
            "deliveries": [{
                "delKey": delivery["delKey"],
                "memo": delivery["memo"],
                "qty": delivery["qty"],
            } for delivery in part_group]
        })

如果您看第二个for循环，这将有助于回答您关于在循环中访问第二层数组的问题。

这种方法对我来说似乎是最好的，以获得所需的输出。我想使用tree方法，但是我无法在树内获取列表。 - guidoc
2
您可以使用基于OrderedDefaultdict的树形数据结构，而不是defaultdict(list)。（该定义来自我另一个无关的答案。）
from collections import OrderedDict

class OrderedDefaultdict(OrderedDict):
    def __init__(self, *args, **kwargs):
        if not args:
            self.default_factory = None
        else:
            if not (args[0] is None or callable(args[0])):
                raise TypeError('first argument must be callable or None')
            self.default_factory = args[0]
            args = args[1:]
        super(OrderedDefaultdict, self).__init__(*args, **kwargs)

    def __missing__ (self, key):
        if self.default_factory is None:
            raise KeyError(key)
        self[key] = default = self.default_factory()
        return default

Tree = lambda: OrderedDefaultdict(Tree)

d = Tree()
for rec in data:
    custName, partNum, delKey = rec['CustName'], rec['PartNum'], rec['delKey']
    details = {"qty": rec["qty"], "memo": rec["memo"]}
    d[custName]['Parts'][partNum]['deliveries'][delKey] = details

因此，对于您问题中显示的data，d将包含以下内容：
d = {
    "customer1": {
        "Parts": {
            "part1": {
                "deliveries": {"0001": {"memo": "blah1", "qty": "10"},
                               "0002": {"memo": "blah2", "qty": "10"},
                               "0003": {"memo": "blah3", "qty": "10"}}}}},
    "customer2": {
        "Parts": {
            "part3": {
                "deliveries": {"0004": {"memo": "blah4", "qty": "20"},
                               "0005": {"memo": "blah5", "qty": "20"}}}}},
    "customer3": {
        "Parts": {
            "partXYZ": {
                "deliveries": {"0006": {"memo": "blah6", "qty": "50"}}},
            "partABC": {
                "deliveries": {"0007": {"memo": "blah7", "qty": "100"}}}}}
}

"这可以很简单地被打印出来，因为它现在按照您想要的方式分组。"
我在想，使用自定义对象是否是正确的方法 - 这样做会更容易实现。谢谢。 - wwii
请注意，正如@Blckknght所说，如果您不需要保留data中项目的顺序，则不需要定义OrderedDefaultdict，而可以使用Tree = lambda：defaultdict（Tree）。如果有许多项目要处理，使用任一基于字典的数据结构都可能比使用基于列表的数据结构更快。 - martineau
这非常接近我所需的，但是在每个级别上都有一个dict会使进一步迭代变得棘手。对我来说，逻辑上应该是Parts：[...]，而不是Parts：{...}，因为每个客户都有一组零件。整个数据混乱的情况都传递给了Angular前端 - 它期望一个数组。 - guidoc
可能会有些笨拙，但是您可以通过编写 __missing__() 方法检查key的值，并在其为 'Parts' 时返回一个空的list，而不是调用 self.default_factory()。更好的实现至少需要将特殊键抽象化而不是硬编码它。本质上，您将定义哪个键指示要求树“叶子”而不是“分支”或节点。 - martineau
0

这是我能想到的最漂亮的方法。它使用相同的defaultdict思想来实现适当的分组，因为Python内置的groupby函数仅适用于有序数据。

请注意，此版本将改变输入数据集中的项目，因此结果中的叶子项与输入中的相同字典实例相同，但已删除"CustName"和"PartNum"条目。

from collections import defaultdict

def groupby_mutate(seq, key):
  d = defaultdict(list)
  for item in seq:
    d[item[key]].append(item)
    del item[key]
  return d

def your_operation(data):
  return [ {
    'CustName': CustName,
    'Parts': [ { 
      'PartNum': PartNum,
      'deliveries': deliveries
    } for PartNum,deliveries in groupby_mutate(custItems, 'PartNum').items() ]
  } for CustName,custItems in groupby_mutate(data, 'CustName').items() ]


# try it
from pprint import *
data = [
    {"CustName":"customer1", "PartNum":"part1", "delKey":"0001", "qty":"10", "memo":"blah1"},
    {"CustName":"customer1", "PartNum":"part1", "delKey":"0002", "qty":"10", "memo":"blah2"},
    {"CustName":"customer1", "PartNum":"part1", "delKey":"0003", "qty":"10", "memo":"blah3"},
    {"CustName":"customer2", "PartNum":"part3", "delKey":"0004", "qty":"20", "memo":"blah4"},
    {"CustName":"customer2", "PartNum":"part3", "delKey":"0005", "qty":"20", "memo":"blah5"},
    {"CustName":"customer3", "PartNum":"partXYZ", "delKey":"0006", "qty":"50", "memo":"blah6"},
    {"CustName":"customer3", "PartNum":"partABC", "delKey":"0007", "qty":"100", "memo":"blah7"}
]

pprint(your_operation(data))

编辑：

以防将来有人需要，这里提供一个不会改变原始数据的版本：

from collections import defaultdict

def groupby_getitem(seq, key):
  d = defaultdict(list)
  for item in seq:
    d[item[key]].append(item)
  return d

def your_operation(data):
  return [ {
    'CustName': CustName,
    'Parts': [ { 
      'PartNum': PartNum,
      'deliveries': [ dict(
        (k,v) for k,v in delivery.items() if not k in ['CustName', 'PartNum']
      ) for delivery in deliveries ]
    } for PartNum,deliveries in groupby_getitem(custItems, 'PartNum').items() ]
  } for CustName,custItems in groupby_getitem(data, 'CustName').items() ]
改变原始数据会有后果吗？函数groupby_mutate通过副作用来完成其任务吗？ - wwii
是的，groupby_mutate函数并不真正可重用，它是专门设计用于适应此情况，我很怀疑它能够在其他地方使用。 - Tamas Hegedus
@wwii：它是否具有后果取决于上下文。对于直接来自服务的数据，如果原始数据实例未被软件的另一个组件使用，则应该没问题。 - Tamas Hegedus
我不想突变数据。我必须添加一些测试来验证数据没有被破坏。 - guidoc
0

按照 "CustName", "PartNum", "delKey" 进行排序。对于每个零件，每个客户的交付项目进行迭代，并累加以匹配您的输出规范。

我喜欢使用 operator.itemgetter - 对我来说这使事情更清晰。

import collections, itertools, operator

cust_name = operator.itemgetter('CustName')
part_num = operator.itemgetter('PartNum')
group_sort = operator.itemgetter('CustName', 'PartNum', 'delKey')
del_key = operator.itemgetter('delKey')
qty = operator.itemgetter('qty')
memo = operator.itemgetter('memo')


# sort on the relavent keys
data.sort(key = group_sort)
result = []

# iterate over customers
for custname, group1 in itertools.groupby(data, cust_name):
    cust_dict = {'CustName' : custname, 'Parts': []}
    # iterate over parts for this customer
    for partnum, group2 in itertools.groupby(group1, part_num):
        part_dict = {"PartNum" : partnum, 'deliveries' : []}
        # iterate over delivery items for this part
        for thing in group2:
            part_dict['deliveries'].append({'delKey':del_key(thing),
                                            'qty':qty(thing),
                                            'memo':memo(thing)})
        cust_dict['Parts'].append(part_dict)
    result.append(cust_dict)

这显然会多次迭代原始数据，可能会影响性能——但我看不到在你需要做的事情上避免多次迭代的方法。

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接