7. 高阶函数
map() 函数 —— 批量映射
map() 是 Python 内置的高级函数，核心作用是"批量处理可迭代对象（列表、元组等）的元素"，将一个函数应用到可迭代对象的每一个元素上，返回一个新的可迭代对象（map 对象）。
语法：map(函数, 可迭代对象1, 可迭代对象2, ...)
- 第一个参数：可以是普通 def 函数，也可以是 lambda 函数（最常用）
- 第二个及以后的参数：可迭代对象，可以有多个，要求长度一致（否则截取最短）
- 返回值：map 对象，需转换为列表（
list()）等才能查看结果 - 优势：替代 for 循环，代码更简洁、高效
python
# 实例1：将列表中所有数字转为平方
nums = [1, 2, 3, 4, 5]
result = map(lambda x: x ** 2, nums)
print(list(result)) # [1, 4, 9, 16, 25]
# 将列表中所有字符串转为小写
strs = ["PYTHON", "JAVA", "C++", "JS"]
result2 = map(lambda s: s.lower(), strs)
print(list(result2)) # ['python', 'java', 'c++', 'js']
# 实例2：两个列表对应位置元素相加
list1 = [10, 20, 30, 40]
list2 = [5, 15, 25, 35]
result = map(lambda x, y: x + y, list1, list2)
print(list(result)) # [15, 35, 55, 75]
# 三个列表对应位置元素相乘
list3 = [1, 2, 3, 4]
result2 = map(lambda x, y, z: x * y * z, list1, list2, list3)
print(list(result2)) # [50, 600, 2250, 5600]
# 实例3：搭配普通 def 函数
def factorial(n):
if n == 0 or n == 1:
return 1
res = 1
for i in range(2, n + 1):
res *= i
return res
nums = [3, 4, 5, 6]
result = map(factorial, nums)
print(list(result)) # [6, 24, 120, 720]
# 实例4：处理字符串
s = "python"
result = map(lambda c: ord(c), s)
print(list(result)) # [112, 121, 116, 104, 111, 110]▶ 运行结果：
输出
[1, 4, 9, 16, 25]
['python', 'java', 'c++', 'js']
[15, 35, 55, 75]
[50, 600, 2250, 5600]
[6, 24, 120, 720]
[112, 121, 116, 104, 111, 110]filter() 函数 —— 筛选过滤
filter() 是 Python 内置的高级函数，核心作用是"筛选可迭代对象中的元素"，根据指定函数的返回值（True/False），保留返回 True 的元素，过滤掉返回 False 的元素。
语法：filter(函数, 可迭代对象)
- 第一个参数：判断函数，必须返回布尔值（True/False）
- 第二个参数：可迭代对象
- 返回值：filter 对象，需转换为列表查看结果
- 与 map() 的区别：map() 是"批量处理"（每个元素都处理），filter() 是"批量筛选"（只保留符合条件的）
特殊情况：如果第一个参数为 None，filter() 会直接过滤掉可迭代对象中的"假值"（0、空字符串、None、False 等）。
python
# 实例1：筛选奇数
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = filter(lambda x: x % 2 != 0, nums)
print(list(result)) # [1, 3, 5, 7, 9]
# 筛选大于10的数
nums2 = [5, 12, 8, 15, 3, 20, 7]
result2 = filter(lambda x: x > 10, nums2)
print(list(result2)) # [12, 15, 20]
# 实例2：筛选长度大于3的字符串
strs = ["a", "ab", "abc", "abcd", "abcde"]
result = filter(lambda s: len(s) > 3, strs)
print(list(result)) # ['abcd', 'abcde']
# 筛选包含"python"的字符串（不区分大小写）
strs2 = ["Python", "java", "Python3", "c++", "python入门"]
result2 = filter(lambda s: "python" in s.lower(), strs2)
print(list(result2)) # ['Python', 'Python3', 'python入门']
# 实例3：搭配普通 def 函数筛选质数
def is_prime(n):
if n <= 1:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
nums = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
result = filter(is_prime, nums)
print(list(result)) # [2, 3, 5, 7, 11]
# 实例4：参数为 None（过滤假值）
data = [0, 1, "", "hello", None, False, 3.14, []]
result = filter(None, data)
print(list(result)) # [1, 'hello', 3.14]▶ 运行结果：
输出
[1, 3, 5, 7, 9]
[12, 15, 20]
['abcd', 'abcde']
['Python', 'Python3', 'python入门']
[2, 3, 5, 7, 11]
[1, 'hello', 3.14]reduce() 函数 —— 累积计算
reduce() 是 Python 内置的高级函数（Python3 中需从 functools 模块导入），核心作用是"累积计算"，将一个函数应用到可迭代对象的元素上，从左到右依次累积，最终得到一个单一的结果（不是可迭代对象）。
语法：from functools import reduce; reduce(函数, 可迭代对象, 初始值)
- 必须先导入 functools 模块中的 reduce
- 第一个参数：累积函数，必须接收两个参数（前一次累积的结果和当前元素），返回一个累积值
- 第二个参数：可迭代对象，不能为空
- 第三个参数（可选）：初始值，若指定则从初始值开始；若不指定，从第一个元素开始
python
from functools import reduce
# 实例1：求列表元素的总和
nums = [1, 2, 3, 4, 5]
result = reduce(lambda a, b: a + b, nums)
print(result) # 15（1+2=3，3+3=6，6+4=10，10+5=15）
# 指定初始值（初始值为10，总和=10+1+2+3+4+5=25）
result2 = reduce(lambda a, b: a + b, nums, 10)
print(result2) # 25
# 实例2：求列表元素的乘积
nums = [2, 3, 4, 5]
result = reduce(lambda a, b: a * b, nums)
print(result) # 120（2*3=6，6*4=24，24*5=120）
# 指定初始值为2，乘积=2*2*3*4*5=240
result2 = reduce(lambda a, b: a * b, nums, 2)
print(result2) # 240
# 实例3：搭配普通 def 函数，求列表中的最大值
def get_max(a, b):
return a if a > b else b
nums = [15, 23, 8, 36, 19]
result = reduce(get_max, nums)
print(result) # 36
# 实例4：拼接字符串
strs = ["我", "爱", "Python", "编程"]
result = reduce(lambda a, b: a + b, strs)
print(result) # 我爱Python编程
# 指定初始值（开头加"中职生："）
result2 = reduce(lambda a, b: a + b, strs, "中职生：")
print(result2) # 中职生：我爱Python编程▶ 运行结果：
输出
15
25
120
240
36
我爱Python编程
中职生：我爱Python编程