当前位置：首页 > news >正文

Python 中 `sort()` 和 `sorted()` 的用法与区别

news 来源：原创 2025/5/29 3:57:13

Python 中 `sort()` 和 `sorted()` 的用法与区别

1. `sort()` 方法：

sort() 是 Python 列表类型 (list) 的一个方法，它用于就地（原地）排序列表，修改原始列表。排序时可以通过 key 参数指定排序依据，还可以通过 reverse 参数来指定是否按降序排序。

语法：

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

key：指定一个函数，用来从列表中的每个元素中提取出用于排序的值。
reverse：布尔值，True 时表示降序排序，False 时表示升序排序（默认）。

示例 1：基本用法

numbers = [5, 2, 9, 1, 5, 6]
numbers.sort()
print(numbers)  # 输出：[1, 2, 5, 5, 6, 9]

示例 2：按降序排序

numbers = [5, 2, 9, 1, 5, 6]
numbers.sort(reverse=True)
print(numbers)  # 输出：[9, 6, 5, 5, 2, 1]

示例 3：使用 `key` 参数按某个规则排序

items = [(3, 'apple'), (1, 'banana'), (2, 'cherry')]
items.sort(key=lambda x: x[0])  # 按照元组的第一个元素（数字）排序
print(items)  # 输出：[(1, 'banana'), (2, 'cherry'), (3, 'apple')]

注意：

sort() 是原地排序，会改变原始列表。
如果你希望保留原始列表并得到一个新的排序结果，使用 sorted()。

2. `sorted()` 函数：

sorted() 是一个内置函数，它可以用于任何可迭代对象（如列表、元组、字典等）。它会返回一个新的已排序的列表，并不会改变原始数据。

语法：

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

iterable：待排序的可迭代对象。
key：同 sort()，指定排序依据。
reverse：同 sort()，是否降序排列。

示例 1：基本用法

numbers = [5, 2, 9, 1, 5, 6]
new_numbers = sorted(numbers)
print(new_numbers)  # 输出：[1, 2, 5, 5, 6, 9]
print(numbers)  # 原始列表未变：[5, 2, 9, 1, 5, 6]

示例 2：使用 `key` 参数按某个规则排序

items = [(3, 'apple'), (1, 'banana'), (2, 'cherry')]
new_items = sorted(items, key=lambda x: x[0])  # 按照元组的第一个元素排序
print(new_items)  # 输出：[(1, 'banana'), (2, 'cherry'), (3, 'apple')]

示例 3：按降序排序

numbers = [5, 2, 9, 1, 5, 6]
new_numbers = sorted(numbers, reverse=True)
print(new_numbers)  # 输出：[9, 6, 5, 5, 2, 1]

注意：

sorted() 会返回一个新的列表，原始数据不受影响。
如果你不需要改变原始数据且想要一个新的排序列表，使用 sorted()。

3. `sort()` 和 `sorted()` 的区别：

特性	`sort()`	`sorted()`
修改原数据	是（原地排序）	否（返回新列表，不修改原数据）
返回值	`None`（返回值是 `None`，修改原列表）	新排序的列表
适用范围	仅适用于列表 (`list`)	适用于任何可迭代对象（如列表、元组、字典等）
性能	因为是原地排序，内存效率更高	返回一个新的列表，会占用额外内存

例子：原地排序与返回新列表的对比

# 使用 sort()
numbers = [4, 2, 7, 1]
numbers.sort()  # 原地排序
print(numbers)  # 输出：[1, 2, 4, 7]

# 使用 sorted()
numbers = [4, 2, 7, 1]
sorted_numbers = sorted(numbers)  # 返回新的列表
print(numbers)  # 输出：[4, 2, 7, 1] (原列表未改变)
print(sorted_numbers)  # 输出：[1, 2, 4, 7]

4. 如何选择使用 `sort()` 或 `sorted()`：

使用 sort()：当你只需要修改原始列表并节省内存时。
使用 sorted()：当你不想修改原始列表时，或者想对其他类型的可迭代对象（如元组、字典等）进行排序。

5. 解题思路：每一个查询的最大美丽值

我们来看一下题目：

给定一个二维数组 items，每个元素是 [price, beauty]，以及一个查询数组 queries，对于每个查询值，要求返回小于等于该查询价格的所有物品中的最大美丽值。

我们可以通过以下步骤来优化解决这个问题：

1. 排序物品列表：

首先，我们可以按照物品的价格排序 items，这样方便在后续的查询过程中增量地处理物品，避免重复遍历。

2. 按查询排序：

将 queries 按升序排序，这样可以确保我们从小到大处理每个查询。

3. 遍历物品并增量更新最大美丽值：

对于每个查询，使用两个指针：一个指向物品列表，一个指向查询数组。每次处理一个查询时，我们通过指针 j 增量遍历物品列表，更新当前可选物品中的最大美丽值。

代码实现：

class Solution:
    def maximumBeauty(self, items: List[List[int]], queries: List[int]) -> List[int]:
        # 排序物品列表，按照价格排序
        items.sort(key=lambda item: item[0])

        # 按照查询值升序排序，并记录原始索引
        idx = sorted(range(len(queries)), key=lambda i: queries[i])

        # 初始化答案列表，max_beauty表示当前最大的美丽值
        ans = [0] * len(queries)
        max_beauty = 0
        j = 0
        
        # 遍历查询
        for i in idx:
            q = queries[i]
            # 处理查询小于等于当前查询价格的物品
            while j < len(items) and items[j][0] <= q:
                max_beauty = max(max_beauty, items[j][1])
                j += 1
            ans[i] = max_beauty

        return ans

示例：

items = [[1, 2], [3, 2], [2, 4], [5, 6], [3, 5]]
queries = [1, 2, 3, 4, 5, 6]
sol = Solution()
print(sol.maximumBeauty(items, queries))  # 输出：[2, 4, 5, 5, 6, 6]