详述python3中的排序和排序

sort和sorted的区别

虽然 python3 中的 sort() 和 sorted() 都可以用于排序，但两者主要有两个区别：

sort 只能应用于列表，而 sorted 可以对所有可迭代对象进行排序

sort 方法将直接对原始列表进行排序，不会创建新列表。 sorted 方法不对原始数据做任何改动，新生成的排序结果。如果我们不需要原始数据并且数据是列表类型的，我们可以使用排序方法来节省空间。否则使用排序方法。

sort

在python2中，sort方法可以有3个参数：key、c​​mp和reverse。但是在python3中，取消了cmp参数，只有key和reverse两个可选参数。参数 reverse 指定排序是正序还是逆序。默认是正序FALSE，我就不多说了。参数键指定只有一个参数的方法，用于从列表的每个元素中提取比较键。请看以下示例：

1.通过元素长度排序

strlist = ["bbb","ccc","bac","ab","ba"]
strlist.sort(key=len)
print(strlist)

打印结果如下：

['ab', 'ba', 'bbb', 'ccc', 'bac']

2.通过元素的字符顺序

strlist = ["bbb","BBB","bAc","ab","bac"]
strlist.sort()print(strlist)
strlist.sort(key=str.lower)print(strlist)

打印结果如下：

['BBB', 'ab', 'bAc', 'bac', 'bbb']
['ab', 'bAc', 'bac', 'BBB', 'bbb']

3.稍微复杂一点的排序：列表中的元素是一个字典，按照字典的一个属性值进行排序。以下按学生年龄排序

student = [{"name": "小C", "age": 12, "score": 90},
           {"name": "小D", "age": 13, "score": 84},
           {"name": "小A", "age": 14, "score": 85},
           {"name": "小E", "age": 15, "score": 89},
           {"name": "小F", "age": 12, "score": 88}]
student.sort(key=lambda a: a["age"])
print(student)

打印结果如下(换行是我自己处理的)：

[{'name': '小C', 'age': 12, 'score': 90},
{'name': '小F', 'age': 12, 'score': 88},
{'name': '小D', 'age': 13, 'score': 84},
{'name': '小A', 'age': 14, 'score': 85}, 
{'name': '小E', 'age': 15, 'score': 89}]

那么原来cmp参数的一些功能是不能实现的呢？当然也可以通过从functools库中导入cmp_to_key来解决，看下面的例子：

1.数组的倒序

from functools import cmp_to_key
list = [5,4,3,2,1]
list.sort(key=cmp_to_key(lambda a,b: b-a))
print(list)

打印结果如下：

[5, 4, 3, 2, 1]

2. 将数组排列成最小的英里数。 python的方案可以这样解决（注意倒数第三行，将map类型转换为list类型）：

from functools import cmp_to_key

class Solution:
    def PrintMinNumber(self, numbers):
        numbers = list(map(str, numbers))
        numbers.sort(key=cmp_to_key(lambda s1, s2: int(s1+s2) - int(s2+s1)))
        return "".join(numbers)

由于 sort 只能用在列表类型中，所以更常用的是 sorted 方法。下面说说排序的方法。

sorted

所有可迭代对象都可以使用 sorted 进行排序，排序不会改变原始对象。 sorted 接受 3 个参数：

sorted(iterable, *, key=None, reverse=False)

iterable是可迭代的对象，key和reverse与sort里的相同。

看下面一个小例子：

student_tuples = [('john', 'A', 15),
                  ('jane', 'B', 12),
                  ('dave', 'B', 10)]
new_tuples = sorted(student_tuples, key=lambda student: student[2])
print(student_tuples)
print(new_tuples)

打印结果如下：

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

新列表按年龄排序，从打印结果可以看出，原来的数据没有改变

由于这种带key参数的方法太常见了，python中提供了一些方法来让accessor函数更方便。例如， operator 模块中的 itemgetter() 和 attrgetter() 方法。

看下下面的例子：

from operator import itemgetter, attrgetter

class Student:
    def __init__(self, name, grade, age):
        self.name = name
        self.grade = grade
        self.age = age
student_objects = [Student('john', 'A', 15),
                   Student('jane', 'B', 12),
                   Student('dave', 'B', 10)]
student_tuples = [('john', 'A', 15),
                  ('jane', 'B', 12),
                  ('dave', 'B', 10) ]
result1 = sorted(student_tuples, key=itemgetter(2))  # 通过元素的第三个值排序
result2 = sorted(student_objects, key=attrgetter('age'))  # 通过对象的age属性排序
result3 = sorted(student_tuples, key=itemgetter(1,2))  # 首先通过元素的第一个值排序，然后通过第二个值排序
result4 = sorted(student_objects, key=attrgetter('grade', 'age'))  # 通过对象的grade属性排序，后通过age属性排序

排序后的结果如下(非打印)：

result1与result2：

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

result3与result4：

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

分拣保证稳定可靠。当排序后的键对应的值相同时，它们会保持它们在原始数据中的顺序。对比排序中的第三个例子，运行结果如下：

from operator import itemgetter
data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
print(sorted(data, key=itemgetter(0)))

打印结果

[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]