Python对列表排序函数sort()和reverse()的讲解

Posted 2023-04-04

参考技术A 列表中的数据种类很多，有字符串，有整型，有其他列表的嵌套，还有更多的数据类型，这些数据在列表中往往是错乱的，没有一定的逻辑关系，但是我们在使用列表的时候往往需要按照一定的逻辑关系进行调用或检索。下面就来看看 列表是如何排序和翻转的 ，所谓翻转也就是把既定列表倒序排列。

返回结果：

从上面的返回结果可以看出来，sort()函数如果遇到字符串是按照首字母顺序进行排列的，如果遇到浮点型数据还是按照大小排列。

由上面的结果可以看出来，不同的数据类型是没有办法进行排列的。

这个方法是把原列表中的元素顺序从左至右的重新存放，而不会对列表中的参数进行排序整理。如果需要对列表中的参数进行整理，就需要用到列表的另一种排序方式sort正序排序。

Python中的字典排序

我想将 b = {‘a‘:234,‘b‘:1,‘c‘:2,‘e‘:2387} 分别按照key和value进行排序，该怎样办呢？

Python中比较常用的排序有两个函数，

一、定义

(1)一个是List数据结构中的sort

>>> help(list.sort)
Help on method_descriptor:

sort(...)
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

 

1. The sort() method takes optional arguments for controlling the comparisons.

   cmp specifies a custom comparison function of two arguments (list items) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument: cmp=lambda x,y:cmp(x.lower(), y.lower()). The default value is None.

   key specifies a function of one argument that is used to extract a comparison key from each list element: key=str.lower. The default value is None.

   reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.

   In general, the key and reverse conversion processes are much faster than specifying an equivalent cmp function. This is because cmpis called multiple times for each list element while key and reverse touch each element only once. Use functools.cmp_to_key() to convert an old-style cmp function to a key function.

   Changed in version 2.3: Support for None as an equivalent to omitting cmp was added.

   Changed in version 2.4: Support for key and reverse was added.

 

(2)内置的函数sorted

sorted(iterable[, cmp[, key[, reverse]]])

Return a new sorted list from the items in iterable.

表明内置的sorted函数会生成一个新的数据表不会改变原有数据的顺序。

The optional arguments cmp, key, and reverse have the same meaning as those for the list.sort() method (described in sectionMutable Sequence Types).

cmp specifies a custom comparison function of two arguments (iterable elements) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument:cmp=lambda x,y: cmp(x.lower(), y.lower()). The default value is None.

key specifies a function of one argument that is used to extract a comparison key from each list element: key=str.lower. The default value is None (compare the elements directly).

reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.

In general, the key and reverse conversion processes are much faster than specifying an equivalent cmp function. This is becausecmp is called multiple times for each list element while key and reverse touch each element only once. Use functools.cmp_to_key() to convert an old-style cmp function to a key function.

 

二、举例

Sorting Basics

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

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

第一种使用的是内置排序方法，第二种是list的排序方法。Usually it‘s less convenient than sorted() - but if you don‘t need the original list, it‘s slightly more efficient.（虽然第一种方法不是很方便，但是通常更有效率）

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

Another difference is that the list.sort() method is only defined for lists. In contrast, the sorted() function accepts any iterable. 

（另外一点就是list.sort()的方法仅仅只能用作列表的数据结构，然而,sorted却可以用作任何可迭代的数据结构）

 

Key Functions

Starting with Python 2.4, both list.sort() and sorted() added a key parameter to specify a function to be called on each list element prior to making comparisons（从2.4以后，新添加了key参数，通过制定一个判断函数来按照key进行排序）

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

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

关于lambda实际上为匿名函数，后面部分会将 lambda 函数参数：返回值

>>> 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))
        def weighted_grade(self):
                return ‘CBA‘.index(self.grade) / float(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 Module Functions

The key-function patterns shown above are very common, so Python provides convenience functions to make accessor functions easier and faster. The operator module has itemgetter, attrgetter, and starting in Python 2.6 a methodcaller function.

Using those functions, the above examples become simpler and faster. 

通过引入operator模块有了更快的查询方式：

 

>>> from operator import itemgetter, attrgetter, methodcaller

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

The operator module functions allow multiple levels of sorting. For example, to sort by grade then by 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)]

Ascending and Descending(升降序）

仅仅在后面添加一个reverse就可以了
>>> 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)]


回到刚开始的地方，我们可以很轻松的写出：

import operator
def sortDict():
b = {‘a‘:234,‘b‘:1,‘c‘:2,‘e‘:2387}
print(sorted(b.iteritems(),key=operator.itemgetter(0)))#按key升序排列
print(sorted(b.iteritems(),key=operator.itemgetter(1)))#按value升序排列
print(sorted(b.items(),key=lambda x:x[1],reverse=True))##按value降序排列

输出结果：

[(‘a‘, 234), (‘b‘, 1), (‘c‘, 2), (‘e‘, 2387)]
[(‘b‘, 1), (‘c‘, 2), (‘a‘, 234), (‘e‘, 2387)]
[(‘e‘, 2387), (‘a‘, 234), (‘c‘, 2), (‘b‘, 1)]