python字典排序

输入为字典，返回依然为字典

sorted函数
sorted(iterable,key,reverse)
sorted一共有iterable，key，reverse这三个参数：

iterable表示可以迭代的对象，例如可以是dict.items()、dict.keys()等，
key是一个函数，用来选取参与比较的元素，
reverse则是用来指定排序是倒序还是顺序，reverse=true则是倒序（从大到小），reverse=false则是顺序，默认是reverse=false。

按照key排序
要对字典按照key排序：
# 声明字典
my_dict = {'bmw':60, 'audi':10, 'benz':12}
print(my_dict)
# 根据key排序，依照lambda表达式
my_dict =dict(sorted(my_dict.items(),key=lambda item:item[0]))
# 输出结果
print(my_dict)

输出结果为：
{'bmw': 60, 'audi': 10, 'benz': 12}
{'audi': 10, 'benz': 12, 'bmw': 60}

按照value排序
共有三种方法可以实现将字典按照value值进行排序
（1）key使用lambda匿名函数取value进行排序
# 声明字典
my_dict = {'bmw':60, 'audi':10, 'porsche' : 8 ,'benz':12 }
print(my_dict)
# 根据value排序，依照lambda表达式
my_dict =dict(sorted(my_dict.items(),key=lambda item:item[1]))
# 输出结果
print(my_dict)

输出结果为
{'bmw': 60, 'audi': 10, 'porsche': 8, 'benz': 12}
{'porsche': 8, 'audi': 10, 'benz': 12, 'bmw': 60}

如果需要倒序则
my_dict =dict(sorted(my_dict.items(),key=lambda item:item[1] , reverse=True))

得到的结果就会是
{'bmw': 60, 'audi': 10, 'porsche': 8, 'benz': 12}
{'bmw': 60, 'benz': 12, 'audi': 10, 'porsche': 8}

（2）使用operator的itemgetter进行排序
import operator
# 声明字典
my_dict = {'bmw':60, 'audi':10, 'porsche' : 8 ,'benz':12 }
print(my_dict)
# 根据value排序，依照itemgetter表达式
my_dict =dict(sorted(my_dict.items(),key=operator.itemgetter(1)))
# 输出结果
print(my_dict)

输出结果为
{'bmw': 60, 'audi': 10, 'porsche': 8, 'benz': 12}
{'porsche': 8, 'audi': 10, 'benz': 12, 'bmw': 60}

Python 字典排序
1. 按键（key）排序
dict1 = {}
dict1[1] = 2
dict1[3] = 24
dict1[2] = 12
dict1[5] = 10
dict1[4] = 30
print(f"排序前字典：{dict1}")
new_dict = dict(sorted(dict1.items()))
print(f"排序后字典：{new_dict}")

--------------------------------------
# 代码运行结果：
"""
排序前字典：{1: 2, 3: 24, 2: 12, 5: 10, 4: 30}
排序后字典：{1: 2, 2: 12, 3: 24, 4: 30, 5: 10}
"""
# 注意：sorted默认升序排列

2. 按值（value）排序
dict1 = {}  
dict1[1] = 2  
dict1[3] = 24  
dict1[2] = 12  
dict1[5] = 10  
dict1[4] = 30  
print(f"排序前字典：{dict1}")  
new_dict = dict(sorted(dict1.items(), key=lambda x: x[1], reverse=True))  
print(f"排序后字典：{new_dict}")
--------------------------------------
# 代码运行结果：
"""
排序前字典：{1: 2, 3: 24, 2: 12, 5: 10, 4: 30}
排序后字典：{4: 30, 3: 24, 2: 12, 5: 10, 1: 2}
"""
# 注意：sorted默认升序排列，reverse=True，降序排列

3.  字典列表排序
lis = [  
    {"name": "T", "age": 50},  
    {"name": "R", "age": 7},  
    {"name": "G", "age": 50},  
    {"name": "W", "age": 80}  
]  
  
# 通过 age 升序排序  
print("列表通过 age 升序排序: ")  
print(sorted(lis, key=lambda i: i['age']))  
# 先按 age 排序，再按 name 排序  
print("列表通过 age 和 name 排序: ")  
print(sorted(lis, key=lambda i: (i['age'], i['name'])))  
# 按 age 降序排序  
print("列表通过 age 降序排序: ")  
print(sorted(lis, key=lambda i: i['age'], reverse=True))

----------------------------------------------------------------
# 代码运行结果
"""
列表通过 age 升序排序: 
[{'name': 'R', 'age': 7}, {'name': 'T', 'age': 50}, {'name': 'G', 'age': 50}, {'name': 'W', 'age': 80}]
列表通过 age 和 name 排序: 
[{'name': 'R', 'age': 7}, {'name': 'G', 'age': 50}, {'name': 'T', 'age': 50}, {'name': 'W', 'age': 80}]
列表通过 age 降序排序: 
[{'name': 'W', 'age': 80}, {'name': 'T', 'age': 50}, {'name': 'G', 'age': 50}, {'name': 'R', 'age': 7}]
"""

4. itemgetter 排序
from operator import itemgetter

