第12讲 python高阶函数

1、匿名函数：

1.1 lambda表达式

lambda函数表达式专门用来创建一些简单的函数，它是函数的另外一种方式
语法 lambda 参数列表 ：返回值
print((lambda a,b : a+b)(10,20))
filter(funtion,iterable) 过滤器
可以从序列当中过滤出符合条件的元素，保存到一个新的序列中
参数一 传递函数
参数二 需要过滤的序列
返回值 过滤后的序列

l = [1,2,3,4,5,6,7,8,9,10]

#定义一个函数 用来检测一个任意数的偶数

def fn2(i):
    if i % 2 ==0:
        return True

#定义一个函数，用来检查指定数字是否大于5

def fn3(i):
    if i > 5:
        return True
    return False

#定义一个函数，用来检查指定数字是否被3整除

def fn4(i):
    if i % 3 == 0:
        return True
    False

#定义一个函数

def fn(func,lst):
    #创建一个新的列表
    new_list = []
    for n in lst:
        if func(n):
        #判断n的奇偶
        # if fn2(n):
            new_list.append(n)
    #返回新的列表
    return new_list

print(fn(fn4,l))
print(list(filter(fn4,l)))

#上面的程序可以用下面的lambda替代

l = [1,2,3,4,5,6,7,8,9,10]
r1 = filter(lambda i : i >5, l)
r2 = filter(lambda i : i % 2 == 0, l)
r3 = filter(lambda i : i % 3 == 0, l)

print(list(r1))
返回值：[6, 7, 8, 9, 10]
print(list(r2))
返回值：[2, 4, 6, 8, 10]
print(list(r3))
返回值：[3, 6, 9]

1.2 map()

map()函数可以对可迭代对象中所有元素做指定操作，然后将其添加到一个新的对象返回
匿名函数一般都作为参数使用，其它地方一般不用

l = [1,2,3,4,5,6,7,8,9,10]
r = map(lambda i : i+1,l)
print(list(r))

上面程序的返回值：[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

1.3 sort()

该方法用来对列表中的元素进行排序
sort() 方法默认比较字符串的大小
在sort()函数中可以接收一个关键字key
key需要一个值作为参数，指定排序方式

l = ['bb','aaaaa','ffff','ddddd']
l.sort()
print(l)

返回值：[‘aaaaa’, ‘bb’, ‘ddddd’, ‘ffff’]

l = ['bb','aaaaa','ffff','ddddd']
l.sort(key=len)
print(l)

返回值：[‘bb’, ‘ffff’, ‘aaaaa’, ‘ddddd’]

l = [2,3,'1','3',5,'4']
l.sort(key=int)
print(l)

返回值：[‘1’, 2, 3, ‘3’, ‘4’, 5]

sorted() 返回值 返回一个新的列表
l = [2,3,‘1’,‘3’,5,‘4’]
#sorted()
print(‘排序前：’,l)
print(‘排序后：’,sorted(l,key=int))
返回值：
排序前： [2, 3, ‘1’, ‘3’, 5, ‘4’]
排序后： [‘1’, 2, 3, ‘3’, ‘4’, 5]

2、闭包

将函数作为返回值返回，也是一种高阶函数（俗称闭包）

def fn():
    #在函数内部再定义一个函数
    a = 10
    def inner():
        print("我是fn2",a)
    #将内部函数作为返回值返回
    return inner
#r 是一个函数，是调用fn()后返回的函数
#这个函数在fn()内部定义的，并不是全局函数
#所以这个函数总是能访问到fn()函数的内部的变量
r = fn()
r()

返回值：我是fn2 10
所以这个函数总是能访问fn()内部变量
它的好处是什么？
通过闭包可以创建一些只有当前函数可以访问到的变量（可以将一些私有的数据藏到闭包当中）

nums = [5,3,1,4,7]
print(sum(nums)/len(nums))

返回值：4.0

#创建一个函数，用来求平均值

def make_average():
    #创建一个空列表
    nums = []
    def average(n):
        nums.append(n)
        #求平均值
        return sum(nums)/len(nums)
    return average

average = make_average()
print(average(10))
print(average(20))
print(average(30))

返回值：
10
15
20

形成闭包的条件
1）函数嵌套
2）将内部函数作为返回值返回
3）内部函数必须要使用到外部函数的变量

3、装饰器引入

通过以上的步骤来实现当前的需求发现以下的问题
1)如果要修改的函数过多,修改起来比较麻烦
2)不方便后期维护
3)这样会违反开闭原则(ocp)
我们在开发的时候,要求你开发对程序的扩展,但是要关闭对程序的修改

在不修改原函数的情况下，来对函数进行扩展

def fn():
    print('我是fn函数')

我创建一个新的函数

def fn2():
    print('函数开始执行')
    fn()
    print('函数执行结束')

fn2()
返回值：
函数开始执行
我是fn函数
函数执行结束

打印 “计算开始”，打印 “计算结束”

def add(a,b):
    #求任意两个数的和
    print('计算开始。。。')
    r = a+b
    print('计算结束。。。')
    return r
    
def new_add(a,b):
    print('函数开始执行。。。')
    r = add(a,b)
    print('函数执行结束。。。')
    return r
r = new_add(1,2)
print(r)

返回值：
函数开始执行。。。
函数执行结束。。。
3

4、装饰器的使用

先创建两个函数

def add(a,b):
    #求任意两个数的和
    r = a+b
    return r

def fn():
    print('我是fn函数')

用来对其它的函数进行扩展，使其它函数可以在执行前打印执行开始，执行后打印执行结束
创建一个函数：
*args接收所有的位置参数
**kwargs接收所有的关键字参数

def start_end(old):
#old将要扩展的函数对象
    def new_function(*args,**kwargs):
        print('开始执行...')
        result = old(*args,**kwargs)
        print('执行结束...')
        return result
    return new_function

f = start_end(add)
print(f(4,5))

返回值：
开始执行…
执行结束…
9

f = start_end(fn)
print(f())

返回值：
开始执行…
我是fn函数
执行结束…
None
象start_end(old)这样的函数我们就称之为装饰器
通过装饰器，可以在不修改原来函数的基础上来对函数进行扩展
在开发当中，我们都是通过对装饰器来扩展函数的功能

@start_end  #作用是载入装饰器
def say_baibai():
	print('再见我的女神')
say_baibai()

返回值：
开始执行…
再见我的女神
执行结束…