一个认为一切根源都是“自己不够强”的INTJ
个人主页:用哲学编程-CSDN博客
专栏:每日一题——举一反三
Python编程学习
Python内置函数
Python-3.12.0文档解读
目录
Python-3.12.0文档解读详细说明
功能描述
参数说明
用法示例
备注
进阶用法
参考资料
记忆策略
常用场景
示例1:基本排序
示例2:逆序排序
示例3:根据字符串长度排序
示例4:对包含字典的列表进行排序
示例5:多重排序(先按部门,再按薪资)
示例6:对元组列表进行排序
示例7:排序包含混合大小写字符串的列表
巧妙用法
技巧1:排序自定义对象列表
技巧2:按多个条件进行复杂排序
技巧3:对嵌套结构进行排序
技巧4:使用 sorted() 进行字符串排列组合
技巧5:根据条件过滤并排序
技巧6:自定义排序顺序(非标准排序)
综合技巧
技巧1:结合 sorted() 和 zip()对多个列表进行同步排序
技巧2:结合 sorted() 和 itertools.groupby() 对数据进行分组
技巧3:结合 sorted() 和 enumarate() 对带索引的数据进行排序
技巧4:结合 sorted() 和 set() 对集合进行排序
技巧5:结合 sorted() 和 pandas 库对数据框进行排序
技巧6:结合 sorted() 和 functools.cmp_to_key() 实现自定义复杂排序
详细说明
sorted(iterable, /, *, key=None, reverse=False)
功能描述
sorted() 函数根据 iterable 中的项返回一个新的已排序列表。
参数说明
- iterable: 要排序的可迭代对象,如列表、元组、字符串等。
- key (可选): 指定一个带有单个参数的函数,用于从 iterable 的每个元素中提取用于比较的键。例如,key=str.lower 将按照忽略大小写的字母顺序进行排序。默认值为 None,即直接比较元素。
- reverse (可选): 一个布尔值。如果设为 True,则每个列表元素将按反向顺序进行排序。默认值为 False。
用法示例
# 按默认顺序排序
sorted_list = sorted([5, 2, 3, 1, 4])
print(sorted_list) # 输出: [1, 2, 3, 4, 5]# 按反向顺序排序
sorted_list = sorted([5, 2, 3, 1, 4], reverse=True)
print(sorted_list) # 输出: [5, 4, 3, 2, 1]# 使用 key 参数进行排序
sorted_list = sorted(["bob", "Alice", "eve"], key=str.lower)
print(sorted_list) # 输出: ['Alice', 'bob', 'eve']
备注
- sorted() 函数确保排序是稳定的。稳定排序意味着不会改变比较结果相等的元素的相对顺序,这对于多重排序非常有用(例如,先按部门、再按薪级排序)。
- 排序算法只使用 < 运算符在项目之间进行比较。虽然定义一个 __lt__() 方法就足以进行排序,但 PEP 8 建议实现所有六个富比较运算符 (__lt__, __le__, __eq__, __ne__, __gt__, __ge__)。这将有助于避免在与其他排序工具(如 max())使用相同的数据时出现错误,因为这些工具依赖于不同的底层方法。实现所有六个比较运算符也有助于避免混合类型比较的混乱,因为混合类型比较可以调用反射到 __gt__() 的方法。
进阶用法
- 使用 functools.cmp_to_key(): 如果你有一个老式的比较函数(cmp 函数),可以使用 functools.cmp_to_key() 将其转换为 key 函数,以便与 sorted() 一起使用。
from functools import cmp_to_keydef compare(x, y):if x < y:return -1elif x > y:return 1else:return 0sorted_list = sorted([5, 2, 3, 1, 4], key=cmp_to_key(compare))
print(sorted_list) # 输出: [1, 2, 3, 4, 5]
参考资料
- PEP 8 - Python 代码风格指南(https://peps.python.org/pep-0008/)
- 排序指南(https://docs.python.org/zh-cn/3/howto/sorting.html)
记忆策略
函数名的含义:
sorted 是 sort 的过去分词形式,表示“已排序的”。这一点暗示了这个函数的作用是返回一个排序后的新列表。
常用场景
示例1:基本排序
# 原始列表包含未排序的数字
numbers = [4, 2, 9, 1, 5, 6]# 使用 sorted() 对列表进行排序,返回一个新的已排序列表
sorted_numbers = sorted(numbers)# 输出排序后的新列表
print(sorted_numbers) # 输出: [1, 2, 4, 5, 6, 9]
示例2:逆序排序
# 原始列表包含未排序的数字
numbers = [4, 2, 9, 1, 5, 6]# 使用 sorted() 并设置 reverse=True 对列表进行逆序排序
sorted_numbers_desc = sorted(numbers, reverse=True)# 输出逆序排序后的新列表
print(sorted_numbers_desc) # 输出: [9, 6, 5, 4, 2, 1]
示例3:根据字符串长度排序
# 原始列表包含不同长度的字符串
words = ["apple", "banana", "cherry", "date"]# 使用 sorted() 并设置 key 参数为 len 函数,对字符串长度进行排序
sorted_by_length = sorted(words, key=len)# 输出按长度排序后的新列表
print(sorted_by_length) # 输出: ['date', 'apple', 'banana', 'cherry']
示例4:对包含字典的列表进行排序
# 原始列表包含字典,每个字典代表一个人及其年龄
people = [{"name": "John", "age": 25},{"name": "Jane", "age": 22},{"name": "Dave", "age": 30}
]# 使用 sorted() 并设置 key 参数为一个 lambda 函数,按年龄进行排序
sorted_by_age = sorted(people, key=lambda person: person["age"])# 输出按年龄排序后的新列表
print(sorted_by_age)
# 输出: [{'name': 'Jane', 'age': 22}, {'name': 'John', 'age': 25}, {'name': 'Dave', 'age': 30}]
示例5:多重排序(先按部门,再按薪资)
# 原始列表包含字典,每个字典代表一个员工及其部门和薪资
employees = [{"name": "John", "department": "HR", "salary": 5000},{"name": "Jane", "department": "Engineering", "salary": 7000},{"name": "Dave", "department": "HR", "salary": 6000},{"name": "Anna", "department": "Engineering", "salary": 6500}
]# 使用 sorted() 进行多重排序,先按部门排序,再按薪资排序
sorted_employees = sorted(employees, key=lambda emp: (emp["department"], emp["salary"]))# 输出按部门和薪资排序后的新列表
print(sorted_employees)
# 输出:
# [{'name': 'Anna', 'department': 'Engineering', 'salary': 6500},
# {'name': 'Jane', 'department': 'Engineering', 'salary': 7000},
# {'name': 'John', 'department': 'HR', 'salary': 5000},
# {'name': 'Dave', 'department': 'HR', 'salary': 6000}]
示例6:对元组列表进行排序
# 原始列表包含元组,每个元组代表一个学生及其分数
students = [("John", 88),("Jane", 92),("Dave", 85)
]# 使用 sorted() 并设置 key 参数为一个 lambda 函数,按分数进行排序
sorted_by_score = sorted(students, key=lambda student: student[1])# 输出按分数排序后的新列表
print(sorted_by_score)
# 输出: [('Dave', 85), ('John', 88), ('Jane', 92)]
示例7:排序包含混合大小写字符串的列表
# 原始列表包含混合大小写的字符串
words = ["banana", "Apple", "cherry", "Date"]# 使用 sorted() 并设置 key 参数为 str.lower,对字符串进行不区分大小写的排序
sorted_case_insensitive = sorted(words, key=str.lower)# 输出按不区分大小写排序后的新列表
print(sorted_case_insensitive) # 输出: ['Apple', 'banana', 'cherry', 'Date']
巧妙用法
sorted() 函数在 Python 中不仅仅是一个简单的排序工具,还可以通过一些巧妙的使用技巧来实现更复杂的操作。以下是一些一般人可能想不到的使用技巧,它们展示了 sorted() 函数的强大和灵活性:
技巧1:排序自定义对象列表
可以通过 sorted() 函数和自定义的 key 函数对自定义对象列表进行排序。
# 定义一个自定义类
class Person:def __init__(self, name, age):self.name = nameself.age = agedef __repr__(self):return f"{self.name} ({self.age})"# 创建一个 Person 对象的列表
people = [Person("John", 25), Person("Jane", 22), Person("Dave", 30)]# 使用 sorted() 对 Person 对象列表按年龄进行排序
sorted_people = sorted(people, key=lambda person: person.age)# 输出排序后的 Person 对象列表
print(sorted_people) # 输出: [Jane (22), John (25), Dave (30)]
技巧2:按多个条件进行复杂排序
可以使用多个 key 条件来对数据进行复杂排序,例如先按一个条件排序,再按另一个条件排序。
# 原始列表包含字典,每个字典代表一个员工及其部门和薪资
employees = [{"name": "John", "department": "HR", "salary": 5000},{"name": "Jane", "department": "Engineering", "salary": 7000},{"name": "Dave", "department": "HR", "salary": 6000},{"name": "Anna", "department": "Engineering", "salary": 6500}
]# 使用 sorted() 进行多重排序,先按部门排序,再按薪资排序
sorted_employees = sorted(employees, key=lambda emp: (emp["department"], emp["salary"]))# 输出按部门和薪资排序后的新列表
print(sorted_employees)
# 输出:
# [{'name': 'Anna', 'department': 'Engineering', 'salary': 6500},
# {'name': 'Jane', 'department': 'Engineering', 'salary': 7000},
# {'name': 'John', 'department': 'HR', 'salary': 5000},
# {'name': 'Dave', 'department': 'HR', 'salary': 6000}]
技巧3:对嵌套结构进行排序
可以通过 sorted() 对嵌套的数据结构(例如列表中的列表或字典中的字典)进行排序。
# 原始列表包含嵌套的列表,每个子列表代表一个人的信息
nested_list = [["John", {"age": 25}],["Jane", {"age": 22}],["Dave", {"age": 30}]
]# 使用 sorted() 并设置 key 参数为一个 lambda 函数,对嵌套的 age 进行排序
sorted_nested_list = sorted(nested_list, key=lambda item: item[1]["age"])# 输出按年龄排序后的嵌套列表
print(sorted_nested_list)
# 输出: [['Jane', {'age': 22}], ['John', {'age': 25}], ['Dave', {'age': 30}]]
技巧4:使用 sorted() 进行字符串排列组合
可以使用 sorted() 函数对字符串中的字符进行排序,从而生成所有字符的排列组合。
# 原始字符串
s = "python"# 将字符串转换为字符列表并使用 sorted() 进行排序
sorted_chars = sorted(s)# 将排序后的字符列表重新组合成字符串
sorted_string = ''.join(sorted_chars)# 输出排序后的字符串
print(sorted_string) # 输出: 'hnopty'
技巧5:根据条件过滤并排序
可以结合列表解析和 sorted() 函数,根据特定条件对数据进行过滤并排序。
# 原始列表包含未排序的数字
numbers = [4, 2, 9, 1, 5, 6, 10, 3]# 使用列表解析和 sorted() 对大于 5 的数字进行排序
sorted_filtered_numbers = sorted([n for n in numbers if n > 5])# 输出过滤并排序后的新列表
print(sorted_filtered_numbers) # 输出: [6, 9, 10]
技巧6:自定义排序顺序(非标准排序)
可以通过自定义的排序顺序来对数据进行排序,例如按特定规则对字符串排序。
# 自定义的排序顺序
order = {'low': 0, 'medium': 1, 'high': 2}# 原始列表包含不同优先级的字符串
priority = ["medium", "high", "low", "medium", "low", "high"]# 使用 sorted() 并设置 key 参数为查找自定义排序顺序的值进行排序
sorted_priority = sorted(priority, key=lambda x: order[x])# 输出按自定义顺序排序后的新列表
print(sorted_priority) # 输出: ['low', 'low', 'medium', 'medium', 'high', 'high']
这些技巧展示了 sorted() 函数的灵活性和强大功能,通过巧妙的使用,可以实现许多复杂的数据排序任务。
综合技巧
结合 sorted() 函数和其他函数或方法,可以实现一些非常巧妙和复杂的操作。以下是几个非常巧妙的组合用法示例:
技巧1:结合 sorted() 和 zip()对多个列表进行同步排序
当有多个相关联的列表时,可以使用 zip() 将它们合并,然后使用 sorted() 进行同步排序,最后再解压缩回来。
# 原始列表
names = ["John", "Jane", "Dave"]
ages = [25, 22, 30]
salaries = [5000, 7000, 6000]# 使用 zip() 将多个列表合并成一个列表的元组
combined = list(zip(names, ages, salaries))# 使用 sorted() 对合并后的列表按年龄进行排序
sorted_combined = sorted(combined, key=lambda x: x[1])# 使用 zip(*iterable) 解压缩回多个列表
sorted_names, sorted_ages, sorted_salaries = zip(*sorted_combined)# 输出排序后的结果
print(sorted_names) # 输出: ('Jane', 'John', 'Dave')
print(sorted_ages) # 输出: (22, 25, 30)
print(sorted_salaries) # 输出: (7000, 5000, 6000)
技巧2:结合 sorted() 和 itertools.groupby() 对数据进行分组
可以使用 sorted() 函数对数据进行排序,然后使用 itertools.groupby() 对数据进行分组。
import itertools# 原始列表包含字典,每个字典代表一个员工及其部门和薪资
employees = [{"name": "John", "department": "HR", "salary": 5000},{"name": "Jane", "department": "Engineering", "salary": 7000},{"name": "Dave", "department": "HR", "salary": 6000},{"name": "Anna", "department": "Engineering", "salary": 6500}
]# 使用 sorted() 按部门排序
sorted_employees = sorted(employees, key=lambda x: x['department'])# 使用 itertools.groupby() 对排序后的结果按部门进行分组
grouped_employees = itertools.groupby(sorted_employees, key=lambda x: x['department'])# 输出分组后的结果
for department, group in grouped_employees:print(department)for employee in group:print(employee)
# 输出:
# Engineering
# {'name': 'Jane', 'department': 'Engineering', 'salary': 7000}
# {'name': 'Anna', 'department': 'Engineering', 'salary': 6500}
# HR
# {'name': 'John', 'department': 'HR', 'salary': 5000}
# {'name': 'Dave', 'department': 'HR', 'salary': 6000}
技巧3:结合 sorted() 和 enumarate() 对带索引的数据进行排序
可以使用 sorted() 函数结合 enumerate() 对带有索引的数据进行排序。
# 原始列表包含未排序的数字
numbers = [4, 2, 9, 1, 5, 6]# 使用 enumerate() 为每个元素添加索引,然后使用 sorted() 按值进行排序
sorted_with_index = sorted(enumerate(numbers), key=lambda x: x[1])# 输出排序后的结果,包含原始索引
print(sorted_with_index)
# 输出: [(3, 1), (1, 2), (0, 4), (4, 5), (5, 6), (2, 9)]
技巧4:结合 sorted() 和 set() 对集合进行排序
可以使用 sorted() 函数对集合(set)进行排序,因为集合是无序的。
# 原始集合包含未排序的数字
numbers_set = {4, 2, 9, 1, 5, 6}# 使用 sorted() 对集合进行排序,返回一个列表
sorted_numbers = sorted(numbers_set)# 输出排序后的列表
print(sorted_numbers) # 输出: [1, 2, 4, 5, 6, 9]
技巧5:结合 sorted() 和 pandas 库对数据框进行排序
如果使用 pandas 库处理数据,可以结合 sorted() 函数对数据框进行排序。
import pandas as pd# 创建一个 DataFrame
data = {'name': ['John', 'Jane', 'Dave', 'Anna'],'age': [25, 22, 30, 28]
}
df = pd.DataFrame(data)# 使用 sorted() 对 DataFrame 按年龄排序
sorted_df = df.loc[sorted(df.index, key=lambda x: df.loc[x, 'age'])]# 输出排序后的 DataFrame
print(sorted_df)
# 输出:
# name age
# 1 Jane 22
# 0 John 25
# 3 Anna 28
# 2 Dave 30
技巧6:结合 sorted() 和 functools.cmp_to_key() 实现自定义复杂排序
可以使用 functools.cmp_to_key() 函数将自定义比较函数转换为 sorted() 函数可接受的 key 函数,从而实现复杂的自定义排序。
from functools import cmp_to_key# 自定义比较函数
def compare(a, b):# 按绝对值大小进行比较return abs(a) - abs(b)# 原始列表包含正负数
numbers = [4, -2, -9, 1, -5, 6]# 使用 sorted() 和 cmp_to_key() 对列表按绝对值进行排序
sorted_numbers = sorted(numbers, key=cmp_to_key(compare))# 输出排序后的列表
print(sorted_numbers) # 输出: [1, -2, 4, -5, 6, -9]
这些巧妙的组合用法展示了 sorted() 函数在与其他函数和方法结合使用时的强大功能。通过这些技巧,可以实现更加复杂和灵活的数据操作。
感谢。