Сортировка 2 списков в Python на основе соотношения отдельных соответствующих элементов или на основе третьего списка

В одной строке:

values, weights = zip(*sorted(zip(values, weights), key=lambda t: t[0]/t[1]))

Чтобы объяснить: во-первых, заархивируйте списки, чтобы соединить их.

pairs = zip(values, weights) 
# [(60, 20), (100, 50), (120, 30)]

Затем отсортируйте по отношению стоимости к весу.

sorted_pairs = sorted(pairs, key=lambda t: t[0]/t[1]) 
# [(100, 50), (60, 20), (120, 30)]

Наконец, распакуйте их обратно в отдельные списки.

values, weights = zip(*sorted_pairs)
# (100, 60, 120), (50, 20, 30)

Альтернативой является создание кортежей, явно содержащих отношение в качестве первого элемента.

ratios, values, weights = zip(*sorted((v/w, v, w) for v, w in zip(values, weights)))

Первый оказался немного быстрее в некоторых быстрых тестах. Если вы ищете оптимальный алгоритм, вам, вероятно, придется разворачивать вещи, и решение не будет таким кратким.

И чтобы ответить на комментарий от @TomWyllie, если у вас уже есть список соотношений, вы можете использовать:

ratios, values, weights = zip(*sorted(zip(ratios, values, weights)))

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

Элегантный способ сделать это — составить многомерный список со значениями и весами:

for i in range(len(values)):
    values_and_weights.append([values[i], weights[i])
# The resulting list is [[60, 20], [100, 50], [120, 30]]

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

values_and_weights.sort(key=(lambda x: x[0]/x[1]))

Для более явного (но, возможно, менее питонического) решения создайте список индексов, отсортированных по значению этого индекса в value_per_unit, и измените порядок values и weights соответственно.

sorted_indices = [index for index, value in 
                  sorted(enumerate(value_per_unit), key=lambda x: x[1])]
values = [values[i] for i in sorted_indices]
weights = [weights[i] for i in sorted_indices]

print(values, weights)

Выходы:

([100, 60, 120], [50, 20, 30])

Вы можете привести это в порядок, устранив ненужные дополнительные циклы, используя zip и выражение генератора;

values, weights = zip(*((values[i], weights[i]) for i, value in
                  sorted(enumerate(value_per_unit), key=lambda x: x[1])))
print(values)
print(weights)

Какие выходы;

(100, 60, 120)
(50, 20, 30)

Обратите внимание, что эти окончательные значения равны tuples, а не lists. Если вам действительно нужно, чтобы на выходе был список, достаточно простого values, weights = map(list, (values, weights)). Вы могли бы даже обернуть это в один вкладыш, хотя к этому моменту, вероятно, становится довольно сложно следить за тем, что происходит.

Проблема, с которой вы столкнулись, связана с использованием вычисляемого поля для каждого элемента (элемент I будет иметь вычисленное значение values[I]/weights[I]). Чтобы решить эту проблему и при этом сохранить ее чрезвычайно простой для понимания, вы можете превратить ее в кортеж следующей формы: ( calculated_value, (value, weight) ) для каждого элемента.

Такой подход упрощает чтение и понимание. Посмотрите на следующее решение:

values = [60, 100, 120]
weights = [20, 50, 30]
value_per_unit = []

for I in range(len(values)):
    value_per_unit.append( (values[I]/weights[I], (values[I], weights[I])) )
sorted_value_per_unit = sorted(value_per_unit, key=lambda x: x[0])

sorted_values = []
sorted_weights = []
for I in range(len(values)):
    (value, weight) = sorted_value_per_unit[I][1]
    sorted_values.append(value)
    sorted_weights.append(weight)

print(str(sorted_values))
print(str(sorted_weights))

Также обратите внимание, что я изменил цикл из вашего исходного кода:

range(values) было изменено на range(len(values))

Поскольку диапазону потребуется длина списка, а не сам список.