เรียงลำดับอาร์เรย์ใน 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

อย่างไรก็ตามคุณจะต้องดูอาร์เรย์ของคุณเป็นอาร์เรย์ที่มีเขตข้อมูล (อาร์เรย์ที่มีโครงสร้าง)

วิธี "ถูกต้อง" ค่อนข้างน่าเกลียดถ้าคุณไม่ได้กำหนดอาเรย์ด้วยฟิลด์ ...

เป็นตัวอย่างด่วนในการจัดเรียงและส่งคืนสำเนา:

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 เป็นวิธีที่ดีที่สุดในการทำเท่าที่ฉันรู้ ...

ข้อได้เปรียบเพียงอย่างเดียวของวิธีนี้คืออาร์กิวเมนต์ "สั่งซื้อ" เป็นรายการของเขตข้อมูลที่จะเรียงลำดับการค้นหาด้วย ตัวอย่างเช่นคุณสามารถจัดเรียงตามคอลัมน์ที่สองจากนั้นคอลัมน์ที่สามจากนั้นคอลัมน์แรกโดยการจัดหา order = ['f1', 'f2', 'f0']

ฉันคิดว่างานนี้: a[a[:,1].argsort()]

นี่เป็นการระบุคอลัมน์ที่สองของaและเรียงลำดับตามนั้น

คุณสามารถจัดเรียงหลายคอลัมน์ตามวิธีของ 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

ดังนั้นดูเหมือนว่าการจัดทำดัชนีด้วยargsortเป็นวิธีที่เร็วที่สุดจนถึง ...

จากวิกิเอกสาร Pythonฉันคิดว่าคุณสามารถทำได้:

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 และจำเป็นต้องจัดเรียงค่าลักษณะเฉพาะของฉันตามลำดับจากมากไปน้อย แต่ฉันต้องการเก็บการแมประหว่างค่าลักษณะเฉพาะและค่าลักษณะเฉพาะ ค่าลักษณะเฉพาะของฉันอยู่ในแถวแรกและค่าลักษณะเฉพาะที่เกี่ยวข้องด้านล่างในคอลัมน์เดียวกัน

ดังนั้นฉันต้องการเรียงคอลัมน์อาเรย์สองมิติโดยเรียงตามลำดับแรกจากมากไปหาน้อย

โซลูชันของฉัน

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

แล้วมันทำงานอย่างไร

a[0,] เป็นเพียงแถวแรกที่ฉันต้องการเรียงลำดับ

ตอนนี้ฉันใช้ argsort เพื่อรับลำดับของดัชนี

ฉันใช้[::-1]เพราะฉันต้องการลำดับจากมากไปน้อย

สุดท้ายฉันใช้a[::, ...]เพื่อรับมุมมองกับคอลัมน์ในลำดับที่ถูกต้อง

lexsortตัวอย่างที่ซับซ้อนขึ้นเล็กน้อย- จากมากไปน้อยในคอลัมน์ที่ 1 และจากนั้นขึ้นไปที่อันดับที่สอง เทคนิคด้วย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]])

เพียงใช้การเรียงลำดับให้ใช้หมายเลข coloumn ตามที่คุณต้องการเรียงลำดับ

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(),:])

นี่เป็น overkill สำหรับสองมิติและa[a[:,1].argsort()]จะเพียงพอต่อคำตอบของ @ steve อย่างไรก็ตามคำตอบนั้นไม่สามารถทำให้เป็นมิติที่สูงขึ้นได้ คุณสามารถหาตัวอย่างของอาร์เรย์ 3 มิติในคำถามนี้

เอาท์พุท:

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