lists：最低值索引和重新排序

Question

I have a list like this:

foo =
[[a1, a2, a3, a4, a5],
 [b1, b2, b3, b4, b5],
 [c1, c2, c3, c4, c5]]
# in real: many more rows & columns

every a_i, b_i and c_i contains 3 values: [x,y,z]

now I want to reorder the entrys this way:: I want to get the index of the a-column where I have the lowest y-value. let's say, in example, in a3 there is the lowest y-value of all a's. so I want to reorder my list this way:

[[a3, a4, a5, a1, a2],
 [b3, b4, b5, b1, b2],
 [c3, c4, c5, c1, c2]]

-> so I don't care about the other y-values, only want to know the lowest one and set this at the first position of my list and keep the sequence (a5 after a4 after a3...) alive -> the values which where in the original list before a3 (a1 and a2) shall appended in the end.

I know I can get the lowest y-value of the first column with this:

xmin, ymin, zmin = map(min, zip(*foo[0]))
print ymin

But I don't need the value, but the index. And how can I reorder my list without a for-loop?

Edit: Reason for not using a for-loop: It's a huge list and I'm looking for a more efficient way. But I would also accept a for-loop.

Answer 1

You could find the appropriate index then use a list comprehension:

from operator import itemgetter

# first get index from first row
min_index = min(enumerate(foo[0]), key=lambda x: x[1][1])[0]

# then apply to all rows
foo = [item[min_index:] + item[:min_index] for item in foo]

Note that this will loop, but any code you write to do this will at some point!

Answer 2

You've got a list of lists of lists; I'm assuming the outer list stays the same.

for row in foo:
    row.sort(key=lambda x:min(*x))

The main takeaway is to sort with a lambda key, and the min(*x) takes the min of all the values in list x

You have to loop through foo, but that's to be expected.

Answer 3

A numpy based solution.

import numpy as np
foo = np.random.randint(0,100,(3,5))    #some random data for testing
print foo                               #original order
i = np.argmin(foo[1,:])                 #find min index of second row
foo[:,[0,i]] = foo[:,[i,0]]             #swap columns to move selected row to front
print foo                               #new order

Or in case you decide you would like to sort the entire row, and don't mind the slightly higher computational load:

import numpy as np
foo = np.random.randint(0,100,(3,5))    #some random data for testing
print foo                               #original order
foo = foo[:,np.argsort(foo[1])]         #complete sorting by second row
print foo                               #new order

Either way, both of these will blow a pure python based solution out of the water, in terms of performance.

Answer 4

Easy: To sort columns by first element, flip along diagonal, sort rows by first element, flip back.

def diagFlip(grid):
    return [[grid[i][j] for i in range(len(grid))] for j in range(len(grid[0]))]

def sortByColumnTops(grid):
    grid = diagFlip(grid)
    grid.sort(key=(lambda row: row[0][1]))
    return diagFlip(grid)

And to prove it works:

test = [[[0,4,0],[0,2,0],[0,3,0],[0,1,0]],
        [[0,1,0],[0,3,0],[0,2,0],[0,4,0]],
        [[0,1,0],[0,2,0],[0,3,0],[0,4,0]]]
test = sortByColumnTops(test)

for row in test: print(row)

yields

[[0, 1, 0], [0, 2, 0], [0, 3, 0], [0, 4, 0]]
[[0, 4, 0], [0, 3, 0], [0, 2, 0], [0, 1, 0]]
[[0, 4, 0], [0, 2, 0], [0, 3, 0], [0, 1, 0]]