Question

我有一个清单

category = ['Toy','Cloth','Food','Auto']

我还有一本字典（其中第一个A，B，C ......是项目名称，每个列表中的第一个元素是类别，第二个是价格。

inventory = {'A':['Food', 5], 'B':['Food', 6], 
          'C':['Auto', 5], 'D':['Cloth', 14], 
           'E':['Toy',19], 'F':['Cloth', 13], 'G':['Toy',20], 'H':['Toy',11]}

我希望首先按照列表中类别的顺序排序，然后我希望它们按价格排序（保持类别顺序），这样结果看起来像这样......

inventory_sorted = {'G':['Toy',20],'E':['Toy',19], 'H':['Toy',11], 'D':['Cloth', 14], 
                    'F':['Cloth', 13], 'B':['Food', 6],'A':['Food', 5],'C':['Auto', 5],}

请你给我两个步骤，第一步是按照列表的类别排序，第二步是按价格排序（反向）保留类别排序。如果你正在使用Lambda，请给我一些叙述，以便我能更好地理解。我是Lamda表达的新手。非常感谢你

Answer 1

您无法对Python dict对象进行排序，因为它们未被排序。最多可以生成一个（键值）对的排序序列。如果您想要包含订单的映射，则可以将这些对提供给collections.OrderedDict() object。

将您的category订单转换为映射以获取订单，然后将其与价格一起用于排序键。由于您希望价格按降序顺序排序，因此您需要返回否定价格：

cat_order = {cat: i for i, cat in enumerate(category)}
inventory_sorted = sorted(inventory.items(),
                          key=lambda i: (cat_order[i[1][0]], -i[1][1]))

i参数传递给每个键值对;然后是i[1]值，i[1][0]类别，i[1][1]价格。

这将按指定的顺序生成键值对：

>>> category = ['Toy','Cloth','Food','Auto']
>>> inventory = {'A':['Food', 5], 'B':['Food', 6], 
...           'C':['Auto', 5], 'D':['Cloth', 14], 
...            'E':['Toy',19], 'F':['Cloth', 13], 'G':['Toy',20], 'H':['Toy',11]}
>>> cat_order = {cat: i for i, cat in enumerate(category)}
>>> sorted(inventory.items(), key=lambda i: (cat_order[i[1][0]], -i[1][1]))
[('G', ['Toy', 20]), ('E', ['Toy', 19]), ('H', ['Toy', 11]), ('D', ['Cloth', 14]), ('F', ['Cloth', 13]), ('B', ['Food', 6]), ('A', ['Food', 5]), ('C', ['Auto', 5])]
>>> from pprint import pprint
>>> pprint(_)
[('G', ['Toy', 20]),
 ('E', ['Toy', 19]),
 ('H', ['Toy', 11]),
 ('D', ['Cloth', 14]),
 ('F', ['Cloth', 13]),
 ('B', ['Food', 6]),
 ('A', ['Food', 5]),
 ('C', ['Auto', 5])]

OrderedDict()对象直接接受此序列：

>>> from collections import OrderedDict
>>> OrderedDict(sorted(inventory.items(), key=lambda i: (cat_order[i[1][0]], -i[1][1])))
OrderedDict([('G', ['Toy', 20]), ('E', ['Toy', 19]), ('H', ['Toy', 11]), ('D', ['Cloth', 14]), ('F', ['Cloth', 13]), ('B', ['Food', 6]), ('A', ['Food', 5]), ('C', ['Auto', 5])])

Answer 2

您可以通过以下方式获得此信息：

sorted(inventory.items(), key=lambda t: category.index(t[1][0]))

这是因为：

inventory.items()将你的dict变成了一个元组列表，可以保留一个命令
key功能订单基于t[1][0]列表中category的显示位置和
t将类似于('G', ('Toy', 20))，因此t[1]为('Toy', 20)而t[1][0]为'Toy'。

但是你不能从这里回到标准的dict（即使这很容易），因为你会再次失去你的排序，使得排序毫无意义。因此，您必须使用此格式的数据，或使用已提及的collections.OrderedDict之类的内容。

Answer 3

另一种完全不同的做法，即相当强大，是

使用python类创建数据结构
将数据存储在列表中
使用key = attrgetter（'variable'）

以下是一段示例代码：

class Item:
    def __init__(self,label,category,number):
        self.label = label
        self.category = category
        self.number = number
    def __repr__(self):
        return "Item(%s,%s,%d)"%(self.label,self.category,self.number)
    def __str__(self):
        return "%s: %s,%d"%(self.label,self.category,self.number)

inventory = []
inventory.append(Item("A","Food",5))
inventory.append(Item("B","Food",6))
inventory.append(Item("C","Auto",5))
inventory.append(Item("D","Cloth",14))
inventory.append(Item("E","Toy",19))
inventory.append(Item("F","Cloth",13))
inventory.append(Item("G","Toy",20))
inventory.append(Item("H","Toy",11))

inventory.sort(key=attrgetter('number'),reverse=True)
inventory.sort(key=attrgetter('category'))

这样做的好处是，排序的目的是维护上一次排序，所以调用它两次（如上所述）允许你主要按类别排序，但是按次数排序。您可以根据需要为多个排序键执行此操作。

您还可以在项目中添加您想要的任何其他信息。

Answer 4

categories = ['Toy','Cloth','Food','Auto']

inventory = {'A':['Food', 5], 'B':['Food', 6], 
          'C':['Auto', 5], 'D':['Cloth', 14], 
           'E':['Toy',19], 'F':['Cloth', 13], 'G':['Toy',20], 'H':['Toy',11]}

from collections import OrderedDict

inventory_sorted = OrderedDict()

for category in categories:
    same_category = [(key, num) for key, (cat, num) in inventory.items() if cat == category] 

    for (key, num) in sorted(same_category, key=lambda (_, num): num, reverse=True):
        inventory_sorted[key] = [category, num]

for key, value in inventory_sorted.items():
    print key, value

由于dictionaries无序，我们将使用OrderedDict来实现您的目标。

工作原理：

same_category是一个简单的列表推导，如果它们与当前循环类别属于同一类别，它会过滤项目，它将形成一个由（key，num）对元组组成的列表。

然后我们使用数字对这个新列表进行排序，执行此操作的行是key=lambda (_, num): num，这将解包元组，使用_丢弃密钥，然后按num排序，我们将其反转，因此它首先显示高数字。

然后我们将每个[category, num]对添加到inventory_sorted中的OrderedDict key。

结果：

G ['Toy', 20]
E ['Toy', 19]
H ['Toy', 11]
D ['Cloth', 14]
F ['Cloth', 13]
B ['Food', 6]
A ['Food', 5]
C ['Auto', 5]

python字典按列表排序

4 个答案: