Сортировка списка по нескольким нестандартным критериям

Question

Я пытаюсь настроить определенную структуру данных в моей программе, которая берет данные из файла Excel. Это нужно было отсортировать по следующим критериям:

1. В порядке возрастания индекса 5.
2. Если две структуры имеют одинаковое значение для индекса 5, поместите ту, которая имеет индекс 0 = 8, чтобы быть в списке первой.

В настоящее время я могу отсортировать, приняв заказ по индексу 5, чтобы превратить это:

[8, 8, 8, 8, 0, 250]
[8, 8, 8, 0, 0, 50]
[8, 8, 0, 0, 0, 5]
[1, 1, 1, 1, 1, 50]
[1, 1, 1, 1, 0, 25]
[1, 1, 1, 0, 0, 4]
[2, 2, 2, 2, 2, 60]
[2, 2, 2, 2, 0, 30]
[2, 2, 2, 0, 0, 5]
[3, 3, 3, 3, 3, 70]
[3, 3, 3, 3, 0, 35]
[3, 3, 3, 0, 0, 8]
[4, 4, 4, 4, 4, 80]
[4, 4, 4, 4, 0, 40]
[4, 4, 4, 0, 0, 10]
[5, 5, 5, 5, 5, 90]
[5, 5, 5, 5, 0, 45]
[5, 5, 5, 0, 0, 12]
[6, 6, 6, 6, 6, 100]
[6, 6, 6, 6, 0, 50]
[6, 6, 6, 0, 0, 15]
[9, 9, 9, 9, 9, 120]
[9, 9, 9, 9, 0, 60]
[9, 9, 9, 0, 0, 20]
[9, 9, 0, 0, 0, 2]
[10, 10, 10, 10, 10, 150]
[10, 10, 10, 10, 0, 75]
[10, 10, 10, 0, 0, 25]
[10, 10, 0, 0, 0, 3]
[11, 11, 11, 11, 11, 400]
[11, 11, 11, 11, 0, 150]
[11, 11, 11, 0, 0, 40]
[11, 11, 0, 0, 0, 3]

в это

[11, 11, 11, 11, 11, 400]
[8, 8, 8, 8, 0, 250]
[11, 11, 11, 11, 0, 150]
[10, 10, 10, 10, 10, 150]
[9, 9, 9, 9, 9, 120]
[6, 6, 6, 6, 6, 100]
[5, 5, 5, 5, 5, 90]
[4, 4, 4, 4, 4, 80]
[10, 10, 10, 10, 0, 75]
[3, 3, 3, 3, 3, 70]
[9, 9, 9, 9, 0, 60]
[2, 2, 2, 2, 2, 60]
[6, 6, 6, 6, 0, 50]
[1, 1, 1, 1, 1, 50]
[8, 8, 8, 0, 0, 50]
[5, 5, 5, 5, 0, 45]
[11, 11, 11, 0, 0, 40]
[4, 4, 4, 4, 0, 40]
[3, 3, 3, 3, 0, 35]
[2, 2, 2, 2, 0, 30]
[10, 10, 10, 0, 0, 25]
[1, 1, 1, 1, 0, 25]
[9, 9, 9, 0, 0, 20]
[6, 6, 6, 0, 0, 15]
[5, 5, 5, 0, 0, 12]
[4, 4, 4, 0, 0, 10]
[3, 3, 3, 0, 0, 8]
[2, 2, 2, 0, 0, 5]
[8, 8, 0, 0, 0, 5]
[1, 1, 1, 0, 0, 4]
[11, 11, 0, 0, 0, 3]
[10, 10, 0, 0, 0, 3]
[9, 9, 0, 0, 0, 2]

Используются функции .sort(key = lambda x:x[5]) и .reverse().

Тем не менее, обращая внимание на один раздел в частности.

[6, 6, 6, 6, 0, 50]
[1, 1, 1, 1, 1, 50]
[8, 8, 8, 0, 0, 50]

Я бы хотел, чтобы что-нибудь с 8 в индексе 0 было первым в списке, так что это должно быть

[8, 8, 8, 0, 0, 50]
[6, 6, 6, 6, 0, 50]
[1, 1, 1, 1, 1, 50]

Мне известно, что в этом конкретном случае это можно сделать, выполнив вторичную сортировку по индексу 0, чтобы получить желаемый результат. Тем не менее, могут быть случаи с разными входами, где мы можем иметь, скажем

[6, 6, 6, 6, 0, 50]
[1, 1, 1, 1, 1, 50]
[8, 8, 8, 0, 0, 50]
[11, 11, 0, 0, 0, 50]

