Python中的sort方法、sorted函数与lambda表达式及用法详解

目录

• 1. sort()方法
• 1.1 sort()方法
• 1.2 基本语法和参数
• A. reverse参数
• B. key参数
• 2. sorted()函数
• 2.1 代码对比
• 3. lambda函数
• 3.1 基本语法
• 3.2 lambda函数与普通函数的对比
• 3.3 lambda表达式的用法
• 示例1：sorted函数和sort方法自定义排序规则
• 示例2：map()——对序列中的每个元素应用函数
• 示例3：filter()——筛选序列中的元素

list.sort()最核心、也最需要记住的特点是：它会直接修改原始列表，使其变为有序状态。也就是原地排序。因此，sort()方法的返回值是None。部分初学者可能会将其结果赋值给新变量，这种用法是错误的。正确的用法是无需将其结果赋值给新变量，直接使用被修改后的原列表即可，如下所示：

nums = [3, 1, 4, 1, 5, 9, 2]
nums.sort()
print(nums)

结果如下：

[1, 1, 2, 3, 4, 5, 9]

sort()方法的完整语法是：

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

它接受两个可自选的关键字参数：key和reverse。

这个参数非常直观

• reverse = False（默认值）：升序排序
• reverse = True：降序排序

numbers = [4, 2, 8, 1, 6]
numbers.sort() # 默认升序
print(numbers) # 输出: [1, 2, 4, 6, 8]
numbers.sort(reverse=True) # 降序
print(numbers) # 输出: [8, 6, 4, 2, 1]

key参数是sort()方法最强大的功能。它允许你自定义排序的逻辑。
key接受一个函数（通常是lambda匿名函数）。在排序比较之前，列表中的每个元素都会先经过这个key函数处理，然后Python会根据这个函数的返回值来进行排序。

words = ["apple", "banana", "kiwi", "cherry"]
# key=len 意味着对每个单词应用 len() 函数，然后按长度排序
words.sort(key=len)
print(words) # 输出: ['kiwi', 'apple', 'banana', 'cherry']

names = ["Bob", "alice", "Charlie", "david"]
names.sort()
print(names) # 输出: ['Bob', 'Charlie', 'alice', 'david'] (默认排序)
names.sort(key=str.lower)
print(names) # 输出: ['alice', 'Bob', 'Charlie', 'david'] (忽略大小写)

people = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]
# 使用 lambda 函数提取 'age' 的值作为排序的 key
people.sort(key=lambda person: person['age'])
print(people)
# 输出:
# [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]

当然也可以同时使用key和reverse：

# 按年龄降序排序
people.sort(key=lambda person: person['age'], reverse=True)
print(people)
# 输出:
# [{'name': 'Charlie', 'age': 35}, {'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}]

Python还提供了一个内置函数sorted()，它也用于排序。理解它们的区别至关重要。

	list.sort()	sorted()
类型	列表的方法（method）	内置函数（function）
使用对象	只能用于列表（list）	可以用于任何可迭代对象（list, tuple, str, dict, etc.）
修改	原地修改	不能修改原始对象，通常赋值给一个新的变量
返回值	None	返回一个新的、已排序的列表

# 使用 list.sort()
original_list = [5, 2, 3]
original_list.sort() # 直接修改 original_list
print(f"Original list after sort(): {original_list}") # 输出: [2, 3, 5]
# 使用 sorted()
original_tuple = (5, 2, 3)
new_list = sorted(original_tuple) # 不会修改 original_tuple，而是返回新列表
print(f"Original tuple: {original_tuple}") # 输出: (5, 2, 3)
print(f"New list from sorted(): {new_list}") # 输出: [2, 3, 5]

一个lambda函数是一个小型的、匿名的、单行表达式函数。

lambda arguments: expression

• lambda：关键字，表示你正在定义一个lambda函数。
• arguments：和普通函数的参数一样，可以有零个或多个，用逗号分割，也就是形参。
• expression：一个单独的表达式。计算这个表达式的结果，并作为函数的返回值。

A. 使用def（普通函数）

def add(x, y):
  return x + y
result = add(2, 3)
print(result) # 输出: 5

B. 使用lambda（匿名函数）

add_lambda = lambda x, y: x + y
result = add_lambda(2, 3)
print(result) # 输出: 5

