Сортировка на основе первого столбца, а затем следующего столбца

Question

У меня есть словарь, который нужно отсортировать. Я хочу сортировать dict на основе значений. И в качестве следующего шага, если два ключа имеют одинаковое значение, я хочу сортировать на основе лексикографических значений ключей.

Я пробовал это.

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

Если я правильно понял ваш вопрос, вы ищете что-то вроде этого:

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

Выход:

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

---

Если вы хотите, чтобы значения в порядке возрастания быть а второй вид будет в порядке убывания, вы можете сделать что-то подобное:

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

Выход:

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

Для получения дополнительной информации о сортировке см Sorting Howtos.

---

Если у вас есть список кортежей, который содержит только строки, вы можете сделать что-то подобное:

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

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

Выход:

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

Answer 2

Возврат и значение, и ключ, в таком порядке:

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

всего за ключами, или

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

для пар ключ-значение; секция отрицательного шага [::-1] меняет значение и ключ для сортировки.

Этот тип сначала относится к значению, а затем использует ключ, если значения равны.

Результат:

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

Для смешанного направления сортировки, свести на нет значения, и обратный порядок:

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

Отрицание число, заставляет их быть отсортированы в порядке убывания в то время как ключи сохраняют по возрастанию; реверсирование затем свопит к восходящему и нисходящему, соответственно.