1. 高阶函数
• 接收函数作为参数，或者将函数作为返回值返回的函数就是高阶函数
#高阶函数
#特点1：接收一个或者多个函数作为函数
#特点2：将函数作为返回值返回
#接收函数作为参数
lst=[1,2,3,4,5,6,7,8,9,10]
#定义一个函数可以将指定的列表中所有的偶数，保存到一个新的列表中返回
def fn(lst):
#参数 lst是要进行筛选的列表
#创建一个新的列表
new_lst=[]
for n in lst:
#判断n的奇偶
if n%2==0:
new_lst.append(n) #将数添加到列表中
return new_lst
print(fn(lst))
[2, 4, 6, 8, 10]
判定是否为奇数：
#接收函数作为参数
lst=[1,2,3,4,5,6,7,8,9,10]
#定义一个函数可以将指定的列表中所有的偶数，保存到一个新的列表中返回
def fn(lst):
#参数 lst是要进行筛选的列表
#创建一个新的列表
new_lst=[]
for n in lst:
#判断n的奇偶
if n%2 !=0:
new_lst.append(n) #将数添加到列表中
return new_lst
print(fn(lst))
[1, 3, 5, 7, 9]
穿插多个条件在函数中，用函数来替代：
# #接收函数作为参数
lst=[1,2,3,4,5,6,7,8,9,10]
# #定义一个函数可以将指定的列表中所有的偶数，保存到一个新的列表中返回
#
def fn(lst):
#参数 lst是要进行筛选的列表
#定义一个函数，用来检测一个偶数
def fn2(i):
if i%2==0:
return True
#定义一个函数用来检测是否大于5
def fn3(i):
if i >5:
return True
#创建一个新的列表
new_lst=[]
for n in lst:
#判断n的奇偶
if not fn3(n):
new_lst.append(n) #将数添加到列表中
return new_lst
print(fn(lst))
[1, 2, 3, 4, 5]
2. 闭包
• 将函数作为返回值也是高阶函数我们也称为闭包
#将函数作为返回值返回，也成为闭包
def fn():
#在函数内部定义一个函数
def fn2():
print("我是fn2")
#将内部函数作为返回值返回
return fn2
print(fn()) #结果是打印出的对象 <function fn.<locals>.fn2 at 0x100a3d620>
#将函数作为返回值返回，也成为闭包
def fn():
#在函数内部定义一个函数
def fn2():
print("我是fn2")
#将内部函数作为返回值返回
return fn2
#r是一个函数，是调用fn()后返回的函数，这个函数是在fn()内部定义，并不是全局函数
r=fn()
r()
我是fn2
# #将函数作为返回值返回，也成为闭包
# def fn():
# #在函数内部定义一个函数
# def fn2():
# print("我是fn2")
# #将内部函数作为返回值返回
# return fn2
# #r是一个函数，是调用fn()后返回的函数，这个函数是在fn()内部定义，并不是全局函数
# r=fn()
# r()
#通过闭包可以创建一些只有当前函数能访问的变量
#可以将一些私有数据藏到闭包中
def make_average():
nums=[] #此时nums是个全局变量
#定义一个函数 计算平均值
def average(n):
#将n添加到列表中
nums.append(n)
#求平均值
return sum(nums)/len(nums)
return average
a=make_average()
print(a(10))
nums=[]
print(a(20))
10.0
15.0
• 闭包的好处
• 通过闭包可以创建一些只有当前函数能访问的变量
• 可以将一些私有数据藏到闭包中
• 行成闭包的条件:
- 函数嵌套
- 将内部函数作为返回值返回
- 内部函数必须要使用到外部函数的变量
3. 装饰器的引入
• 我们可以直接通过修改函数中的代码来完成需求，但是会产生以下一些问题
#求任意两个数的和
def add(a,b):
# print("开始计算")
# print("计算结束")
return a+b
#求任意两个数的积
def mul(a,b):
return a*b
r=add(1,20)
print(r)
#我们可以直接通过修改函数中的代码来完成这个需求，但是会产生一些问题
#1.如果需要修改的函数比较多，修改起来比较麻烦
#2.不方便后期维护
#3.这样做会违反开闭原则（OCP）程序的设计 要求开发对程序的扩展，要关闭对程序的修改
#在希望不修改原函数的情况下，来对函数进行扩展
def fn():
print("我是fn函数")
#定义一个函数，对fn进行扩展
def fn2():
print("函数开始执行")
fn()
print("函数执行结束")
fn2()
21
函数开始执行
我是fn函数
函数执行结束
• 如果修改的函数多，修改起来会比较麻烦
• 不方便后期的维护
• 这样做会违反开闭原则(ocp)
• 程序的设计，要求开发对程序的扩展，要关闭对程序的修改
4. 装饰器的使用
• 通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
def fn():
print("我是fn函数")
def add (a,b):
return a+b
def start_end(old):
#用来对其他的函数进行扩展 扩展函数执行的时候 打印开始执行 执行后打印执行
#参数old要扩展的函数对象
#创建一个函数
def new_function(a,b):
print("开始执行")
#要调用被扩展的函数
result=old(a,b)
print("执行结束")
return result
#返回新函数
return new_function
f=start_end(add)
r= f(1,2)
print(r)
开始执行
执行结束
3
def fn():
print("我是fn函数")
def add (a,b):
return a+b
def start_end(old):
#用来对其他的函数进行扩展 扩展函数执行的时候 打印开始执行 执行后打印执行
#参数old要扩展的函数对象
#创建一个函数
def new_function(*args,**kwarges):
#*args接收所有的位置参数， **kwarges接收所有的关键字参数
#装包，把参数包成一个一个元组或一个一个字典
print("开始执行")
#要调用被扩展的函数
result=old(*args,**kwarges)
# 把位置参数拆包，放在一个元组进去，或者把一个关键字拆包
print("执行结束")
return result
#返回新函数
return new_function
f=start_end(fn)
r= f()
# print(r)
开始执行
我是fn函数
执行结束
• 在开发中，我们都是通过装饰器来扩展函数的功能的
def fn():
print("我是fn函数")
def add (a,b):
return a+b
def start_end(old):
#用来对其他的函数进行扩展 扩展函数执行的时候 打印开始执行 执行后打印执行
#参数old要扩展的函数对象
#创建一个函数
def new_function(*args,**kwarges):
#*args接收所有的位置参数， **kwarges接收所有的关键字参数
#装包，把参数包成一个一个元组或一个一个字典
print("开始执行")
#要调用被扩展的函数
result=old(*args,**kwarges)
# 把位置参数拆包，放在一个元组进去，或者把一个关键字拆包
print("执行结束")
return result
#返回新函数
return new_function
f=start_end(add)
r= f(555,666)
print(r)
#若以后对某一函数进行扩展，直接调用start_end, 最终都会返回一个新的函数，都是对原有的函数进行
#扩展，此时start_end就是一个装饰器
#向我们今天讲的这个start_end（old)类似于这样的函数我们就称之为装饰器
#通过装饰器，可以在不修改原来的函数的情况下来对函数进行扩展
#在开发中，我们都是通过装饰器来扩展函数的功能的
@start_end
def speak():
print("大家加油")
speak()
开始执行
执行结束
1221
开始执行
大家加油
执行结束
扫一扫
742
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
