Как в Python сохранить группировку при сортировке по одному значению, а затем по другому?

Я бы просто заполнил словарь максимумом для каждой группы, а затем отсортил бы максимум группы, а затем индивидуальный балл. Нравится:

data = [
  (5 , 0.85, "Europe"),
  (8 , 0.77, "Australia"),
  (12, 0.70, "S.America"),
  (13, 0.71, "Australia"),
  (42, 0.82, "Europe"),
  (45, 0.90, "Asia"),
  (65, 0.91, "Asia"),
  (73, 0.72, "S.America"),
  (77, 0.84, "Asia")
]

maximums_by_group = dict()

for indx, score, group in data:
    if group not in maximums_by_group or maximums_by_group[group] < score:
        maximums_by_group[group] = score

data.sort(key=lambda e: (maximums_by_group[e[2]], e[1]), reverse=True)

for indx, score, group in data:
    print indx, score, group

Это дает ожидаемый результат

65 0.91 Asia
77 0.84 Asia
45 0.73 Asia
12 0.87 S.America
73 0.72 S.America
5 0.85 Europe
42 0.82 Europe
8 0.83 Australia
13 0.71 Australia

Я думаю, что есть лучший способ итерации, чем то, что у меня здесь, но это работает:

from operator import itemgetter

dataset = [
    { 'idx': 5, 'score': 0.85, 'group': 'Europe' },
    { 'idx': 8, 'score': 0.77, 'group': 'Australia' },
    { 'idx': 12, 'score': 0.70, 'group': 'S.America' },
    { 'idx': 13, 'score': 0.71, 'group': 'Australia' },
    { 'idx': 42, 'score': 0.82, 'group': 'Europe' },
    { 'idx': 45, 'score': 0.90, 'group': 'Asia' },
    { 'idx': 65, 'score': 0.91, 'group': 'Asia' },
    { 'idx': 73, 'score': 0.72, 'group': 'S.America' }
]

score_sorted = sorted(dataset, key=itemgetter('score'), reverse=True)

group_score_sorted = []
groups_completed = []
for score in score_sorted:
    group_name = score['group']
    if not group_name in groups_completed:
        groups_completed.append(group_name)

        for group in score_sorted:
            if group['group'] = group_name:
                group_score_sorted.append(group)

#group_score_sorted now contains sorted list

Я думаю, что самый простой способ - сначала разделить по группам, а затем выполнить сортировку в два этапа (первая сортировка по максимальному количеству группы, вторая сортировка по оценке внутри группы).

data = [[ 5, 0.85, "Europe"],
        [ 8, 0.77, "Australia"],
        [12, 0.70, "S.America"],
        [13, 0.71, "Australia"],
        [42, 0.82, "Europe"],
        [45, 0.90, "Asia"],
        [65, 0.91, "Asia"],
        [73, 0.72, "S.America"],
        [77, 0.84, "Asia"]]

groups = {}
for idx, score, group in data:
    try:
        groups[group].append((idx, score, group))
    except KeyError:
        groups[group] = [(idx, score, group)]

for group in sorted((group for group in groups.keys()),
                    key = lambda g : -max(x[1] for x in groups[g])):
    for idx, score, group in sorted(groups[group], key = lambda g : -g[1]):
        print idx, score, group

Конечный результат

65 0.91 Asia
45 0.9  Asia
77 0.84 Asia
 5 0.85 Europe
42 0.82 Europe
 8 0.77 Australia
13 0.71 Australia
73 0.72 S.America
12 0.7  S.America

это отличается от того, что вы предоставили, но для результатов в вашем вопросе я думаю, что у вас есть опечатка, потому что оценка 0.87 для S.America отсутствует во входных данных.

Самый простой способ сделать это - выгрузить данные в список, потому что словари Python не отсортированы. Затем используйте собственный алгоритм timsort в Python, который сохраняет прогоны или группировки во время сортировки.

Итак, ваш код будет примерно таким:

data = [[ 5, 0.85, "Europe"],
        [ 8, 0.77, "Australia"],
        [12, 0.70, "S.America"],
        [13, 0.71, "Australia"],
        [42, 0.82, "Europe"],
        [45, 0.90, "Asia"],
        [65, 0.91, "Asia"],
        [73, 0.72, "S.America"],
        [77, 0.84, "Asia"]]

data.sort(key=lambda x: x[1], reverse=True)
data.sort(key=lambda x: x[2].upper())

Это произведет:

[65, 0.91, 'Asia']
[45, 0.90, 'Asia']
[77, 0.84, 'Asia']
[8, 0.77, 'Australia']
[13, 0.71, 'Australia']
[5, 0.85, 'Europe']
[42, 0.82, 'Europe']
[73, 0.72, 'S.America']
[12, 0.70, 'S.America']

Мне нравятся itertools и оператор:

from itertools import groupby, imap
from operator import itemgetter

def sort_by_max(a_list):
    index, score, group = imap(itemgetter, xrange(3))
    a_list.sort(key=group)
    max_index = dict(
        (each, max(imap(index, entries)))
            for each, entries in groupby(a_list, group)
    )
    a_list.sort(key=lambda x:(-max_index[group(x)], -score(x)))

Используется так:

the_list = [
    [5, 0.85, 'Europe'],
    [8, 0.77, 'Australia'],
    [12, 0.87, 'S.America'],
    [13, 0.71, 'Australia'],
    [42, 0.82, 'Europe'],
    [45, 0.90, 'Asia'],
    [65, 0.91, 'Asia'],
    [73, 0.72, 'S.America'],
    [77, 0.84, 'Asia']
]
sort_by_max(the_list)
for each in the_list:
    print '{0:2} : {1:<4} : {2}'.format(*each)

дает:

65 : 0.91 : Asia
45 : 0.9  : Asia
77 : 0.84 : Asia
12 : 0.87 : S.America
73 : 0.72 : S.America
 5 : 0.85 : Europe
42 : 0.82 : Europe
 8 : 0.77 : Australia
13 : 0.71 : Australia

[РЕДАКТИРОВАТЬ]

Если подумать, мне также нравятся defaultdict и max:

from collections import defaultdict

def sort_by_max(a_list):
    max_index = defaultdict(int)
    for index, score, group in a_list:
        max_index[group] = max(index, max_index[group])
    a_list.sort(key=lambda (index, score, group):(-max_index[group], -score))