Python学习系列之sort和sorted

排序函数

sort是列表的内置排序函数只能作用于列表。sort() 是Python内置的一个排序函数，它会从一个迭代器返回一个排好序的新列表。是内建高级函数，是可以对可迭代对象进行排序的函数。可迭代对象包括列表，集合，字典，但是返回一个列表。

sort

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。永久性的修改元素的排列顺序。也就是无法恢复原来的顺序。

函数原型：

list.sort(cmp=None, key=None, reverse=False)

参数说明： 

• cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

返回值：

该方法没有返回值，但是会对列表的对象进行排序。返回值为None。

示例：

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
 
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
 
# 指定第二个元素排序
random.sort(key=takeSecond)
 
# 输出类别
print '排序列表：', random
排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

sorted

sorted() 函数对所有可迭代的对象进行排序操作。

函数原型：

sorted(iterable, cmp=None, key=None, reverse=False)
sorted(iterable[, cmp[, key[, reverse]]])

参数说明：

• iterable -- 可迭代对象。
• cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。相当于比较器，可以比较两个参数的大小的比较函数。返回值: 负数: e1 < e2, 0: e1 == e2, 正数: e1 > e2. 默认为 None, 即用内建的比较函数。比较的参数是key函数处理之后的可迭代对象里的元素。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。对参数（可迭代对象的单个元素）进行映射和处理，用来为每个元素提取比较值。默认为 None，即直接比较每个元素。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

通常, key 和 reverse 比 cmp 快很多, 因为对每个元素它们只处理一次; 而 cmp 会处理多次。cmp与key均可以采用lambda表达式，因为都是函数参数。采用cmp是确定排序方式，如何去排序（如：从大到小还是从小到大），排序的key是函数自己选择；采用key是确定排序的key，排序方式是函数自己选择。

返回值：

返回重新排序的新的列表。

示例：

>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

利用key函数实现自定义排序

sorted()函数也是一个高阶函数，它可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']

 key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。

sorted函数作用于元组 

>>> a = (1,2,4,2,3)   # a 是元组，故不能用sort() 排序
>>> a.sort()
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'sort'
>>> sorted(a)    # sorted() 可以为元组排序，返回一个新有序列表
[1, 2, 2, 3, 4]
>>> a=['1',1,'a',3,7,'n']
>>> sorted(a)
[1, 3, 7, '1', 'a', 'n']
>>> a     # sorted() 不改变原列表
['1', 1, 'a', 3, 7, 'n']     
>>> print a.sort()
None
>>> a      # a.sort()直接修改原列表
[1, 3, 7, '1', 'a', 'n']

sorted函数作用于字典

作用于任何可迭代对象都返回列表

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})     # 根据字典键排序
[1, 2, 3, 4, 5]
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}.values())    # 根据字典值排序
['A', 'B', 'B', 'D', 'E']

sorted函数对多维列表排序

>>> student_tuples = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10)]
>>> sorted(student_tuples, key = lambda student: student[0]) # 对姓名排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> sorted(student_tuples, key = lambda student: student[2])  # 年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

 调用operator模块中的 itemgetter() 可以实现根据多个参数排序

>>> sorted(student_tuples, key = itemgetter(2))  # 根据年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> sorted(student_tuples, key = itemgetter(1, 2))  # 根据成绩和年龄排序
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
>>> sorted(student_tuples, key = itemgetter(1, 2), reverse=True) # 反转排序结果
[('jane', 'B', 12), ('dave', 'B', 10), ('john', 'A', 15)]

注： itemgetter 返回一个函数，实现取元素的功能。比如
f = itemgetter(2)，调用 f(r) 返回 r[2];
f = itemgetter(2, 5, 3)，调用 f(r) 返回元组 (r[2], r[5], r[3]). 

sort 与 sorted 区别

1. sort 是应用在 list 上的方法；sorted 可以对所有可迭代的对象进行排序操作，可迭代对象作为参数传入。
2. list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作，新创建的对象。
3. 两个函数类似于Java的列表排序及比较器，都是默认是数字比较大小，字符串是字典比较大小。除非加参数（策略设计模式？好像是）。
4. sort() 是Python列表的一个内置的排序方法，元组不能用sort() 排序。sorted() 可以为元组排序，返回一个新有序列表。
5. 因为 sort() 函数不需要复制原有列表，消耗的内存较少，效率也较高。

在java中默认对基本类型采用快速排序，对引用类型采用归并排序。