Tengo una lista de listas o 3d matriz numpy y necesito a solucionar el problema, por el más pequeño primero índice de elemento. Estos son los últimos dos tentativas que hice en este programa. En este momento, estoy bastante seguro de que es una pregunta fácil / tonto, sino como un novato en la programación de 'forma de pensar', que es un poco difícil para mí. Primer intento:
lstsArray = [[[54,21,31], [1,2,3], [15,25,35]],
[[12,22,32], [3,2,1], [16,26,36]],
[[34,24,38], [0.1,1,1], [17,27,37]]]
val = np.array(lstsArray)
menor = 120e26
for item in val:
for i in item:
if menor >= i[0] and i[0] >= min(i):
menor = i[0]
print(menor)
lstA = list(val)
a = sorted(lstA, key=itemgetter(menor))
print(a)
Segundo intento
for i in val:
for j in i:
print(sorted((i), key =itemgetter(j[0])))
Salida deseada
[[[0.1,1,1],[1,2,3],[3,2,1]],
[[12,22,32],[15,25,35],[16,26,36]],
[[17,27,37],[34,24,38],[54,21,31]]]
Su lista, y la matriz hecha de la misma. Tenga en cuenta los flotadores de la matriz:
In [124]: lstsArray = [[[54,21,31], [1,2,3], [15,25,35]],
...: [[12,22,32], [3,2,1], [16,26,36]],
...: [[34,24,38], [0.1,1,1], [17,27,37]]]
In [125]: val=np.array(lstsArray)
In [126]: val
Out[126]:
array([[[54. , 21. , 31. ],
[ 1. , 2. , 3. ],
[15. , 25. , 35. ]],
[[12. , 22. , 32. ],
[ 3. , 2. , 1. ],
[16. , 26. , 36. ]],
[[34. , 24. , 38. ],
[ 0.1, 1. , 1. ],
[17. , 27. , 37. ]]])
Esta es una (3,3,3) matriz con forma. Sin embargo, su clasificación ignora el (3,3) disposición inicial, así que vamos a seguir adelante y darle una nueva forma:
In [133]: val = np.array(lstsArray).reshape(-1,3)
In [134]: val
Out[134]:
array([[54. , 21. , 31. ],
[ 1. , 2. , 3. ],
[15. , 25. , 35. ],
[12. , 22. , 32. ],
[ 3. , 2. , 1. ],
[16. , 26. , 36. ],
[34. , 24. , 38. ],
[ 0.1, 1. , 1. ],
[17. , 27. , 37. ]])
Ahora podemos formar de nuevo fácilmente en el primer valor de la columna. argsortda el orden de clasificación:
In [135]: idx = np.argsort(val[:,0])
In [136]: idx
Out[136]: array([7, 1, 4, 3, 2, 5, 8, 6, 0])
In [137]: val[idx]
Out[137]:
array([[ 0.1, 1. , 1. ],
[ 1. , 2. , 3. ],
[ 3. , 2. , 1. ],
[12. , 22. , 32. ],
[15. , 25. , 35. ],
[16. , 26. , 36. ],
[17. , 27. , 37. ],
[34. , 24. , 38. ],
[54. , 21. , 31. ]])
y para llegar de nuevo a 3d:
In [138]: val[idx].reshape(3,3,3)
Out[138]:
array([[[ 0.1, 1. , 1. ],
[ 1. , 2. , 3. ],
[ 3. , 2. , 1. ]],
[[12. , 22. , 32. ],
[15. , 25. , 35. ],
[16. , 26. , 36. ]],
[[17. , 27. , 37. ],
[34. , 24. , 38. ],
[54. , 21. , 31. ]]])
o en la visualización de la lista:
In [139]: val[idx].reshape(3,3,3).tolist()
Out[139]:
[[[0.1, 1.0, 1.0], [1.0, 2.0, 3.0], [3.0, 2.0, 1.0]],
[[12.0, 22.0, 32.0], [15.0, 25.0, 35.0], [16.0, 26.0, 36.0]],
[[17.0, 27.0, 37.0], [34.0, 24.0, 38.0], [54.0, 21.0, 31.0]]]
Pero si la lista tenía sólo un nivel de anidamiento:
In [140]: alist = val.tolist()
In [141]: alist
Out[141]:
[[54.0, 21.0, 31.0],
[1.0, 2.0, 3.0],
[15.0, 25.0, 35.0],
[12.0, 22.0, 32.0],
[3.0, 2.0, 1.0],
[16.0, 26.0, 36.0],
[34.0, 24.0, 38.0],
[0.1, 1.0, 1.0],
[17.0, 27.0, 37.0]]
la pitón ordenadas funciona bastante bien:
In [142]: sorted(alist, key=lambda x:x[0]) # or itemgetter
Out[142]:
[[0.1, 1.0, 1.0],
[1.0, 2.0, 3.0],
[3.0, 2.0, 1.0],
[12.0, 22.0, 32.0],
[15.0, 25.0, 35.0],
[16.0, 26.0, 36.0],
[17.0, 27.0, 37.0],
[34.0, 24.0, 38.0],
[54.0, 21.0, 31.0]]
El hecho de que usted tiene una lista anidada doble, pero desea que el tipo de ignorar una capa, complica el procesamiento de listas. Ahí es donde numpyreshape ayuda mucho.
Por ahora no voy a probar las velocidades relativas de estos enfoques.