Python:如何排序(sort)

一、前言

Python的列表(list)有两个排序方法:

一种是内建的list.sort()方法,可以直接改变列表的内容:

>>> list1 = [9,8,7,6,5]
>>> list1.sort()
>>> list1
[5, 6, 7, 8, 9]

另一个内建函数是sorted(),它的特点是不改变原列表的内容,而是根据一个可迭代对象建立一个新的列表:

>>> list2 = [4,3,2,1]
>>> list3 = sorted(list2)
>>> list2
[4, 3, 2, 1]
>>> list3
[1, 2, 3, 4]

二、基础排序

一个最简单的升序排序是非常容易的:直接调用sorted()函数就可以了,它返回一个新的列表:

>>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]

也可以使用列表本身的方法list.sort()去排序。它会改变list的内容,然后返回None作为执行的结果,以避免混淆。一般来说它没有sorted()那么方便,但是如果你不需要原来的列表的话,使用它在性能上会有轻微的提升。

>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]

另一个区别就是,list.sort()方法只能用于列表,相对的,sorted()函数则适用于所有的可迭代对象,如:

>>> sorted({1: ‘D‘, 2: ‘B‘, 3: ‘B‘, 4: ‘E‘, 5: ‘A‘})
[1, 2, 3, 4, 5]

三、key函数

从Python2.4开始,无论是list.sort()还是sorted()都增加了一个key参数,指定一个在进行比较之前在每个列表元素上调用的函数。

例如,以下就是大小写不敏感的字符串比较:

>>> sorted("This is a test string from Andrew".split(), key=str.lower)
[‘a‘, ‘Andrew‘, ‘from‘, ‘is‘, ‘string‘, ‘test‘, ‘This‘]

key参数对应的值,必须是这样一个函数:接受一个参数然后返回一个用来排序的键。用这种技术来排序的速度是非常快的,因为key函数恰好被每一个输入记录调用一次。

一种常用的模式是,在对复杂对象进行排序的时候,使用这个对象的索引作为排序的键,例如:

>>> student_tuples = [
...     (‘john‘, ‘A‘, 15),
...     (‘jane‘, ‘B‘, 12),
...     (‘dave‘, ‘B‘, 10),
... ]
>>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]

用对象的命名属性也是一样的,例如:

>>> class Student:
...     def __init__(self, name, grade, age):
...         self.name = name
...         self.grade = grade
...         self.age = age
...     def __repr__(self):
...         return repr((self.name, self.grade, self.age))

>>> student_objects = [
...     Student(‘john‘, ‘A‘, 15),
...     Student(‘jane‘, ‘B‘, 12),
...     Student(‘dave‘, ‘B‘, 10),
... ]
>>> sorted(student_objects, key=lambda student: student.age)   # sort by age

[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]

四、使用Operator模块的函数

上面提到的key函数在排序中是很常用的,因此Python本身提供了很多很方便的函数,让创建访问器函数变得更快、更容易。operater模块提供的函数有operator.itemgetter(),operator.attrgetter(),另外从Python2.5开始新增了operator.methodcaller()函数。

使用这些函数,上面的例子可以变得更简单和更快:

>>> from operator import itemgetter, attrgetter
>>> sorted(student_tuples, key=itemgetter(2))
[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]
>>> sorted(student_objects, key=attrgetter(‘age‘))
[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]

operator模块提供的几个函数允许多重级别的排序。例如,根据grade和age进行排序:

>>> sorted(student_tuples, key=itemgetter(1,2))
[(‘john‘, ‘A‘, 15), (‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12)]
>>> sorted(student_objects, key=attrgetter(‘grade‘, ‘age‘))
[(‘john‘, ‘A‘, 15), (‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12)]

operator.methodcaller()函数会在每个被排序的对象上执行一个固定参数的方法调用,例如,str.count()方法可以通过统计在每个消息中感叹号的数量,来计算消息的优先度:

>>> from operator import methodcaller
>>> messages = [‘critical!!!‘, ‘hurry!‘, ‘standby‘, ‘immediate!!‘]
>>> sorted(messages, key=methodcaller(‘count‘, ‘!‘))
[‘standby‘, ‘hurry!‘, ‘immediate!!‘, ‘critical!!!‘]

