Сортировка сложного словаря Python только по одному из его значений

мне проще использовать лямбда-выражения чем помнить, различные operator функции.

предполагая, на данный момент, что ваша оценка eval является 3-м элементом вашего кортежа значения (т. е. (post, number, eval, types, over):

MyDiccoSorted = sorted(MyDicco.items(), key=lamba x:x[1][2])

кроме того, вы можете создать именованную функцию для выполнения задания:

def myKey(x): return x[1][2]
MyDiccoSorted = sorted(MyDicco.items(), key=myKey)

вы можете использовать лямбда-выражение вместо operator.itemgetter(), чтобы получить точный элемент для сортировки. Предполагая, что ваш eval является первым пунктом в кортеж values, в противном случае используйте индекс точного элемента, который вы хотите в x[1][0] .Пример -

MyDiccoSorted = sorted(MyDicco.items(), key=lambda x: x[1][0])

как это работает -

A dict.items() возвращает что-то похожее на список кортежей (хотя и не совсем то, что в Python 3.х) пример -

>>> d = {1:2,3:4}
>>> d.items()
dict_items([(1, 2), (3, 4)])

теперь,, в key аргумент принимает объект функции (который может быть лямбда, или operator.itemgetter() который также возвращает функцию или любую простую функцию), функцию, которую вы передаете в key следует принять один аргумент, который будет элементом сортируемого списка.

то key функция вызывается с каждым элементом,и вы должны вернуть правильное значение для сортировки списка. Пример поможет вам понять это -

>>> def foo(x):
...     print('x =',x)
...     return x[1]
...
>>> sorted(d.items(),key=foo)
x = (1, 2)
x = (3, 4)
[(1, 2), (3, 4)]

это то, что вам нужно?

sorted(MyDicco.items(), key=lambda x: x[1][0])

index_of_evaluation_score = 0
MyDiccoSorted = sorted(MyDicco.items(), key=lambda key_value: key_value[1][index_of_evaluation_score])

поставив свою оценку в конце, где вы хотели, вы можете использовать следующее:

MyDicco = {
    (0, 0, 1, 1): (75, 2, 2, 0, 22),
    (0, 0, 0, 3): (75, 3, 1, 0, 31),
    (0, 0, 2, 0): (100, 2, 1, 25, 2521),
    (0, 1, 0, 0): (200, 1, 1, 125, 12511),
    (1, 0, 0, 0): (350, 1, 1, 275, 27511)} 

MyDiccoSorted = sorted(MyDicco.items(), key=lambda x: x[1][4])

print MyDiccoSorted

даем:

[((0, 0, 1, 1), (75, 2, 2, 0, 22)), ((0, 0, 0, 3), (75, 3, 1, 0, 31)), ((0, 0, 2, 0), (100, 2, 1, 25, 2521)), ((0, 1, 0, 0), (200, 1, 1, 125, 12511)), ((1, 0, 0, 0), (350, 1, 1, 275, 27511))]

Я думаю, одна из вещей, которые вы могли бы искать стабильный сорт.

функции сортировки в Python обычно являются "стабильными" сортами. Например, если вы сортируете:

 1 4 6
 2 8 1
 1 2 3
 2 1 8

по его первой колонке вы получите:

 1 4 6
 1 2 3
 2 8 1
 2 1 8

порядок строк с одинаковым значением в столбце 1 не изменяется. 1 4 6 сортируется перед 1 2 3 потому что это был исходный порядок этих строк перед сортировкой столбца 1. Сортировка была "стабильной" с версии 2.2 Питон. Подробнее здесь.

на другой ноте меня интересует, сколько вам пришлось объяснить свой код. Это признак того, что код выиграет от рефакторинга, чтобы сделать его цель более ясной.

именованные кортежи могут использоваться для удаления трудночитаемых индексов кортежей, которые вы видите во многих ответах здесь, например key=lambda x: x[1][0]-- что это значит? Что он делает?

вот версия с использованием именованных кортежей, которая помогает читателям (самое главное, вам!) понять, что ваш код пытается сделать. Обратите внимание, как лямбда теперь объясняет себя намного лучше.

from collections import namedtuple

StampMix = namedtuple('StampMix', ['c350', 'c200', 'c50', 'c25'])
Stats = namedtuple('Stats', ['score', 'postage', 'stamps', 'types', 'overpayment'])

data = {
    (0, 0, 1, 1): (22, 75, 2, 2, 0),
    (0, 0, 0, 3): (31, 75, 3, 1, 0),
    (0, 0, 2, 0): (2521, 100, 2, 1, 25),
    (0, 1, 0, 0): (12511, 200, 1, 1, 125),
    (1, 0, 0, 0): (27511, 350, 1, 1, 275)
}

candidates = {}
for stampmix, stats in data.items():
    candidates[StampMix(*stampmix)] = Stats(*stats)

print(sorted(candidates.items(), key=lambda candidate: candidate[1].score))

вы можете увидеть преимущества этого подхода в выходной:

>>> python namedtuple.py
(prettied-up output follows...)
[
    (StampMix(c350=0, c200=0, c50=1, c25=1), Stats(score=22, postage=75, stamps=2, types=2, overpayment=0)),
    (StampMix(c350=0, c200=0, c50=0, c25=3), Stats(score=31, postage=75, stamps=3, types=1, overpayment=0)),
    (StampMix(c350=0, c200=0, c50=2, c25=0), Stats(score=2521, postage=100, stamps=2, types=1, overpayment=25)),
    (StampMix(c350=0, c200=1, c50=0, c25=0), Stats(score=12511, postage=200, stamps=1, types=1, overpayment=125)),
    (StampMix(c350=1, c200=0, c50=0, c25=0), Stats(score=27511, postage=350, stamps=1, types=1, overpayment=275))
]

и он поможет с вашими алгоритмами. Например:

def score(stats):
    return stats.postage * stats.stamps * stats.types + 1000 * stats.overpayment