python_005_匿名函数，闭包函数，递归函数

Posted 2022-05-10 t-a-n-g-124798

一.匿名函数

#匿名函数:帮助开发人员完成简单的业务处理逻辑
"""
语法
lambda 参数1, 参数2, 参数3...: 函数体
注意函数体内部代码只能存在一句表达式，如果该表达式计算之后有结果，此时该结果作为匿名函数的返回值返回给外界
"""

#fun1 = lambda x, y, **kwargs: max(x, y)
#num = fun1(1,2)
#print(num)

 

二.闭包函数

 

#闭包函数
"""
两个函数A，B，如果函数B在函数A内部定义，并且B作为函数A的返回值返回给外界，此时B称为A的闭包函数
闭包函数的作用：闭包函数可以延迟局部变量被系统回收的时间，保证变量可以根据用户的需求动态的使用
"""
import random
#函数A
def getRandomSum(min, max, num):
    list1 = [random.randint(min, max) for i in range(num)]
    print(list1)
    #函数B
    def getSum():
        print(list1)
        return sum(list1)

    return getSum

#调用函数A，此时函数A执行完之后会返回一个闭包函数B
fun1 = getRandomSum(10,50,5)
print(fun1())

 

三.递归函数

 

#递归函数
"""
递归函数的定义：
在函数A内部调用一个和函数A同名的函数，此时函数会根据内部代码的实现完成任务的逐层递交
注意：
1、递归函数首先完成的是任务测逐层递交，因此任务递减必须能够终止
2、其次任务执行会从最后一次开始，逐层向上执行，直到最外层调用结束
"""
#求5的阶乘
def jiecheng(n):
    if n == 1:
        return 1
    else:
        return n*jiecheng(n-1)

print(jiecheng(5))

 

四 回掉函数（先进再出）
"""
A,B两个函数，B函数作为A函数调用时的一个参数被传入到A函数内部，在A内部调用B函数，此时B函数称为A函数的回掉函数
回掉函数一般情况下会作为主函数A的一个条件传入，目的是对A函数产生的结果做出处理，从而实现对A函数功能的扩充
"""
# 定义A函数(完成对所有可迭代数据的遍历)
def mapList(data, fun):#fun是一个函数
    for item in data:
        fun(item)#调用函数

#回掉函数B（输出遍历得到的元素）
def outPut(num):
    print(num)

#定义回掉函数完成求列表数据的和
sum_num = 0
def sumNum(num):
    global sum_num
    sum_num += num

mapList(range(1, 10), outPut)#函数B相当于fun中的参数，在函数A中被调用
mapList(range(1,10), sumNum)#内部函数被外界调用，回掉函数完成求列表数据的和

print(sum_num)

五，装饰器
"""
装饰器的作用：在不改变原函数任何代码情况下对原函数功能进行升级
"""
# 定义函数完成对参与运算的数据类型的比对
import functools#functools 作用于函数的函数 functools 模块提供用于调整或扩展函数和其他可调用对象的工具
def adjust(fun):
    # 将被修饰函数的名字绑定给wrapper
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):#闭包（可变参数，命名关键字参数）
        kind = type(args[0])#类型判断
        or_common = True
        for item in args:
            if kind != type(item):
                or_common = False
                break
        if or_common:
            return fun(*args, **kwargs)
        else:
            print(‘数据类型不匹配，无法完成运算‘)
            return None
    return wrapper
"""
@adjust在修饰qiuhe函数时等价于
qiuhe = adjust(qiuhe)
#外部求和qiuhe==fun
#装饰器调用
#fun==wrapper==qiuhe

"""
@adjust
def qiuhe(num1, num2, num3):
    return num1+num2+num3

print(qiuhe.__name__)#求和的名字
# qiuhe = adjust(qiuhe)

@adjust
def qiucha(num1, num2):
    return num1-num2
@adjust
def qiuji(num1, num2):
    return num1*num2

print(qiuhe(10,"30", 30))

import functools
#带参数装饰器
def logs(log):
    def adjust(fun):
        print(log)
        @functools.wraps(fun)
        def wrapper(*args, **kwargs):
            kind = type(args[0])
            or_common = True
            for item in args:
                if kind != type(item):
                    or_common = False
                    break
            if or_common:
                return fun(*args, **kwargs)
            else:
                print(‘类型不匹配‘)
                return None
        return wrapper
    return adjust

@logs(‘当前运行的是第22行代码‘)
def qiuhe(*args):
    num_sum = 0
    for item in args:
        num_sum += item
    return num_sum
# 带参数的装饰器修饰函数时等价于
# qiuhe = logs(‘当前运行的是第22行代码‘)(qiuhe)
print(qiuhe(10,20,30,40))