Python基础之函数：3、多层语法糖、装饰器和装饰器修复技术及递归函数

目录

• 一、多层语法糖
  • 1、什么是多层语法糖：
  • 2、多层语法糖用法：
• 二、有参装饰器
  • 1、什么是有参装饰器：
  • 2、有参装饰器的作用：
• 三、装饰器修复技术
  • 1、什么是装饰器修复技术：
• 四、递归函数
  • 1、什么是递归函数：
  • 1、递归函数的作用：

一、多层语法糖

1、什么是多层语法糖：

​ 多层语法糖是指在单个源代码函数名上方添加了多个语法糖，使这段源代码函数体具备多个功能

2、多层语法糖用法：

​ 首先定义好装饰器功能，将需要添加功能的函数体代码放置在装饰器下方，将需要执行功能的装饰器语法糖按照执行的顺序防在原函数体函数名上方，多层语法糖加载顺序由下往上

• 代码用法：

def outter1(func1):
    print('加载了outter1')
    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)
        return res1
    return wrapper1

def outter2(func2):
    print('加载了outter2')
    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2
    return wrapper2

def outter3(func3):
    print('加载了outter3')
    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3
    return wrapper3

@outter1
@outter2
@outter3
def index():
    print('from index')

二、有参装饰器

1、什么是有参装饰器：

​ 有参装饰器是指在无参装饰器的基础的函数体外层再加上一层函数

2、有参装饰器的作用：

​ 当无参函数体内需要局部名称需要外部传参时，我们就可以再有参装饰器函数名后方参数内进行传参

• 有参装饰器模板：

def 有参装饰器(x,y,z):
    def outter(func):
        def wrapper(*args, **kwargs):
            res = func(*args, **kwargs)
            return res
        return wrapper
    return outter

@有参装饰器(1,y=2,z=3)
def 被装饰对象():
    pass

• 有参装饰器实战用法：

def auth(db_type):
    def deco(func):
        def wrapper(*args, **kwargs):
            name = input('your name>>>: ').strip()
            pwd = input('your password>>>: ').strip()

            if db_type == 'file':
                print('基于文件的验证')
                if name == 'egon' and pwd == '123':
                    res = func(*args, **kwargs)  # index(1,2)
                    return res
                else:
                    print('user or password error')
            elif db_type == 'mysql':
                print('基于mysql的验证')
            elif db_type == 'ldap':
                print('基于ldap的验证')
            else:
                print('不支持该db_type')
        return wrapper
    return deco

@auth(db_type='file')  # @deco # index=deco(index) # index=wrapper
def index(x, y):
    print('index->>%s:%s' % (x, y))

@auth(db_type='mysql')  # @deco # home=deco(home) # home=wrapper
def home(name):
    print('home->>%s' % name)

@auth(db_type='ldap')  # 账号密码的来源是ldap
def transfer():
    print('transfer')

# index(1, 2)
# home('egon')
# transfer()

三、装饰器修复技术

1、什么是装饰器修复技术：

​ 装饰器修复技术是指，虽然我们再使用装饰器时，可以通过不改变源代码的调用方式和代码能够执行了新的功能，但我们调用的源代码函数名地址的用法并不是源代码的地址，这时我们就可以通过使用装饰件修复技术使调用的源文件地址和用法和源文件相同

• 代码表现

1.首先全局中调用装饰器修饰模块
	from functools import wraps
2.再闭包函数或装饰器代码提中调用
	@warps 需要修复的函数名

• 实战用法

from functools import wraps

def outer(func_name):
    @wraps(func_name)
    def inner(*args, **kwargs):
        res = func_name(*args, **kwargs)
        return res

    return inner

@outer
def func():
    print('我是func函数体代码')

func()
print(func)
help(func)
--------------------------------------------------------------------------
我是func函数体代码
<function func at 0x00000217883988B0>
Help on function func in module __main__:

func()

四、递归函数

1、什么是递归函数：

​ 1.函数体代码内部调用自己本身函数名

​ 2.两个函数体代码内部相互调用对方函数名

​ 3.每一次调用能得出一个新的数据值，并且明确了结束时间

注意事项：

​ 1.在递归函数未明确结束条件时，代码会进入死循环，这时会触发python保护机制，这段代码最多可运行1000次左右

• 代码表现

1.直接调用自己本身
    count = 0

    def func():
        global count
        count += 1
        print(count)
        return func()

    func()

2.间接调用:
    count = 0

    def func():
        global count
        count += 1
        print(count)
        return func1()

    def func1():
        print(count)
        return func()

	func()

1、递归函数的作用：

​ 1.是一种计算过程，可以通过递归函数进行数学运算

• 实战用法

'''
问：
    小明第一天做了20个俯卧撑
    以后每增加一天就会多做1个
求：
    小米第100做多少个俯卧撑
'''

def func(n):
    if n == 100:
        return 20
    return func(n + 1)+1

res = func(1)
print(res)
--------------------------------------------------------------------------
119