核心概念：sort() 和 sorted() 的比较

特点
sort()
sorted()
用法 列表的方法 内置函数
返回值 None（原地排序，不返回值） 返回新的排序后的列表
作用对象 仅限于列表 任何可迭代对象（如列表、元组、集合、字符串等）但是串列里面的资料必须都是相同型态才能进行排序
改变原始数据 会改变原始列表 不会改变原始数据
排序方式 可以升序或降序排序 可以升序或降序排序
使用 key 参数 支持 支持
其他 字元顺序排列会由小至大（升序）：Ａ->Z->a->z

.sort() 列表的方法

语法范例

# 创建一个列表
numbers = [5, 2, 9, 1, 5, 6]

# 使用 sort() 进行升序排序
numbers.sort()
print(numbers) # 输出：[1, 2, 5, 5, 6, 9]

# 使用 sort() 进行降序排序
numbers.sort(reverse=True)
print(numbers) # 输出：[9, 6, 5, 5, 2, 1]

# 使用 key 参数来根据绝对值排序
numbers = [-5, -1, 2, -3]
numbers.sort(key=abs)
print(numbers) # 输出：[-1, 2, -3, -5]

sorted(list) 函数

语法

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

参数：iterable：要排序的可迭代对象。key：可选，指定一个函数，用于从每个可迭代元素中提取一个用于比较的键。reverse：可选，布林值，若设为 True，则将列表按降序排序。范例：

lst= [\'four\',\'9\',\'10\']
sorted_lst = sorted(lst)
print(sorted_lst)
#[\'10\',\'9\',\'four\']

what 什么是 key 参数？：客制化排序的利器

  • 一个函数： key 参数接受一个可调用对象，通常是一个函数。
  • 排序依据： 这个函数会对序列中的每个元素进行操作，并返回一个值。sorted() 函数会根据这些返回值来进行排序。

why 为什么要使用 key 参数？

  • 复杂排序： 当我们需要根据元素的某个特定属性或计算结果来排序时，key 参数就显得非常有用。
  • 自定义排序逻辑： 我们可以完全自定义排序的规则，而不仅仅是按照元素本身的大小进行排序。
  • 用法：
    • len：按长度排序
    • lambda：自定义排序逻辑

how 如何使用 key 参数？

  • 按字符串长度len排序

    • fruits = [\'banana\', \'apple\', \'orange\', \'grape\']
    sorted_fruits = sorted(fruits, key=len)
    print(sorted_fruits) # 输出: [\'apple\', \'grape\', \'banana\', \'orange\']

    这里，len 函数会返回每个字符串的长度，sorted() 函数会根据返回的长度进行排序。

  • 按字典中的值value排序

    • students = [
    {\'name\': \'Alice\', \'age\': 25},
    {\'name\': \'Bob\', \'age\': 23},
    {\'name\': \'Charlie\', \'age\': 27}
    ]
    sorted_students = sorted(students, key=lambda x: x[\'age\'])
    print(sorted_students)
    # 按照年龄升序排序
    #[{\'name\': \'Bob\', \'age\': 23}, {\'name\': \'Alice\', \'age\': 25}, {\'name\': \'Charlie\', \'age\': 27}]

    这里，lambda x: x[\'age\'] 是一个匿名函数，它会返回字典中 age 键对应的值。sorted() 函数会根据返回的年龄值进行排序。

  • 多级排序lambda

    • data = [(1, \'a\'), (3, \'c\'), (2, \'b\')]
    sorted_data = sorted(data, key=lambda x: (x[1], x[0]))
    print(sorted_data)
    # 首先按第二个元素排序，然后按第一个元素排序
    #[(1, \'a\'), (2, \'b\'), (3, \'c\')]

    这里，lambda x: (x[1], x[0]) 返回一个元组，包含了原元组的第二个和第一个元素。sorted() 函数会先根据元组的第一个元素（即原元组的第二个元素）进行排序，如果第一个元素相等，再根据第二个元素（即原元组的第一个元素）进行排序。

    如果是要sorted dictionary 是如何运用？

    在 Python 中，字典（dictionary）本身是一种无序的数据结构，因此无法直接对字典进行排序。然而，我们可以使用 sorted() 函数来根据字典的键或值进行排序，并返回排序后的结果（通常以元组列表的形式）。这样我们就能依据不同的需求对字典进行灵活的排序操作。

    • 按字典中键排序sorted(my_dict):要根据字典的键进行升序排序，可以直接对字典的键使用 sorted()：

    my_dict = {\'apple\': 3, \'banana\': 1, \'cherry\': 2}
    sorted_by_keys = sorted(my_dict) # 只返回排序后的键
    print(sorted_by_keys) # 输出：[\'apple\', \'banana\', \'cherry\']

    • 按字典中的值value排序:

    students = [
    {\'name\': \'Alice\', \'age\': 25},
    {\'name\': \'Bob\', \'age\': 23},
    {\'name\': \'Charlie\', \'age\': 27}
    ]
    sorted_students = sorted(students, key=lambda x: x[\'age\'])
    print(sorted_students)
    # 按照年龄升序排序
    #[{\'name\': \'Bob\', \'age\': 23}, {\'name\': \'Alice\', \'age\': 25}, {\'name\': \'Charlie\', \'age\': 27}]

    这里，lambda x: x[\'age\'] 是一个匿名函数，它会返回字典中 age 键对应的值。sorted() 函数会根据返回的年龄值进行排序。

    • 按**键-值- 对排序.items()：

    sorted_dict_by_keys = dict(sorted(my_dict.items()))
    print(sorted_dict_by_keys) # 输出：{\'apple\': 3, \'banana\': 1, \'cherry\': 2}

    为什么可以考虑只使用 sorted()？

    1.不改变原始数据：sorted() 不会修改原始的可迭代对象，它会返回一个新的已排序列表。这对于保持数据完整性特别重要，避免无意中改变了原始数据。

    2.适用于所有可迭代对象：sorted() 不仅适用于列表，还可以对元组、集合、字符串等进行排序，而 sort() 只能用于列表。这使得 sorted() 更加通用。

    3.灵活性：无论你是对列表进行排序，还是对其他不可变对象（如 tuple、set）进行排序，sorted() 都能应对。而且，它与 key 和 reverse 参数的配合使用也相当灵活。

    什么情况下使用 sort()？

    尽管 sorted() 很好，但在某些情况下使用 sort() 仍有它的价值：

    • 性能考量：如果你不需要保留原始列表，并且想避免创建一个新的列表，sort() 会更高效，因为它是就地排序，不需要分配额外的内存来存放新的列表。
    • 列表操作：当你确定只对列表进行操作，而且不在意原始列表的变化，sort() 是一个简洁且高效的选择。

    总结

    使用 sort()：

    当你想对一个列表进行就地排序时，可以使用 sort() 方法。这种方法适合在你不需要保留原始列表的情况下进行排序。

    使用 sorted()：

    当你需要对其他可迭代对象进行排序，或需要保留原始数据时，使用 sorted() 函数。sorted() 是更通用和灵活的选择，因为它可以用于多种类型的数据。