Python各种排序

发表于 | 分类于 | 评论数： | 阅读次数：

0、基础

主要用到list.sort()、sorted()、lambda进行各种排序操作。

其中：list.sort()是Python列表的一个内置排序方法，只供list结构使用，list.sort()方法排序时直接修改原列表，返回None。而sorted()函数接受一切迭代器，返回新列表。

相比list.sort()，sorted()使用范围更广，但是如果不需要保留原列表的情况下对列表排序，可以选择list.sort()方法，不需要复制原有列表，消耗内存小，效率也较高。

list.sort()

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

语法

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

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
# 列表排序
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()函数对所有可迭代对象进行排序操作。

语法

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

示例

1
2
3
4
5
6
7
8
9
10
# 排序
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并不会带来程序效率的提高，只是使代码更简洁？

语法

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

上述用法等价于：

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

示例

1
2
3
4
5
6
7
8
9
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排序

1
2
3
4
5
6
7
8
9
10
11
12
13
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排序

1
2
3
4
5
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排序

1
2
3
4
5
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排序

1
2
3
4
5
6
7
8
9
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排序

1
2
3
4
5
6
7
8
9
10
11
12
13
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排序

1
2
3
4
5
6
7
8
9
10
11
12
13
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排序

1
2
3
4
5
6
7
8
9
10
11
12
13
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()实现。

1
2
3
4
5
6
7
8
9
10
11
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，则排序前后其先后顺序不变；

-------------本文结束感谢您的阅读-------------
0%