который нужно отсортировать по

[8, 8, 8, 0, 0, 50]
[6, 6, 6, 6, 0, 50]
[1, 1, 1, 1, 1, 50]
[11, 11, 0, 0, 0, 50]

Таким образом, выполнение сортировки по вторичной переменной не будет работать. Где я могу начать искать решение этой конкретной проблемы?

Answer 1

Попробуйте:

l = [[8, 8, 8, 8, 0, 250],    [8, 8, 8, 0, 0, 50],    [8, 8, 0, 0, 0, 5],    [1, 1, 1, 1, 1, 50],    [1, 1, 1, 1, 0, 25],    [1, 1, 1, 0, 0, 4],    [2, 2, 2, 2, 2, 60],    [2, 2, 2, 2, 0, 30],    [2, 2, 2, 0, 0, 5],    [3, 3, 3, 3, 3, 70],    [3, 3, 3, 3, 0, 35],    [3, 3, 3, 0, 0, 8],    [4, 4, 4, 4, 4, 80],    [4, 4, 4, 4, 0, 40],    [4, 4, 4, 0, 0, 10],    [5, 5, 5, 5, 5, 90],    [5, 5, 5, 5, 0, 45],    [5, 5, 5, 0, 0, 12],    [6, 6, 6, 6, 6, 100],    [6, 6, 6, 6, 0, 50],    [6, 6, 6, 0, 0, 15],    [9, 9, 9, 9, 9, 120],    [9, 9, 9, 9, 0, 60],    [9, 9, 9, 0, 0, 20],    [9, 9, 0, 0, 0, 2],    [10, 10, 10, 10, 10, 150],    [10, 10, 10, 10, 0, 75],    [10, 10, 10, 0, 0, 25],    [10, 10, 0, 0, 0, 3],    [11, 11, 11, 11, 11, 400],    [11, 11, 11, 11, 0, 150],    [11, 11, 11, 0, 0, 40],    [11, 11, 0, 0, 0, 3], [11, 11, 0, 0, 0, 50]]

ls = sorted(l, key = lambda x: [x[5], x[0]==8], reverse = True)

Дает вывод в виде:

[[11, 11, 11, 11, 11, 400], [8, 8, 8, 8, 0, 250], [10, 10, 10, 10, 10, 150], [11, 11, 11, 11, 0, 150], [9, 9, 9, 9, 9, 120], [6, 6, 6, 6, 6, 100], [5, 5, 5, 5, 5, 90], [4, 4, 4, 4, 4, 80], [10, 10, 10, 10, 0, 75], [3, 3, 3, 3, 3, 70], [2, 2, 2, 2, 2, 60], [9, 9, 9, 9, 0, 60], [8, 8, 8, 0, 0, 50], [1, 1, 1, 1, 1, 50], [6, 6, 6, 6, 0, 50], [11, 11, 0, 0, 0, 50], [5, 5, 5, 5, 0, 45], [4, 4, 4, 4, 0, 40], [11, 11, 11, 0, 0, 40], [3, 3, 3, 3, 0, 35], [2, 2, 2, 2, 0, 30], [1, 1, 1, 1, 0, 25], [10, 10, 10, 0, 0, 25], [9, 9, 9, 0, 0, 20], [6, 6, 6, 0, 0, 15], [5, 5, 5, 0, 0, 12], [4, 4, 4, 0, 0, 10], [3, 3, 3, 0, 0, 8], [8, 8, 0, 0, 0, 5], [2, 2, 2, 0, 0, 5], [1, 1, 1, 0, 0, 4], [10, 10, 0, 0, 0, 3], [11, 11, 0, 0, 0, 3], [9, 9, 0, 0, 0, 2]]

Сортирует на основе пятого элемента списка в качестве первого приоритета и, если они равны, проверьте наличиевторой приоритет - равен ли первый элемент списка 8 (сначала помещает список с 8 в первый индекс, а затем в порядке сортировки первого элемента), например:

 [8, 8, 8, 0, 0, 50],
 [1, 1, 1, 1, 1, 50],
 [6, 6, 6, 6, 0, 50],
 [11, 11, 0, 0, 0, 50],

Answer 2

Если вы используете data.sort (key = lambda x: x [0] == 8), то он будет сортировать каждый с 8 на позиции 0 до последнего места. Так что вы могли бы сделать следующее:

Сначала отсортируйте их, чтобы все 8 в позиции 0 были в конце:

data.sort(key = lambda x:x[0] == 8)

Затем сортируйте по позиции 5:

data.sort(key = lambda x:x[5])

А затем в обратном порядке:

data.reverse()