python基础班笔记10 函数三

2021/2/4

高阶函数

高阶函数的特点

1. 接受一个或多个函数作为参数
2. 将函数作为返回值返回

#示例：
def fun():
	def fun1():
		pass
	return fun1

#例题：提取列表 list1 中的偶数
list1 = [1,2,3,4,5,6,7,8,9,10]
def fun1(i):
	if i % 2 == 0
		return True
def fun(fun1,list1) :		
	list2 = []
	for i in list1:
		if fun1(i):
			list2.append(i)
	retrun list2
print(fun(list1))

---

匿名函数

filter()类

filter（） 需要传递两个参数，并按所设定的规则，过滤出所需要的数据

1. 传递一个函数
2. 传递一个需要过滤的序列（可迭代的）

list1 = [1,2,3,4,5,6,7,8,9,10]
def fun1(i):
	if i % 2 == 0
		return True
print(list(filter(fun1,list1)))

lambda函数

专门用作一些简单函数
语法： lambda参数：表达式

#示例1
print((lambda a,b: a+b )(10,20))
#示例2
r = lambda a,b: a+b
print(r(10 ,20))

#例题 提取列表 list1 中的偶数
list1 = [1,2,3,4,5,6,7,8,9,10]
r = lambda i: i % 2 ==0
print(list(filter(r,list1)))

---

闭包

将函数作为返回值也是高阶函数我们也称为闭包

闭包的好处
• 通过闭包可以创建一些只有当前函数能访问的变量
• 可以将一些私有数据藏到闭包中

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

闭包的第一个特性：变量不被销毁

def func_out(num1):
    def func_inner(num2):     # 函数嵌套
        result = num1 + num2  # 外层参数调用
        print(result)

    return func_inner   # 将内部函数作为返回值返回


f = func_out(1)  # 给num1传一个1
f(2)             # 函数调用，给num2传一个2
运行结果 》》》3
f(3)
运行结果 》》》4

闭包的第二个特性：变量不可被更改

def func_out(num1):
    def func_inner(num2):     # 函数嵌套
        num1 = 10
        result = num1 + num2  # 外层参数调用
        print(result)

    print(num1)         #这里就可以很清晰的看到num1的变化
    func_inner(2)
    print(num1)

    return func_inner   # 将内部函数作为返回值返回


func_out(1)   # 函数对象是func_out   函数调用是func_out()

运行结果 》》》
1
12
1

闭包中让外部变量可以修改

def func_out(num1):

    def func_inner(num2):     # 函数嵌套
        # 告诉解释器，此处使用的是外部变量num1
        nonlocal num1
        # 这里的本意是要修改外部变量num1的值，实际上是重新进行了赋值
        num1 = 10
        result = num1 + num2  # 外层参数调用
        print(result)

    print(num1)
    func_inner(2)
    print(num1)

    return func_inner   # 将内部函数作为返回值返回


func_out(1)   # 函数对象是func_out   函数调用是func_out()
运行结果 》》》
1
12
10

---

装饰器

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

• 如果修改的函数多，修改起来会比较麻烦
• 不方便后期的维护
• 这样做会违反开闭原则(ocp)
  • 程序的设计，要求开发对程序的扩展，要关闭对程序的修改

def add(a, b):
    return a + b


def fun_out(fn, *args, **kwargs):

    def fun_inner():
        print('函数开始执行')
        r = fn(*args, **kwargs)
        print(r)
        print('函数执行完毕')

    return fun_inner


f = fun_out(add, 1, 2)  
f()
运行结果 》》》
函数开始执行
3
函数执行完毕

装饰器的使用

通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
在开发中，我们都是通过装饰器来扩展函数的功能的

# 通用装饰器
def fun_out(fn, *args, **kwargs):

    def fun_inner(*args, **kwargs):
        print('函数开始执行')
        r = fn(*args, **kwargs)
        print(r)
        print('函数执行完毕')

    return fun_inner


# 需要被装饰的函数
@fun_out            # 等价于 f=fun_out(fun)
def add(a, b):
    return a + b

add(1, 2)
运行结果 》》》
函数开始执行
3
函数执行完毕

---

作业

1. 请使用装饰器实现已存在的函数的执行所花费的时间。
   • time模块

import time

def  func_out(fn,*argas,**kwargas):
    def fun_inner(*args, **kwargs):
        print('函数开始执行')
        a = time.time()
        r = fn(*args, **kwargs)
        print(r)
        b = time.time()
        c = round((b-a),3)
        print('函数执行完毕,用时%s',c)
    return fun_inner

@func_out
def fun(a):
    list = []
    for i in range(a):
        if i % 10 == 0:
            list.append(i)
    return list

fun(100000)
运行结果 》》》
函数开始执行
[0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000, 12000, 13000, 14000, 15000, 16000, 17000, 18000, 19000, 20000, 21000, 22000, 23000, 24000, 25000, 26000, 27000, 28000, 29000, 30000, 31000, 32000, 33000, 34000, 35000, 36000, 37000, 38000, 39000, 40000, 41000, 42000, 43000, 44000, 45000, 46000, 47000, 48000, 49000, 50000, 51000, 52000, 53000, 54000, 55000, 56000, 57000, 58000, 59000, 60000, 61000, 62000, 63000, 64000, 65000, 66000, 67000, 68000, 69000, 70000, 71000, 72000, 73000, 74000, 75000, 76000, 77000, 78000, 79000, 80000, 81000, 82000, 83000, 84000, 85000, 86000, 87000, 88000, 89000, 90000, 91000, 92000, 93000, 94000, 95000, 96000, 97000, 98000, 99000]
函数执行完毕,用时%s 0.005