sort、sorted、heapq、bisect排序

aa=[1,2,8,7,0,13,28,3]
sorted(aa) #原list不变，从小到大排序

aa.sort() #改变原lis
aa.sort(reverse=True) #反转

for i in (sorted(dir(q),reverse=True)):i #方法，属性倒序显示

示例：

sorted([1,8,2,4,99],reverse=True) #从大到小排序

sorted([1,8,2,4,99],lambda x,y:y-x) #从大到小排序

#key的值应该是一个函数，这个函数接收一个参数并且返回一个用于比较的关键字。这种技术比较快，原因在于对每个输入记录，这个函数只会被调用一次。

sorted("This is a test string from Andrew".split(), key=str.lower)  #大小写不敏感排序。

student_tuples = [ ('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10), ]
sorted(student_tuples,key=lambda age:age[2]) #按年龄排序（age是lambda函数的参数，age[2]表示抽取第二列的值）
sorted(student_tuples,key=lambda age:age[0]) #按姓名排序（第一列的值）

 按第四列排序
a=os.listdir('/root')
for i in sorted(a,key = lambda x: x[4]):dir(i)

sorted()函数说明：http://www.cnblogs.com/woshitianma/p/3222989.html

同样的技术适用于有named属性的对象。例如：

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

3)Operator Module Functions (Operator模块中的函数)

上面的key-function模式很常见，因此Python提供了方便的函数使得祖先函数更简单和快捷。operator module有itemgetter,attrgetter，以及从Python2.6开始的methodcaller函数。

使用这些函数，上面的例子会变得更简单和快捷：

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

operator模块支持多级排序。例如先按成绩排序，再按年龄排序：

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

######################################################

按照文件修改时间对某个目录下所有文件进行排序（sort）：
方法一（使用key进行排序）：

dirr = 'E:IISLog'
files = [os.path.join(dirr,x) for x in os.listdir(dirr)]
files.sort(key = os.path.getmtime, reverse = True) #reverse = True实现降序排列。key在使用时必须提供一个排序过程总调用的函数（os.path.getmtime是一个方法）
print files


方法二（自定义排序方法）：

dirr = 'E:IISLog'
files = [os.path.join(dirr,x) for x in os.listdir(dirr)]
def comp(x, y): #自定义排序方法，降序
    if os.path.getmtime(x) < os.path.getmtime(y):
        return 1
    elif os.path.getmtime(x) > os.path.getmtime(y):
        return -1
    else:
        return 0

files.sort(comp)
print files #降序排列

自定义key排序：

d1={'name':'zhangsan','age':20,'contry':'China'}
d3={'name':'wangwu','age':19,'contry':'USA'}
d2={'name':'lisi','age':22,'contry':'JP'}
lst=[d1,d2,d3]
#lst要求按照每个dict中的age进行排序：

#方法一：
print sorted(lst,key = lambda x:x['name'],reverse=False)
#方法二：
print sorted(lst,key=itemgetter('age')) #lst自身不变   from operator import itemgetter
#方法三：
lst.sort(key=itemgetter('age'),reverse=True) #lst排序后自身被改变，倒序排序
print lst

返回：
[{'contry': 'JP', 'age': 22, 'name': 'lisi'}, {'contry': 'USA', 'age': 19, 'name': 'wangwu'}, {'contry': 'China', 'age': 20, 'name': 'zhangsan'}]

按照多个条件排序，先对name排序，然后对age排序：

print sorted(lst,key = lambda x:(x['name'],x['age']),reverse=False)

保持已有列表排序，插入新元素

import bisect #保持有序列表
l=[1,2,3,8,11,25] #l已排过序
bisect.insort(l,4)
print(l) #返回 [1, 2, 3, 4, 8, 11, 25]

堆排序，取list中的最大、最小值

import heapq #堆排序
l=[3,2,9,11,22,1,55,100,36,1,2]
m=heapq.nlargest(3,l) #取最大的3个数
sm=heapq.nsmallest(3,l) #取最小的3个数
print(m,sm) #返回[100, 55, 36] [1, 1, 2]


d={1:'a', 3:'d', 8:'g', 5:'m', 9:'t', 4:'s', 2:'u'} 
keys=heapq.nlargest(3,d.keys())
print([d[k] for k in keys]) #返回['t', 'g', 'm']

######################################################


sort排序：
引用：http://www.jb51.net/article/52730.htm

一、基本形式
列表有自己的sort方法，其对列表进行原址排序，既然是原址排序，那显然元组不可能拥有这种方法，因为元组是不可修改的。

x = [4, 6, 2, 1, 7, 9]
x.sort()
print x # [1, 2, 4, 6, 7, 9]

如果需要一个排序好的副本，同时保持原有列表不变，怎么实现呢

x =[4, 6, 2, 1, 7, 9]
y = x[ : ]
y.sort()
print y #[1, 2, 4, 6, 7, 9]
print x #[4, 6, 2, 1, 7, 9]

注意：y = x[:] 通过分片操作将列表x的元素全部拷贝给y，如果简单的把x赋值给y：y = x，y和x还是指向同一个列表，并没有产生新的副本。

另一种获取已排序的列表副本的方法是使用sorted函数：

x =[4, 6, 2, 1, 7, 9]
y = sorted(x)
print y #[1, 2, 4, 6, 7, 9]
print x #[4, 6, 2, 1, 7, 9]

sorted返回一个有序的副本，并且类型总是列表，如下：

1	`print` `sorted('Python')` `#['P', 'h', 'n', 'o', 't', 'y']`

二、自定义比较函数

可以定义自己的比较函数，然后通过参数传递给sort方法：

def comp(x, y):
if x < y:
return 1
elif x > y:
return -1
else:
return 0
 
nums = [3, 2, 8 ,0 , 1]
nums.sort(comp)
print nums # 降序排序[8, 3, 2, 1, 0]
nums.sort(cmp) # 调用内建函数cmp ，升序排序
print nums # 降序排序[0, 1, 2, 3, 8]

三、可选参数

sort方法还有两个可选参数：key和reverse

1、key在使用时必须提供一个排序过程总调用的函数：

x = ['mmm', 'mm', 'mm', 'm' ]
x.sort(key = len)
print x # ['m', 'mm', 'mm', 'mmm']

2、reverse实现降序排序，需要提供一个布尔值：

y = [3, 2, 8 ,0 , 1]
y.sort(reverse = True)
print y #[8, 3, 2, 1, 0]