xml地图|网站地图|网站标签 [设为首页] [加入收藏]

sorted高级排序技巧,python翻译排序

来源:http://www.ccidsi.com 作者:集成介绍 人气:177 发布时间:2019-05-07
摘要:python 列表排序方法sort、sorted本领篇 转自   Pythonlist内置sort()方法用来排序,也得以用python内置的大局sorted()方法来对可迭代的连串排序生成新的类别。 一)排序基础 轻巧易行的升序排

python 列表排序方法sort、sorted本领篇

转自

 

Python list内置sort()方法用来排序,也得以用python内置的大局sorted()方法来对可迭代的连串排序生成新的类别。

一)排序基础

轻巧易行的升序排序是相当轻便的。只必要调用sorted()方法。它回到贰个新的list,新的list的因素基于小于运算符(__lt__)来排序。

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

您也得以接纳list.sort()方法来排序,此时list自身将被涂改。常常此办法不比sorted()方便,不过即使你没有必要保留原来的list,此格局将更实用。

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

另一个不如便是list.sort()方法仅被定义在list中,相反地sorted()方法对具有的可迭代连串都灵验。

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

2)key参数/函数

从python2.四开首,list.sort()和sorted()函数增添了key参数来钦定一个函数,此函数将要种种成分比较前被调用。 举例通过key钦点的函数来忽略字符串的高低写:

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

key参数的值为3个函数,此函数唯有一个参数且重返叁个值用来进行相比。这些技能是便捷的因为key指定的函数将标准地对种种成分调用。

越来越宽泛的使用意况是用繁体对象的一点值来对复杂对象的类别排序,举例:

图片 1

>>> 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)]

图片 2

同样的手艺对具备命名属性的复杂性对象也适用,比如:

>>> 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提供了一些方便人民群众的函数来驱动访问方法特别便于和飞跃。operator模块有itemgetter,attrgetter,从贰.六发端还扩充了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)]

四)升序和降序

list.sort()和sorted()都承受2个参数reverse(True or False)来代表升序或降序排序。举例对地点的student降序排序如下:

>>> 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)]

五)排序的安澜和复杂排序

从python二.二始发,排序被担保为协调的。意思是说八个要素要是有同1的key,则排序前后他们的先后顺序不变。

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

专注在排序后'blue'的逐条被有限帮助了,即'blue', 一在'blue', 2的日前。
更复杂地你能够营造多个步骤来进展更复杂的排序,比如对student数据先以grade降序排列,然后再以age升序排列。

>>> 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)]

六)numpy中数组矩阵的排序方法argsort()

argsort(a, axis=-1, kind='quicksort', order=None)
    Returns the indices that would sort an array.

从中能够见见argsort函数再次来到的是数组值从小到大的索引值

Examples
    --------
    One dimensional array:一维数组

    >>> x = np.array([3, 1, 2])
    >>> np.argsort(x)
    array([1, 2, 0])

    Two-dimensional array:2维数组

    >>> x = np.array([[0, 3], [2, 2]])
    >>> x
    array([[0, 3],
           [2, 2]])

    >>> np.argsort(x, axis=0) #按列排序
    array([[0, 1],
           [1, 0]])

    >>> np.argsort(x, axis=1) #按行排序
    array([[0, 1],
           [0, 1]])

 

例1:

>>> x = np.array([3, 1, 2])
>>> np.argsort(x) #按升序排列
array([1, 2, 0])
>>> np.argsort(-x) #按降序排列
array([0, 2, 1])

>>> x[np.argsort(x)] #通过索引值排序后的数组
array([1, 2, 3])
>>> x[np.argsort(-x)]
array([3, 2, 1])

另一种艺术完成按降序排序:

>>> a = x[np.argsort(x)]
>>> a
array([1, 2, 3])
>>> a[::-1]
array([3, 2, 1])   

 

python翻译[排序高档],python翻译排序

Python list内置sort()方法用来排序,也足以用python内置的大局sorted()方法来对可迭代的行列排序生成新的行列。

 

一)排序基础 简单的升序排序是非常轻易的。只供给调用sorted()方法。它回到多个新的list,新的list的因素基于小于运算符(__lt__)来排序。   >>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]    

你也足以行使list.sort()方法来排序,此时list本身将被修改。日常此措施不及sorted()方便,可是倘诺您无需保留原来的list,此方法将更实惠。

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

另三个不等就是list.sort()方法仅被定义在list中,相反地sorted()方法对持有的可迭代体系都灵验。

 

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

 

2)key参数/函数

从python二.4发端,list.sort()和sorted()函数扩展了key参数来钦赐一个函数,此函数将要各样成分比较前被调用。 比方通过key钦定的函数来忽略字符串的轻重缓急写:   >>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']    

key参数的值为二个函数,此函数只有一个参数且重返三个值用来打开相比较。这几个本领是急忙的因为key钦定的函数将规范地对各个成分调用。

