如何在 Python 中检查元组是否按升序排序

简介

在这个实验中，你将学习如何在 Python 中检查一个元组（tuple）是否按升序排列。元组与列表（list）类似，是不可变序列。由于不能使用修改原始序列的方法直接对元组进行排序，本实验将探索其他方法。

本实验将演示如何使用 sorted() 函数从元组创建一个新的排序列表，并将其转换回元组。它还将介绍 all() 和 zip() 函数，作为验证元组是否已经按升序排列的工具。

Skills Graph

了解排序后的元组

在这一步中，你将了解 Python 中排序后的元组（tuple）。元组与列表（list）类似，但它们是不可变的，这意味着它们的元素在创建后不能被更改。排序后的元组就是其元素按特定顺序排列的元组，通常是升序或降序。

由于元组是不可变的，你不能使用像 sort() 这样会修改原始列表的方法直接对它们进行排序。相反，你将使用 sorted() 函数，该函数会从任何可迭代对象（包括元组）的元素中返回一个新的排序列表。然后，你可以将这个排序列表再转换回元组。

让我们从创建一个简单的元组开始：

my_tuple = (5, 2, 8, 1, 9)
print(my_tuple)

现在，让我们使用 sorted() 函数对这个元组进行排序，并将结果转换回元组：

1. 在 LabEx 环境中打开 VS Code 编辑器。
2. 在 ~/project 目录下创建一个名为 sort_tuple.py 的新文件。
3. 将以下代码复制并粘贴到 sort_tuple.py 中：

my_tuple = (5, 2, 8, 1, 9)
sorted_list = sorted(my_tuple)
sorted_tuple = tuple(sorted_list)

print("Original tuple:", my_tuple)
print("Sorted tuple:", sorted_tuple)

这段代码首先定义了一个名为 my_tuple 的元组。然后，它使用 sorted() 函数从 my_tuple 的元素中创建一个排序列表。最后，它将这个排序列表转换回一个名为 sorted_tuple 的元组。

要运行这个脚本，在 VS Code 中打开一个终端（你可以在底部面板找到它），并执行以下命令：

python sort_tuple.py

你应该会看到以下输出：

Original tuple: (5, 2, 8, 1, 9)
Sorted tuple: (1, 2, 5, 8, 9)

如你所见，sorted() 函数返回一个新的元组，其中原始元组的元素按升序排列。

你还可以通过使用 sorted() 函数的 reverse 参数对元组进行降序排序：

my_tuple = (5, 2, 8, 1, 9)
sorted_list = sorted(my_tuple, reverse=True)
sorted_tuple = tuple(sorted_list)

print("Original tuple:", my_tuple)
print("Sorted tuple (descending):", sorted_tuple)

保存 sort_tuple.py 的更改并再次运行它：

python sort_tuple.py

现在的输出应该是：

Original tuple: (5, 2, 8, 1, 9)
Sorted tuple (descending): (9, 8, 5, 2, 1)

现在你就有了一个降序排列的元组。

与 sorted() 函数对比

在上一步中，你学习了如何使用 sorted() 函数对元组进行排序。在这一步，我们将深入探讨 sorted() 函数，并将其行为与其他方法进行对比，突出其多功能性和使用场景。

sorted() 函数是 Python 的内置函数，可用于对任何可迭代对象进行排序，包括列表（list）、元组（tuple）、字符串（string）和字典（dictionary）。它会返回一个新的排序列表，而不会修改原始的可迭代对象。当你想保留原始数据结构时，这一点特别有用。

让我们通过一些示例来展示 sorted() 函数的强大功能：

1. 在 LabEx 环境中打开 VS Code 编辑器。
2. 修改 ~/project 目录下现有的 sort_tuple.py 文件，如果该文件不存在则创建它。
3. 将以下代码复制并粘贴到 sort_tuple.py 中：

## Sorting a list of strings
string_list = ["banana", "apple", "orange"]
sorted_string_list = sorted(string_list)
print("Original list:", string_list)
print("Sorted list:", sorted_string_list)

## Sorting a string (characters)
my_string = "hello"
sorted_string = sorted(my_string)
print("Original string:", my_string)
print("Sorted string (as list):", sorted_string)

## Sorting a dictionary (keys)
my_dict = {"c": 3, "a": 1, "b": 2}
sorted_dict_keys = sorted(my_dict)
print("Original dictionary:", my_dict)
print("Sorted dictionary keys:", sorted_dict_keys)

这段代码展示了如何将 sorted() 函数用于不同的数据类型。它按字母顺序对字符串列表进行排序，对字符串中的字符进行排序，以及对字典的键进行排序。

要运行这个脚本，在 VS Code 中打开一个终端（你可以在底部面板找到它），并执行以下命令：

python sort_tuple.py

你应该会看到以下输出：

Original list: ['banana', 'apple', 'orange']
Sorted list: ['apple', 'banana', 'orange']
Original string: hello
Sorted string (as list): ['e', 'h', 'l', 'l', 'o']
Original dictionary: {'c': 3, 'a': 1, 'b': 2}
Sorted dictionary keys: ['a', 'b', 'c']

