python：sort，sorted，argsort，lexsort

Python list内置sort()方法用来排序，也可以用python内置的全局sorted()方法来对可迭代的序列排序生成新的序列

1.使用sort排序

用法：
list.sort(func=None, key=None, reverse=False(or True))

• 对于reverse这个bool类型参数，当reverse=False时：为正向排序；当reverse=True时：为方向排序。默认为False。
• 执行完后会改变原来的list，如果你不需要原来的list，这种效率稍微高点
• 为了避免混乱，其会返回none

my_list = [3, 5, 1, 4, 2]
my_list.sort()
print my_list

#输出： [1, 2, 3, 4, 5]

2.使用sorted()排序

这个和第一种的差别之处在于：

• sorted()不会改变原来的list，而是会返回一个新的已经排序好的list
• list.sort()方法仅仅被list所定义，sorted()可用于任何一个可迭代对象

用法：
sorted(list)

• 该函数也含有reverse这个bool类型的参数，当reverse=False时：为正向排序(从小到大)；当reverse=True时：为反向排序(从大到小)。当然默认为False。
• 执行完后会有返回一个新排序好的list

my_list = [3, 5, 1, 4, 2]
result = sorted(my_list)
print result

#输出： [1, 2, 3, 4, 5]

my_dict = {"a":"1", "c":"3", "b":"2"}
result = sorted(my_dict)
print result

#输出: ['a', 'b', 'c']

key参数

1.对复杂的元组排序

student_tuples = [
        ('john', 'A', 15),
        ('jane', 'B', 12),
        ('dave', 'B', 10),
]
result = sorted(student_tuples, key=lambda student: student[2])
print result

#输出 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

#  lambda student:student[2] 等价于

#  def f(student):

#      return student[2]

2.根据字典的value排序

默认sorted是对dict的key排序的，如果要根据dict的value排序就需要指定key参数了

my_dict = {"a":"2", "c":"5", "b":"1"}

result = sorted(my_dict)
print result
#默认对dict排序，不指定key参数,会默认对dict的key值进行比较排序
#result输出: ['a', 'b', 'c']

result2 = sorted(my_dict, key=lambda x:my_dict[x])
print result2
#指定key参数，根据dict的value排序
#result2输出:['b', 'a', 'c']

3对多列排序

a = [[2,3,4], [2,4,5],[3,3,4]]
sorted(a, key=lambda x: (x[1], x[0]))
print(a)
#输出 [[2, 3, 4], [3, 3, 4], [2, 4, 5]]

3.argsort

numpy.argsort(a, axis=1, kind=‘quicksort’, order=None)

• a：所需排序的数组
• axis：数组排序时的基准，axis=0，按列排列；axis=1，按行排列
• order：一个字符串或列表，可以设置按照某个属性进行排序

参数axis

>>>list1=[4,2,5,7,3]
>>>a=np.array(list1)
>>>a
array([4, 2, 5, 7, 3])
>>>b=np.argsort(a)
>>>b
array([1, 4, 0, 2, 3], dtype=int64)
# 列表b的元素表示的是原列表a中的元素的索引，5各元素的索引分别为0-4
# 返回的结果可以这样解读：
# 	b[0]=1，表示原列表a的最小元素的索引为1，即原列表a中的第2个元素为最小值
#	b[1]=4，表示原列表a的第二小元素的索引为4，即原列表a中的第5个元素为第二小元素
#	...
#	b[4]=3，表示原列表a中的最大元素的索引为3，即原列表a中的第4个元素为最大值
>>>list2=[[3, 2],[5, 7]]
>>>c=np.array(list2)
>>>c
array([[3, 2],[5, 7]])
>>>np.argsort(c, axis=1)
array([[1, 0],[0, 1]],dtype=int64)
# axis=1，表明按照行进行排序，即是对[3, 2]进行排序，所以得到索引为[1, 0],其他同理
>>>np.argsort(c, axis=0)
array([[0, 1],[0, 1]],dtype=int64)
# axis=0，表明按照列进行排序，即是对[3, 5]进行排序，所以得到索引为[0, 1],其他同理

参数order

>>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
>>> x
array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
>>> np.argsort(x, order=('x','y'))
# 先按照x进行比较，再按照y进行比较，即是先比较1与0
array([1, 0])
>>> np.argsort(x, order=('y','x'))
# 先按照y进行比较，再按照x进行比较，即是先比较0与1
array([0, 1])

4.lexsort

numpy.argsort(a, axis=-1, kind=‘quicksort’, order=None)

• a：所需排序的数组
• axis：数组排序时的基准，axis=0，按列排列；axis=1，按行排列
• order：一个字符串或列表，可以设置按照某个属性进行排序

>>> a=[1,5,1,4,3,4,4]
>>> b=[9,4,0,4,0,2,1]
>>> np.lexsort((b,a))
# b在前，a在后，即是先按照a的元素进行比较
# 如a中的最小值为两个1，其索引分别为0,2，再计较b中相应索引上的值，即9,0
# 对应的最小应是：1,0，而其对应的索引为2，所以排序后返回的结果第一个值为索引2
# 下一个最小应是：1,9，而其对应的索引为0，所以排序后返回的结果第一个值为索引0
# 以此类推...
array([2, 0, 4, 6, 5, 3, 1], dtype=int64)
>>> np.lexsort((a,b))
# a在前，b在后，即是先按照b的元素进行比较
# 如b中的最小值为两个0，其索引分别为0,4，再计较a中相应索引上的值，即1,3
# 对应的最小应是：0,1，而其对应的索引为2，所以排序后返回的结果第一个值为索引2
# 下一个最小应是：0,3，而其对应的索引为4，所以排序后返回的结果第一个值为索引4
# 以此类推...
array([2, 4, 6, 5, 3, 1, 0], dtype=int64)
>>> c=[[1,5,1,4,3,4,4],[9,4,0,4,0,2,1]]
>>> c
[[1, 5, 1, 4, 3, 4, 4], [9, 4, 0, 4, 0, 2, 1]]
>>> np.lexsort(c)
# 此种情况与先b后a的情况一致
array([2, 4, 6, 5, 3, 1, 0], dtype=int64)

参考：
python sort与sorted使用笔记
Python 排序—sort与sorted学习
Python——numpy排序（sort、argsort、lexsort、partition、sorted）