更广泛的采纳状态是用繁体对象的有些值来对复杂对象的行列排序,举例:

  图片 3 >>> 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)] 图片 4    

无差别于的技艺对富有命名属性的错综相连对象也适用,举例:

  图片 5 >>> 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)] 图片 6    

三)Operator 模块函数

上面包车型大巴key参数的行使尤其布满,由此python提供了某个有益于的函数来驱动访问方法越发轻易和高效。operator模块有itemgetter,attrgetter,从二.陆始发还扩张了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)]    

4)升序和降序

list.sort()和sorted()都承受1个参数reverse(True or False)来表示升序或降序排序。比如对地点的student降序排序如下:   >>> 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)]    

5)排序的安静和复杂排序

从python二.二发端,排序被担保为平稳的。意思是说八个要素假如有一致的key,则排序前后他们的先后顺序不改变。   >>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
>>> sorted(data, key=itemgetter(0))
[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]   注意在排序后'blue'的11被保证了,即'blue', 一在'blue', 二的先头。    

更纵横交错地你能够创设多个步骤来拓展更千头万绪的排序,比如对student数据先以grade降序排列,然后再以age升序排列。

  >>> 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)]  

 

六)最老土的排序方法-DSU 我们称其为DSU(Decorate-Sort-Undecorate),原因为排序的经过供给下列三步: 第贰:对原始的list进行李装运裱,使得新list的值能够用来决定排序; 第2:对装修后的list排序; 第二:将装修删除,将排序后的装饰list重新创设为本来类型的list;

 

  举例,使用DSU方法来对student数据依赖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)] 上边的比较能够工作,原因是tuples是能够用来相比较,tuples间的可比首先比较tuples的第1个元素,倘若第二个一律再相比第3个因素,由此及彼。

 

  并不是具备的情状下都亟待在上述的tuples中涵盖索引,可是包涵索引能够有以下好处: 第叁:排序是稳固的,如若四个因素有一样的key,则他们的固有先后顺序保持不变; 第二:原始的要素不必用来做比较,因为tuples的第一和第叁成分用来比较已经是拾足了。

 

  此办法被RandalL.在perl中普及推广后,他的另一个名为也被称作Schwartzian transform。

 

  对大的list或list的要素计算起来太过复杂的事态下,在python二.四前,DSU很或然是最快的排序方法。不过在二.四之后,上边表明的key函数提供了类似的成效。

 

  七)其余语言布满采纳的排序方法-cmp函数 在python2.四前,sorted()和list.sort()函数未有提供key参数,不过提供了cmp参数来让用户钦定相比函数。此措施在别的语言中也广泛存在。

 

  在python3.0中,cmp参数被深透的移除了,从而简化和归并语言,减少了尖端比较和__cmp__办法的争论。

 

  在python二.x中cmp参数钦赐的函数用来打开成分间的比较。此函数须求3个参数,然后回来负数表示小于,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]    

当大家将长存的二.x的代码移植到三.x时,需求将cmp函数转化为key函数,以下的wrapper很有援助:

图片 7 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 图片 8    

当须要将cmp转化为key时,只需求:

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

从python2.7,cmp_to_key()函数被扩大到了functools模块中。 

 

八)其余注意事项 * 对亟待展开区域连锁的排序时,能够采纳locale.strxfrm()作为key函数,可能使用local.strcoll()作为cmp函数。

 

* reverse参数任然保持了排序的大吉大利,有意思的时,一样的效劳能够应用reversed()函数三遍来达成: >>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
>>> assert sorted(data, reverse=True) == list(reversed(sorted(reversed(data))))  

* 其实排序在中间是调用成分的__cmp__来进展的,所以我们得感觉要素类型扩大__cmp__方法使得成分可正如,比方:

>>> Student.__lt__ = lambda self, other: self.age < other.age
>>> sorted(student_objects)
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]  

* key函数不止能够访问须要排序成分的里边数据,还足以访问外部的财富,比如,假设学生的成正是积累在dictionary中的,则足以应用此dictionary来对学员名字的list排序,如下:

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

 

*当你要求在拍卖数量的还要拓展排序的话,sort(),sorted()或bisect.insort()不是最佳的不二秘诀。在那种情状下,能够应用heap,red-black tree或treap。

 

 

完! 

 

Python list内置sort()方法用来排序,也得以用python内置的全局sorted()方法来对可迭代的种类排序生成新的序...

python sort、sorted高等排序本事,pythonsorted

Python list内置sort()方法用来排序,也能够用python内置的大局sorted()方法来对可迭代的队列排序生成新的队列。

一)排序基础

简单易行的升序排序是格外轻易的。只必要调用sorted()方法。它回到三个新的list,新的list的成分基于小于运算符(__lt__)来排序。

复制代码 代码如下:

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

 
您也足以采取list.sort()方法来排序,此时list自己将被修改。平常此办法不及sorted()方便,但是一旦你无需保留原来的list,此格局将更有效。