lambda的主要用途是作为高阶函数的参数，

这是lambda最经典、最常见的用途。sorted函数和sort方法有一个key参数，你可以提供一个函数，sorted函数和sort方法会根据这个函数的返回值对元素进行排序。假设有一个元组列表，每个元组代表 (商品, 价格)。我们想按价格排序。

items = [('apple', 2.5), ('banana', 1.8), ('cherry', 3.0)]
# 使用 def 的繁琐方式
def get_price(item):
  return item[1]
sorted_items = sorted(items, key=get_price)
print(sorted_items)
# 使用 lambda 的简洁方式
sorted_items_lambda = sorted(items, key=lambda item: item[1])
print(sorted_items_lambda)
# 输出都是：
# [('banana', 1.8), ('apple', 2.5), ('cherry', 3.0)]

key=lambda item: item[1]创建了一个临时的、无需命名的函数，它接受一个item（元组），也就是items中的一个元素，并返回该元组的第二个元素（价格）。
其原理如下：

• sorted()函数开始工作，它拿到了items列表。
• 它需要对列表中的元素进行比较排序。它看到了key=lambda item: item[1]这个规则。
• 它取出第一个元素 ('apple', 2.5)。
• 它将这个元素传递给lambda函数，即item参数现在是 ('apple', 2.5)。
• lambda函数执行它的表达式item[1]，返回的结果是2.5。sorted()函数在内部记下：('apple', 2.5)的排序值为2.5。
• 接着，它取出第二个元素('banana', 1.8)。
• 它将这个元素传递给lambda函数，item变成了('banana', 1.8)。
• lambda函数执行item[1]，返回1.8。sorted()记下：('banana', 1.8)的排序值为1.8”。
• 它取出第三个元素('cherry', 3.0)，同样地，通过lambda函数得到它的排序值为3.0。
• 最后，sorted()根据这些排序值[2.5, 1.8, 3.0]来对原始的items列表进行排序。1.8最小，2.5其次，3.0最大。
• 所以，最终返回的排序结果是：[('banana', 1.8), ('apple', 2.5), ('cherry', 3.0)]。

上面的例子是对价格进行升序排列，如果要进行降序排列可以这样写：

items = [('apple', 2.5), ('banana', 1.8), ('cherry', 3.0)]
# 使用 lambda 的简洁方式
# 该技巧仅适用于数值类型，其他类型，例如字符可能需要进行多次排序
sorted_items_lambda = sorted(items, key=lambda item: -item[1])
print(sorted_items_lambda)
# 输出是：
# [('cherry', 3.0), ('apple', 2.5), ('banana', 1.8)]

如果要进行多级排序，可以这样写：

# 列表中元组中元素的含义分别为名称、价格、重量
data = [
    ('Cherry', 20, 100),
    ('Apple', 20, 150),
    ('Banana', 30, 120),
    ('Date', 10, 500),
    ('Blueberry', 20, 100)
]
# 使用 lambda 返回一个元组作为排序的 key
# (item[1], item[2], item[0]) -> (价格, 重量, 名称)
# 先按照价格排序，价格相同的情况下按照重量排序，价格和重量都相同的情况下按照名称进行排序
sorted_data = sorted(data, key=lambda item: (item[1], item[2], item[0]))
print(sorted_data)
# 输出结果为：
[('Date', 10, 500), ('Blueberry', 20, 100), ('Cherry', 20, 100), ('Apple', 20, 150), ('Banana', 30, 120)]

numbers = [1, 2, 3, 4, 5]
# 使用 lambda
squared_numbers = map(lambda x: x * x, numbers)
print(list(squared_numbers)) # 输出: [1, 4, 9, 16, 25]

# 从序列中筛选出所有的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
# 使用 lambda
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers)) # 输出: [2, 4, 6, 8]

到此这篇关于Python中的sort方法、sorted函数与lambda表达式及用法详解的文章就介绍到这了,更多相关python sort sorted函数与lambda表达式内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• Python函数sort()与sorted()的区别及key=lambda x:x[]的理解
• 详解python中的lambda与sorted函数
• Python中sorted()函数之排序的利器详解
• python3中sort和sorted使用与区别
• Python中sorted()函数的强大排序技术实例探索
• Python中的SortedList详解
• python中字典dict排序sorted的实现
• python的sorted函数及使用解析