2020-10-11

我的博客第10篇

1.高阶函数
。接收函数作为参数
。或者将函数作为返回值返回的函数就是高阶函数
对比练习：

#需求：将一个指定列表中的偶数，保存到一个新的列表中返回
list1 = [1,2,3,4,5,6,7,8,9,10]
def fn(list1):
    new_list = []
    for i in list1:
        if i % 2 == 0:
            new_list.append(i)
    return new_list
r = fn(list1)
print(r)
#结果
[2, 4, 6, 8, 10]

高阶函数练习

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

def fn(fun,list1):
    new_list = []
    for i in list1:
        if fun(i):
            new_list.append(i)
    return new_list

r = fn(fn1,list1)
print(r)
#结果
[2, 4, 6, 8, 10]

2.匿名函数
。lambda函数 （无名函数）
。语法：lambda 参数列表：表达式

def fn (a,b):
    return a + b
r = fn(1,2)
print(r)
#结果
3
print((lambda a, b: a + b)(1,2))

fn1 = lambda a, b: a + b
print(fn(1,2))

fn2 = lambda a, b: a + b
r = fn2(1,2)
print(r)
#结果全部为：
3

filter（）过滤列表的
。第一个参数：函数
。第二个参数：序列

#filter()  
#1.传递一个函数进去
#2.需要被过滤的序列（列表）
list1 = [1,2,3,4,5,6,7,8,9,10]
def fn1(i):
    if i % 2 == 0:
        return True
print(list(filter(fn1,list1)))
#结果
[2, 4, 6, 8, 10]

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

#闭包的作用：
#闭包可以保存外部函数的变量，不会随着外部函数调用完而销毁

#注意点：
#由于闭包引用了外部函数的变量（参数），则外部函数的变量没有及时释放，消耗内存

def fun_out(num1):
    def fun_inner(num2):
        r = num1 + num2   #闭包的特性，num1并没有被销毁 “num1”是外层函数的临时变量，而在内层函数使用到了 “num1 + num2”
        print(r)
    return fun_inner         #将内部函数作为返回值返回
r = fun_out(1)
r(2)
r(3)
#结果
3
4

4.装饰器
。我们可以直接通过修改函数中的代码来完成需求，但是会产生以下一些问题
。如果修改的函数多，修改起来会比较麻烦
。不方便后期的维护
。这样做会违反开闭原则（ocp）
**.**程序的设计要求开发对程序的扩展，要关闭对程序的修改
。装饰器是一个另类的闭包

#无参数的装饰，起到一个装饰的作用：严格来说不是真正的装饰器
def add(a,b):
    return a + b
def fn1():
    print('我是fn1')
def fn():       #装饰器
    print('函数开始执行')
    fn1()							#装饰fn1  给它添加一些功能
    print('函数执行结束')
fn()

#有参数的装饰
def add(a,b):
    return a + b
def fn1():
    print('我是fn1')
def fn(a,b):           #这段代码 用来装饰 函数add
    print('函数开始执行')
    r = add(a,b)
    print('函数执行结束')
    return r
r = fn(1,2)
print(r)
#结果
函数开始执行
函数执行结束
3

5.装饰器的使用
。通用装饰器
。装饰器的语法糖写法
@fn

def fn(fun):
    def new_fun(*args,**kwargs):
        print('函数开始执行')
        r = fun(*args,**kwargs)
        print('函数执行结束')
        return r
    return new_fun

#通用装饰器
def fn(fun):
    def new_fun(*args,**kwargs):
        print('函数开始执行')
        r = fun(*args,**kwargs)
        print('函数执行结束')
        return r
    return new_fun

def fn1():
    print('我是fn1')

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

@fn
def speak():
    print('同学们好好学习啊！！')
speak()             #调用
#结果
函数开始执行
同学们好好学习啊！！
函数执行结束
#装饰器的语法糖写法
#@fn 等价于 speak = fn(speak)

#r = fn(fn1)
#r()

6.推导式
列表推导式：
。语法：[表达式 for 变量 in 旧列表 if 条件]

#列表推导式
#旧的列表 ------>新的列表
#语法：[表达式 for 变量 in 旧列表 if 条件]
#找到长度大于3的名字
list1 = ['cheney','jerry','amy','anny','tony','james','wolf','居然','豆腐']

r = [name for name in list1 if len(name) > 3 ]
print(r)
#结果
['cheney', 'jerry', 'anny', 'tony', 'james', 'wolf']

7.生成器
。第一种方式：推导式得到
。gen = (表达式 for 变量 in 旧列表 if 条件)
。第二种方式: 函数方式得到 通过yield关键字

def fn():
    print('fn执行了')
    i = 1
    while True:
        yield i
        i += 1

r = fn()

print(next(r))
print(next(r))
print(next(r))

作业

1.请使用装饰器实现已存在的函数的执行所花费的时间。
方式1：

import functools
import time

def fn(fun):
    @functools.wraps(fun)
    def new_fun(*args, **kwargs):
        start = time.time()
        r = fun(*args, **kwargs)
        print('%s 运行了 %f 秒' % (fun.__name__, time.time() - start))
        return r

    return new_fun
   

#测试
@fn
def test(n):
    time.sleep(n)
    print("运行结束")

test(5)

方式2：

import time
def get_time(fn):
    def get_inner():   #内部
        begin = time.time()
        fn()
        end = time.time()
        print('函数执行时间为%s' % (end - begin))
    return get_inner         

@get_time
def fn1():
    for i in range(10000):
        print(i)
fn1()