五、升序和降序

list.sort()和sorted()都接受一个reverse参数,这个参数的取值是一个布尔值,用来标记是否降序排序。例如,用age字段降序排列去获取学生信息:

>>> sorted(student_tuples, key=itemgetter(2), reverse=True)
[(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
>>> sorted(student_objects, key=attrgetter(‘age‘), reverse=True)
[(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]

六、排序稳定性及复杂排序

从Python2.2版本开始,排序都是稳定的,也就是说如果有两个记录他们的排序键相等,则排序前后他们的相对位置是固定的。

>>> data = [(‘red‘, 1), (‘blue‘, 1), (‘red‘, 2), (‘blue‘, 2)]
>>> sorted(data, key=itemgetter(0))
[(‘blue‘, 1), (‘blue‘, 2), (‘red‘, 1), (‘red‘, 2)]

观察可以得知两个排序键同样是’blue’的记录,他们的原始顺序在排序前后没有改变,(‘blue’, 1)保证在(‘blue’, 2)前面。

这种极妙的属性可以让你用一系列排序的步骤去创建一种复杂的排序。例如,用grade字段降序,age字段升序去排序学生数据,age字段先排,grade字段后排。

>>> s = sorted(student_objects, key=attrgetter(‘age‘))     # sort on secondary key
>>> sorted(s, key=attrgetter(‘grade‘), reverse=True)       # now sort on primary key, descending
[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]

Python的Timsort算法可以高效率地进行多重排序,因为它能很好的利用数据集中已经存在的有序序列。

七、使用decorate-sort-undecorated老方法

这个习语是以它的三个步骤而被命名为decorate-sort-undecorate(装饰-排序-去装饰)的:

  • 首先,原始的列表被装饰以生成新的值,这些值是用来控制排序顺序的。
  • 然后,对被装饰过的列表进行排序。
  • 最后,去掉装饰,以新的顺序创建一个列表,这个列表只包含原来列表中的值。

例如,使用DSU方法用学生数据中的grade字段对其进行排序:

>>> decorated = [(student.grade, i, student) for i, student in enumerate(student_objects)]
>>> decorated.sort()
>>> [student for grade, i, student in decorated]               # undecorate
[(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]

在这里,元组是按照字典序进行比较的,首先第一项被比较,如果他们相等则对第二项进行比较,以此类推。

不是在所有的情况下都需要在被装饰的列表中包含下标i,但是包含它会有两个好处:

让排序稳定——如果两个项拥有一样的键,那么他们在排序列表中的顺序不会改变。

原始的项不需要是可对比的,因为被装饰的元组的顺序最多被前面两个项决定。举个例子,原始列表可以包含不能直接排序的复数。

这个习语的另一个名字是Schwartzian transform,以Randal L. Schwartz进行命名,因为他用Per语言推广了这种方法。

对于大型的列表,以及那些计算对比关系的代价很昂贵的列表来说,在Python的2.4版本之前,DSU几乎是排序这类列表的最快的方法。但是在2.4及之后的版本,key函数就提供了一样的功能了。

八、使用cmp参数老方法

在这篇文章中提到的很多设计,其实都是Python2.4或之后的版本才给出的。在此之前,无论sorted()函数还是list.sort()方法都没有不带参的调用方式。相反的,所有Py2.x版本支持cmp参数,来处理用户指定的对比函数。

在Python3中,cmp参数是完全被移除了(这是对简化和统一这门语言作出的努力的一部分,另外也消除了富比较(rich comparisons )和__cmp()__魔术方法的冲突)。

在Python2中,sort()允许指定一个可选的函数,这个函数作为比较的用途被调用。这个函数必须带两个被用来比较的参数,然后返回一个值,如果小于是负数,如果相等是0,如果大于则返回正数。例如,我们可以这么做:

>>> def numeric_compare(x, y):
...     return x - y
>>> sorted([5, 2, 4, 1, 3], cmp=numeric_compare)
[1, 2, 3, 4, 5]

或者你也可以反转对比的顺序:

>>> def reverse_numeric(x, y):
...     return y - x
>>> sorted([5, 2, 4, 1, 3], cmp=reverse_numeric)
[5, 4, 3, 2, 1]

从Python2.x导入代码到3.x的时候,如果你使用这种比较函数的时候,代码会报错,然后你就需要把它转为一个key函数了。以下的包装器可以让这个转化过程变得更简单:

def cmp_to_key(mycmp):
    ‘Convert a cmp= function into a key= function‘
    class K(object):
        def __init__(self, obj, *args):
            self.obj = obj
        def __lt__(self, other):
            return mycmp(self.obj, other.obj) < 0
        def __gt__(self, other):
            return mycmp(self.obj, other.obj) > 0
        def __eq__(self, other):
            return mycmp(self.obj, other.obj) == 0
        def __le__(self, other):
            return mycmp(self.obj, other.obj) <= 0
        def __ge__(self, other):
            return mycmp(self.obj, other.obj) >= 0
        def __ne__(self, other):
            return mycmp(self.obj, other.obj) != 0
    return K

想转化成一个key函数,直接包装旧的对比函数就可以了:

>>> sorted([5, 2, 4, 1, 3], key=cmp_to_key(reverse_numeric))
[5, 4, 3, 2, 1]

在Python2.7中,functools.cmp_to_key()函数已经被增加到functools模块中了。

九、其他

对于浮点数的排序,使用locale.strxfrm()作为key函数,或者locale.strcoll()作为对比函数。

reverse参数依旧保持排序的稳定性。有趣的是,这个效果可以用内建函数reversed()函数两次进行模拟:

>>> data = [(‘red‘, 1), (‘blue‘, 1), (‘red‘, 2), (‘blue‘, 2)]
>>> standard_way = sorted(data, key=itemgetter(0), reverse=True)
>>> double_reversed = list(reversed(sorted(reversed(data), key=itemgetter(0))))
>>> assert standard_way == double_reversed
>>> standard_way
[(‘red‘, 1), (‘red‘, 2), (‘blue‘, 1), (‘blue‘, 2)]

为一个类创建一种标准的排序顺序,只需要增加合适的富比较函数即可:

>>> Student.__eq__ = lambda self, other: self.age == other.age
>>> Student.__ne__ = lambda self, other: self.age != other.age
>>> Student.__lt__ = lambda self, other: self.age < other.age
>>> Student.__le__ = lambda self, other: self.age <= other.age
>>> Student.__gt__ = lambda self, other: self.age > other.age
>>> Student.__ge__ = lambda self, other: self.age >= other.age
>>> sorted(student_objects)
[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]

对于一般用途的比较,一般的方法建议定义全部六个富对比操作符。现在functools.total_ordering() 类装饰器让这一切变得更加容易实现。

key函数不一定要直接基于被排序的对象。key函数同样可以访问外部的资源。举个例子,如果学生的年级被存储在一个字典之中,那它就可以用来为另一个单独的的学生的名字组成的列表进行排序:

>>> students = [‘dave‘, ‘john‘, ‘jane‘]
>>> grades = {‘john‘: ‘F‘, ‘jane‘:‘A‘, ‘dave‘: ‘C‘}
>>> sorted(students, key=grades.__getitem__)
[‘jane‘, ‘dave‘, ‘john‘]

以上内容翻译自Python2.7.15文档,Sorting HOW TO。

(完)

原文地址:https://www.cnblogs.com/harrymore/p/9460532.html

时间: 2024-10-08 07:58:01

Python:如何排序(sort)的相关文章

&lt;转&gt;python字典排序 关于sort()、reversed()、sorted()

一.Python的排序 1.reversed() 这个很好理解,reversed英文意思就是:adj. 颠倒的:相反的:(判决等)撤销的 print list(reversed(['dream','a','have','I'])) #['I', 'have', 'a', 'dream'] 2.让人糊涂的sort()与sorted() 在Python 中sorted是内建函数(BIF),而sort()是列表类型的内建函数list.sort(). sorted() sorted(iterable[,

python 字典排序 关于sort()、reversed()、sorted()

一.Python的排序 1.reversed() 这个很好理解,reversed英文意思就是:adj. 颠倒的:相反的:(判决等)撤销的 print list(reversed(['dream','a','have','I'])) #['I', 'have', 'a', 'dream'] 2.让人糊涂的sort()与sorted() 在Python 中sorted是内建函数(BIF),而sort()是列表类型的内建函数list.sort(). sorted() sorted(iterable[,

Python中的sort()方法的使用

本文和大家分享的主要是python中的sort()方法相关知识,一起来看看吧,希望对大家学习python有所帮助. 一.基本形式 sorted(iterable[, cmp[, key[, reverse]]]) iterable.sort(cmp[, key[, reverse]]) 参数解释: (1)iterable指定要排序的list或者iterable,不用多说: (2)cmp为函数,指定排序时进行比较的函数,可以指定一个函数或者lambda函数,如: students为类对象的list

Python 关于‘inf’,sort(),sorted(),min()的一些用法

Python float("inf") // delete an element in list A = ["a","b"] Del A[0] A.remove("a") // python timeit module http://woodpecker.org.cn/diveintopython/performance_tuning/timeit.html http://www.cnblogs.com/moinmoin/ar

python sorted排序

python sorted排序 Python不仅提供了list.sort()方法来实现列表的排序,而且提供了内建sorted()函数来实现对复杂列表的排序以及按照字典的key和value进行排序. sorted函数原型 sorted(data, cmp=None, key=None, reverse=False) #data为数据 #cmp和key均为比较函数 #reverse为排序方向,True为倒序,False为正序 基本用法 对于列表,直接进行排序 >>> sorted([5, 2

Python中的sort()

Python中的sort()方法用于数组排序,本文以实例形式对此加以详细说明: 一.基本形式列表有自己的sort方法,其对列表进行原址排序,既然是原址排序,那显然元组不可能拥有这种方法,因为元组是不可修改的. 1 2 3 x = [4, 6, 2, 1, 7, 9] x.sort() print x # [1, 2, 4, 6, 7, 9] 如果需要一个排序好的副本,同时保持原有列表不变,怎么实现呢 1 2 3 4 5 x =[4, 6, 2, 1, 7, 9] y = x[ : ] y.sor

python dict 排序

我们知道Python的内置dictionary数据类型是无序的,通过key来获取对应的value.可是有时我们需要对dictionary中 的item进行排序输出,可能根据key,也可能根据value来排.到底有多少种方法可以实现对dictionary的内容进行排序输出呢?下面摘取了 一些精彩的解决办法. python对容器内数据的排序有两种,一种是容器自己的sort函数,一种是内建的sorted函数. sort函数和sorted函数唯一的不同是,sort是在容器内(in-place)排序,so

详细解说 STL 排序(Sort)(转)

作者Winter 详细解说 STL 排序(Sort) 0 前言: STL,为什么你必须掌握 1 STL提供的Sort 算法 1.1 所有sort算法介绍 1.2 sort 中的比较函数 1.3 sort 的稳定性 1.4 全排序 1.5 局部排序 1.6 nth_element 指定元素排序 1.7 partition 和stable_partition 2 Sort 和容器 3 选择合适的排序函数 4 小结 5 参考文档 一切复杂的排序操作,都可以通过STL方便实现 ! 0 前言: STL,为

设计模式 - 模板方法模式(template method pattern) 排序(sort) 详解

模板方法模式(template method pattern) 排序(sort) 详解 本文地址: http://blog.csdn.net/caroline_wendy 参考模板方法模式(template method pattern): http://blog.csdn.net/caroline_wendy/article/details/32159455 模板方法模式的一个主要的应用是排序(sort)算法. 对象的排列方式并不是完全相同, 所以需要排序(sort)算法compareTo()

JS数组去重,js中数组(Array)的排序(sort)

JS数组去重 var ddd = [1,2,4,5,2, 222,1,5,6]; var uq = {}; var rq = []; for(var i=0; i<9; i++){ if(!uq[ddd[i]]){ uq[ddd[i]] = true; rq.push(ddd[i]); } } return rq; js中数组(Array)的排序(sort)注意事项 var arrDemo = new Array(); arrDemo[0] = 10; arrDemo[1] = 50; arrD