Python 排序---sort与sorted学习

当咱们从数据库中获取一写数据后，通常对于列表的排序是常常会遇到的问题，今天总结一下python对于列表list排序的经常使用方法：

第一种：内建方法sort()

能够直接对列表进行排序

用法：

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

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

例如：

>>> list = [2,8,4,6,9,1,3]
>>> list.sort()
>>> list
[1, 2, 3, 4, 6, 8, 9]

 

第二种：内建函数sorted()

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

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

用法：

sorted(list)

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

例如：

>>> list = [2,8,4,1,5,7,3]
>>> other = sorted(list)
>>> other
[1, 2, 3, 4, 5, 7, 8]

 

扩展用法：

1.Key Function：

从Python2.4开始，list.sort() 和 sorted() 都增长了一个 ‘key’ 参数用来在进行比较以前指定每一个列表元素上要调用的函数。

例如：

区分大小写的字符串比较排序：

>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

key应该是一个函数，其接收一个参数，而且返回一个用于排序依据的key。其执行效率很高，由于对于输入记录key function可以准确的被调用。

对于复杂的对象，使用对象的下标做为key。

例如：

>>> student_tuples = [
...     ('john', 'A', 15),
...     ('jane', 'B', 12),
...     ('dave', 'B', 10),
... ]
>>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

使用对象的属性进行操做：

例如：

>>> class Student:
...     def __init__(self, name, grade, age):
...         self.name = name
...         self.grade = grade
...         self.age = age
...     def __repr__(self):
...         return repr((self.name, self.grade, self.age))
>>>
>>> student_objects = [
...     Student('john', 'A', 15),
...     Student('jane', 'B', 12),
...     Student('dave', 'B', 10),
... ]
>>> sorted(student_objects, key=lambda student: student.age)   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

 

前段时间遇到这种状况，那就是列表里面每个元素不止一个元素（好比：列表里面，元素为元祖类型），咱们除了想对第一个关键字排序以外，还想在第一次的基础上面根据第二个关键字进行排序，正好是用到的这种方法：

简化出一个例子：

咱们想先排序列表list中元素的第一个关键字，而后在第一个元素的基础上排序按第二个关键字进行排序，看结果：

>>> list = [('d',3),('a',5),('d',1),('c',2),('d',2)]
>>> print sorted(list, key = lambda x:(x[0],x[1]))
[('a', 5), ('c', 2), ('d', 1), ('d', 2), ('d', 3)]

 

2.Operator Module Functions

这个操做模块有：

• operator.itemgetter()   ----- 经过下标
• operator.attrgetter()   ----- 经过参数
• operator.methodcaller() -----python 2.5 被引入，下文详细介绍

使用这几个函数，对于上面 Key Function 的例子处理起来将会更加的简便和快速

先一块介绍 operator.itemgetter() 和 operator.attrgetter() 这俩个，会更加容易理解：

例如：

>>> from operator import itemgetter, attrgetter
>>>
>>> sorted(student_tuples, key=itemgetter(2))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>>
>>> sorted(student_objects, key=attrgetter('age'))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

这个操做模块也容许多层次的进行排序，例如能够先排序 “成绩grand” 再排序 “年龄age”

例如：

>>> sorted(student_tuples, key=itemgetter(1,2))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
>>>
>>> sorted(student_objects, key=attrgetter('grade', 'age'))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

如今回过头来发现，上面在前几天遇到的问题，能够用这个operator.itemgetter进行解决：

>>> list = [('d',3),('a',5),('d',1),('c',2),('d',2)]
>>> from operator import itemgetter
>>> sorted(list, key=itemgetter(0,1))
[('a', 5), ('c', 2), ('d', 1), ('d', 2), ('d', 3)]

可是仍是推荐 1.key function 中的方法，由于为了这一个排序而引入一个库文件，相对来讲得不偿失。

下面介绍operator.methodcaller() 函数：

这个函数是对某个对象的使用固定参数进行排序，例如：str.count() 函数能够计算每一个字符串对象中含有某个参数的个数，那运用这个函数我就能够经过 str.count() 计算出某个字符的个数从而来肯定排序的优先级：

>>> from operator import methodcaller
>>> messages = ['critical!!!', 'hurry!', 'standby', 'immediate!!']
>>> sorted(messages, key=methodcaller('count', '!'))
['standby', 'hurry!', 'immediate!!', 'critical!!!']

 

3.注意事项：

排序的稳定性：

从python2.2版本开始，排序是保障稳定性的，意思就是说，当复杂的排序中，对象有相同的key的时候，会保持原有的顺序不变：

例如：

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
>>> sorted(data, key=itemgetter(0))
[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]

能够看到，('blue',1) 和 (‘blue’,2) 的顺序仍是维持原来那样不改变。

复杂排序：

这个排序的属性可让你在一系列的步骤中构建复杂的排序操做。例如上面的例子，排序中，我想先经过 “成绩grand” 进行降序操做，而后再经过“年龄age” 进行升序操做，首先先经过 “年龄age” 排序，而后再经过 “成绩grand” 排序：

>>> s = sorted(student_objects, key=attrgetter('age'))     # sort on secondary key
>>> sorted(s, key=attrgetter('grade'), reverse=True)       # now sort on primary key, descending
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

 

4.新增的问题：

今天遇到了这么一个问题，就是遇到一个字符串的处理问题，好比说 f10 得排在 f2 的后面。找到了这么一种方法，供参考：

参考地址：http://blog.csdn.net/houyj1986/article/details/22966799

#encoding=utf-8  
print '中国'  
#根据字符串中的数字排序，如f10应该在f2后面  
import re  
  
re_digits = re.compile(r'(\d+)')  
  
def emb_numbers(s):  
    pieces=re_digits.split(s)  
    pieces[1::2]=map(int,pieces[1::2])      
    return pieces  
  
def sort_strings_with_emb_numbers(alist):  
    aux = [(emb_numbers(s),s) for s in alist]  
    aux.sort()  
    return [s for __,s in aux]  
  
def sort_strings_with_emb_numbers2(alist):  
    return sorted(alist, key=emb_numbers)  
  
filelist='file10.txt file2.txt file1.txt'.split()  
  
print filelist  
  
print '--DSU排序'  
print sort_strings_with_emb_numbers(filelist)  
  
print '--内置DSU排序'  
print sort_strings_with_emb_numbers2(filelist)  

打印结果以下：

中国
['file10.txt', 'file2.txt', 'file1.txt']
--DSU排序
['file1.txt', 'file2.txt', 'file10.txt']
--内置DSU排序
['file1.txt', 'file2.txt', 'file10.txt']