高阶函数
• 返回函数
• 匿名函数
• 装饰器
• 偏函数

二、lambda表达式

• 函数：最大程度上复用代码 存在问题：如果函数很小，反而觉得麻烦
• 如果函数被调用次数少，则造成浪费
• 对于读者来说，造成阅读流程被迫中断

lambda表达式（匿名函数）

• 一个表达式，函数体相对简单
• 不是一个代码块，仅仅是一个表示式
• 可以有一个或多个参数，用逗号隔开
  lambda表达式的用法
  1、以lambda开头
  2、紧跟一定的参数（如果有的话）
  3、参数后用冒号和表达式主题隔开
  4、只是一个表达式，没有return

#lambda表达式的用法
stm = lambda x: 100 * x
a = stm(12)
print(a)
stm2 = lambda x,y,z: x+10*y+100*z
b = stm2(4,5,6)
print(b)

三、高阶函数

• 把函数作为参数使用的函数，叫做高阶函数 函数名称就是一个变量
• 既然函数名称是变量，则应该可以被当做参数传入另一个函数

#函数名称就是一个变量
def funA():
print("In funA")
funB = funA
funB()
def funC(n):
return n * 100

#在写一个函数，把传入参数乘以300倍
def funD(n):
return funC(n) * 3
print(funD(9))

#写一个高阶函数
def funE(n,f):
return f(n) * 3
print(funE(9,funC))

四、系统高阶函数

1、map

• 原意就是映射，即把集合或者列表的元素，每一个元素都按照一定的规则进行操作，生成一个新的列表或者集合
• map函数是系统提供的具有映射功能的函数，返回值是一个迭代对象

#由一个列表，相对每个元素都乘以10，得到新的列表
l1 = [i for i in range(10)]
print(l1)
l2 = []
for i in l1:
l2.append(i * 10)
print(l2)
#利用map实现
def mulTen(n):
return n * 10
l3 = map(mulTen,l1)
print(type(l3))
#map类型是一个可迭代的结构
print(l3)
for i in l3:
print(i)

2、reduce

• 原意是归并，缩减
• 把一个可迭代对象最后归并成一个结果
• 对于作为参数的函数要求，必须有两个参数，必须有返回结果
• reduce需要导入functools包

from functools import reduce
def Add(x,y):
return x+y
a = reduce(Add,[1,2,3,4,5])
print(a)

3、filter函数

• 过滤函数：对一组数据进行过滤，符合条件的数据会生成一个新的列表并返回
• 与map的比较 相同
  都是对列表的每个元素进行操作 不同
  1、map会生成一个跟原来数据相对应的新队列
  2、filter不一定，只有符合条件的才会进入新队列

利用给定函数进行判断
• 返回值一定是一个布尔值
• 调用格式

filter(fun,date)，fun是过滤函数，date是数据

#定义过滤函数#要求有输入，返回布尔值
def isEven(a):
return a % 2 == 0
l = [3,4,5,12,45,14,3,11,51]
rst = filter(isEven, l)
print(type(rst))
print(rst)
print([i for i in rst])

五、高阶函数-排序

• 把一个序列按照给定算法就行排序
• key：在排序前对每一个元素进行key函数运算，可以理解成按照kay函数定义的逻辑进行排序
• python2和python3相差巨大
• sorted函数
  格式：
  sorted(a,reverse),a是要进行排序的数据，reverse是正序或倒序的参数
  reverse为False时为正序排列，为True时为倒序排列
  默认reverse为False

a = [12,4,5,6,8,54,587,422,4679,52]
al = sorted(a)
print(al)
al1 = sorted(a,reverse = True)
print(al1)
b = [12,-54,23,-5,5,48,-65,74,-78]
#按照绝对值进行排序#abs是求绝对值的意思
b1 = sorted(b,key=abs)
print(b1)
#字符串排序
c = ['da','Da','fdsf','dfc','EFxc','Erv']
c1 = sorted(c)
print(c1)
c2 = sorted(c,key=str.lower)
print(c2)

六、返回函数

• 函数可以返回具体的值
• 也可以返回一个函数作为结果

#定义一个普通函数
def myF(a):
print('In myF')
return None
a = myF(2)
print(a)
#函数作为返回值返回，被返回的函数在函数体内定义
def myF2():
def myF3():
print('In myF3')
return 3
return myF3
f3 = myF2()
print(type(f3))
print(f3)
f3()
print(f3())
#复杂一点的返回函数的例子d
def myF4(*args):
def myF5():
rst = 0
for n in args:
rst += n
return rst
return myF5
f5 = myF4(1,2,3,4,5,6)
print(f5())

七、闭包（closure)

• 当一个函数在内部定义函数，并且内部函数应用外部函数的参数或者局部变量，当内部函数被当做返回值的时候，相关参数和变量保存在返回的函数中，这种结果叫做闭包
• 上例中的myF4就是一个标准的闭包

#闭包常见的坑
def count():
fs = []
for i in range(1,4):
#定义一个函数f
#f是一个闭包结构
def f():
return i*i
fs.append(f)
return fs
f1,f2,f3 = count()
print(f1())
print(f2())
print(f3())

• 上例中的问题
  1、出现的问题：
  造成上述问题的原因是返回函数引用了变量i，i并非立即执行，而是等到三个函数都返回的时候才统一使用，此时i已经变成了3，所以返回的都是3*3
  所以，返回闭包时返回函数不能引用任何循环变量
  2、解决方案：
  再创建一个函数，用该函数的参数绑定循环变量的当前值，无论该循环变量以后怎么改变，已经绑定的函数参数值不在改变

如下

def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1,4):
fs.append(f(i))
return fs
f1,f2,f3 = count()
print(f1())
print(f2())
print(f3())

八、装饰器

• 一个普通的函数

def hello():
print('hello')
return None
hello()
f = hello
f()
print(id(f))
print(id(hello))
#上述说明f和hello是同一个函数，也可以用以下方法验证
print(f.__name__)
print(hello.__name__)

• 现在有新的需求，对hello的功能就行扩展，每次打印hello之前打印当前系统时间，实现这个功能又不能改变现有代码
• 这是就是用装饰器
• 1、装饰器定义： 在不改动函数代码的基础上无限制扩展函数功能的一种机制，本质上讲，装饰器是一个返回函数的高阶函数

使用@语法，即在每次要扩展到函数定义千使用@+函数名
• 实现对hello的扩展的案例

import time
#高阶函数，以函数作为参数
def printTime(f):
def wrapper(*args,**kwargs):
print("Time：",time.ctime())
return f(*args,**kwargs)
return wrapper
#上面定义了装饰器，使用的时候需要用到@，此符号是python的语法糖
@printTime
def hello():
print("Hello")
hello()
@printTime
def hello2():
print('hahah')
hello2()

• 3、装饰器的好处 一次定义，可以装饰任何函数
• 一旦被其装饰，则把装饰器的功能直接添加到定义函数的功能上
• 而且不用改动定义函数的代码，非常安全，绿色