在本教程中，我们将了解如何根据不同的标准对可迭代的容器(如列表、元组、字符串和字典)进行排序。

对列表排序

有两种方法可以对列表进行排序。我们可以使用sort()方法或sorted()函数。sort()方法是一个列表方法，因此只能用于列表。sorted()函数适用于任何容器。

sort()方法

sort()方法是一个列表方法，它就地修改列表并返回None。换句话说，sort()方法修改或更改调用它的列表，而不创建新列表。

sort()方法有两个可选参数：key参数和reverse参数。key参数接受一个接受单个参数并返回用于排序的键的函数。

默认情况下，sort()方法将按数字的值和字符串的字母顺序对列表进行排序。reverse参数接受布尔值True或False。reverse的默认值为False，这意味着它按升序排序。为了按降序排序，我们将设置reverse=True。当我们看下面的一些例子时，这些参数将更有意义。

对数字列表排序

假设我们有一个数字列表，我们想按升序排序。

num_list = [1,-5,3,-9,25,10]num_list.sort()print(num_list)# [-9,-5,1,3,10,25]

所以我们有一个num_list列表，我们对此列表调用sort()方法。请注意，我们没有为键参数传递值。因此，它只是根据实际值对这个num_list进行排序。因为我们没有设置reverse=True，所以它按升序排序。sort()方法修改了num_list。

如果我们想根据数字的绝对值对列表进行排序呢？这时我们需要使用key参数。key参数接受一个接受单个参数并返回用于排序的键的函数。

num_list = [1,-5,3,-9,25,10]def absolute_value(num):    return abs(num)num_list.sort(key = absolute_value)print(num_list) # [1,3,-5,-9,10,25]

我们定义了一个函数，absolute_value，它接受一个数字并返回它的绝对值。然后，我们将此函数作为sort()方法的键参数的参数传入。因此，在进行比较之前，它通过绝对值函数运行num_list的每个元素或数字。因此，这些数字的绝对值将用于按升序对该列表进行排序(因为reverse默认设置为False)。

使用lambda表达式

我们可以为键参数传入lambda表达式，如下所示：

num_list.sort(key = lambda num: abs(num))

请在此处查看有关lambda表达式的教程：

请记住，sort()方法返回None。因此，如果我们将sort()方法的输出或返回值设置为一个新变量，则如下所示：

new_list = num_list.sort(key = absolute_value)print(new_list)# None

我们不必像上面那样编写我们自己的绝对值函数，而只需为键参数传入python内置的abs()函数，如下所示：

num_list.sort(key = abs)

sorted()函数可以接受三个参数：容器、key和reverse。sorted()函数可以处理任何可迭代的容器，例如列表、元组、字典等。但是，与sort()方法不同的是sort()方法返回None并修改原始列表，sorted()函数返回一个新列表，同时保持原始对象不变。

让我们再次使用绝对值对num_list排序，但使用sorted()函数：

num_list = [1,-5,3,-9,25,10]new_list = sorted(num_list, key = abs)print(new_list) # [1,3,-5,-9,10,25]print(num_list)# [1,-5,3,-9,25,10]

我们将容器 num_list传递给sorted()函数，同时将内置的abs函数传递给key参数。我们将sorted()函数的输出设置为一个新变量new_list。注意num_list是如何保持不变的，因为sorted()函数不会修改它所作用的容器。

注意：不管传入sorted()函数的容器是什么，它总是返回一个列表。

排序元组列表

假设我们有一个元组列表。列表的每个元素都是一个元组，包含三个元素：姓名、年龄和薪水。

list_of_tuples = [    ('john', 27, 45000),    ('jane', 25, 65000),    ('beth', 31, 70000)]

我们可以按字母顺序，按年龄，或按薪水来排序。我们可以指定要与键参数一起使用的对象。

要按年龄排序，我们可以使用以下代码：

sorted_age_list = sorted(list_of_tuples, key = lambda person: person[1])print(sorted_age_list) # [('jane', 25, 65000), ('john', 27, 45000), ('beth', 31, 70000)]

list_of_tuples的每个元素都作为person参数传递给lambda函数。在每个元组元素的索引1处返回。这是用于对列表排序的值，即年龄。

为了按字母顺序对名称进行排序，我们可以在不传递任何键的情况下执行此操作，因为默认情况下，每个元组的第一个元素是被比较的(记住，默认情况下，字符串是按字母顺序排序的)：

sorted_name_list = sorted(list_of_tuples)print(sorted_name_list) # [('beth', 31, 70000), ('jane', 25, 65000), ('john', 27, 45000)]

但是，我们可以指定要按每个元组的第一个元素排序，如下所示：

sorted_name_list = sorted(list_of_tuples, key = lambda person: person[0])print(sorted_name_list) # [('beth', 31, 70000), ('jane', 25, 65000), ('john', 27, 45000)]

