Python 2.5字典2密钥排序

I have a dictionary of 200,000 items (the keys are strings and the values are integers).

我有一个包含200,000个条目的字典(键是字符串，值是整数)。

What is the best/most pythonic way to print the items sorted by descending value then ascending key (i.e. a 2 key sort)?

按降序值和升序键(即2个键)排序的项的最佳/最python方式是什么?

 a={ 'keyC':1, 'keyB':2, 'keyA':1 }
b = a.items()
b.sort( key=lambda a:a[0])
b.sort( key=lambda a:a[1], reverse=True )
print b
>>>[('keyB', 2), ('keyA', 1), ('keyC', 1)]

6 个解决方案

#1

You can't sort dictionaries. You have to sort the list of items.

你不能排序字典。你必须对项目列表进行排序。

Previous versions were wrong. When you have a numeric value, it's easy to sort in reverse order. These will do that. But this isn't general. This only works because the value is numeric.

以前的版本是错误的。当你有一个数值时，很容易按顺序排序。这些将这样做。但这不是一般的。这仅仅是因为值是数值。

a = { 'key':1, 'another':2, 'key2':1 }

b= a.items()
b.sort( key=lambda a:(-a[1],a[0]) )
print b

Here's an alternative, using an explicit function instead of a lambda and the cmp instead of the key option.

这里有一个替代方法，使用显式函数而不是lambda函数，使用cmp而不是key选项。

def valueKeyCmp( a, b ):
    return cmp( (-a[1], a[0]), (-b[1], b[0] ) )

b.sort( cmp= valueKeyCmp )
print b

The more general solution is actually two separate sorts

更一般的解实际上是两个不同的排序。

b.sort( key=lambda a:a[1], reverse=True )
b.sort( key=lambda a:a[0] )
print b

#2

data = { 'keyC':1, 'keyB':2, 'keyA':1 }

for key, value in sorted(data.items(), key=lambda x: (-1*x[1], x[0])):
    print key, value

#3

The most pythonic way to do it would be to know a little more about the actual data -- specifically, the maximum value you can have -- and then do it like this:

最复杂的方法是多了解一些实际数据，特别是你能得到的最大值，然后这样做:

def sortkey((k, v)): 
    return (maxval - v, k)

items = thedict.items()
items.sort(key=sortkey)

but unless you already know the maximum value, searching for the maximum value means looping through the dict an extra time (with max(thedict.itervalues())), which may be expensive. Alternatively, a keyfunc version of S.Lott's solution:

但是，除非您已经知道最大值，否则搜索最大值就意味着要花额外的时间(使用max(thedict.itervalues()))，这可能很昂贵。或者，一个keyfunc版本的S。洛特的解决办法:

def sortkey((k, v)): 
    return (-v, k)

items = thedict.items()
items.sort(key=sortkey)

An alternative that doesn't care about the types would be a comparison function:

另一种不关心类型的方法是比较函数:

def sortcmp((ak, av), (bk, bv)):
    # compare values 'in reverse'  
    r = cmp(bv, av)
    if not r:
        # and then keys normally
        r = cmp(ak, bk)
    return r

items = thedict.items()
items.sort(cmp=sortcmp)

and this solution actually works for any type of key and value that you want to mix ascending and descending sorting with in the same key. If you value brevity you can write sortcmp as:

这个解决方案实际上适用于任何类型的键和值你想在同一个键中混合升序和降序排序。如果您重视简洁性，可以将sortcmp写成:

def sortcmp((ak, av), (bk, bv)):
    return cmp((bk, av), (ak, bv))

#4

You can use something like this:

你可以这样使用:

dic = {'aaa':1, 'aab':3, 'aaf':3, 'aac':2, 'aad':2, 'aae':4}

def sort_compare(a, b):
    c = cmp(dic[b], dic[a])
    if c != 0:
        return c
    return cmp(a, b)

for k in sorted(dic.keys(), cmp=sort_compare):
    print k, dic[k]

Don't know how pythonic it is however :)

不知道巨蟒皮是怎么回事

#5

Building on Thomas Wouters and Ricardo Reyes solutions:

基于Thomas Wouters和Ricardo Reyes解决方案:

def combine(*cmps):
    """Sequence comparisons."""
    def comparator(a, b):
        for cmp in cmps:
            result = cmp(a, b):
            if result:
                return result
        return 0
    return comparator

def reverse(cmp):
    """Invert a comparison."""
    def comparator(a, b):
        return cmp(b, a)
    return comparator

def compare_nth(cmp, n):
    """Compare the n'th item from two sequences."""
    def comparator(a, b):
        return cmp(a[n], b[n])
    return comparator

rev_val_key_cmp = combine(
        # compare values, decreasing
        reverse(compare_nth(1, cmp)),

        # compare keys, increasing
        compare_nth(0, cmp)
    )

data = { 'keyC':1, 'keyB':2, 'keyA':1 }

for key, value in sorted(data.items(), cmp=rev_val_key_cmp):
    print key, value

#6

>>> keys = sorted(a, key=lambda k: (-a[k], k))

或

>>> keys = sorted(a)
>>> keys.sort(key=a.get, reverse=True)

then

然后

print [(key, a[key]) for key in keys]
[('keyB', 2), ('keyA', 1), ('keyC', 1)]

#1