dict1 = {
    "a": 10,
    "c": 20,
    "d": 15,
    "b": 5
}
print(f"排序前，原始字典数据{dict1}")
print("key值排序，降序：")
print(sorted(dict1.items(), key=itemgetter(0), reverse=True))
print("value值排序，降序：")
print(sorted(dict1.items(), key=itemgetter(1), reverse=True))
----------------------------------------------------------------
# 注意：itemgetter(0) 获取key值，
# itemgetter(1) 获取value值。
# 代码运行结果：
"""
排序前，原始字典数据{'a': 10, 'c': 20, 'd': 15, 'b': 5}
key值排序，降序：
[('d', 15), ('c', 20), ('b', 5), ('a', 10)]
value值排序，降序：
[('c', 20), ('d', 15), ('a', 10), ('b', 5)]
"""

                                                       python 字典排序    


import operator
dict={'a':1,'b':4,'c':3}
sortedDict=sorted(dict.iteritems(),key=operator.itemgetter(0),reverse=True)
sortedDict1=sorted(dict.iteritems(),key=operator.itemgetter(1),reverse=True)
sortedDict2=sorted(dict.iteritems(),key=lambda asd:asd[0],reverse=True)
sortedDict3=sorted(dict.iteritems(),key=lambda asd:asd[1],reverse=True)
print  "sorted",sortedDict
print  "sorted",sortedDict1
print  "sorted",sortedDict2
print  "sorted",sortedDict3

利用引出一个例子来理解
例如：比如使用Python字典排序，d={'a':1,'c':3,'b':2}按值升序排列，我们可以用sorted高阶函数或者用列表的.sort()方法。下面具体阐述两种排序方法：
一、sorted高阶函数
d={'a':1,'c':3,'b':2}   #首先建一个字典dd.items()      #d.items()返回的是： dict_items([('a', 1), ('c', 3), ('b', 2)])
d_result=sorted(d.items(),key=lambda x:x[1],reverse=False) #按字典集合中，每一个元组的第二个元素排列。x相当于字典集合中遍历出来的一个元组。
print(d_result) #得到:  [('a', 1), ('b', 2), ('c', 3)]
sorted排序方法：
1. sorted高阶函数语法格式：  sorted(可迭代对象,key=函数名,reverse=False/True)
作用：从可迭代对象中，依次取出一个元素，该元素再按照key规定的排列依据排序。
可迭代对象：即可依次取值的对象，例如：集合，序列（列表，字符串，元组），字典等。
key : 是列表排列的依据，一般可以自定义一个函数返回排序的依据，再把函数名绑定给key。
reverse : 译为反转，reverse默认等于False，从小到大排序。等于True时，从大到小排序。
2. 匿名函数lambda的格式：    函数名 = lambda  [形参1,形参2,...] :  ，返回操作语句块产生的结果并绑定给函数名。
例如：key=lambda x : x[1]
# x：相当于字典集合中的一个元组， 例：dict_items([('a', 1), ('c', 3), ('b', 2)])中的('a', 1)或('c', 3)或('b', 2)
# x[1]: 返回x中的第二个元素，即键值对元组中的值。dict_items([('a', 1), ('c', 3), ('b', 2)])中的1或2或3
注意：
1. sorted函数中的可迭代对象不要用字典d，那样只能迭代出的字典d的键。要用d.items()才可迭代出字典的键值对。
例：不能用 d_result=sorted(d,key=lambda x:x[1],reverse=False)，要用 d_result=sorted(d.items(),key=lambda x:x[1],reverse=False)
2. sorted函数排好序后，要绑定一个对象(赋值)
例：d_result=sorted(d.items(),key=lambda x:x[1],reverse=False)，因为字典是无序类型，用sorted函数排好序后不绑定d_result，字典会自动打乱顺序。
二、列表的.sort()方法
Python中的字典是无序类型，没有自己的排序方法。但可以用列表的.sort()方法来进行排序。
首先要把字典转换为列表，再进行排序。
d={'a':1,'c':3,'b':2}    #首先建一个字典dd.items()#得到: dict_items([('a', 1), ('c', 3), ('b', 2)])L=list(d.items())       #得到列表: L=[('a', 1), ('c', 3), ('b', 2)]L.sort(key=lambda x:x[1],reverse=False)  #按列表中，每一个元组的第二个元素从小到大排序。x代表从L中遍历出的一个元组
print(L)      #得到:  [('a', 1), ('b', 2), ('c', 3)]
注意：
1.上面的例子中最要的一步就是：  L=list(d.items()),  即： L = list(dict_items([('a', 1), ('c', 3), ('b', 2)])
用list()列表构造函数，将L= dict_items([('a', 1), ('c', 3), ('b', 2)]) 转变为列表，得到列表:  L=[('a', 1), ('c', 3), ('b', 2)] 。
list()构造函数可以把 d.items()产生的dict_items键值对集合类型，直接变成列表。
2.列表的L.sort()方法：  L.sort(key=函数名,reverse=False/True)
L.sort()：会自动遍历列表中的元素，即依次取出一个元素。再以key绑定的函数为依据排序。
例如： L.sort(key=lambda x:x[1],reverse=False)       #L=[('a', 1), ('c', 3), ('b', 2)]
从列表L中取出第一个元素('a', 1)元组，以元组的第二个元素'1'为排序依据，再依次从列表中依次取出第二，第三,...个元素确定排序依据，最后reverse=False，按从小到大的顺序排列。