跳到主要内容

函数式编程基础

学习目标

  • 理解函数式编程的基本思想
  • 掌握 lambda 匿名函数
  • 熟练使用 map()filter()sorted() 的 key 参数
  • 理解闭包和装饰器的基本概念

什么是函数式编程?

简单来说,函数式编程就是把函数当作数据来传递和使用

在 Python 中,函数是一等公民——它和数字、字符串一样,可以:

  • 赋值给变量
  • 作为参数传给另一个函数
  • 作为返回值返回
# 函数可以赋值给变量
def greet(name):
return f"你好,{name}!"

say_hi = greet # 把函数赋值给变量(注意没有括号)
print(say_hi("小明")) # 你好,小明!

# 函数可以放进列表
def add(a, b): return a + b
def sub(a, b): return a - b
def mul(a, b): return a * b

operations = [add, sub, mul]
for op in operations:
print(op(10, 3)) # 13, 7, 30

Lambda 匿名函数

lambda 是一种一次性的小函数,不需要用 def 定义,也不需要名字。

基本语法

# 普通函数
def square(x):
return x ** 2

# 等价的 lambda
square = lambda x: x ** 2

print(square(5)) # 25

语法:lambda 参数: 表达式

# 一个参数
double = lambda x: x * 2
print(double(5)) # 10

# 多个参数
add = lambda a, b: a + b
print(add(3, 5)) # 8

# 带条件的
grade = lambda score: "及格" if score >= 60 else "不及格"
print(grade(75)) # 及格
print(grade(45)) # 不及格

lambda 的主要用途

lambda 最常见的用法是作为参数传给其他函数

# 场景:按特定规则排序
students = [
{"name": "张三", "score": 85},
{"name": "李四", "score": 92},
{"name": "王五", "score": 78},
]

# 按成绩排序
students.sort(key=lambda s: s["score"])
print([s["name"] for s in students]) # ['王五', '张三', '李四']

# 按成绩降序
students.sort(key=lambda s: s["score"], reverse=True)
print([s["name"] for s in students]) # ['李四', '张三', '王五']
lambda 使用原则
  • 简单逻辑用 lambda:lambda x: x * 2
  • 复杂逻辑用 def:如果 lambda 写出来很长、很难读,就应该用 def 定义命名函数
  • lambda 只能写一个表达式,不能写多行代码

map():对每个元素做同样的操作

map(函数, 可迭代对象) 对序列中的每个元素应用函数,返回新的序列。

# 把列表中的每个数字平方
numbers = [1, 2, 3, 4, 5]

# 方法 1:用 for 循环
squares = []
for n in numbers:
squares.append(n ** 2)

# 方法 2:用 map
squares = list(map(lambda x: x ** 2, numbers))
print(squares) # [1, 4, 9, 16, 25]

# 方法 3:用列表推导式(通常更推荐)
squares = [x ** 2 for x in numbers]
print(squares) # [1, 4, 9, 16, 25]

实际应用

# 批量转换数据类型
str_numbers = ["10", "20", "30", "40"]
numbers = list(map(int, str_numbers))
print(numbers) # [10, 20, 30, 40]

# 批量处理字符串
names = [" alice ", " BOB", "charlie "]
clean_names = list(map(str.strip, names))
print(clean_names) # ['alice', 'BOB', 'charlie']

# 使用已有函数
temperatures_c = [0, 20, 37, 100]
def c_to_f(c):
return c * 9/5 + 32

temperatures_f = list(map(c_to_f, temperatures_c))
print(temperatures_f) # [32.0, 68.0, 98.6, 212.0]

filter():筛选满足条件的元素

filter(函数, 可迭代对象) 保留函数返回 True 的元素。

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 筛选偶数
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens) # [2, 4, 6, 8, 10]

# 等价的列表推导式
evens = [x for x in numbers if x % 2 == 0]
print(evens) # [2, 4, 6, 8, 10]

实际应用

# 筛选及格的成绩
scores = [45, 78, 55, 92, 88, 30, 67, 100]
passed = list(filter(lambda s: s >= 60, scores))
print(f"及格的: {passed}") # [78, 92, 88, 67, 100]

# 筛选非空字符串
data = ["hello", "", "world", "", "python", ""]
non_empty = list(filter(None, data)) # filter(None, ...) 过滤掉假值
print(non_empty) # ['hello', 'world', 'python']

# 筛选特定类型的文件
files = ["data.csv", "model.py", "readme.md", "train.py", "config.json"]
py_files = list(filter(lambda f: f.endswith(".py"), files))
print(py_files) # ['model.py', 'train.py']

sorted() 的 key 参数

sorted()key 参数让你自定义排序规则:

# 按绝对值排序
numbers = [-5, 3, -1, 4, -2]
result = sorted(numbers, key=abs)
print(result) # [-1, -2, 3, 4, -5]

# 按字符串长度排序
words = ["python", "AI", "deep", "learning"]
result = sorted(words, key=len)
print(result) # ['AI', 'deep', 'python', 'learning']

# 按字典的某个键排序
students = [
{"name": "张三", "age": 20, "score": 85},
{"name": "李四", "age": 22, "score": 92},
{"name": "王五", "age": 19, "score": 78},
]

# 按成绩排序
by_score = sorted(students, key=lambda s: s["score"], reverse=True)
for s in by_score:
print(f"{s['name']}: {s['score']}分")
# 李四: 92分
# 张三: 85分
# 王五: 78分

