NumPy에서 배열을 열로 정렬

NumPy에서 n 번째 열을 기준으로 배열을 정렬하려면 어떻게합니까?

예를 들어

a = array([[9, 2, 3],
           [4, 5, 6],
           [7, 0, 5]])

두 번째 열을 기준으로 행을 정렬하고 싶습니다.

array([[7, 0, 5],
       [9, 2, 3],
       [4, 5, 6]])

@ steve 의 대답 은 실제로 가장 우아한 방법입니다.

"올바른"방법은 numpy.ndarray.sort 의 order 키워드 인수를 참조하십시오.

그러나 배열을 필드가있는 배열 (구조적 배열)로보아야합니다.

처음에 필드로 배열을 정의하지 않은 경우 "올바른"방법은 매우 추악합니다 ...

간단한 예를 들어 정렬하고 사본을 반환하려면 다음을 수행하십시오.

In [1]: import numpy as np

In [2]: a = np.array([[1,2,3],[4,5,6],[0,0,1]])

In [3]: np.sort(a.view('i8,i8,i8'), order=['f1'], axis=0).view(np.int)
Out[3]: 
array([[0, 0, 1],
       [1, 2, 3],
       [4, 5, 6]])

제자리에 정렬하려면 다음을 수행하십시오.

In [6]: a.view('i8,i8,i8').sort(order=['f1'], axis=0) #<-- returns None

In [7]: a
Out[7]: 
array([[0, 0, 1],
       [1, 2, 3],
       [4, 5, 6]])

@ Steve 's는 내가 아는 한 실제로 그것을하는 가장 우아한 방법입니다 ...

이 방법의 유일한 장점은 "order"인수가 검색을 정렬 할 필드 목록이라는 것입니다. 예를 들어 order = [ 'f1', 'f2', 'f0']을 제공하여 두 번째 열, 세 번째 열, 첫 번째 열을 기준으로 정렬 할 수 있습니다.

나는 이것이 효과가 있다고 생각한다. a[a[:,1].argsort()]

이것은 두 번째 열을 나타내며 a그에 따라 정렬합니다.

Steve Tjoa의 방법에 따라 mergesort와 같은 안정적인 정렬을 사용하고 인덱스를 가장 중요하지 않은 열에서 가장 중요한 열로 정렬하여 여러 열을 정렬 할 수 있습니다.

a = a[a[:,2].argsort()] # First sort doesn't need to be stable.
a = a[a[:,1].argsort(kind='mergesort')]
a = a[a[:,0].argsort(kind='mergesort')]

이것은 열 0, 1, 2로 정렬됩니다.

누군가 프로그램의 중요한 부분에서 정렬을 사용하려는 경우 다른 제안에 대한 성능 비교가 있습니다.

import numpy as np
table = np.random.rand(5000, 10)

%timeit table.view('f8,f8,f8,f8,f8,f8,f8,f8,f8,f8').sort(order=['f9'], axis=0)
1000 loops, best of 3: 1.88 ms per loop

%timeit table[table[:,9].argsort()]
10000 loops, best of 3: 180 µs per loop

import pandas as pd
df = pd.DataFrame(table)
%timeit df.sort_values(9, ascending=True)
1000 loops, best of 3: 400 µs per loop

그래서 지금까지 가장 빠른 방법은 argsort 를 사용한 색인 생성입니다 ...

에서 파이썬 문서 위키 , 나는 당신이 할 수 있다고 생각 :

a = ([[1, 2, 3], [4, 5, 6], [0, 0, 1]]); 
a = sorted(a, key=lambda a_entry: a_entry[1]) 
print a

출력은 다음과 같습니다.

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

에서 NumPy와 메일 링리스트 , 여기에 또 다른 솔루션입니다 :

>>> a
array([[1, 2],
       [0, 0],
       [1, 0],
       [0, 2],
       [2, 1],
       [1, 0],
       [1, 0],
       [0, 0],
       [1, 0],
      [2, 2]])
>>> a[np.lexsort(np.fliplr(a).T)]
array([[0, 0],
       [0, 0],
       [0, 2],
       [1, 0],
       [1, 0],
       [1, 0],
       [1, 0],
       [1, 2],
       [2, 1],
       [2, 2]])

나는 비슷한 문제가 있었다.

내 문제:

SVD를 계산하고 고유 값 을 정렬해야합니다. 을 내림차순 . 그러나 고유 값과 고유 벡터 간의 매핑을 유지하고 싶습니다. 내 고유 값은 첫 번째 행에 있었고 해당 고유 벡터는 같은 열에있었습니다.

그래서 첫 번째 행을 기준으로 2 차원 배열을 내림차순으로 정렬합니다.

내 솔루션

a = a[::, a[0,].argsort()[::-1]]

어떻게 작동합니까?

a[0,] 정렬하려는 첫 번째 행입니다.

이제 argsort를 사용하여 인덱스 순서를 가져옵니다.

[::-1]내림차순이 필요 하기 때문에 사용 합니다.

마지막으로 a[::, ...]올바른 순서로 열이있는보기를 얻는 데 사용 합니다.

좀 더 복잡한 lexsort예-첫 번째 열에서 내림차순으로 두 번째에서 두 번째로 오름차순. 트릭 lexsort은 행을 정렬하므로 (따라서 .T) 마지막에 우선 순위를 부여한다는 것입니다.

In [120]: b=np.array([[1,2,1],[3,1,2],[1,1,3],[2,3,4],[3,2,5],[2,1,6]])
In [121]: b
Out[121]: 
array([[1, 2, 1],
       [3, 1, 2],
       [1, 1, 3],
       [2, 3, 4],
       [3, 2, 5],
       [2, 1, 6]])
In [122]: b[np.lexsort(([1,-1]*b[:,[1,0]]).T)]
Out[122]: 
array([[3, 1, 2],
       [3, 2, 5],
       [2, 1, 6],
       [2, 3, 4],
       [1, 1, 3],
       [1, 2, 1]])

다음은 모든 열을 고려한 또 다른 솔루션 입니다 ( JJ 의 대답 보다 컴팩트 한 방법 ).

ar=np.array([[0, 0, 0, 1],
             [1, 0, 1, 0],
             [0, 1, 0, 0],
             [1, 0, 0, 1],
             [0, 0, 1, 0],
             [1, 1, 0, 0]])

lexsort로 정렬

ar[np.lexsort(([ar[:, i] for i in range(ar.shape[1]-1, -1, -1)]))]

산출:

array([[0, 0, 0, 1],
       [0, 0, 1, 0],
       [0, 1, 0, 0],
       [1, 0, 0, 1],
       [1, 0, 1, 0],
       [1, 1, 0, 0]])

간단히 sort를 사용하여 정렬하려는 열수를 사용하십시오.

a = np.array([1,1], [1,-1], [-1,1], [-1,-1]])
print (a)
a=a.tolist() 
a = np.array(sorted(a, key=lambda a_entry: a_entry[0]))
print (a)

그것은 오래된 질문이지만 이것을 2 차원 배열 이상으로 일반화 해야하는 경우 쉽게 일반화 할 수있는 해결책이 있습니다.

np.einsum('ij->ij', a[a[:,1].argsort(),:])

이것은 2 차원에 대한 과잉이며 a[a[:,1].argsort()]@ steve의 대답마다 충분하지만 대답을 더 높은 차원으로 일반화 할 수는 없습니다. 찾을 수 있습니다이 질문에서 3D 배열의 예를 .

산출:

[[7 0 5]
 [9 2 3]
 [4 5 6]]