第十课 函数下 高阶函数

1. ⾼阶函数

接收函数作为参数，或者将函数作为返回值返回的函数就是⾼阶函数。

1.1 特点一接收一个或多个函数作为参数。不加（）

1.2 特点二将函数作为返回值。

例子：将一个指定列表中的偶数，保存到一个新的列表中。
#需求：将一个指定列表中的偶数，保存到一个新的列表中。
lst=[1,2,3,4,5,6,7,8,9,10]
def fn(lst):
# 参数lst 要进行筛选的列表
# 创建一个新列表
newlst=[]
# 对要筛选的列表进行遍历
for n in lst:
# 要对n的奇偶进行判断，之后返回一个新的列表。
if n % 2== 0:
newlst.append(n)
return newlst
print(fn(lst))
结果：
[2, 4, 6, 8, 10]

例子2：单独把判断偶数列为一个函数：
lst=[1,2,3,4,5,6,7,8,9,10]
def fn(lst):
#定义一个函数用来检测任意数的偶数：
def fn2(i):
if i % 2 == 0:
return True #如果把Ture 改为i也可以，下面fn2（n）的返回值就是n值了。
# 参数lst 要进行筛选的列表
# 创建一个新列表
newlst=[]
# 对要筛选的列表进行遍历
for n in lst:
# 要对n的奇偶进行判断，之后返回一个新的列表。
if fn2(n): #如果是判断奇数，就是if not fn2(n)
newlst.append(n)
# print(fn2(n))
return newlst
print(fn(lst))

例子3：把整体函数作为传递目标：
#为了更加方便，在输入时候即可定义需求。因此可以用下列方式实现：
lst=[1,2,3,4,5,6,7,8,9,10]
#定义一个函数用来检测任意数的偶数：
def fn2(i):
if i % 2 == 0:
return True #如果把Ture 改为i也可以，下面fn2（n）的返回值就是n值了。
#定义一个函数用来检测大于5的数：
def fn3(i):
if i>5:
return True
def fn(func,lst):
# 参数lst 要进行筛选的列表
# 创建一个新列表
newlst = []
# 对要筛选的列表进行遍历
for n in lst:
# 要对n的奇偶进行判断，之后返回一个新的列表。
if func(n):
newlst.append(n)
# print(fn2(n))
return newlst
print(fn(fn3,lst))

#参数：1函数，2需要过滤的序列（可迭代）返回值，过滤后的新序列。
lst=[1,2,3,4,5,6,7,8,9,10]
def fn4(i):
if i % 3 == 0:
return True
return False
print(filter(fn4,lst))
#结果返回了一个对象：
#<filter object at 0x02D8B058>

lst=[1,2,3,4,5,6,7,8,9,10]
def fn4(i):
if i % 3 == 0:
return True
return False
print(list(filter(fn4,lst)))
#结果为：[3, 6, 9]

例子：

#匿名函数

#filter()

#参数：1函数，2需要过滤的序列（可迭代）返回值，过滤后的新序列。

lst=[1,2,3,4,5,6,7,8,9,10]
def fn4(i):
if i % 3 == 0:
return True
return False
print(filter(fn4,lst))
#结果返回了一个对象：
#<filter object at 0x02D8B058>

lst=[1,2,3,4,5,6,7,8,9,10]
def fn4(i):
if i % 3 == 0:
return True
return False
print(list(filter(fn4,lst)))
#结果为：[3, 6, 9]

#匿名函数 lambda函数表达方式，好处是只用一次。用完就从内测消失。

#lambda函数表达方式就是专门用来创建一些简单的函数。

#语法：lambda参数列表：返回值

lst=[1,2,3,4,5,6,7,8,9,10]
def fn5(a,b):
return a+b
print(fn5(1,2))
print(lambda a,b : a+b) #这句的结果：<function at 0x031486A0>
print((lambda a,b : a+b)(50,60)) #这句结果：110。因此以后想要实现比较简单的函数，就可以用lambda来实现。
fn6=(lambda a,b:a+b) #也可以这样写
print(fn6(5,6)) #结果11
r= filter(lambda i:i%3 ==0,lst)
print(list®) #结果[3,6,9]

#闭包

#特点：将函数作为返回值。也是高阶函数的一种。

#通过闭包可以创建一些只有当前函数可以访问的变量，将一些私有数据藏到闭包中。

#形成闭包的条件：

#1 函数嵌套

#2 将内部函数作为返回值返回。

#3 内部函数必须使用到外部函数的变量。

def fn():
a=10
#在函数内部定义一个函数
def fn2():
print(‘我是fn2’,a) #这样就可以访问内部函数a了，由于a不是全局变量，因此是无法从外面直接访问。
#将内部函数fn2作为返回值返回。
return fn2
#print(fn()) #结果：<function fn..fn2 at 0x038D8658>
r=fn() #用r来接收返回值。
r() #调用r 结果：我是fn2 10
#print(a) #无法从外界直接访问a

3. 装饰器的引⼊

我们可以直接通过修改函数中的代码来完成需求，但是会产⽣以下⼀些问题。

3.1 如果修改的函数多，修改起来会⽐较麻烦。

3.2 不⽅便后期的维护。

3.3 这样做会违反开闭原则(ocp)，程序的设计，要求开发对程序的扩展，要关闭对程序的修改。

例子：
#装饰器的引入
#问题1如果要修改的函数过多，修改起来比较麻烦。
#问题2不方便后期维护。
#问题3违反开闭原则（ocp）程序的设计思想，要求开放对程序的扩展，要关闭对程序的修改。
#因此，装饰器的作用是，在不修改原函数的前提下，扩展该函数的功能。
def fn():
print(‘我是fn函数’)
#创建一个新的函数来对原函数进行扩展。
def fn2():
print(‘函数开始执行…’)
fn()
print(‘函数执行结束…’)
fn2()

def add(a,b):
return print(a+b)
#print(add(1,2))
add(1,2)
def new_add(a,b):
print(‘函数开始执行…’)
add(a,b)
print(‘函数执行结束…’)
new_add(1,2)
#print ( r)

4. 装饰器的使⽤

4.1 通过装饰器，可以在不修改原来函数的情况下来对函数进⾏扩展。

4.2 在开发中，我们都是通过装饰器来扩展函数的功能的。