열별로 NumPy 배열 정렬

열별로 NumPy 배열 정렬

N번째 열로 NumPy의 배열을 정렬하려면 어떻게 해야 하는가?

예를 들어,

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

두 번째 열로 행을 정렬하여 다음과 같이 되돌리십시오.

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

의 두 번째 열로 정렬하려면a:

a[a[:, 1].argsort()]

@steve의 대답은 사실 그것을 하는 가장 우아한 방법이다.

올바른 방법은 numpy.ndarray의 순서 키워드 인수를 참조하십시오.분류하다

그러나 배열을 필드(구조화된 배열)가 있는 배열로 보아야 할 것이다.

처음에 필드를 사용하여 배열을 정의하지 않았다면 "정확한" 방법은 상당히 추하다...

간단히 예를 들어, 해당 문서를 정렬하고 사본을 반환하려면:

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의 방법은 정말 내가 아는 한 가장 우아한 방법이야...

이 방법의 유일한 장점은 "주문" 인수가 검색을 명령할 필드 목록이라는 것이다.예를 들어, 두 번째 열, 세 번째 열, 그리고 순서=['f1'],f2'',f0'을 입력하여 첫 번째 열을 정렬할 수 있다.

병합과 같은 안정적인 정렬을 사용하여 가장 유의하지 않은 열에서 가장 유의하지 않은 열까지 지수를 정렬하면 Steve Tjoa의 방법에 따라 여러 열을 정렬할 수 있다.

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

그래서 지금까지 아그소트로 인덱싱하는 것이 가장 빠른 방법인 것 같다...

Python 문서 wiki에서 다음 작업을 수행할 수 있다.

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,]내가 분류하고 싶은 첫 번째 줄이야.

이제 나는 지수의 순서를 얻기 위해 아그소트를 사용한다.

나는 사용한다[::-1]내림차순서가 필요하거든

마지막으로 나는 사용한다.a[::, ...]열을 올바른 순서로 보기 위해.

import numpy as np
a=np.array([[21,20,19,18,17],[16,15,14,13,12],[11,10,9,8,7],[6,5,4,3,2]])
y=np.argsort(a[:,2],kind='mergesort')# a[:,2]=[19,14,9,4]
a=a[y]
print(a)

원하는 출력은[[6,5,4,3,2],[11,10,9,8,7],[16,15,14,13,12],[21,20,19,18,17]]

에 유의하다argsort(numArray)의 지수를 반환하다numArray정리가 되어 있는 대로

예시

x=np.array([8,1,5]) 
z=np.argsort(x) #[1,3,0] are the **indices of the predicted sorted array**
print(x[z]) #boolean indexing which sorts the array on basis of indices saved in z

답은 다음과 같다.[1,5,8]

조금 더 복잡한lexsort예제 - 첫 번째 열에서 내림차순, 두 번째 열에서 오름차순.tricks의 의 요령부득.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]])

여기 모든 컬럼을 고려한 또 다른 해결책이 있다(더 콤팩트한 J 방식).J의 대답);

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]])

렉소트로 정렬하면

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]])

오래된 질문이지만 2차원 이상의 어레이로 일반화해야 하는 경우, 쉽게 일반화할 수 있는 솔루션보다 다음과 같은 것이 있다.

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

과 2차원의 이다.a[a[:,1].argsort()]그러나 그 대답은 더 높은 차원으로 일반화될 수 없다.이 질문에서 3D 배열의 예를 찾을 수 있다.

출력:

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

#열 1을 따라 정렬할 경우

indexofsort=np.argsort(dataset[:,0],axis=-1,kind='stable') 
dataset   = dataset[indexofsort,:]

def sort_np_array(x, column=None, flip=False):
    x = x[np.argsort(x[:, column])]
    if flip:
        x = np.flip(x, axis=0)
    return x

원래 질문의 배열:

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

의 의 결과.sort_np_array질문 작성자가 예상한 대로 기능한다.

sort_np_array(a, column=1, flip=False)

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

이 게시물 덕분에: https://stackoverflow.com/a/5204280/13890678

구조화된 배열을 사용하여 보다 "일반적인" 대답을 찾았다.나는 이 방법의 한 가지 장점은 코드를 읽기 쉽다는 것이라고 생각한다.

import numpy as np
a = np.array([[9, 2, 3],
           [4, 5, 6],
           [7, 0, 5]])

struct_a = np.core.records.fromarrays(
    a.transpose(), names="col1, col2, col3", formats="i8, i8, i8"
)
struct_a.sort(order="col2")

print(struct_a)

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

완벽을 기하기 위해 접근하는 판다:

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

             
a.sort_values(1, ascending=True).to_numpy()
array([[7, 0, 5], # '1' means sort by second column
       [9, 2, 3],
       [4, 5, 6]])

prl900 벤치마크를 허용한 답변과 비교:

%timeit pandas_df.sort_values(9, ascending=True)
1000 loops, best of 3: 400 µs per loop

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

정렬을 사용하면 정렬할 열 번호를 사용하십시오.

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)

참조URL: https://stackoverflow.com/questions/2828059/sorting-arrays-in-numpy-by-column