Ordinamento basato sulla prima colonna e quindi sulla colonna successiva

Question

Ho un dizionario che deve essere ordinato. Voglio ordinare il dict in base ai valori. E come passo successivo, se due chiavi hanno lo stesso valore, voglio ordinare in base ai valori lessicografici delle chiavi.

Ho provato questo.

>>> l 
{'a': 5, 'aa': 5, 'c': 1, 'b': 7} 
>>> sorted(l) 
['a', 'aa', 'b', 'c'] 
>>> sorted(l.items()) 
[('a', 5), ('aa', 5), ('b', 7), ('c', 1)] 
>>> sorted(l.items(), reverse=True) 
[('c', 1), ('b', 7), ('aa', 5), ('a', 5)] 
>>> sorted(l.items(), key=l.get, reverse=True) 
[('a', 5), ('aa', 5), ('c', 1), ('b', 7)] 
>>> l 
{'a': 5, 'aa': 5, 'c': 1, 'b': 7} 
>>> 5>7 
False 
>>> sorted(l.items(), key=l.get, reverse=True) 
[('a', 5), ('aa', 5), ('c', 1), ('b', 7)] 
>>> sorted(l, key=l.get, reverse=True) 
['b', 'a', 'aa', 'c'] 
>>> s=sorted(l, key=l.get, reverse=True) 
>>> s 
['b', 'a', 'aa', 'c'] 
>>> s.sort() 
>>> s 
['a', 'aa', 'b', 'c'] 

Answer 1

Se ho ben capito la tua domanda, siete alla ricerca di qualcosa di simile:

d = {'a': 5, 'aa': 5, 'c': 1, 'b': 7} 
result = sorted(d.items(), key=lambda x: (x[1], x[0])) 
print(result) 

uscita:

[('c', 1), ('a', 5), ('aa', 5), ('b', 7)] 

---

Se si desidera che i valori siano ordine crescente e la secondo tipo in ordine decrescente, puoi fare qualcosa del genere:

d = {'a': 5, 'aa': 5, 'c': 1, 'b': 7} 
result = sorted(d.items(), reverse=True, key=lambda x: (-x[1], x[0])) 
print(result) 

uscita:

[('c', 1), ('aa', 5), ('a', 5), ('b', 7)] 

Per ulteriori informazioni sull'ordinamento, vedere la Sorting Howtos.

---

Se si dispone di una lista di tuple che contiene solo le stringhe, si può fare qualcosa di simile:

l = [('foo', 'bar'), ('foo', 'spam'), ('baz', 'egg')] 

result = sorted(l, key=lambda x: (x[0], [-ord(c) for c in x[1]])) 
print(result) 

Uscita:

[('baz', 'egg'), ('foo', 'spam'), ('foo', 'bar')] 

Answer 2

ritorno sia il valore e la chiave, in questo ordine:

sorted(l, key=lambda k: (l[k], k)) 

solo per le chiavi, o

sorted(l.items(), key=lambda i: i[::-1]) 

per coppie valore-chiave; la slice del passaggio negativo [::-1] inverte il valore e la chiave per l'ordinamento.

Questo ordina prima il valore, quindi utilizza la chiave se i valori sono uguali.

risultati:

>>> l = {'a': 5, 'aa': 5, 'c': 1, 'b': 7} 
>>> sorted(l, key=lambda k: (l[k], k)) 
['c', 'a', 'aa', 'b'] 
>>> sorted(l.items(), key=lambda i: i[::-1]) 
[('c', 1), ('a', 5), ('aa', 5), ('b', 7)] 

Per una direzione di ordinamento misto, negare valori, e invertire il tipo:

>>> sorted(d.items(), key=lambda i: (-i[1], i[0]), reverse=True) 
[('c', 1), ('aa', 5), ('a', 5), ('b', 7)] 

negazione di numeri li fa essere filtrate in ordine decrescente mentre il i tasti mantengono l'ordine crescente; Inversione quindi scambia quello in ordine ascendente e discendente, rispettivamente.