从列表中查找“ n”个最小值及其索引

Question

I have a list of lists in python:

final_distances=[[10,21,1,5,0],[10,2,1,5,0],[3,21,1,5,0]]

How do I find the 'n'(consider n =3) minimum values and indices of each list?

Expected Output:

minimum_values=[[0, 1, 5], [0, 1, 2], [0, 1, 3]]

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

This is what I've tried so far...

new_distances=copy.deepcopy(final_distances)
k=3
for list1 in new_distances:
    min_list =[]
    min_index=[]
    for i in range(0, k):     
        min1 = 9999999;
        for j in range(len(list1)):       
            if list1[j]<min1: 
                min1 = list1[j]          
        min_list.append(min1)
        list1.remove(min1)

I am able to find the minimum values but am not able to keep track of the indices...

Answer 1

You can simply use enumerate(iterable) and zip(iterables) to get to what you want:

def get_min_N_nums_and_indexes_from_inner(l, N=3):
    for inner in l:
        # sort each lists enumeration so you have (index,value) to begin with
        #     use the value as key to sort
        # take first N
        s = sorted(enumerate(inner), key=lambda x:x[1])[:N]
        # seperate values from indexes using zip
        z_idx, z_value = map(list, zip(*s))
        # yield each tuple of (values,indexes)
        yield ( z_value,z_idx )

Test:

final_distances=[[10,21,1,5,0],[10,2,1,5,0],[3,21,1,5,0]]

k = list( get_min_N_nums_and_indexes_from_inner(final_distances))

for nr,(value,idx) in enumerate(k):
    print( f"{final_distances[nr]} ==> min values {value} -- min index {idx}")

Output:

[10, 21, 1, 5, 0] ==> min values [0, 1, 5] -- min index [4, 2, 3]
[10, 2, 1, 5, 0] ==> min values [0, 1, 2] -- min index [4, 2, 1]
[3, 21, 1, 5, 0] ==> min values [0, 1, 3] -- min index [4, 2, 0] 

Answer 2

You can use .index() to retrieve the index of an element from a list.

for list1 in new_distances:
    min_list =[]
    min_index=[]

    cpList = copy.copy(list1)  # create a temporary list so that we can reference the original list1 index later on  
                               # a shallow copy will work with 1D lists

    for i in range(0, k):     
        min1 = 9999999;
        for j in range(len(cpList)):    # note that I changed list1 to cpList  
            if cpList[j]<min1:          # as I don't want to modify the original
                min1 = cpList[j]        
        min_list.append(min1)

        ind = list1.index(min1)  # place this before `.remove()`
        min_index.append(ind)    # or else min1 might not be found

        cpList.remove(min1)      # `list1.remove()` will modify your `new_distances` in place
                                 # which is one reason why we did a copy before
                                 # so we use cpList instead
    print(f'List: {min_list}; Index: {min_index}')

Output:

List: [0, 1, 5]; Index: [4, 2, 3]
List: [0, 1, 2]; Index: [4, 2, 1]
List: [0, 1, 3]; Index: [4, 2, 0]

On another note, you could simplify this part of your code:

min1 = 9999999;
for j in range(len(cpList)):       
    if cpList[j]<min1: 
        min1 = cpList[j]  

into

min1 = min(cpList)

by using the min() built-in function which can find the minimum from a list.

You also don't need

new_distances=copy.deepcopy(final_distances)

as you'll only need to perform lookup and will copy individual sublists in the loop. So you can remove it unless you have other plans in mind.