python如何用sorted函数排序

在Python中，可以使用sorted()函数对序列（如列表、元组或字符串）进行排序。使用sorted()函数可以根据多种标准进行排序，如按数值、字母顺序或者根据自定义的排序规则进行排序。sorted()函数返回的是一个新的列表，而不会改变原来的序列。下面将详细介绍如何使用sorted()函数进行排序，并通过一些实例来展示其应用。

一、基本用法

sorted()函数的基本用法非常简单，只需传递一个可迭代对象（如列表、元组或字符串）即可。它会返回一个按升序排序的新列表。

# 对列表进行排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
对字符串进行排序
letters = "python"
sorted_letters = sorted(letters)
print(sorted_letters)  # 输出: ['h', 'n', 'o', 'p', 't', 'y']

二、使用`key`参数

sorted()函数可以接收一个名为key的参数，用于指定一个函数，这个函数将应用于每个元素以确定排序顺序。通过使用key参数，可以实现更加复杂的排序逻辑。

# 按照字符串长度排序
words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=len)
print(sorted_words)  # 输出: ['date', 'apple', 'banana', 'cherry']

在上面的例子中，len函数作为key参数传递给sorted()函数，这样字符串将按照长度进行排序。

三、使用`reverse`参数

默认情况下，sorted()函数按升序排序。可以通过设置reverse参数为True来按降序排序。

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

四、对复合数据结构排序

对于包含复杂数据结构的序列（如列表中的元组或字典），可以使用key参数指定一个函数，以确定如何进行排序。

# 对包含元组的列表进行排序
students = [("John", 85), ("Jane", 92), ("Dave", 78)]
sorted_students = sorted(students, key=lambda student: student[1])
print(sorted_students)  # 输出: [('Dave', 78), ('John', 85), ('Jane', 92)]

在这个例子中，key参数使用了一个lambda函数，lambda student: student[1]，它指定排序依据为每个元组的第二个元素（即成绩）。

五、自定义排序函数

有时需要进行更复杂的排序，此时可以定义一个自定义的排序函数，并将其作为key参数传递给sorted()函数。

# 自定义排序函数
def custom_sort(student):
    return student[1], student[0]
students = [("John", 85), ("Jane", 92), ("Dave", 78)]
sorted_students = sorted(students, key=custom_sort)
print(sorted_students)  # 输出: [('Dave', 78), ('John', 85), ('Jane', 92)]

在这个例子中，custom_sort函数返回一个元组(student[1], student[0])，先按成绩排序，如果成绩相同则按名字排序。

六、排序对象

除了基本数据类型，sorted()函数也可以用于排序对象。需要在对象的类中定义__lt__、__gt__等比较方法，或者使用key参数指定排序规则。

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
    def __repr__(self):
        return f"({self.name}, {self.grade})"
students = [Student("John", 85), Student("Jane", 92), Student("Dave", 78)]
sorted_students = sorted(students, key=lambda student: student.grade)
print(sorted_students)  # 输出: [(Dave, 78), (John, 85), (Jane, 92)]

在这个例子中，通过key参数指定按Student对象的grade属性进行排序。

七、链式排序

链式排序指的是按多个条件进行排序。可以先对次要条件排序，再对主要条件排序，这样就可以实现链式排序效果。

# 先按名字排序，再按成绩排序
students = [("John", 85), ("Jane", 92), ("Dave", 78), ("John", 78)]
sorted_students = sorted(students, key=lambda student: (student[0], student[1]))
print(sorted_students)  # 输出: [('Dave', 78), ('Jane', 92), ('John', 78), ('John', 85)]

在这个例子中，key参数使用了一个包含两个元素的元组，先按名字排序，再按成绩排序。

八、稳定排序

Python的sorted()函数是稳定排序，这意味着当两个元素相等时，它们在原序列中的相对顺序在排序后的序列中保持不变。这对于需要保持某些特定顺序的应用场景非常有用。

# 稳定排序
data = [(1, 'orange'), (2, 'apple'), (2, 'banana'), (1, 'grape')]
sorted_data = sorted(data, key=lambda x: x[0])
print(sorted_data)  # 输出: [(1, 'orange'), (1, 'grape'), (2, 'apple'), (2, 'banana')]

在这个例子中，排序后的结果保持了原始数据中相同第一个元素的相对顺序。

九、使用`functools.cmp_to_key`

在某些情况下，可能需要使用自定义的比较函数。Python提供了functools.cmp_to_key函数，它可以将一个比较函数转换为key函数，从而与sorted()函数一起使用。

from functools import cmp_to_key
自定义比较函数
def compare(x, y):
    if x < y:
        return -1
    elif x > y:
        return 1
    else:
        return 0
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers, key=cmp_to_key(compare))
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

在这个例子中，compare函数定义了两个元素之间的比较规则，然后使用cmp_to_key将其转换为key函数。

十、排序与性能

排序算法的性能在某些应用场景中非常重要。Python的sorted()函数使用的是Timsort算法，这是一种混合排序算法，结合了归并排序和插入排序的优点，平均时间复杂度为O(n log n)。

import time
import random
生成一个大列表
large_list = random.sample(range(1000000), 1000000)
测量排序时间
start_time = time.time()
sorted_large_list = sorted(large_list)
end_time = time.time()
print(f"排序时间: {end_time - start_time}秒")

在这个例子中，生成了一个包含100万个随机数的大列表，并测量了使用sorted()函数进行排序的时间。

十一、排序与多线程

虽然Python的GIL（全局解释器锁）限制了多线程的并行执行，但在某些情况下，可以通过多进程或其他方式来提高排序性能。

from multiprocessing import Pool
对列表进行分块排序
def sort_chunk(chunk):
    return sorted(chunk)
large_list = random.sample(range(1000000), 1000000)
chunk_size = len(large_list) // 4
chunks = [large_list[i:i + chunk_size] for i in range(0, len(large_list), chunk_size)]
with Pool(4) as pool:
    sorted_chunks = pool.map(sort_chunk, chunks)
合并排序后的块
sorted_large_list = sorted(sum(sorted_chunks, []))

在这个例子中，使用多进程将大列表分成多个块，每个块独立排序，然后合并排序后的块。

十二、总结

sorted()函数是Python中非常强大的排序工具，可以根据多种标准对数据进行排序，包括按数值、按字母顺序、自定义排序规则等。通过使用key参数、reverse参数、链式排序、自定义排序函数等，可以实现各种复杂的排序需求。此外，了解排序算法的性能以及如何在多线程或多进程环境中优化排序性能，对于处理大规模数据也非常重要。希望通过本文的详细介绍，您能够更好地掌握和应用Python的sorted()函数。