python学习笔记——高阶函数和函数功能抽象

目录

• 高阶函数
  • 什么是高阶函数
  • 高阶函数实现基础
  • 函数作为参数：行为抽象
  • Python 内置高阶函数：map /filter/reduce:三个最常用的 “函数式工具”
    • map：映射
    • filter：过滤
    • reduce：聚合
  • 函数作为返回值：嵌套函数与闭包
    • 嵌套函数
    • 执行环境：Parent Frame 机制
    • nonlocal 关键字
    • global 关键字
  • 闭包（Closure）
    • 1. 闭包是什么
  • 函数的运算：复合、柯里化、装饰器
    • 1. 函数复合（compose）
    • 2. 柯里化（Currying）
    • 3. 装饰器（Decorator）
  • lambda 匿名函数

高阶函数

什么是高阶函数

高阶函数（Higher-order Function） 是满足以下任一条件的函数：
1.把函数作为参数传入
2.把函数作为返回值返回

高阶函数实现基础

函数式编程的核心基础:

Python 中函数是一等公民（First-class Function）：
可以赋值给变量
可以作为参数传递
可以作为结果返回
可以存入列表、字典等数据结构
这是函数式编程的核心基础。

函数作为参数：行为抽象

把 “怎么做” 抽成函数，把 “做什么” 作为参数传入，实现通用逻辑复用。

很多求和逻辑结构一样，只是每一项计算不同：

自然数和：1+2+3+…+n
立方和：1³+2³+…+n³
圆周率级数和
我们可以只写一遍循环，把项规则作为函数传进去。

def summation(n, term):
    total = 0
    for k in range(1, n + 1):
        total += term(k)
    return total
term 是一个函数，负责计算第 k 项的值
同一个 summation 可以完成任意数列求和

def square(x):
    return x * x

def pi_term(x):
    return (-1) ** (x-1) / (2*(x-1)+1)

summation(100, square)        # 平方和:
summation(100, pi_term) * 4   # 近似 π

Python 内置高阶函数：map /filter/reduce:三个最常用的 “函数式工具”

map：映射

对序列每个元素应用函数，返回新迭代器。

map(lambda x: x**2, [1,2,3,4])
# 结果：1,4,9,16

多参数用法：

map(lambda x,y: x*y, [1,2,3], [4,5,6])

filter：过滤

保留函数返回 True 的元素。

filter(lambda x: x%2==1, [1,2,3,4,5])
# 结果：1,3,5

reduce：聚合

把序列反复合并成一个值。

reduce(函数, 可迭代对象, [初始值])
函数：必须接收两个参数 (累计值, 当前元素)

带初始值

reduce(lambda a,b:a+b, [1,2,3], 10)  
# 初始累计值=10 → 10+1+2+3

from functools import reduce
reduce(lambda x,y: x+y, [1,2,3,4])  # 1+2+3+4=10

函数作为返回值：嵌套函数与闭包

嵌套函数

在函数内部定义函数，避免全局命名污染。

def golden_ratio():
    def golden_update(guess):
        return 1 / (guess + 1)
    def golden_accurate(guess):
        return abs(guess*guess + guess -1) < 1e-10
    return improve(golden_update, golden_accurate)

特点：
内部函数只在外层函数内可见
适合封装工具逻辑

执行环境：Parent Frame 机制

每个函数调用创建局部帧（Local Frame）,嵌套函数的帧会记录 parent frame
查找变量顺序：当前帧 → 父帧 → 全局帧
这就是嵌套函数能访问外层变量的原理。

nonlocal 关键字

用于修改外层函数变量，而不是新建局部变量。

def outer(x):
    def inner():
        nonlocal x
        x += 10
        print(x)
    inner()
    print(x)
不加 nonlocal：会新建局部变量
加 nonlocal：修改父帧中的变量

global 关键字

用于在函数内修改全局变量。

x = 10
def f():
    global x
    x = 5

闭包（Closure）

1. 闭包是什么

外层函数返回内层函数，且内层函数引用了外层的变量，就形成闭包。

• 特点：
  1.外层函数的帧不会被销毁
  2.内部函数持续持有外层状态
  3.实现带状态的函数

def make_withdraw(balance):
    def withdraw(amount):
        nonlocal balance
        if amount > balance:
            return "Insufficient funds"
        balance -= amount
        return balance
    return withdraw

运行

wd = make_withdraw(20)
wd2 = make_withdraw(7)

wd(8)   # 12
wd2(6)  # 1

每个闭包拥有独立状态，互不干扰
这就是面向对象的函数式版本

函数的运算：复合、柯里化、装饰器

1. 函数复合（compose）

把两个函数串起来，先算 g，再算 f。

def compose(f, g):
    def h(x):
        return f(g(x))
    return h
def square(x): return x*x
def add1(x): return x+1

f = compose(square, add1)
f(12)  # (12+1)² = 169

2. 柯里化（Currying）

把多参数函数拆成一连串单参数函数。

def curry2(f):
    def g(x):
        def h(y):
            return f(x, y)
        return h
    return g

例子：

def add(x,y): return x+y
add3 = curry2(add)(3)
add3(7)  # 10

• 用途：
  1.固定部分参数
  2.适配高阶函数（map/reduce）
  3.更灵活的函数组合

3. 装饰器（Decorator）

https://realpython.com/primer-on-python-decorators/#adding-syntactic-sugar
用高阶函数包装原有函数，在不修改代码的前提下增强功能。
标准模板：

def 装饰器名(原函数):
    def 包装函数(*args, **kwargs):
        # 执行函数前 增强操作
        res = 原函数(*args, **kwargs)
        # 执行函数后 增强操作
        return res
    return 包装函数

示例：打印c

def trace(fn):
    def wrapped(x):
        print('->', fn, '(', x, ')')
        return fn(x)
    return wrapped

@trace
def triple(x):
    return 3*x

triple(12)

等价于：

triple = trace(triple)

常见用途：日志打印,计时,权限检查,参数校验

lambda 匿名函数

lambda 参数: 表达式
特点：
单行、无名字、自动 return
适合简单逻辑，作为临时函数传入高阶函数

lambda 也是函数对象，同样遵循 Frame + Parent 环境模型。