Python 2.5 dictionnaire 2 clés de tri

J'ai un dictionnaire de 200 000 documents (les clés sont des chaînes de caractères et les valeurs sont des nombres entiers).

Quel est le meilleur/le plus pythonic façon d'imprimer les éléments triés par ordre décroissant puis croissant de la clé (c'est à dire un 2 clé de tri)?

 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)]

Voir ma réponse à une question connexe here.

OriginalL'auteur | 2008-10-01

python

17

Vous ne pouvez pas trier les dictionnaires. Vous devez trier la liste des éléments.

Versions précédentes ont été mauvais. Lorsque vous avez une valeur numérique, il est facile de les trier dans l'ordre inverse. Ces va le faire. Mais ce n'est pas général. Cela ne fonctionne que parce que la valeur est numérique.
```
a = { 'key':1, 'another':2, 'key2':1 }

b= a.items()
b.sort( key=lambda a:(-a[1],a[0]) )
print b
```
Voici une autre, à l'aide d'une fonction explicite au lieu d'un lambda et le cpm au lieu de la touche option.
```
def valueKeyCmp( a, b ):
    return cmp( (-a[1], a[0]), (-b[1], b[0] ) )

b.sort( cmp= valueKeyCmp )
print b
```
La plus générale de la solution est en fait deux sortes
```
b.sort( key=lambda a:a[1], reverse=True )
b.sort( key=lambda a:a[0] )
print b
```
Je vous remercie, mais ce n'est pas l'adresse de l'ordre de tri ou la touche 2 nature de la sorte.
Yep. Compris. Désolé. Republié avec des corrections.
Le troisième exemple n'est pas un 2 clés de tri, le deuxième type annule la première
Reyes: le python, le tri est un tri stable. Lors du tri d'abord sur la moindre clés, le résultat final est atteint.
Reyes: docs.python.org/lib/typesseq-mutable.html

OriginalL'auteur S.Lott

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

C'est le plus pythonic solution, à mon avis et le plus facile à comprendre.
Il trie par valeur, pas de clé.

OriginalL'auteur Ricardo Reyes

1

Les plus pythonic façon de le faire serait d'en savoir un peu plus sur les données réelles, plus précisément, la valeur maximale que vous pouvez avoir, et ensuite de faire comme ceci:
```
def sortkey((k, v)): 
    return (maxval - v, k)

items = thedict.items()
items.sort(key=sortkey)
```
mais, sauf si vous connaissez déjà la valeur maximale, la recherche de la valeur maximale des moyens boucle par le dict un temps supplémentaire (avec max(thedict.itervalues())), ce qui peut être coûteux. Sinon, un keyfunc version de S. Lott solution:
```
def sortkey((k, v)): 
    return (-v, k)

items = thedict.items()
items.sort(key=sortkey)
```
Une alternative qui ne se soucient pas des types serait une fonction de comparaison:
```
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) 
```
et cette solution fonctionne pour n'importe quel type de clé et de la valeur que vous voulez mélanger ascendant et descendant de tri avec la même clé. Si vous la valeur de concision, vous pouvez écrire sortcmp:
```
def sortcmp((ak, av), (bk, bv)):
    return cmp((bk, av), (ak, bv))
```
Sachant que la valeur maximale est inutile; utiliser n'importe quelle valeur max valeur. 0 vient à l'esprit instantanément, comme S. Lott a suggéré. 😉

OriginalL'auteur Thomas Wouters

Vous pouvez utiliser quelque chose comme ceci:

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]

Ne sais pas comment pythonic il est cependant 🙂

OriginalL'auteur rslite

Bâtiment sur Thomas Wouters et Ricardo Reyes solutions:

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

OriginalL'auteur Markus Jarderot

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

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

puis

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

OriginalL'auteur A. Coady

Vous devez vous connecter pour publier un commentaire.