请记住，我们可以为变量分配lambda表达式(类似于使用def关键字定义函数)。因此，我们可以根据lambda表达式用于对列表排序的条件来组织它们：

name = lambda person: person[0]age = lambda person: person[1]salary = lambda person: person[2]#按名称排序sorted(list_of_tuples, key = name)#按年龄排序sorted(list_of_tuples, key = age)#按薪资排序sorted(list_of_tuples, key = salary)

我们可以使用operator模块中的itemgetter()函数，而不是使用lambda表达式从元组中访问name、age或salary元素。

我们可以通过传入索引来指定要访问元组中的哪个元素。列表中的每个元组都被传递给itemgetter()函数，并根据指定的索引返回该元组中的特定元素。

import operator#按名称排序sorted(list_of_tuples, key = operator.itemgetter(0))#按年龄排序sorted(list_of_tuples, key = operator.itemgetter(1))#按薪资排序sorted(list_of_tuples, key = operator.itemgetter(2))

函数的作用是：允许多级排序。例如，假设我们有一个元组列表：

list_of_tuples = [ ('john', 27, 45000), ('jane', 25, 65000), ('joe', 25, 35000), ('beth', 31, 70000)]

注意jane和joe的年龄都一样。因此，如果我们想先按年龄排序，再按薪水排序，我们可以将两个值传递给itemgetter()函数：

print(sorted(list_of_tuples, key=operator.itemgetter(1,2))# [('joe', 25, 35000), ('jane', 25, 65000), ('john', 27, 45000), ('beth', 31, 70000)]

由于age的索引是传入的第一个值，因此它将首先用于对元素进行排序。如果年龄相同，将使用salary对元素进行排序。

还可以使用名为attr()的属性对getter()进行排序。例如，如果我们编写了自己的类并实例化了该类的对象，则可以使用attrgetter()函数使用特定的命名属性对这些对象进行排序。

我们只需将属性的名称传递给attrgetter()函数，然后将该函数传递到sorted()函数的键参数中。例如，为了按年龄对对象排序，我们将把以下内容传递给key参数：key = attrgetter(‘age’).。

对元组排序

对元组进行排序与使用sorted()函数对列表排序相同。此外，由于元组是不可变的对象，因此我们不能使用sort()方法，因为sort()方法修改了原始列表。

请记住，即使我们将元组传递给sorted()函数，也会返回一个列表。

num_tuple = (5,2,53,9,25)sorted_tuple = sorted(num_tuple)print(sorted_tuple)# [2,5,9,25,53]

字符串是可调的。因此，也可以使用sorted()函数对它们进行排序。sorted()函数将逐字符遍历字符串。默认情况下，sorted()函数将按字母顺序对字符串进行排序。

sorted_string = sorted(‘dinosaur’)print(sorted_string)# ['a','d','i','n','o','r','s','u']

注意sorted()函数如何按字母顺序返回字符列表。

对字典排序

字典由key:value对组成。因此，可以按键或值进行排序。

假设我们有一个字典，键是名字，值是年龄。

dictionary_of_names = {'beth': 37,                        'jane': 32,                       'john': 41,                        'mike': 59}

如果我们只是将整个字典作为容器传递给sorted()函数，我们将得到以下输出：

print(sorted(dictionary_of_names))# ['beth', 'jane', 'john', 'mike']

如我们所见，如果我们将整个字典作为容器传递给sorted()函数，它将返回一个只包含按字母顺序排序的键的列表。

使用items()方法

如果要获取整个字典的排序副本，则需要使用dictionary items()方法：

print(dictionary_of_names.items())# dict_items([('beth', 37), ('jane', 32), ('john', 41), ('mike', 59)])

请注意items()方法如何返回dict_items对象，该对象看起来类似于元组列表。这个dict_items对象是一个容器，它可以作为容器传递给sorted()函数。

我们可以像对前面看到的元组列表排序一样，对dict_items对象进行排序。例如，要按每个元组中的第二个元素(即年龄)进行排序，可以使用以下代码：

sorted_age = sorted(dictionary_of_names.items(), key = lambda kv: kv[1])print(sorted_age)# [('jane', 32), ('beth', 37), ('john', 41), ('mike', 59)]

请注意sorted()函数是如何返回元组列表的，这些元组按年龄(或每个元组中的第二个元素)排序。要将此元组列表转换为字典，可以使用内置的dict()函数：

sorted_dictionary = dict(sorted_age)print(sorted_dictionary)# {'jane': 32, 'beth': 37, 'john': 41, 'mike': 59}

现在我们有一个按年龄分类的字典！

结论

在本教程中，我们比较了排序列表时sort()方法和sorted()函数。我们学习了sort()方法如何修改原始列表，sorted()函数返回一个新列表。我们还了解到sort()方法只对列表有效，但是sorted()函数可以处理任何容器。然后我们学习了如何对不同类型的容器进行排序并使用不同的标准。