函数式程序设计
思想
函数可以用来给变量赋值
python中的函数是对象, 可像普通变量一样赋值,传值,返回
函数可作为函数的参数
python中的可调用对象( 即可以用
()调用 ) 包括普通函数和实现了__call__方法的类实例class A:def __init__(self,n):self.n = ndef __call__(self,x):return self.n + xdef add(x, y, f):return f(x) + f(y)print(add(1,10,abs)) #=> 11print(add(1,10,A(5))) #=> 21lambda表达式可以被赋值给变量, 也可作为函数的返回值和参数
回顾
filter(function,iterable)挑选出可迭代对象**中每一个满足function的元素返回一个迭代器trick:
b=lambda x:lambda y:x+y#b是一个lambda表达式, 返回值是一个lambda表达式a=b(3) #暂时存放3print(a(2)) # 5⚠️函数内部声明的变量自动视为局部变量
⚠️可以直接读取外部全局变量, 但是若要修改🌊需要
global x的声明
闭包(closure)
能够维持外部变量值的函数
⚠️修改维持的变量要使用
nonlocal x声明告诉python不要创建局部变量, 要去外围func函数中查找x并修改
def func(x): def g(y): nonlocal x x+=1 return x+y #g是一个闭包,即能够维持外部变量值的函数 return gf=func(10)print(f(4))f=func(20)print(f(4))print(f(5))闭包的作用
调用/补充别人的库函数而不修改别人的库
# ========== 原始库（dummy_network.py）==========class DummyNet(): def __init__(self, weight, bias): self.weight = weight self.bias = bias def forward(self, input): return input * self.weight + self.bias def __call__(self, input): return self.forward(input)# 使用方式import numpy as npdata = np.array([-1., 0., 1., 2.])mynet = DummyNet(weight=2.0, bias=-1.0)print(mynet(data)) # array([-3., -1., 1., 3.])- 场景
- 别人写好了库（如
DummyNet），不能改源码 - 但需要修改运行流程（如给线性层加 ReLU 激活）
- 闭包写法
def my_forward(self): # 外层函数接收 mynet 实例 def forward(input): # 内层函数才是真正的 forward tmp = input * self.weight + self.bias tmp = np.maximum(0, tmp) # 加上 ReLU 非线性激活 return tmp return forward # 返回内层函数（闭包）# 关键：把闭包绑定到实例上mynet.forward = my_forward(mynet) # 不修改类，只改这个实例的 forward内层 forward 函数捕获了外层 self 变量（即 mynet 实例），即使外层函数执行完毕，self 仍然被内层函数”关”在里面，随时可用。
print(mynet(data)) # array([0., 0., 1., 3.])# 负数被 ReLU 截断为 0等价于:
# my_forward(mynet) 执行后：# self = mynet# 返回一个绑定了 self 的 forward 函数# 等价于：mynet.forward = lambda input: np.maximum(0, input * mynet.weight + mynet.bias)
偏应用函数(Partical Application)
用于固定函数中的某些参数
from functools import particaladd=lambda a,b:a+badd1024=partical(add,1024)#固定aprint(add1024(1))print(add1024(10))迭代器
基本概念
能用
for i in x形式遍历的对象x称为可迭代对象(iterable)可迭代对象必须实现迭代器协议, 即
__iter__()和__next__()方法- 前者方法返回对象本身
- 后者方法返回下一元素
for i in x循环中python会自动调用x.__iter__()方法获得迭代器p, 并自动调用next(p)获取元素, 并自动检查StopIteration异常, 碰到即结束(否则无限循环)x = [1,2,3,4]for i in x:print(i)#→ 等价于it = iter(x)while True:try:print(next(it))except StopIteration:break #空语句，什么都不做
操作
获取与移动
x=[1,2,3,4]it=iter(x) #获取迭代器print(next(it))print(next(it)) #操作迭代器移向下一位若到达末尾, 执行next将抛出异常
设置类迭代器
class MyRange: def __init__(self,n): self.idx=0 self.n=ndef __iter__(self): return self def __next__(self): if self.idx<self.n: val=self.idx self.idx+=1 return val else: #self.idx=0 #不加这行无法进行多次迭代 raise StopIteration()for i in MyRange(5): print(i)print([i for i in MyRange(5)])更佳的复用方式
class MyRange: # 容器：只存数据，不存迭代状态 def __init__(self, n): self.n = n def __iter__(self): return MyRangeIterator(self.n) # 每次新建迭代器！class MyRangeIterator: # 迭代器：存状态（i, n） def __init__(self, n): self.i = 0 self.n = n def __iter__(self): return self #可不写 def __next__(self): if self.i < self.n: val = self.i self.i += 1 return val raise StopIteration()x = MyRange(5)print([i*i for i in x])print([i for i in x])it=iter(x)print(next(it))print(next(it))for i in x: print(i) #才不会阶段输出# [0, 1, 4, 9, 16]# [0, 1, 2, 3, 4]# 0# 1# 0# 1# 2# 3# 4
迭代重载
只写 __getitem__，不写 __iter__，for 循环照样能跑。
class stepper: def __getitem__(self, i): return self.data[i]X = stepper()X.data = 'Spam' #临时创建一个for item in X: # 没写 __iter__ 也能 for 循环！ print(item) # S p a mPython 的 for 循环有回退机制：
for item in X: ...实际执行逻辑：
# 第1步：找 __iter__try: iterator = iter(X) # 调用 X.__iter__()except TypeError: # 第2步：没有 __iter__，就用 __getitem__ 硬凑 iterator = 内部迭代器(X) # Python 自动创建一个临时迭代器# 内部迭代器的行为：i = 0while True: try: item = X[i] # 调用 X.__getitem__(i) i += 1 except (IndexError, StopIteration): break # 越界就停过程拆解
X.data = 'Spam'for 调用 iter(X): └─ 发现没有 __iter__ └─ Python 新建临时迭代器，i = 0 ├─ X[0] = 'S' → 输出 S ├─ X[1] = 'p' → 输出 p ├─ X[2] = 'a' → 输出 a ├─ X[3] = 'm' → 输出 m └─ X[4] → IndexError → for 捕获 → 结束stepper 本身没有状态。每次 for 循环，Python 都新建一个临时迭代器（从零开始计数），所以：
print(list(X)) # ['S', 'p', 'a', 'm']print(list(X)) # ['S', 'p', 'a', 'm'] ✅ 还能用！生成器(generator)
概念
- 一种延时求值对象, 内部包含计算过程, 真正需要时才完成计算
例子:
a=(i*i for i in range(5)) #a为生成器,其内容并未生成print(a) #<generator object <genexpr> at 0x105b27b90>for x in a: print(x,end=' ')#0 1 4 9 16 #后面就迭代不了了matrix = ((i*3+j for j in range(3)) for i in range(3))# matrix 是生成器，其元素也是生成器for x in matrix:for y in x:print(y,end=" ") # 0 1 2 3 4 5 6 7 8#区别于写法二# matrix = ([i*3+j for j in range(3)] for i in range(3))# # matrix 是生成器，其元素也是生成器# for x in matrix:# for y in x:# print(y,end=" ") # 0 1 2 3 4 5 6 7 8延迟绑定Late Binding
写法1如果先全部取出再遍历，结果会错：
matrix = ((i*3+j for j in range(3)) for i in range(3))rows = list(matrix) # ❌ 先全部取出来for row in rows: print(list(row)) # [6, 7, 8]# [6, 7, 8]# [6, 7, 8] ← 全是 i=2 的结果！为什么？
内层生成器
(i*3+j for j in range(3))没有立刻算，它只记住了”以后要用i“。当
list(matrix)把外层迭代完后，i的最终值是2。之后你再遍历内层生成器，它们才想起来去查i，但此时i已经是2了。# 内层生成器实际上存的是：# gen0: "等我运行时，去看看 i 是多少" → 运行时 i=2# gen1: "等我运行时，去看看 i 是多少" → 运行时 i=2# gen2: "等我运行时，去看看 i 是多少" → 运行时 i=2写法2没问题，因为内层列表推导式立即计算：
matrix = ([i*3+j for j in range(3)] for i in range(3))rows = list(matrix)for row in rows: print(row)# [0, 1, 2]# [3, 4, 5]# [6, 7, 8] ✅ 正确！列表推导式在
i=0,1,2的当下就把值算好存进列表了，不会受后续i变化的影响。写法1什么时候是对的
边取边用，在内层生成器被消费时，外层还没跑完：
matrix = ((i*3+j for j in range(3)) for i in range(3))for row in matrix: # 外层取一个 print(list(row)) # 内层立刻消费 ✅# [0, 1, 2]# [3, 4, 5]# [6, 7, 8]
- 与列表解析式(即列表推导式list comprehension)区别:
i=(x+1 for x in lst)生成器表达式, 不需要生成结果列表, 延时求值print([x+1 for x in lst])列表解析, 生成了结果列表
yield关键字定义生成器
使用了yield的函数称为生成器
def test_yield(): yield 1 yield 2 yield (1,2)a=test_yield()while True: try: print(next(a)) except StopIteration: break def h(): print ('To be brave')yield 5 x = h() #无输出print(next(x)) #To be brave #5next(x) #引发异常使用 yield 实现斐波那契数列：
def fibonacci(n): # 生成器函数 – 用于求斐波那契数列前n项a, b, counter = 0, 1, 0while counter <= n:yield aa, b = b, a + bcounter += 1f = fibonacci(10) # f 是一个迭代器，由生成器返回生成while True:try:print (next(f), end=" ")except StopIteration:break#或#for i in f:#print (i, end=" ")好处是:不用事先准备过程需要的所有元素, 仅仅迭代到该元素时才计算, 可以处理♾️
称之为延迟计算 或 惰性求值(lazy evaluation)
send语句
特点
- 带
yield的函数，调用时返回生成器对象（迭代器） - 执行到
yield暂停，下次从断点恢复 - 遍历完即耗尽，不能复用
yield右边产出值给外部，左边接收send()的值
示例
def h(): print ('hello') m = yield 5 #m的值要从外部获得 print ("m=", m) d = yield 12 print ('d=' ,d ) yield 13c = h() #无输出x = next(c) #默认等价于多了一句c.send(None)print("x=",x)y = next(c) #此时m赋值为了Noneprint("y=",y)z = c.send("good")print("z=",z)# hello# x= 5# m= None# y= 12# d= good# z= 13应用⚠️⚠️⚠️
# ========== 1. 生成器做任务控制器（协程/状态机）==========def task_controller(): task_id = 1 while True: action = yield f"任务{task_id} 等待指令" if action == "start": print(f"任务{task_id} 开始执行...") elif action == "pause": print(f"任务{task_id} 已暂停") elif action == "stop": print(f"任务{task_id} 已停止") task_id += 1 elif action is None: breakcontroller = task_controller()next(controller) # 启动print(controller.send("start")) # 任务1开始 → 产出"任务2等待指令"print(controller.send("pause")) # 任务2暂停 → 产出"任务3等待指令"print(controller.send("stop")) # 任务3停止 → task_id=2 → 产出"任务4等待指令"# ========== 2. 用生成器实现 map（惰性求值）==========def myMap(func, iterable): for arg in iterable: yield func(arg)names = ["ana", "bob", "dogge"]x = myMap(lambda x: x.capitalize(), names)print(x) # <generator object ...>print(list(x)) # ['Ana', 'Bob', 'Dogge']for name in x: # ❌ 无输出，已耗尽# ========== 3. 用生成器求全排列（递归回溯）==========def perm(items): n = len(items) if n == 1: yield items for i in range(n): v = items[i:i+1] rest = items[:i] + items[i+1:] for p in perm(rest): yield v + pa = perm('abc')print(next(a)) # abcprint(next(a)) # acbprint("****")for b in a: # 从剩余继续 print(b) # bac, bca, cab, cba双向通信：任务控制器（协程）
action = yield msg # 产出 msg 给外部；恢复后 action = send 的值
调用 生成器内部 next(controller)启动，跑到 yield，产出状态send("start")恢复， action="start"，执行逻辑，再yield暂停惰性计算：自定义 map
对比 列表推导式 生成器版 内存 全部存列表 用到一个算一个 返回 列表 生成器对象 多次遍历 ✅ ❌ 只能一次 # 惰性 map：遍历时才计算def myMap(func, iterable): for arg in iterable: yield func(arg)# 等价于map(func, iterable) # 内置 map 也是返回迭代器陷阱：
list(x)或for遍历完后，生成器耗尽，再次遍历为空。递归回溯：全排列
def perm(items): if len(items) == 1: yield items for i in range(len(items)): v = items[i:i+1] rest = items[:i] + items[i+1:] for p in perm(rest): # 递归子问题 yield v + p # 拼接产出执行流程（
perm('abc')）：perm('abc')├─ 固定 'a' + perm('bc') → abc, acb├─ 固定 'b' + perm('ac') → bac, bca└─ 固定 'c' + perm('ab') → cab, cba特点：
- 深度优先遍历解空间
- 遇到完整解就
yield，不用等全部算完next()和for可混用，共用迭代状态易错点
错误 原因 生成器遍历为空 迭代器已耗尽，需重新创建 send(非None)启动未启动的生成器只能用 next()或send(None)递归生成器没 yield from子生成器的结果需要用 for ... yield或yield from传递# 3.3+ 可用 yield from 简化def perm(items): if len(items) == 1: yield items for i in range(len(items)): rest = items[:i] + items[i+1:] yield from (items[i:i+1] + p for p in perm(rest))
其他语法特性
eval函数
概念
把字符串看作python表达式请求其值, 返回其值
expression=input("请输入算式")result=eval(expression)print(result)compile和exec函数
| 函数 | 作用 | 返回值 |
|---|---|---|
eval | 将字符串看作Python表达式求值 | ✅ 有返回值 |
exec | 执行字符串中的Python语句 | ❌ 无返回值(None) |
compile | 编译字符串为代码对象，供eval/exec使用 | 代码对象 |
# eval有返回值result = eval("3*4+5") # 17# exec无返回值exec('a=10')print(a) # 10result = exec("x = 10")print(result) # Noneexec可执行多行代码:
exec("""a = 10b = 20result = a + bprint(result)""") # 输出: 30compile提高多次运行效率:
str = "for i in range(0,10): print (i,end = ' ')"c = compile(str,'','exec') # 编译exec(c) #=> 0 1 2 3 4 5 6 7 8 9x=4y=5str2 = "3*x + 4*y"c2 = compile(str2, '', 'eval') # compile过运行更快,适合多次调用result = eval(c2)print(result) # 32动态导入模块:
module_name = "math"exec(f"import {module_name}")print(sqrt(16)) # 4.0指定作用域
eval和exec可以通过字典指定作用域:
a = 10b = 20def func(x): return x+1scope={} #用字典当作用域scope['a'] = 3scope['b'] = 4scope['func'] = lambda x:x*xprint(eval("a+b")) #=> 30 (使用全局作用域)print(eval("a+b",scope)) #=> 7 (使用自定义作用域)# print(eval("a+b+c",scope)) # error, c无定义print(eval("func(7)")) #=> 8 (调用全局func)print(eval("func(7)",scope)) #=> 49 (调用scope中的lambda)exec("print(a)") #=> 10exec("print(a)",scope) #=> 3⚠️ 作用域查找规则:
参数 说明 不提供scope 使用当前全局/局部作用域 提供 scope字典从字典中查找变量 变量不存在 抛出 NameError
反射(reflection)
概念
获取并使用对象的信息
反射的核心是在运行时动态获取对象的属性和方法，并对其进行操作。
class A(): def __init__(self,x): self.x = x def func(self): print("x=",self.x)a = A(12)四大反射函数:
| 函数 | 作用 | 示例 |
|---|---|---|
dir(obj) | 列出对象的所有属性和方法 | dir(a) |
hasattr(obj, name) | 判断对象是否有指定属性/方法 | hasattr(a, 'x') |
getattr(obj, name) | 获取对象的属性值或方法 | getattr(a, 'x') |
setattr(obj, name, value) | 设置对象的属性值 | setattr(a, 'x', 100) |
a = A(12)# dir: 列出所有属性和方法print(dir(a))# ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', # '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', # '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', # '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', # '__sizeof__', '__str__', '__subclasshook__', '__weakref__', # 'func', 'x']# hasattr: 判断是否存在if hasattr(a,'x'): # True setattr(a,'x','hello,world') # 修改属性值 print(getattr(a,'x')) # hello,world# getattr获取方法并调用if hasattr(a,'func'): getattr(a,'func')() # x= hello,world # 等价于 a.func()反射的应用场景:
- 动态调用方法: 根据字符串名称调用对象方法
- 动态配置: 通过配置文件指定要操作的属性名
- 调试 introspection: 查看对象内部结构
- 插件系统: 动态加载和调用模块中的功能
异常处理
try … except
捕获异常，防止程序崩溃:
# 捕获所有异常try: f = open("ssr.txt","r")except: print("error")# 捕获特定异常并获取错误信息try: print(aa)except Exception as e: print(e)# name aa is not defined多分支捕获:
try: print(aa)except IOError as e: print(f"IO错误: {e}")except NameError as e: print(f"名称错误: {e}")# name 'aa' is not defined# 兜底捕获try: 可能出错的代码except 特定异常 as e: 处理特定错误except Exception as e: # 捕获一切错误 print(f"其他错误: {e}")try … finally
无论有无异常，finally块都会执行:
try: print(aa)except: pass # 空操作，忽略异常finally: print("done") # 不论有无异常都会执行异常处理最佳实践:
写法 说明 except:捕获所有异常（过于宽泛，不推荐） except SpecificError:捕获特定异常 ✅ except Exception as e:捕获所有异常并获取信息 try...finally:用于资源释放（如关闭文件） pass空语句，什么都不做
装饰器
基本概念
在不改变原有函数代码的情况下扩展函数功能
也许你已经在深度学习中见过装饰器:
import torchx = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)@torch.no_grad() # 装饰器语法def double(tensor): return tensor * 2result = double(x)print(result)# tensor([2., 4., 6.])# 对比：不用装饰器def double(tensor): return tensor * 2result = double(x)print(result)# tensor([2., 4., 6.], grad_fn=<MulBackward0>)自定义装饰器
def good(func): def wrapper(*args): print("%s called" % func.__name__) return func(*args)+5 return wrapper@good # good是一个装饰器def mysum(a,b,c): return a + b + cprint(mysum(3,4,5))# mysum called# 17# @good 等价于 mysum = good(mysum)# mysum(3,4,5) 等价于 good(mysum)(3,4,5)带参数的装饰器
def good2(var1): def decorator(func): def wrapper(*args): print("%s called" % func.__name__) return func(*args) + var1 return wrapper return decorator@good2(10)def f(x,y): return x * y@good2(100)def f2(x,y): return x * yprint(f(1,2)) # f called 12 (1*2+10)print(f2(1,2)) # f2 called 102 (1*2+100)# @good2(10) 等价于 good2(10)(f)(1,2)用对象做装饰器
class decorator: def __init__(self,x): self.x = x def de(self,func): def wrapper(*args): print("%s called" % func.__name__) return func(*args) + self.x return wrappermyobj = decorator(100)@myobj.dedef f3(x,y,z): return x + y + zprint(f3(1,2,3)) # f3 called 106 (1+2+3+100)myobj.x = 7 # 修改装饰器的参数print(f3(1,2,3)) # f3 called 13 (1+2+3+7)]]>装饰器执行时机:
阶段 行为 定义时 @decorator立即执行，原函数被替换为wrapper调用时 执行的是wrapper函数，其中再调用原函数 三层嵌套解析（带参数装饰器）:
@good2(10)def f(x,y): return x*y# 执行步骤:# 1. good2(10) → 返回 decorator 函数# 2. decorator(f) → 返回 wrapper 函数# 3. f = wrapper (原f被包装)
