Python教程：list.sort()和函数sorted(list)

1.sort()是列表的方法,修改原列表使得它按照大小排序,没有返回值,返回None

1. In [90]: x = [4, 6, 2, 1, 7, 9]
3. In [91]: x.sort()
5. In [92]: x
6. Out[92]: [1, 2, 4, 6, 7, 9]
7. In [98]: aa = x.sort()
8. In [99]: aa #  返回None

复制代码

2.sorted()是函数,不改变列表,重新生成一个按大小排序的列表

1. In [94]: a = sorted(x)
2. In [95]: a
3. Out[95]: [1, 2, 4, 6, 7, 9]
5. In [96]: x
6. Out[96]: [4, 6, 2, 1, 7, 9]

复制代码

3.可选参数 列表sort方法还有两个可选参数：key和reverse

1. ## 1、key在使用时必须提供一个排序过程总调用的函数：
2. x = ['mmm', 'mm', 'mm', 'm']
3. x.sort(key=len)
4. print(x)  # 输出 ['m', 'mm', 'mm', 'mmm']
6. ## 2、reverse实现降序排序，需要提供一个布尔值：
7. y = [3, 2, 8, 0, 1]
8. y.sort(reverse=True)
9. print(y)  # [8, 3, 2, 1, 0]

复制代码

4.优先级排序(具体的我也不太懂)

1. def sort_priority(values,group):
2.     def helper(x):
3.         if x in group:
4.             print('在group',0,x)
5.             return (0,x)
6.             # print(values)
7.         print('不在group',1,x)
8.         return (1,x)
9.     values.sort(key=helper)
10.     # values.sort()
12. numbers = [8,3,1,2,5,4,7,6]
13. group = {2,3,5,7}
14. sort_priority(numbers,group)
15. print(numbers)

复制代码

输出:

1. 不在group 1 8
2. 在group 0 3
3. 不在group 1 1
4. 在group 0 2
5. 在group 0 5
6. 不在group 1 4
7. 在group 0 7
8. 不在group 1 6
9. [2, 3, 5, 7, 1, 4, 6, 8]

复制代码

这个函数之所以能够正常运作，是基于下列三个原因:

• Python支持闭包（ closure):闭包是一种定义在某个作用域中的函数，这种函数引用了那个作用域里面的变量。helper函数之所以能够访问sort_priority的group参数，原因就在于它是闭包。
  
• Python的函数是一级对象(first-class object)，也就是说，我们可以直接引用函数、把函数赋给变量、把函数当成参数传给其他函数，并通过表达式及if语句对其进行比较和判断，等等。于是，我们可以把 helper这个闭包函数，传给sort方法的key参数。
  
• Python使用特殊的规则来比较两个元组°。它首先比较各元组中下标为0的对应元素，如果相等，再比较下标为1的对应元素，如果还是相等，那就继续比较下标为2的对应元素，依次类推。
  

5.闭包修改标志变量

1. def sort_priority2(values,group):
2.     found = False
3.     def helper(x):
4.         if x in group:
5.             found = True
6.             return (0,x)
7.         return (1,x)
8.     values.sort(key=helper)
9.     return found
10. numbers = [8,3,1,2,5,4,7,6]
11. group = [8,5,2,3,4,7,9]
12. found = sort_priority2(numbers,group)
13. print('最后的numbers',numbers)
14. print("found",found)
15. 输出:最后的numbers [2, 3, 4, 5, 7, 8, 1, 6]
16. found False

复制代码

6.闭包修改标志变量2, 新增nonlocal

下面用nonlocal来实现这个函数:
Python 3中有一种特殊的写法，能够获取闭包内的数据。我们可以用nonlocal语句来表明这样的意图，也就是:给相关变量赋值的时候，应该在上层作用域中查找该变量。
nonlocal的唯一限制在于，它不能延伸到模块级别，这是为了防止它污染全局作用域。

1. def sort_priority2(values,group):
2.     found = False
3.     def helper(x):
4.         if x in group:
5.             nonlocal found
6.             found = True
7.             return (0,x)
8.         return (1,x)
9.     values.sort(key=helper)
10.     return found
11. numbers = [8,3,1,2,5,4,7,6]
12. group = [8,5,2,3,4,7,9]
13. found = sort_priority2(numbers,group)
14. print('最后的numbers',numbers)
15. print("found",found)
16. 输出:最后的numbers [2, 3, 4, 5, 7, 8, 1, 6]
17. found True

复制代码

nonlocal语句清楚地表明:如果在闭包内给该变量赋值，那么修改的其实是闭包外那个作用域中的变量。这与global语句互为补充，global用来表示对该变量的赋值操作，将会直接修改模块作用域里的那个变量。
然而，nonlocal也会像全局变量那样，遭到滥用，所以，建议大家只在极其简单的函数里使用这种机制。nonlocal的副作用很难追踪，尤其是在比较长的函数中，修饰某变量的nonlocal语句可能和修改该变量的赋值操作离得比较远，从而导致代码更加难以理解。
如果使用nonlocal的那些代码，已经写得越来越复杂，那就应该将相关的状态封装成辅助类(helper class)。下面定义的这个类，与nonlocal所达成的功能相同。它虽然有点长，但是理解起来相当容易(其中有个名叫_call_的特殊方法

1. '''
2. 学习中遇到问题没人解答？小编创建了一个Python学习交流群：711312441
3. 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
4. '''
5. class Sorter(object):
6.     def __init__(self,group):
7.         self.group = group
8.         self.found = False
9.     def __call__(self,x):
10.         if x in self.group:
11.             self.found = True
12.             return (0,x)
13.         return (1,x)
14. group = [8,5,2,3,4,7,9]
15. numbers = [8,3,1,2,5,4,7,6]
16. sorter = Sorter(group)
17. numbers.sort(key=sorter)
18. assert sorter.found is True
19. print(sorter.found)

复制代码

sorted的关键字排序

1. student_tuples = [
2.     ('john', 'A',20, 15),
3.     ('jane', 'B',21, 12),
4.     ('dave', 'B', 22,10),
5. ]
6. print(sorted(student_tuples, key=lambda student: student[0]))   # sort by age
7. # [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
9. L = [{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
10. def f(x):
11.     return len(x)
12. L.sort(key=f) #reverse = True #怎样在此处天加速reverse
13. print (L)

复制代码

输出:

1. student_tuples = [
2.     ('john', 'A',20, 15),
3.     ('jane', 'B',21, 12),
4.     ('dave', 'B', 22,10),
5. ]
6. print(sorted(student_tuples, key=lambda student: student[0]))   # sort by age
7. # [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
9. L = [{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
10. def f(x):
11.     return len(x)
12. L.sort(key=f) #reverse = True #怎样在此处天加速reverse
13. print (L)

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！