# 按多个条件排序(先按成绩降序,成绩相同按年龄升序)
students2 = [
{"name": "A", "age": 20, "score": 85},
{"name": "B", "age": 22, "score": 85},
{"name": "C", "age": 19, "score": 92},
]
result = sorted(students2, key=lambda s: (-s["score"], s["age"]))
for s in result:
print(f"{s['name']}: score={s['score']}, age={s['age']}")
# C: score=92, age=19
# A: score=85, age=20
# B: score=85, age=22

闭包(Closure)

闭包是一个函数,它记住了外层函数的变量,即使外层函数已经执行完毕。

def make_multiplier(factor):
"""创建一个乘法器"""
def multiplier(x):
return x * factor # factor 来自外层函数
return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5)) # 10
print(triple(5)) # 15
print(double(10)) # 20

闭包的实际应用

# 创建计数器
def make_counter(start=0):
count = [start] # 用列表包装,以便在内层函数中修改
def counter():
count[0] += 1
return count[0]
return counter

counter = make_counter()
print(counter()) # 1
print(counter()) # 2
print(counter()) # 3

# 创建带前缀的日志函数
def make_logger(prefix):
def log(message):
from datetime import datetime
timestamp = datetime.now().strftime("%H:%M:%S")
print(f"[{prefix}] {timestamp} {message}")
return log

info = make_logger("INFO")
error = make_logger("ERROR")

info("程序启动") # [INFO] 14:30:01 程序启动
error("文件未找到") # [ERROR] 14:30:01 文件未找到

装饰器(Decorator)

装饰器是一种给函数添加额外功能的优雅方式,本质上就是闭包的应用。

问题场景

假设你想给多个函数加上执行时间的统计:

import time

# 不用装饰器的做法:每个函数都要加计时代码
def train_model():
start = time.time()
# ... 训练逻辑 ...
time.sleep(1)
end = time.time()
print(f"train_model 耗时: {end - start:.2f}秒")

def process_data():
start = time.time()
# ... 处理逻辑 ...
time.sleep(0.5)
end = time.time()
print(f"process_data 耗时: {end - start:.2f}秒")

每个函数都要重复写计时代码——太烦了!

装饰器解决方案

import time

def timer(func):
"""计时装饰器"""
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"⏱ {func.__name__} 耗时: {end - start:.2f}秒")
return result
return wrapper

# 用 @ 语法使用装饰器
@timer
def train_model():
"""训练模型"""
time.sleep(1)
print("训练完成!")

@timer
def process_data(filename):
"""处理数据"""
time.sleep(0.5)
print(f"处理 {filename} 完成!")

train_model()
# 训练完成!
# ⏱ train_model 耗时: 1.00秒

process_data("data.csv")
# 处理 data.csv 完成!
# ⏱ process_data 耗时: 0.50秒

@timer 等价于 train_model = timer(train_model)

常用的装饰器模式

# 重试装饰器
def retry(max_attempts=3):
def decorator(func):
def wrapper(*args, **kwargs):
for attempt in range(1, max_attempts + 1):
try:
return func(*args, **kwargs)
except Exception as e:
print(f"第 {attempt} 次尝试失败: {e}")
if attempt == max_attempts:
raise
return wrapper
return decorator

@retry(max_attempts=3)
def risky_operation():
import random
if random.random() < 0.7:
raise ConnectionError("连接失败")
return "成功!"

map / filter vs 列表推导式

方式适用场景示例
列表推导式大多数情况(推荐)[x**2 for x in nums]
map()已有函数可以直接用list(map(int, strings))
filter()配合已有判断函数list(filter(str.isdigit, items))
# 当已经有现成函数时,map 更简洁
numbers = ["1", "2", "3"]
list(map(int, numbers)) # 简洁
[int(x) for x in numbers] # 也行,但稍长

# 当需要变换+条件时,列表推导式更清晰
[x**2 for x in range(10) if x % 2 == 0]
# 比 list(filter(lambda x: x%2==0, map(lambda x: x**2, range(10)))) 清晰得多

动手练习

练习 1:数据处理管道

# 用 map 和 filter 处理以下数据
raw_data = [" 23 ", "abc", "45.6", "", "78", "not_a_number", "90.1"]

# 1. 去除空白
# 2. 过滤掉无法转换为数字的字符串
# 3. 转换为浮点数
# 4. 过滤掉小于 50 的数
# 提示:可以结合使用 map、filter 和列表推导式

练习 2:自定义排序

products = [
{"name": "笔记本", "price": 5999, "rating": 4.5},
{"name": "鼠标", "price": 199, "rating": 4.8},
{"name": "键盘", "price": 599, "rating": 4.2},
{"name": "显示器", "price": 2999, "rating": 4.7},
]

# 1. 按价格从低到高排序
# 2. 按评分从高到低排序
# 3. 按性价比(rating/price)从高到低排序

练习 3:写一个装饰器

写一个 @log 装饰器,在函数执行前后打印日志:

@log
def add(a, b):
return a + b

add(3, 5)
# 应该输出:
# 调用 add,参数: (3, 5) {}
# add 返回: 8

小结

概念说明示例
lambda匿名函数lambda x: x * 2
map()对每个元素应用函数map(int, ["1", "2"])
filter()筛选满足条件的元素filter(lambda x: x>0, nums)
sorted(key=)自定义排序sorted(data, key=lambda x: x["score"])
闭包函数记住外层变量工厂函数模式
装饰器给函数添加额外功能@timer
核心理解

函数式编程的核心是把函数当作数据——你可以把函数存起来、传来传去、组合使用。这种思维在数据处理中特别有用,因为你经常需要对一组数据做"变换 → 筛选 → 排序"的操作链。不需要完全掌握函数式编程,但 lambda、map/filter、装饰器这几个工具一定要会用。