总结字典的前两个选择

Question

inventory = {'A':['Toy',3, 1000], 'B':['Toy',8, 1100], 
              'C':['Cloth',15, 1200], 'D':['Cloth',9, 1300], 
               'E':['Toy',11, 1400], 'F':['Cloth', 18, 1500], 'G':['Appliance', 300, 50]}

字母是商品名称，[]括号中的第一个字段是商品的类别，[]括号中的第二个字段是价格，第三个是已售出的数字。

我想获得每个类别中价格最高的前两种商品。 如果每个类别中至少没有两个商品，则将其删除。 所以我应该得到以下结果。

inventorySummary = {'B':['Toy',8, 1100], 'E':['Toy',11, 1400], 
                     'C':['Cloth',15, 1200], 'F':['Cloth', 18, 1500]}

您能帮我些什么代码，以方便实现吗？ 我需要一个不仅可以用于价格最高的两个项目，而且可以用于价格最高的三，四个项目的项目。 我最终将对更大的数据集使用它，因此，如果可以使用更通用的代码会更好。 同样，我很难理解lambda表达式，如果您选择提供带有lambda表达式的代码，能否请您解释一下每个部分的工作方式，以便我能够在任何变化的需求下进行操作。

我只有这些模块可用于我的系统：

对分，cmath，集合，日期时间，functools，heapq，itertools，数学，numpy，pandas，pytz，队列，随机，re，scipy，statsmodels，sklearn，talib，时间，zipline

Answer 1

您可以使用itertools.groupby创建组：

from itertools import groupby

def summarize_inventory(inventory):
    # We use -price so that we are also sorting by descending price
    sort_key = lambda (code, (cat, price, sold)): (cat, -price)
    group_key = lambda (code, (cat, price, sold)): cat

    new_dict = {}
    sorted_inventory = sorted(inventory.iteritems(), key=sort_key)
    for cat, group in groupby(sorted_inventory, key=group_key):
        group = list(group)
        if len(group) > 1:
            for (code, item) in group[:2]:
                new_dict[code] = item
    return new_dict

例

>>> summarize_inventory(inventory)

{'B': ['Toy', 8, 1100],
 'C': ['Cloth', 15, 1200],
 'E': ['Toy', 11, 1400],
 'F': ['Cloth', 18, 1500]}

Answer 2

要以最有效的方式获得任何系列的前N个，请使用heapq模块 。 您必须为每个类别创建一个堆：

from heapq import heapify, heappushpop

def summarize_inventory(inventory, top_n=2):
    categories = {}
    for id, info in inventory.items():
        cat, _, sold = info
        heap = categories.setdefault(cat, [])
        if len(heap) < top_n:
            heap.append((sold, id, info))
            if len(heap) == top_n:
                heapify(heap)
        else:
            heappushpop(heap, (sold, id, info))

    # produce the final summary, only include categories with enough items
    return {id: info 
            for cat, heap in categories.items() if len(heap) == top_n
            for sold, id, info in heap}

第一个循环将堆的大小最大扩展到2，然后对这两个项进行heapq.heappushpop()然后使用heapq.heappushpop()函数将下一个项添加到堆中，并在一步之内删除迄今为止最小的项。

这是一个O（NlogK）解决方案； 对于大小为N（输入字典中键的数量）的输入并要求输入前K个元素，堆队列方法需要N倍log K个步骤才能产生解决方案。

如果要将其与O（NlogN）排序解决方案（按类别和价格排序，然后按类别分组）进行比较，则随着N增加，此解决方案完成的时间会更少。 为了获得给定1000个项目的前两个结果，这需要1.000 * 1 == 1.000的步骤。 排序将采用1.000 * 10 == 10.000的步骤。 对于1.000.000输入，这变成了100万对10亿步等。

对于产生的给定库存：

>>> summarize_inventory(inventory)
{'B': ['Toy', 8, 1100], 'E': ['Toy', 11, 1400], 'D': ['Cloth', 9, 1300], 'F': ['Cloth', 18, 1500]}
>>> from pprint import pprint
>>> pprint(_)
{'B': ['Toy', 8, 1100],
 'D': ['Cloth', 9, 1300],
 'E': ['Toy', 11, 1400],
 'F': ['Cloth', 18, 1500]}

该函数适用于您可能希望产生的任何前N个：

>>> summarize_inventory(inventory, 3)
{'A': ['Toy', 3, 1000], 'C': ['Cloth', 15, 1200], 'B': ['Toy', 8, 1100], 'E': ['Toy', 11, 1400], 'D': ['Cloth', 9, 1300], 'F': ['Cloth', 18, 1500]}
>>> summarize_inventory(inventory, 1)
{'E': ['Toy', 11, 1400], 'G': ['Appliance', 300, 50], 'F': ['Cloth', 18, 1500]}

Answer 3

enrico.bacis在itertools.groupby解决方案上击败了我，但如果有帮助，这是我的版本（我尝试使用FP样式）：

def summarize_inventory(inventory, top_n=2):
    sort_key = lambda (id, (category, price, sold)): (category, price)
    group_key = lambda (id, (category, price, sold)): category

    # items in inventory grouped by their category
    items_by_category = (
        (category, list(items))
        for category, items in itertools.groupby(
            sorted(inventory.iteritems(), key=sort_key),
            group_key
        )
    )

    # the top_n items from each category if there are >= top_n items
    inventory_summary = dict(itertools.chain.from_iterable(
        items[-1 * top_n:]
        for category, items in items_by_category
        if len(items) >= top_n
    ))

    return inventory_summary