欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

第十讲---函数下

程序员文章站 2022-05-28 13:29:28
...

1. 高阶函数

# @Time : 2020/8/12 14:29
# @Author : PanHui
# @File : 高阶函数.py
# 高阶函数
# 特点一 接收一个或多个函数作为参数
# 特点二 将函数作为返回值代码
# 当我们使用一个函数作为参数的时候,实际上是将指定的代码传递了目标函数
# 需求:将一个指定列表中的偶数,保存到一个新的列表中返回
lst = [1,2,3,4,5,6,7,8,9,10]
# 定义一个函数用来检测任意数的偶数
def fn(lst):
    def fn2(i):
        if i % 2 ==0:
             return True
#定义一个函数用来检测大于5的数
    # def fn3(i):
    #     if i > 5:
    #         return True
    #     return False
    def fn4(i):
         if i % 3 == 0:
            return True
         return False
# def fn(f,lst):
    # 参数lst要进行筛选的列表
    # 创建一个新的列表
    new_lst = []
    # 对筛选的列表进行遍历
    for n in lst:
        # 判断n的奇偶
        if fn4(n):
            new_lst.append(n)
    return new_lst
print(fn(lst))

2.匿名函数

# @File : 匿名函数.py
# 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
def fn4(i):
    return i % 3 == 0
r = filter(lambda i : i % 3 == 0,lst)
print(list(r))
# print(list(filter(fn4,lst)))
# 匿名函数 lambda函数表达式
# lambda函数表达式就是专门用来创建一些简单的函数
# lambda 参数列表:返回值
# def fn5(a,b):
#     return a+b
# # print(fn5(1,2))
# fn6 = (lambda a,b : a + b)
# # print((lambda a,b : a + b)(50,60))
# print(fn6(5,6))

3.闭包

# @File : 闭包.py
# 特点二 将函数作为返回值也是高阶函数
# 通过闭包可以创建一些只有当前函数能够访问的变量,将一些私有数据藏到闭包中
def fn():
    a = 10
    # 在函数内部定义一个函数
    def fn2():
        print('我是fn2',a)
    # 将内部函数fn2作为返回值返回
    return fn2
# print(fn())
# r = fn()
# r()
# print(a) # NameError: name 'a' is not defined
# 形成闭包的条件
# 1.函数嵌套
# 2.将内部函数作为返回值返回
# 3.内部函数必须使用到外部函数的变量
# 求平均数 是指在一组数据中所有数据之和再除以这组数据的个数
# nums = [1,2,3,4,5,6]
# print(sum(nums)/len(nums))
def make_fn():
    nums2 = []
    # 定义一个函数来实现求平均数

    def fn1(n):
        nums2.append(n)

        return sum(nums2) / len(nums2)
    return fn1
# print(fn1(10))
# print(fn1(30))
m = make_fn()
print(m(10))
print(m(30))

4. 装饰器的引入

# @File : 装饰器的引入.py
# 我们可以通过修改函数中的代码来完成这个需求,但是会产生一些问题
# 问题一 如果要修改的函数过多,修改起来比较麻烦
# 问题二 不方便后期的维护
# 问题三 违反开闭原则(ocp) 程序的设计思想 要求开发对程序的扩展,要关闭对程序的修改
# 求任意两个数的和
def add(a,b):
    # print('函数开始计算')
    # print('函数计算结束')
    return a + b
# 求任意两个数的积
def mul(a,b):
    return a * b
# r = add(1,3)
# print(r)
# 希望在不修改原函数的前提下,来多函数扩展功能
def fn():
    print('我是fn函数')
# 创建一个新的函数来对原函数进行扩展
def fn2():
    print('函数开始执行.....')
    fn()
    print('函数执行结束.....')
# fn()
# fn2()

def new_add(a,b):
    print('函数开始执行.....')
    r = add(a,b)
    print('函数执行结束.....')
    return r
r = new_add(1,2)
print(r)

5. 装饰器的使用

# @File : 装饰器的使用.py
# 定义一个函数来对其他的函数进行扩展,是其他的函数可以在执行前打印开始执行,执行后打印执行结束

# start_end(old)这一类函数我们就称之为装饰器
# 通过装饰器,可以在不修改原来的函数的情况下来对函数进行扩展
# 在开发中,我们都是通过装饰器来扩展函数的功能
def fn():
    # 参数old 要扩展的函数对象
    print('我是fn函数')
def add(a,b):
    return a + b
def start_end(old):
    # 创建一个新的函数
    def new_function(*args,**kwargs):
        print('函数开始执行.....')
        r = old(*args,**kwargs)
        print('函数执行结束.....')
        return r

    # 返回函数
    return new_function
f = start_end(fn)
# r = f()
# print(r)
# f2 = start_end()
# print(f)
# print(f2)
@start_end
def speak():
    print('同学们好好复习!!!')
# speak()
@start_end
def listen():
    print('I love you')
listen()
相关标签: python