0、基础

主要用到list.sort()、sorted()、lambda进行各种排序操作。其中：list.sort()是Python列表的一个内置排序方法，只供list结构使用，list.sort()方法排序时直接修改原列表，返回None。而sorted()函数接受一切迭代器，返回新列表。相比list.sort()，sorted()使用范围更广，但是如果不需要保留原列表的情况下对列表排序，可以选择list.sort()方法，不需要复制原有列表，消耗内存小，效率也较高。

list.sort()

list.sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语法

list.sort(cmp=None, key=None, reverse=False)

|参数

  • cmp：可选参数，如果指定了该参数则使用该参数的方法进行排序，Python3取消了该参数；
  • key：用来进行比较的元素，取自可迭代对象中，指定可迭代对象中的一个元素来进行排序；
  • reverse：排序规则，True降序，False升序（默认）；
  • 返回值
    • 该方法直接修改原列表，返回None；

示例

|

# 列表排序  
test = ['Google', 'Runoob', 'Taobao', 'Facebook']  
test.sort()  
print(test)  
# result:  
# ['Facebook', 'Google', 'Runoob', 'Taobao']  
  
# 列表降序排序  
vowels = ['e', 'a', 'u', 'o', 'i']  
vowels.sort(reverse=True)  
print (vowels)  
# result:  
# ['u', 'o', 'i', 'e', 'a']

sorted()

sorted() 函数对所有可迭代对象进行排序操作。

语法

sorted(iterable, key=None, reverse=False)
  • 参数
    • iterable：可迭代对象；
    • key：用来进行比较的元素，取自可迭代对象中，指定可迭代对象中的一个元素来进行排序；
    • reverse：排序规则，True降序，False升序（默认）；
  • 返回值
    • 返回排序好的列表；

示例

# 排序  
sorted([5, 2, 3, 1, 4])  
# result：  
# [1, 2, 3, 4, 5]  
  
# 降序排序  
example_list = [5, 0, 6, 1, 2, 7, 3, 4]  
sorted(example_list, reverse=True)  
# result：  
# [7, 6, 5, 4, 3, 2, 1, 0]

lambda

Python使用lambda创建匿名函数，即不使用def这样的标准语句来定义函数，允许快速定义单行函数，类似于C语言的宏，可以用在任何需要函数的地方。

  • lambda的主体是一个表达式，而不是一个代码块，仅能在其中封装有限的逻辑；
  • lambda函数拥有自己的命名空间，不能访问参数列表之外或全局命名空间里的参数；
  • lambda并不会带来程序效率的提高，只是使代码更简洁？

语法

lambda [arg1 [,arg2,.....argn]]:expression

上述用法等价于：

def <lambda>(arg1 [,arg2,......argn]):  
    return expression

示例

sum = lambda arg1, arg2: arg1 + arg2  
   
# 调用sum函数  
print ("sum(10,20) = ", sum( 10, 20 ))  
print ("sum(20,30) = ", sum( 20, 30 ))  
  
# result:  
# sum(10,20) = 30  
# sum(20,30) = 50

1、各种排序

参考链接

1.1、list排序

lis = ['a', 'b', 'c']  
  
print(sorted(lis))  
# ['a', 'b', 'c']  
print(sorted(lis, reverse=True))  
# ['c', 'b', 'a']  
  
lis.sort()  
print(lis)  
# ['a', 'b', 'c']  
lis.sort(reverse=True)  
print(lis)  
# ['c', 'b', 'a']

1.2、dict按key排序

dic = {'c': 1, 'b': 2, 'a': 3}  
print(sorted(dic))  
# ['a', 'b', 'c']  
print(sorted(dic, reverse=True))  
# ['c', 'b', 'a']

1.3、dict按value排序

dic = {'c': 1, 'b': 2, 'a': 3}  
print(sorted(dic, key=lambda k: dic[k]))  
# ['c', 'b', 'a']  
print(sorted(dic, key=lambda k: dic[k], reverse=True))  
# ['a', 'b', 'c']

1.4、list内嵌套list排序

lis = [[4, 2, 9], [1, 5, 6], [7, 8, 3]]  
print(sorted(lis, key=lambda k: k[0]))  
# [[1, 5, 6], [4, 2, 9], [7, 8, 3]]  
print(sorted(lis, key=lambda k: k[1]))  
# [[4, 2, 9], [1, 5, 6], [7, 8, 3]]  
print(sorted(lis, key=lambda k: k[2]))  
# [[7, 8, 3], [1, 5, 6], [4, 2, 9]]  
print(sorted(lis, key=lambda k: k[0], reverse=True))  
# [[7, 8, 3], [4, 2, 9], [1, 5, 6]]

1.5、dict内嵌套dict排序

dic = {  
    'a': {'x': 3, 'y': 2, 'z': 1},  
    'b': {'x': 2, 'y': 1, 'z': 3},  
    'c': {'x': 1, 'y': 3, 'z': 2},  
}  
print(sorted(dic, key=lambda k: dic[k]['x']))  
# ['c', 'b', 'a']  
print(sorted(dic, key=lambda k: dic[k]['y']))  
# ['b', 'a', 'c']  
print(sorted(dic, key=lambda k: dic[k]['z']))  
# ['a', 'c', 'b']  
print(sorted(dic, key=lambda k: dic[k]['x'], reverse=True))  
# ['a', 'b', 'c']

1.6、list内嵌套dict排序

