很多人对max和min的理解停留在“传入一个列表，返回最大/最小的数”。但它们的用法远比你想象的丰富。
1.基础用法
最简单的，传入一个可迭代对象，它就会返回其中的最大值或最小值。比如一个数字列表：
numbers = [1, 2, 3, 4, 5]print(max(numbers)) # 5print(min(numbers)) # 1
字符串也可以这样用。Python会按字符的ASCII码来比较，所以max('12345')返回的是字符'5'。
text = "12345"print(max(text)) # 5print(min(text)) # 1
2.多个序列比较
你知道吗？max可以传入多个参数，它会比较这些序列本身，返回“最大”的那个。
这里的比较规则是：依次比较序列中的元素，哪个序列的元素更大，哪个就是最大值。
list_1 = [1, 3, 5]list_2 = [2, 8, 9]list_3 = [1, 2, 9]print(max(list_1, list_2, list_3)) # [2, 8, 9]
在这个例子中，[2,8,9]的第一个元素2大于其他两个列表的第一个元素，所以它是最大值。
min的逻辑完全相反，返回的是最小的那个序列。
3.key参数——排序规则
这是max最强大的地方。当你需要“按某个规则找最大值”时，key就是你的利器。
比如，你想找列表中最长的字符串，而不是按字母顺序比较：
test_list = ['bug', 'bug_one', 'bug_three']print(max(test_list, key=len)) # 按长度找最长：bug_three
key接受一个函数，用于从每个元素中提取比较键。
上面的代码中，key=len表示按字符串的长度来比较，而不是字符串本身。
同样的逻辑，找最短的字符串就用min：
print(min(test_list, key=len)) # bug
你也可以用lambda表达式定义更复杂的规则。比如，按字符串中某个字符的数量来比较：
找包含字母'o'最多的字符串print(max(test_list, key=lambda s: s.count('o'))) # bug_one
4.复杂数据结构
实际开发中，我们经常遇到列表里嵌套元组或字典的情况。这时候key就能大显身手。
先看一个例子：我们有一个学生列表，每个学生是(姓名, 分数)的元组结构，想找出分数最高的学生。
students = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]print(max(students, key=lambda x: x[1])) # ('Bob', 92)
这里的lambda x: x[1]表示从每个元组中取出第二个元素（分数）作为比较依据。
再来看字典列表的情况。假设我们有一个商品列表，每个商品是包含name和price的字典，想找出最贵的商品：
products = [ {"name": "laptop", "price": 1000}, {"name": "phone", "price": 500}, {"name": "tablet", "price": 300}]print(max(products, key=lambda x: x["price"])) # {'name': 'laptop', 'price': 1000}
5.自定义对象
如果你定义了自定义类，同样可以用max和min。只要在key中指定要比较的属性即可：
class Person: def _init_(self, name, age): self.name = name self.age = age def _repr_(self): return f"Person({self.name}, {self.age})"people = [ Person("Alice", 25), Person("Bob", 30), Person("Charlie", 22)]oldest = max(people, key=lambda p: p.age)print(oldest) # Person(Bob, 30)
小结：max和min的核心是key参数。掌握它，你就能优雅地处理各种复杂数据结构的极值查找，再也不用写又臭又长的循环了。
很多人对sum的理解停留在“把列表里的数字加起来”。但它的能力远不止于此。
1.基础求和
最简单的用法，传入一个数字列表，它就会返回所有元素的和：
numbers = [1, 2, 3, 4, 5]print(sum(numbers)) # 15
start参数可以指定一个起始值，所有元素会从这个起始值开始累加。默认是0，但你可以改成任何数字：
print(sum(numbers, 10)) # 从10开始累加：10+1+2+3+4+5 = 25
2.各种可迭代对象
sum不挑食，任何包含数字的可迭代对象它都能处理：
#元组tuple_nums = (1, 2, 3, 4)print(sum(tuple_nums)) # 10# 集合set_nums = {1, 2, 3}print(sum(set_nums)) # 6# 生成器（比如用range生成的）gen = (x for x in range(1, 6))print(sum(gen)) # 15
3.高阶应用
sum搭配推导式或生成器表达式，可以完成很多实用的计算。这才是它真正的威力所在。
计算平均值：先求和，再除以元素个数。
scores = [85, 92, 78, 90]average = sum(scores) / len(scores)print(average) # 86.25
条件求和：比如只求列表中的偶数之和。这里用生成器表达式过滤掉奇数，再求和。
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]even_sum = sum(x for x in numbers if x % 2 == 0)print(even_sum) # 30
多维列表求和：如果一个列表里嵌套了多个子列表，想求所有元素的总和，可以嵌套两个sum。
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]total = sum(sum(row) for row in matrix)print(total) # 45
字典求和：字典的values()方法可以返回所有值，直接传给sum即可。
scores = {'数学': 90, '语文': 85, '英语': 92}total_score = sum(scores.values())print(total_score) # 267
如果字典的键是数字，你也可以对键求和：
data = {1: 'a', 2: 'b', 3: 'c'}key_sum = sum(data.keys())print(key_sum) # 6
4.避坑指南
sum虽好，但有几个地方需要留个心眼。
类型错误：sum只能处理数字类型。如果列表里混入了字符串，就会报错。
mixed = [1, 2, '3']# sum(mixed) # TypeError！
空列表：空列表的和是0，但如果你设置了start参数，返回的就是start本身。
empty_list = []print(sum(empty_list)) # 0print(sum(empty_list, 100)) # 100
浮点数精度问题：这是Python浮点数运算的通病。比如三个0.1相加，你期望得到0.3，但实际结果却是0.30000000000000004。
numbers = [0.1, 0.1, 0.1]print(sum(numbers)) # 0.30000000000000004
解决方案是用round保留指定小数位数：
print(round(sum(numbers), 1)) # 0.3
小结：sum不仅能求和，还能配合推导式完成条件求和、多维数据求和等复杂操作。掌握它，你的数据处理代码会简洁很多。
sorted是Python最强大的排序工具。它返回新列表，不改变原序列，而且支持各种自定义排序规则。
1.基础排序
最简单的用法，传入一个列表，返回升序排列的新列表：
numbers = [3, 1, 4, 1, 5, 9, 2]print(sorted(numbers)) # [1, 1, 2, 3, 4, 5, 9]
如果你想降序排列，加上reverse=True参数即可：
print(sorted(numbers, reverse=True)) # [9, 5, 4, 3, 2, 1, 1]
字符串也会被排序，按字符的ASCII值：
print(sorted('cbhacefg')) # ['a', 'b', 'c', 'c', 'e', 'f', 'g', 'h']
2.各种可迭代对象
sorted支持所有可迭代对象，但返回值总是列表：
#元组tuple_data = (5, 2, 8, 1)print(sorted(tuple_data)) # [1, 2, 5, 8]# 集合（注意集合是无序的，但排序后变有序）set_data = {3, 1, 4, 1, 5}print(sorted(set_data)) # [1, 3, 4, 5]# 字典（默认对键排序）dict_data = {"b": 2, "a": 1, "c": 3}print(sorted(dict_data)) # ['a', 'b', 'c']
3.key参数
和max一样，key是sorted的核心。你可以指定一个函数，让排序按照这个函数的返回值来进行。
按字符串长度排序：
words = ['bug', 'bug_three', 'bug_one']print(sorted(words, key=len)) # ['bug', 'bug_one', 'bug_three']
按绝对值排序：
numbers = [-5, 3, -1, 2, -4, 0]print(sorted(numbers, key=abs)) # [0, -1, 2, 3, -4, -5]
按平方值排序：
numbers2 = [-3, 2, -1, 4, -2]print(sorted(numbers2, key=lambda x: x ** 2)) # [-1, 2, -2, -3, 4]
4.复杂结构排序
实际开发中最常用的场景是处理列表中的元组或字典列表。
列表中的元组：按分数排序
students = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]# 按分数升序print(sorted(students, key=lambda x: x[1]))# [('Charlie', 78), ('Alice', 85), ('Bob', 92)]# 按分数降序print(sorted(students, key=lambda x: x[1], reverse=True))# [('Bob', 92), ('Alice', 85), ('Charlie', 78)]
字典列表：按价格排序
products = [ {"name": "laptop", "price": 1000, "rating": 4.5}, {"name": "phone", "price": 500, "rating": 4.2}, {"name": "tablet", "price": 300, "rating": 4.7}]by_price = sorted(products, key=lambda x: x["price"])print([p["name"] for p in by_price]) # ['tablet', 'phone', 'laptop']by_rating = sorted(products, key=lambda x: x["rating"], reverse=True)print([p["name"] for p in by_rating]) # ['tablet', 'laptop', 'phone']
5.多级排序
有时候我们需要“先按值排序，值相同再按键排序”。这种需求在key里返回一个元组就能实现。
scores = {"Alice": 85, "Bob": 92, "Charlie": 78, "David": 92}# 按键排序（默认）print(sorted(scores)) # ['Alice', 'Bob', 'Charlie', 'David']# 按值排序print(sorted(scores.items(), key=lambda x: x[1])) # [('Charlie', 78), ('Alice', 85), ('Bob', 92), ('David', 92)]# 按值降序，值相同时按键升序print(sorted(scores.items(), key=lambda x: (-x[1], x[0]))) # [('Bob', 92), ('David', 92), ('Alice', 85), ('Charlie', 78)]
注意这里-x[1]的写法：负号让数字大的排在前面，实现了降序效果。
小结：sorted配合key和reverse，几乎可以满足你所有的排序需求。多级排序时，key返回元组即可。
reversed这个函数有点特别。它不是简单地返回反转后的列表，而是返回一个反向迭代器。这意味着它不会一次性创建整个反转后的序列，而是按需生成，内存效率极高。
1.基础用法
先看几个基础例子：
my_list = [1, 2, 3, 4, 5]print(list(reversed(my_list))) # [5, 4, 3, 2, 1]print(my_list) # 原列表不变 [1, 2, 3, 4, 5]
字符串反转是常见需求，reversed配合join就能搞定：
text = "Hello, World!"print(''.join(reversed(text))) # "!dlroW ,olleH"
元组和range对象也支持：
#元组my_tuple = (1, 2, 3, 4, 5)print(tuple(reversed(my_tuple))) # (5, 4, 3, 2, 1)# range对象my_range = range(1, 6)print(list(reversed(my_range))) # [5, 4, 3, 2, 1]
2.迭代器特性
这是最容易踩坑的地方。reversed返回的不是列表，而是一个迭代器对象。看看它的类型：
my_list = [1, 2, 3]result = reversed(my_list)print(result) # <list_reverseiterator object at 0x...>print(type(result)) # <class 'list_reverseiterator'>
迭代器有一个重要特性：只能遍历一次。第一次遍历时，它会按顺序输出所有元素；第二次遍历时，它就空了。
第一次遍历print(list(result)) # [3, 2, 1]# 第二次遍历——迭代器已耗尽！print(list(result)) # []
如果你需要多次使用反转后的结果，记得把它转换成列表保存起来。
3.内存效率优势
对于大列表，reversed比切片[::-1]更省内存。因为切片会创建一个完整的新列表，而reversed只是返回一个迭代器，不会占用额外内存。
large_list = list(range(1000000))# 使用reversed() - 内存效率高（不创建新列表）rev_iter = reversed(large_list)# 使用切片 - 创建完整的新列表，内存占用大rev_slice = large_list[::-1]
如果你只需要遍历反转后的序列一次，用reversed是最优选择。如果你确实需要反转后的列表副本，再用切片。
4.反向遍历
reversed最常见的用法是在循环中反向遍历：
fruits = ['apple', 'banana', 'cherry', 'date']print("正向遍历:")for fruit in fruits: print(fruit) print("反向遍历:")for fruit in reversed(fruits): print(fruit)
5.数字反转
一个实用的小技巧：用reversed反转数字的各位。注意这里需要先转成字符串，反转后再转回整数。
def reverse_number(n: int) -> int: """数字反转""" return int(''.join(reversed(str(n)))) print(reverse_number(12345)) # 54321print(reverse_number(100)) # 1（注意：001变成1）
6.注意事项
集合是无序的，所以不支持reversed。如果你尝试反转集合，Python会报错。
my_set = {1, 2, 3}# reversed(my_set) # TypeError！
字典的reversed只对键起作用。因为字典的默认迭代器是遍历键，所以reversed返回的是键的反向顺序。
my_dict = {'a': 1, 'b': 2, 'c': 3}print(list(reversed(my_dict))) # ['c', 'b', 'a']
如果你需要反转字典的键值对，可以先把items()转成列表再反转，或者用字典推导式：
#反转键值对（注意键和值互换）reversed_dict = {v: k for k, v inreversed(my_dict.items())}print(reversed_dict) # {3: 'c', 2: 'b', 1: 'a'}
7.高级：自定义类的反向迭代
如果你希望自己的类支持reversed，可以实现reversed方法。这样当别人对你的对象调用reversed时，就能按照你定义的逻辑返回内容。
class Countdown: def _init_(self, start): self.start = start def _iter(self): # 正向迭代：从start倒数到1 return iter(range(self.start, 0, -1)) def _reversed(self): # 反向迭代：从1正数到start return iter(range(1, self.start + 1)) cd = Countdown(5)print("倒计时:")for i in cd: print(i) # 5, 4, 3, 2, 1print("正计时:")for i in reversed(cd): print(i) # 1, 2, 3, 4, 5
这个例子中，我们自定义了一个倒计时类。直接遍历它是倒序输出，用reversed遍历它就变成了正序输出。这种灵活性正是Python面向对象设计的魅力所在。
小结：reversed返回迭代器，内存高效，但只能遍历一次。掌握这个特性，你就能写出更高效的代码。如果你需要处理自定义类的反转逻辑，实现reversed方法即可。
