转 Python 字典 列表 嵌套 复杂排序大全

原：https://blog.csdn.net/ray_up/article/details/42084863

一: 字典排序

解析: 使用sorted 方法, 排序后的结果为一个元组. 可以字符串排序(那数字肯定更没问题了!)   

1:  按照键值(value)排序

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = {
     
     'a': 
     
     'China', 
     
     'c': 
     
     'USA', 
     
     'b': 
     
     'Russia', 
     
     'd': 
     
     'Canada'}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     b = sorted(a.items(), key=
     
     lambda x: x[
     
     1], reverse=
     
     True)
    
    
   
   
 
 

结果:

[('c', 'USA'), ('b', 'Russia'), ('a', 'China'), ('d', 'Canada')]
 
 

2: 按照键名(key)排序

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = {
     
     'a': 
     
     'China', 
     
     'c': 
     
     'USA', 
     
     'b': 
     
     'Russia', 
     
     'd': 
     
     'Canada'}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     b = sorted(a.items(), key=
     
     lambda x: x[
     
     0], reverse=
     
     True)
    
    
   
   
 
 

结果:

[('d', 'Canada'), ('c', 'USA'), ('b', 'Russia'), ('a', 'China')]

 
 

3: 嵌套字典, 按照字典键名(key)排序

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = {
     
     'a': {
     
     'b':  
     
     'China'}, 
     
     'c': {
     
     'd': 
     
     'USA'}, 
     
     'b': {
     
     'c': 
     
     'Russia'}, 
     
     'd': {
     
     'a': 
     
     'Canada'}}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     b = sorted(a.items(), key=
     
     lambda x: x[
     
     1], reverse=
     
     True)
    
    
   
   
 
 

结果:

[('c', {'d': 'USA'}), ('b', {'c': 'Russia'}), ('a', {'b': 'China'}), ('d', {'a': 'Canada'})]
 
 

4: 嵌套列表, 针对列表第一个元素排序( 其实直接写 x: x[1] 就是按照第一个值排序. )

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = {
     
     'a': [
     
     1, 
     
     3], 
     
     'c': [
     
     3, 
     
     4], 
     
     'b': [
     
     0, 
     
     2], 
     
     'd': [
     
     2, 
     
     1]}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     b = sorted(a.items(), key=
     
     lambda x: x[
     
     1][
     
     0], reverse=
     
     True)
    
    
   
   
 
 

结果:

[('c', [3, 4]), ('d', [2, 1]), ('a', [1, 3]), ('b', [0, 2])]
 
 

4-2: 嵌套列表, 按照列表其他元素排序  只需要修改列表对应的下标

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = {
     
     'a': [
     
     1, 
     
     3], 
     
     'c': [
     
     3, 
     
     4], 
     
     'b': [
     
     0, 
     
     2], 
     
     'd': [
     
     2, 
     
     1]}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     b = sorted(a.items(), key=
     
     lambda x: x[
     
     1][
     
     1], reverse=
     
     True)
    
    
   
   
 
 

结果:

[('c', [3, 4]), ('a', [1, 3]), ('b', [0, 2]), ('d', [2, 1])]
 
 

总结:  此处使用lambda方法, x: x[1][1] 就可以看做是在访问字典的值, 想要按照哪个数值排序, 用相应的坐标对应即可, 但当字典过于复杂后, 应该选择用元组存储, 简化排序过程. 

===========================列表排序========================
二: 列表排序

1: 按照字母排序

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = [
     
     'USA', 
     
     'China', 
     
     'Canada', 
     
     'Russia']
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     a.sort(reverse=
     
     True)
    
    
   
   
 
 

结果:

['USA', 'Russia', 'China', 'Canada']
 
 

2; 嵌套列表的排序, 按照子列表的其他值排序雷系, 修改x[0] 这里的下标即可

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = [[
     
     'USA', 
     
     'b'], [
     
     'China', 
     
     'c'], [
     
     'Canada', 
     
     'd'], [
     
     'Russia', 
     
     'a']]
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     a.sort(key=
     
     lambda x: x[
     
     0], reverse=
     
     True)
    
    
   
   
 
 

结果:

[['USA', 'b'], ['Russia', 'a'], ['China', 'c'], ['Canada', 'd']]
 
 

3: 嵌套字典, 按照字典值(value) 排序

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = [{
     
     'letter': 
     
     'b'}, {
     
     'letter': 
     
     'c'}, {
     
     'letter': 
     
     'd'}, {
     
     'letter': 
     
     'a'}]
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     a.sort(key=
     
     lambda x: x[
     
     'letter'], reverse=
     
     True)
    
    
   
   
 
 

结果:

[{'letter': 'd'}, {'letter': 'c'}, {'letter': 'b'}, {'letter': 'a'}]
 
 

当字典值也是字典时, 这时候会优先按照键名排序, 再按照键值排序. 例子如下

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = [{
     
     'letter': {
     
     'a': 
     
     'b'}}, {
     
     'letter': {
     
     'a': 
     
     'c'}}, {
     
     'letter': {
     
     'a': 
     
     'd'}}, {
     
     'letter': {
     
     'a': 
     
     'a'}}]
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     a.sort(key=
     
     lambda x: x[
     
     'letter'], reverse=
     
     True)
    
    
   
   
 
 

结果:

[{'letter': {'a': 'd'}}, {'letter': {'a': 'c'}}, {'letter': {'a': 'b'}}, {'letter': {'a': 'a'}}]
 
 

和

 
 

   
   

    
    

   
   
   
   

    
    

     
     a = [{
     
     'letter': {
     
     'a': 
     
     'b'}}, {
     
     'letter': {
     
     'b': 
     
     'c'}}, {
     
     'letter': {
     
     'c': 
     
     'd'}}, {
     
     'letter': {
     
     'd': 
     
     'a'}}]
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     a.sort(key=
     
     lambda x: x[
     
     'letter'], reverse=
     
     True)
    
    
   
   
 
 

结果:

[{'letter': {'d': 'a'}}, {'letter': {'c': 'd'}}, {'letter': {'b': 'c'}}, {'letter': {'a': 'b'}}]
 
 

总结: 

常规查询均能够只用lambda实现, 另外还有其他方法, 比如使用operator包中的方法.  本处没有比较各个方法的效率, python 为2.7.8版本

总的来说, 上面的例子已经很详尽, 基本覆盖常见情况, 如有没有罗列, 请指正, 一起探讨!