Ottieni secondi valori minimi per colonna nell'array 2D

Come posso ottenere il secondo valore minimo da ogni colonna? Ho questo array:

A = [[72 76 44 62 81 31]
     [54 36 82 71 40 45]
     [63 59 84 36 34 51]
     [58 53 59 22 77 64]
     [35 77 60 76 57 44]]

Vorrei avere un output come:

A = [54 53 59 36 40 44]

Prova questo, in una sola riga:

[sorted(i)[1] for i in zip(*A)]

in azione:

In [12]: A = [[72, 76, 44, 62, 81, 31], 
    ...:      [54 ,36 ,82 ,71 ,40, 45], 
    ...:      [63 ,59, 84, 36, 34 ,51], 
    ...:      [58, 53, 59, 22, 77 ,64], 
    ...:      [35 ,77, 60, 76, 57, 44]] 

In [18]: [sorted(i)[1] for i in zip(*A)]                                                                                                                                                                           
Out[18]: [54, 53, 59, 36, 40, 44]

zip(*A) trasporrà il tuo elenco di elenchi in modo che le colonne diventino righe.

e se hai un valore duplicato, ad esempio:

In [19]: A = [[72, 76, 44, 62, 81, 31], 
    ...:  [54 ,36 ,82 ,71 ,40, 45], 
    ...:  [63 ,59, 84, 36, 34 ,51], 
    ...:  [35, 53, 59, 22, 77 ,64],   # 35
    ...:  [35 ,77, 50, 76, 57, 44],]  # 35

Se devi saltare entrambi 35, puoi usare set():

In [29]: [sorted(list(set(i)))[1] for i in zip(*A)]                                                                                                                                                                
Out[29]: [54, 53, 50, 36, 40, 44]

Le operazioni sugli numpyarray devono essere eseguite con numpyfunzioni, quindi guarda questo:

np.sort(A, axis=0)[1, :]

Out[61]: array([54, 53, 59, 36, 40, 44])

puoi usare heapq.nsmallest

from heapq import nsmallest

[nsmallest(2, e)[-1] for e in zip(*A)]

produzione:

[54, 53, 50, 36, 40, 44]

Ho aggiunto un semplice benchmark per confrontare le prestazioni delle diverse soluzioni già pubblicate:

from simple_benchmark import BenchmarkBuilder
from heapq import nsmallest


b = BenchmarkBuilder()

@b.add_function()
def MehrdadPedramfar(A):
    return [sorted(i)[1] for i in zip(*A)]

@b.add_function()
def NicolasGervais(A):
    return np.sort(A, axis=0)[1, :]

@b.add_function()
def imcrazeegamerr(A):
    rotated = zip(*A[::-1])

    result = []
    for arr in rotated:
        # sort each 1d array from min to max
        arr = sorted(list(arr))
        # add the second minimum value to result array
        result.append(arr[1])

    return result

@b.add_function()
def Daweo(A):
    return np.apply_along_axis(lambda x:heapq.nsmallest(2,x)[-1], 0, A)

@b.add_function()       
def kederrac(A):
    return [nsmallest(2, e)[-1] for e in zip(*A)]


@b.add_arguments('Number of row/cols (A is  square matrix)')
def argument_provider():
    for exp in range(2, 18):
        size = 2**exp
        yield size, [[randint(0, 1000) for _ in range(size)] for _ in range(size)]

r = b.run()
r.plot()

L'uso zipcon la sortedfunzione è la soluzione più veloce per piccoli elenchi 2D mentre si utilizza zipcon gli heapq.nsmallestspettacoli per essere il migliore su grandi elenchi 2D

Spero di aver capito bene la tua domanda, ma in entrambi i casi ecco la mia soluzione, sono sicuro che ci sia un modo più elegante di farlo ma funziona

A = [[72,76,44,62,81,31]
 ,[54,36,82,71,40,45]
 ,[63,59,84,36,34,51]
 ,[58,53,59,22,77,64]
 ,[35,77,50,76,57,44]]

#rotate the array 90deg
rotated = zip(*A[::-1])

result = []
for arr in rotated:
    # sort each 1d array from min to max
    arr = sorted(list(arr))
    # add the second minimum value to result array
    result.append(arr[1])
print(result)

Supponendo che Aè numpy.array(se questo è vero si prega di considerare l'aggiunta di numpytag alla tua domanda) allora si potrebbe utilizzare apply_along_axisper quella seguente modo:

import heap
import numpy as np
A = np.array([[72, 76, 44, 62, 81, 31],
              [54, 36, 82, 71, 40, 45],
              [63, 59, 84, 36, 34, 51],
              [58, 53, 59, 22, 77, 64],
              [35, 77, 60, 76, 57, 44]])
second_mins = np.apply_along_axis(lambda x:heapq.nsmallest(2,x)[-1], 0, A)
print(second_mins)  # [54 53 59 36 40 44]

Nota che ho usato heapq.nsmallest in quanto fa tutto l'ordinamento necessario per ottenere 2 elementi più piccoli, a differenza di quello sortedche completa l'ordinamento.

>>> A = np.arange(30).reshape(5,6).tolist()
>>> A
[[0, 1, 2, 3, 4, 5], 
 [6, 7, 8, 9, 10, 11], 
 [12, 13, 14, 15, 16, 17], 
 [18, 19, 20, 21, 22, 23],
 [24, 25, 26, 27, 28, 29]]

Aggiornato : utilizzare setper impedire la duplicazione e trasposizione dell'elenco mediantezip(*A)

>>> [sorted(set(items))[1] for items in zip(*A)]
[6, 7, 8, 9, 10, 11]

vecchio: secondo elemento minimo in ogni riga

>>> [sorted(set(items))[1] for items in A]
[1, 7, 13, 19, 25]