注意，无论输入类型如何，sorted() 函数总是返回一个列表。如果你需要将结果转换为其他格式，例如元组，你可以像上一步那样使用 tuple() 函数进行转换。

sorted() 函数的另一个重要特性是 key 参数。这个参数允许你指定一个函数，该函数将用于从可迭代对象的每个元素中提取一个比较键。这对于根据特定属性对复杂对象进行排序非常有用。

例如，让我们根据每个元组的第二个元素对元组列表进行排序：

## Sorting a list of tuples based on the second element
tuple_list = [(1, 'z'), (2, 'a'), (3, 'b')]
sorted_tuple_list = sorted(tuple_list, key=lambda x: x[1])
print("Original list of tuples:", tuple_list)
print("Sorted list of tuples (by second element):", sorted_tuple_list)

将这段代码添加到你的 sort_tuple.py 文件中并再次运行：

python sort_tuple.py

现在的输出应该包括：

Original list of tuples: [(1, 'z'), (2, 'a'), (3, 'b')]
Sorted list of tuples (by second element): [(2, 'a'), (3, 'b'), (1, 'z')]

在这个示例中，lambda x: x[1] 函数提取每个元组的第二个元素，sorted() 函数使用这些元素来确定排序后列表中元组的顺序。

使用 all() 和 zip() 进行检查

在这一步，你将学习如何结合使用 all() 和 zip() 函数与排序后的元组，以执行更高级的检查和比较。

all() 函数是 Python 的内置函数，如果可迭代对象的所有元素都为真（或者可迭代对象为空），则返回 True。它常用于检查序列中的所有元素是否都满足某个条件。

zip() 函数是另一个 Python 内置函数，它接受多个可迭代对象作为参数，并返回一个元组迭代器。每个元组包含来自输入可迭代对象的对应元素。它对于将不同序列的元素配对进行比较或其他操作很有用。

让我们看看如何将这些函数与排序后的元组一起使用：

1. 在 LabEx 环境中打开 VS Code 编辑器。
2. 修改 ~/project 目录下现有的 sort_tuple.py 文件，如果该文件不存在则创建它。
3. 将以下代码复制并粘贴到 sort_tuple.py 中：

## Checking if a tuple is sorted using all() and zip()
def is_sorted(data):
    ## zip(data, data[1:]) pairs consecutive elements
    ## all(x <= y for x, y in ...) checks if each pair is in ascending order
    return all(x <= y for x, y in zip(data, data[1:]))

my_tuple1 = (1, 2, 3, 4, 5)
my_tuple2 = (5, 2, 8, 1, 9)

print("Tuple 1:", my_tuple1, "is sorted:", is_sorted(my_tuple1))
print("Tuple 2:", my_tuple2, "is sorted:", is_sorted(my_tuple2))

这段代码定义了一个 is_sorted() 函数，用于检查给定的元组是否按升序排序。它使用 zip() 函数将元组的连续元素配对，并使用 all() 函数检查每对元素是否按升序排列。

要运行这个脚本，在 VS Code 中打开一个终端（你可以在底部面板找到它），并执行以下命令：

python sort_tuple.py

你应该会看到以下输出：

Tuple 1: (1, 2, 3, 4, 5) is sorted: True
Tuple 2: (5, 2, 8, 1, 9) is sorted: False

如你所见，is_sorted() 函数能正确识别元组是否已排序。

让我们扩展这个示例，检查两个元组排序后是否相同：

## Checking if two tuples are identical after sorting
def are_identical_after_sorting(tuple1, tuple2):
    return sorted(tuple1) == sorted(tuple2)

tuple_a = (3, 1, 4, 1, 5)
tuple_b = (1, 5, 1, 4, 3)
tuple_c = (1, 2, 3, 4, 5)

print("Tuple A:", tuple_a, "and Tuple B:", tuple_b, "are identical after sorting:", are_identical_after_sorting(tuple_a, tuple_b))
print("Tuple A:", tuple_a, "and Tuple C:", tuple_c, "are identical after sorting:", are_identical_after_sorting(tuple_a, tuple_c))

将这段代码添加到你的 sort_tuple.py 文件中并再次运行：

python sort_tuple.py

现在的输出应该包括：

Tuple A: (3, 1, 4, 1, 5) and Tuple B: (1, 5, 1, 4, 3) are identical after sorting: True
Tuple A: (3, 1, 4, 1, 5) and Tuple C: (1, 2, 3, 4, 5) are identical after sorting: False

在这个示例中，are_identical_after_sorting() 函数检查两个元组是否包含相同的元素，而不考虑它们的原始顺序。它对两个元组进行排序，然后比较排序后的列表。

总结

在这个实验中，你学习了 Python 中的排序元组以及如何创建它们。由于元组是不可变的，你不能直接对它们进行排序。相反，sorted() 函数用于从元组的元素创建一个新的排序列表，然后再将其转换回元组。

本实验展示了如何使用 sorted() 函数按升序对元组进行排序，以及如何使用打印语句查看原始元组和排序后的元组。实验还提到了可以使用 reverse 参数按降序排序，不过完整的代码被省略了。