lis = [  
    {'x': 3, 'y': 2, 'z': 1},  
    {'x': 2, 'y': 1, 'z': 3},  
    {'x': 1, 'y': 3, 'z': 2},  
]  
print(sorted(lis, key=lambda k: k['x']))  
# [{'z': 2, 'x': 1, 'y': 3}, {'z': 3, 'x': 2, 'y': 1}, {'z': 1, 'x': 3, 'y': 2}]  
print(sorted(lis, key=lambda k: k['y']))  
# [{'z': 3, 'x': 2, 'y': 1}, {'z': 1, 'x': 3, 'y': 2}, {'z': 2, 'x': 1, 'y': 3}]  
print(sorted(lis, key=lambda k: k['z']))  
# [{'z': 1, 'x': 3, 'y': 2}, {'z': 2, 'x': 1, 'y': 3}, {'z': 3, 'x': 2, 'y': 1}]  
print(sorted(lis, key=lambda k: k['x'], reverse=True))  
# [{'z': 1, 'x': 3, 'y': 2}, {'z': 3, 'x': 2, 'y': 1}, {'z': 2, 'x': 1, 'y': 3}]

1.7、dict内嵌套list排序

dic = {  
    'a': [1, 2, 3],  
    'b': [2, 1, 3],  
    'c': [3, 1, 2],  
}  
print(sorted(dic, key=lambda k: dic[k][0]))  
# ['a', 'b', 'c']  
print(sorted(dic, key=lambda k: dic[k][1]))  
# ['b', 'c', 'a']  
print(sorted(dic, key=lambda k: dic[k][2]))  
# ['c', 'b', 'a']  
print(sorted(dic, key=lambda k: dic[k][0], reverse=True))  
# ['c', 'b', 'a']

1.8、按照多个参数排序

使用operator模块的itemgetter()实现。

from operator import itemgetter  
student_tuples = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10)]  
  
print (sorted(student_tuples, key = itemgetter(2)))  # 根据年龄排序  
print (sorted(student_tuples, key = itemgetter(1, 2)))  # 根据成绩和年龄排序  
print (sorted(student_tuples, key = itemgetter(1, 2), reverse=True)) # 反转排序结果  
  
# result:  
# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]  
# [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]  
# [('jane', 'B', 12), ('dave', 'B', 10), ('john', 'A', 15)]

2、其他

list排序可视情况采用sorted()或list.sort()，其他各种排序主要是sorted()和lambda的结合操作；

dict的排序只取其key，所以需要对value操作时需要在lambda中先转换为对应的value才可以；

排序是稳定的，即如果多个元素有相同的key，则排序前后其先后顺序不变；

字典的排序：在学习python的时候，字典是一个无序的数据结构，一般都不对其进行排序的。但是要想对字典进行排序，是可以通过sorted()函数进行操作的。sorted()默认是按照升序排列，并且是按照ASCII码表的顺序排列的。
sorted函数的介绍：
sorted( iterable, key, reverse)
（1）iterable：是可迭代类型的数据;
（2）key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;
（3）reverse：排序规则. reverse = True 或者 reverse = False，有默认值，默认为升序排列False

关于字典的排序，下面从键key 和 值value 进行代码的运行和分析：

# 先定义一个字典，首先声明注意一点，字典中的值需要为同一种数据类型；比如在本案例中的值都是字符串类型。
sys = {'name': '张三',
       'age': '十八',
       'gender': 'man'}

①根据字典的key排序

#  单独打印出排序后的key值
new_sys = sorted(sys)
print(new_sys)

# 根据key的升序排列，把key value都打印出来
new_sys1 = sorted(sys.items(), key=lambda d: d[0], reverse=False)
print(new_sys1)

打印结果：

[‘age’, ‘gender’, ‘name’]
    [(‘age’, ‘十八’), (‘gender’, ‘man’), (‘name’, ‘张三’)]
  1. new_sys = sorted(sys)将字典直接传入到sorted函数中 ，sorted函数会默认根据字典的键k对字典进行排序，同时只取字典的键k的内容，并以列表的形式返回。
  2. new_sys1 = sorted(sys.items(), key=lambda d: d[0], reverse=False)其中sys.items()这段代码，在打印输出后，会显示如下结果：dict_items([(‘name’, ‘张三’), (‘age’, ‘十八’), (‘gender’, ‘man’)])，将原来的字典中的键值对分别搜存入到一个元组中–>(key,value)。key=lambda d: d[0]是一个匿名函数；其中：d == (‘name’, ‘张三’) 或 (‘age’, ‘十八’)或(‘gender’, ‘man’)，d[0]是获取每个元组中的第一个元素，就是原sys字典中的key；并将匿名函数的返回值返回给sorted函数的key参数reverse=False 排序默认是按照升序排列的，也可以改为True。

②根据字典的value值进行排序

# 单独打印出排序后的value值
new_sys1 = sorted(sys.values())
print(new_sys1)

# 打印出根据value排序后的键值对的具体值
new_sys2 = sorted(sys.items(),  key=lambda d: d[1], reverse=False)
print(new_sys2)

打印结果：

[‘man’, ‘十八’, ‘张三’]
    [(‘gender’, ‘man’), (‘age’, ‘十八’), (‘name’, ‘张三’)]
  1. sorted(sys.values())sorted函数默认是根据键key排序的，所以想要根据值value排序，就需要在sys后面使用values()，获取字典的value值
  2. new_sys2 = sorted(sys.items(), key=lambda d: d[1], reverse=False)其中d == (‘name’, ‘张三’) 或 (‘age’, ‘十八’)或(‘gender’, ‘man’)， d[1]是获取每个元组中的第二个元素，就是原sys字典中的value；并将匿名函数的返回值返回给sorted函数的key参数