复制代码 代码如下:

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

另3个分歧就是list.sort()方法仅被定义在list中,相反地sorted()方法对具备的可迭代类别都灵验。

复制代码 代码如下:

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

2)key参数/函数

从python二.四开头,list.sort()和sorted()函数扩大了key参数来钦命2个函数,此函数就要各种成分比较前被调用。 比如通过key钦点的函数来忽略字符串的尺寸写:

复制代码 代码如下:

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

key参数的值为二个函数,此函数唯有二个参数且再次来到3个值用来拓展比较。那几个能力是飞快的因为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)]

3)Operator 模块函数

下边包车型客车key参数的施用分外广阔,由此python提供了部分便利的函数来驱动访问方法特别便于和高速。operator模块有itemgetter,attrgetter,从贰.陆初叶还扩充了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)]

四)升序和降序

list.sort()和sorted()都接受2个参数reverse(True or False)来代表升序或降序排序。比如对上面的student降序排序如下:

复制代码 代码如下:

>>> 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.二初阶,排序被有限扶助为平安的。意思是说多少个成分假若有雷同的key,则排序前后他们的先后顺序不改变。

复制代码 代码如下:

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

只顾在排序后'blue'的逐条被保证了,即'blue', 一在'blue', 2的前面。
 
更千头万绪地你能够创设四个步骤来拓展更复杂的排序,比方对student数据先以grade降序排列,然后再以age升序排列。

复制代码 代码如下:

>>> 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)]

六)最老土的排序方法-DSU

大家称其为DSU(Decorate-Sort-Undecorate),原因为排序的历程必要下列三步:
首先:对原来的list举办李装运点,使得新list的值能够用来调整排序;
其次:对装修后的list排序;
其3:将装修删除,将排序后的装饰list重新营造为原本类型的list;  

比如,使用DSU方法来对student数据依照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)]
地点的相比能够工作,原因是tuples是能够用来相比,tuples间的可比首先相比tuples的第壹个成分,借使第三个一律再相比第三个因素,就那样推算。  

并不是富有的境况下都亟需在上述的tuples中隐含索引,可是包罗索引能够有以下好处:
率先:排序是平静的,固然四个因素有同样的key,则他们的本来先后顺序保持不改变;
第2:原始的要素不必用来做比较,因为tuples的第2和第二成分用来相比较已经是10足了。  

此格局被RandalL.在perl中常见推广后,他的另一个名为也被称为Schwartzian transform。  

对大的list或list的因素计算起来太过复杂的情景下,在python二.四前,DSU很恐怕是最快的排序方法。可是在贰.四事后,上边表达的key函数提供了接近的魔法。  

7)别的语言广泛选拔的排序方法-cmp函数

在python二.四前,sorted()和list.sort()函数未有提供key参数,不过提供了cmp参数来让用户钦命相比函数。此格局在别的语言中也广泛存在。

在python三.0中,cmp参数被通透到底的移除了,从而简化和合并语言,减弱了高等相比和__cmp__方法的争持。

在python贰.x中cmp参数钦命的函数用来开始展览成分间的可比。此函数供给1个参数,然后回到负数表示小于,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]

当大家将现成的二.x的代码移植到3.x时,须要将cmp函数转化为key函数,以下的wrapper很有帮衬:

复制代码 代码如下:

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

当须要将cmp转化为key时,只必要:

复制代码 代码如下:

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

从python2.7,cmp_to_key()函数被扩张到了functools模块中。

八)别的注意事项

* 对亟待张开区域相关的排序时,能够选用locale.strxfrm()作为key函数,或然应用local.strcoll()作为cmp函数。

* reverse参数任然保持了排序的平静,风趣的时,同样的职能能够运用reversed()函数三回来贯彻:

复制代码 代码如下:

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
>>> assert sorted(data, reverse=True) == list(reversed(sorted(reversed(data))))

* 其实排序在中间是调用成分的__cmp__来展开的,所以大家可感到要素类型扩大__cmp__方法使得成分可正如,举例:

复制代码 代码如下:

>>> Student.__lt__ = lambda self, other: self.age < other.age
>>> sorted(student_objects)
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

* key函数不仅仅能够访问须要排序成分的中间数据,还足以访问外部的财富,比方,假设学生的实际业绩是积累在dictionary中的,则足以采纳此dictionary来对学生名字的list排序,如下:

复制代码 代码如下:

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

*当你必要在拍卖多少的还要拓展排序的话,sort(),sorted()或bisect.insort()不是最佳的法子。在那种情状下,能够应用heap,red-black tree或treap。

sort、sorted高等排序手艺,pythonsorted Python list内置sort()方法用来排序,也能够用python内置的全局sorted()方法来对可迭代的队列排序生成新...

本文由68399皇家赌场发布于集成介绍,转载请注明出处:sorted高级排序技巧,python翻译排序

关键词: 68399皇家赌场

最火资讯