【4.9】python排序--sort()、reversed()、sorted()、reverse
一、python排序
1.1 reverse()
是python中列表的一个内置方法（也就是说，在字典，字符串或者元组中，是没有这个内置方法的），用于列表中数据的反转；
lista = [1, 2, 3, 4]
lista.reverse()
print(lista)
该方法没有返回值，但是会对列表的元素进行反向排序
1.2 reversed()
而reversed()是python自带的一个方法，准确说，应该是一个类； 关于reversed()官方解释：
reversed(sequence) -> reverse iterator over values of the sequence
Return a reverse iterator
也就是说，在经过reversed()的作用之后，返回的是一个把序列值经过反转之后的迭代器，所以，需要通过遍历，或者List,或者next()等方法，获取作用后的值；
下面通过几个案例进行说明：
1.列表的反转：
bb = [1,3,5,7]
print(list(reversed(bb)))
打印结果：
[7, 5, 3, 1]
2.元组的反转：
aa = (1, 2, 3)
print(tuple(reversed(aa)))
打印结果：
(3, 2, 1)
3.字符串的反转
ss = "qwer1234"
print(''.join(reversed(ss)))
打印结果：
4321rewq
1.3 让人糊涂的sort()与sorted()
在Python 中sorted是内建函数(BIF),而sort()是列表类型的内建函数list.sort()。
sorted(iterable[, cmp[, key[, reverse]]])
#字符串排序使用是字典序，而非字母序
"""sorted()按照字典序排序"""
lis = ['a','c','z','E','T','C','b','A','Good','Tack']
print sorted(lis) #['A', 'C', 'E', 'Good', 'T', 'Tack', 'a', 'b', 'c', 'z']
sort()
.sort([cmp[, key[, reverse]]])
a.sort() 已改变其结构，b = a.sort() 是错误的写法! 而 sorted(a, …)并没有改变a的结构。
二、python字典的排序
1、关于Python字典的一些特征
无序：
字典，形如 dic = {'a':1 , 'b':2 , 'c': 3} ,字典中的元素没有顺序，所以dic[0]是有语法错误的。
无重：
不可以有重复的键值，所以 dic.add[‘c’] = 4后，字典变成 {‘a’:1 , ‘b’:2 , ‘c’: 4}.
2、根据“键”或“键值”进行不同顺序的排序
函数原型：sorted(dic,value,reverse)
<strong>解释：</strong>dic为比较函数，value 为排序的对象（这里指键或键值），
reverse：注明升序还是降序，True--降序，False--升序（默认）
3、例子
dic = {'a':31, 'bc':5, 'c':3, 'asd':4, '33':56, 'd':0}
想把dic的value按照从大到小排序（value都是整数）。
dic = {'a':31, 'bc':5, 'c':3, 'asd':4, '33':56, 'd':0}
print sorted(dic.iteritems(), key=lambda d:d[1], reverse = False )
#[('d', 0), ('c', 3), ('asd', 4), ('bc', 5), ('a', 31), ('33', 56)]
4.多重排序
先按Big后small排序
sort_lis = sorted(lis, key=lambda s:(s['Big'], s['small]))
lis={"a1":{'Big':13,'small':21},"a2":{'Big':1,'small':21},"a3":{'Big':13,'small':23}}
print lis
aa=sorted(lis.items(),key=lambda (k,v):(v["Big"],v["small"]),reverse=False)
print aa
5.字典，按d[key][1] 排序
d = { 'a1': ['g',6],
'a2': ['e',2],
'a3': ['h',3],
'a4': ['s',2],
'a5': ['j',9],
'a6': ['y',7] }
# L = sorted(d, key=lambda k:d[k][1])
# L = sorted(d, key=lambda k:d[k][0])
L = sorted(d.items(), key=lambda (k, v): v[1])
# L [('a2', ['e', 2]), ('a4', ['s', 2]), ('a3', ['h', 3]), ('a1', ['g', 6]), ('a6', ['y', 7]), ('a5', ['j', 9])]
# 获取排序后的key
map(lambda (k,v): k, L)
# ['a2', 'a4', 'a3', 'a1', 'a6', 'a5']
三、python3的新玩法
list
line_seq_value_list = sorted(line_seq_value_list, key=lambda s: s[1], reverse=True)[0:self.wwj_fragmentTopNum]
hash
sorted_top_terminal_type_seqs = sorted(top_terminal_type_seqs.items(),key=lambda vv:vv[1]['score'],reverse=True )
-
设值reverse=True 进行反向排序
-
dict1.items()，得到包含键，值的元组。由于迭代对象是元组，返回值自然是元组组成的列表，这里对排序的规则进行了定义，x指元组，x[1]是值，x[0]是键
dict1={‘a’:2,‘e’:3,‘f’:8,’d':4} list1= sorted(dict1.items(),key=lambda x:x[1]) print(list1)
结果为：
[('a', 2), ('e', 3), ('d', 4), ('f', 8)]
参考资料
