【python】sorted() list.sort()

文章目录

• sorted()和list.sort()
• • [sorted 函数](#sorted 函数)
  • • sorted()根据键对字典排序
    • • 根据字典的键排序
      • 根据字典的值排序
      • 将排序结果转换回字典
  • [list.sort() 方法](#list.sort() 方法)
  • • 总结
  • [key=lambda student: student['age']](#key=lambda student: student['age'])

sorted()和list.sort()

在Python中，sorted 函数和 list.sort() 方法都可以用来排序，但它们有一些不同之处。

sorted 函数

sorted 是一个内置函数，它可以对所有可迭代的对象进行排序，不仅限于列表。sorted 函数在排序完成后会返回一个新的列表，而不会改变原来的数据。

基本用法：

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

• iterable：要排序的可迭代对象。
• key：一个函数，它会被用来在进行比较之前从每个列表元素中提取一个比较键（比如通过一个函数指定排序的依据）。
• reverse：布尔值。如果设置为True，则列表元素将被逆序排列，默认为False。

示例：

# 基本排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)  # 默认升序排序
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序
sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

# 通过key参数自定义排序规则
students = [{'name': 'John', 'age': 15}, {'name': 'Steve', 'age': 12}, {'name': 'Marry', 'age': 13}]
sorted_students = sorted(students, key=lambda student: student['age'])
print(sorted_students)  # 按年龄排序的列表

实际上，sort() 方法是列表（list）对象的一部分，因此它只能直接用于列表。它是一个就地排序方法，意味着它会修改原列表，而不是返回一个新的排序列表。

不过，虽然 sort() 方法只能用于列表，但 sorted() 函数可以用于任何可迭代对象，包括列表、元组、字典、集合以及任何实现了 __iter__() 方法的自定义对象。

下面是 sorted() 函数的一些例子，展示了它如何应用于不同类型的可迭代对象：

列表（List）：

numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)

元组（Tuple）：

numbers_tuple = (3, 1, 4, 1, 5, 9, 2, 6)
sorted_numbers_tuple = sorted(numbers_tuple)

字典（Dictionary）：

# 注意：字典是无序的，sorted会根据键来排序
my_dict = {'b': 2, 'c': 3, 'a': 1}
sorted_dict_keys = sorted(my_dict)

集合（Set）：

my_set = {3, 1, 4, 1, 5, 9, 2, 6}
sorted_set = sorted(my_set)

对于非列表类型的可迭代对象，sorted() 函数会返回一个新的列表，其中包含了按照指定顺序排列的元素。

需要注意的是，当对字典或集合使用 sorted() 函数时，只能对字典的键或集合的元素进行排序，因为集合是无序的，而字典在Python 3.7之前是无序的（Python 3.7及以后版本中，字典是有序的，但排序通常是基于键进行的）。

---

sorted()根据键对字典排序

在Python中，字典是无序的集合，直到Python 3.7版本，字典开始保持插入顺序。如果你需要根据字典的键或值对字典进行排序，你可以使用sorted()函数，并通过key参数指定排序依据。

根据字典的键排序

如果你想要按照字典的键来排序，可以直接使用sorted()函数，因为默认情况下，它就是根据键来排序的。

my_dict = {'b': 2, 'c': 3, 'a': 1}
sorted_by_key = sorted(my_dict.items())
print(sorted_by_key)  # 输出: [('a', 1), ('b', 2), ('c', 3)]

这里，my_dict.items()返回一个包含字典键值对的列表，sorted()函数按照键进行排序。

根据字典的值排序

如果你想要按照字典的值来排序，可以通过key参数传递一个函数，这个函数返回字典的值。

my_dict = {'b': 2, 'c': 1, 'a': 3}
sorted_by_value = sorted(my_dict.items(), key=lambda item: item[1])
print(sorted_by_value)  # 输出: [('c', 1), ('b', 2), ('a', 3)]

在这个例子中，lambda item: item[1]是一个匿名函数，它接受一个键值对item，并返回这个键值对的值（item[1]），sorted()函数使用这个值来排序。

将排序结果转换回字典

sorted()函数返回的是一个列表，如果你想要将排序后的结果转换回字典，可以使用字典推导式或dict()构造函数。

sorted_dict = dict(sorted_by_key)
print(sorted_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# 或者使用字典推导式
sorted_dict = {k: v for k, v in sorted_by_key}
print(sorted_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

这样，你就可以得到一个根据键或值排序后的字典。

list.sort() 方法

list.sort() 是列表对象的一个方法，它只对列表进行排序，不适用于其他可迭代对象。这个方法会就地修改原列表，不会返回新列表。

基本用法：

list.sort(key=None, reverse=False)

参数和 sorted 函数的相同，区别在于 list.sort() 直接修改原列表。

示例：

# 基本排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort()  # 直接修改原列表
print(numbers)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort(reverse=True)
print(numbers)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

# 自定义排序规则
students = [{'name': 'John', 'age': 15}, {'name': 'Steve', 'age': 12}, {'name': 'Marry', 'age': 13}]
students.sort(key=lambda student: student['age'])
print(students)  # 按年龄排序的列表

总结

• 如果你需要排序后的列表，并且不想修改原始数据，使用 sorted 函数。
• 如果你只需要对列表进行排序，并且不介意修改原始列表，可以使用 list.sort() 方法。
• sorted 函数可以对任何可迭代对象进行排序，而 list.sort() 方法只能用于列表。
• sorted 函数返回一个新的列表，而 list.sort() 方法没有返回值（因为它直接修改原列表）。

key=lambda student: student['age']

在Python的sorted函数或list.sort()方法中，key参数允许你指定一个函数，这个函数会在排序之前应用于每个元素。这个函数的返回值将被用作排序的依据。key参数提供了一种灵活的方式来自定义排序逻辑。

当你使用lambda表达式作为key参数时，你实际上是在创建一个匿名函数。lambda表达式是一种简洁的方式来定义一个函数，它通常用于编写简单的、一次性的小函数。

让我们分解一下key=lambda student: student['age']这个表达式：

• lambda：关键字，用于定义一个匿名函数。
• student：这是lambda函数的参数，它代表列表中的每个元素。在这个上下文中，每个元素都是一个字典，代表一个学生的信息。
• :：在lambda表达式中，:用于分隔参数和表达式的主体。
• student['age']：这是lambda函数的主体，它指定了排序的依据。对于列表中的每个学生字典，这个表达式会返回学生的age值。

当sorted函数或list.sort()方法使用这个key参数时，它会在内部对每个元素（在这个例子中是学生字典）应用这个lambda函数，然后根据返回的age值进行排序。

示例：

假设我们有一个学生列表，每个学生都是一个包含姓名和年龄的字典：

students = [
    {'name': 'John', 'age': 15},
    {'name': 'Steve', 'age': 12},
    {'name': 'Marry', 'age': 13}
]

如果我们想根据年龄对这个列表进行排序，我们可以这样使用sorted函数和lambda表达式：

sorted_students = sorted(students, key=lambda student: student['age'])

在这个例子中，sorted函数会对students列表中的每个字典应用lambda函数，lambda函数会从每个字典中提取age值。然后，sorted函数会根据这些age值对原始的学生字典进行排序。

最终，sorted_students将是一个新列表，其中的学生字典按照年龄升序排列：

[
    {'name': 'Steve', 'age': 12},
    {'name': 'Marry', 'age': 13},
    {'name': 'John', 'age': 15}
]

使用lambda表达式作为key参数是一种非常简洁和高效的方式来指定自定义排序逻辑。