11 递归函数、闭包、装饰器

1.递归函数

# 递归函数： 自己调用自己
# 特性：
# 1.必须要有一个明确的结束条件
# 2.相邻两次重复之间有紧密的关系

# 阶乘的运算、斐波那契数列

# 1.计算累积和
def funa(n):
    s = 0
    for i in range(1, n+1):
        s += i
    print(s)

# funa(4)

# 使用递归函数  求1+2+3
# RecursionError: maximum recursion depth exceeded  递归超过了最大的深度
def funb(m):  # m=3
    if m == 1:
        return 1  # 给了结束的条件
    else:
        return m + funb(m-1) # 3 + funb(2) ----  3+2+funb(1) --- 3+2+1
        # funb(1)的结果是1
        # 每调用一次本身，就相当于复制一份这个函数，只不过是参数有变化

# print(funb(3))

# 斐波那契数列：从第三项开始，每一项都是等于前两项之和

# 1、1、2、3、5、8、13、21、34
def func(n):
    if n <= 1:
        return n
    else:
    # 第三个数的结果是前两个数的和,    当前数字：n    前一个数n-1   前两个数n-2
        return func(n-1) + func(n-2)

print(func(3))

# 遍历取值
# for i in range(1,9):
#     print(func(i))

2.闭包

# 条件
# 1.函数中嵌套了一个函数
# 2.内层函数对外层函数的作用域有一个非全局变量的引用
# 3.外层函数的返回值是内层函数的函数名  # 注意

# 举例一
# def outer(m):  # 外层函数
#     n = 10  # 局部变量
#     def inner():  # 内层函数
#         # 在内函数中，用到了外函数的变量
#         print(m+n)
#     # 外函数的返回值是内函数的引用
#     return inner
#
# # 第一种写法  函数调用：函数名()
# ot = outer(2)  # m = 2, 返回的是inner，inner是函数名
# # ot存了外函数的返回值，也就是inner的引用，相当于执行inner函数
# ot()
# 第二种写法
# outer(2)()

# 举例二
def outer(m):
    print('外层函数中的值：', m)
    def inner(n):
        print('内层函数中的值：', n)
        return m + n
    return inner

# 给外层函数中m传值, ot中保存的是inner的引用， ot()就是调用inner函数
ot = outer(10)
# 这里的20是给参数n, 也就是内层函数中的参数
print(ot(20))

# print(outer(100)(200))


# 1.闭包
# def funa():
#     a = 1
#     def funb():
#         b = 2
#         print(a + b)
#     return funb  # 返回的是内层函数的引用
#
#
# a1 = funa()
# a1()

# 2.函数引用
# def test1():
#     print(456)
# 调用函数
# test1()

# 引用函数
# res = test1  # 把引用保存另外一个变量中

# 通过引用调用该函数
# res()

3.装饰器

# 3.装饰器
# 举例一：
# def check(fn):
#     def inner():
#         print('这是增加的功能')
#         fn()
#     return inner


# def test():  # 被装饰的函数，需要给test加功能
#     print(123)

# 第一种方法
# ck = check(test)  # ck返回的是inner函数的引用
# ck()
# 或 check(test)()

# 第二种方法
# 语法糖  写法：@函数名
# @check   # @check 等价于 ck = check(test)
# def test():  # 被装饰的函数，需要给test加功能
#     print(123)
#
# test()

# 举例二：被装饰的函数无参数
# def funa(fa):  # fa参数代表被装饰函数
#     print('这是funa')
#     def inner():
#         fa()    # 调用被装饰函数
#         print('这是inner')
#     return inner     # 装饰器返回值是一个函数引用
#
# @funa
# def test2():   # 被装饰函数
#     print('这是test2')
#
# test2()

# 举例三：被装饰的函数有参数
# def eaxm(fn):
#     def inner(*args, **kwargs):  # 如果被装饰的函数有参数，inner中也要有
#         print('这是inner')
#         fn(*args, **kwargs)
#     return inner
#
# @eaxm
# def test3(a, b):  # 被装饰的函数
#     print('结果是：', (a + b))
#
# test3(1, 2)

# 举例四：多个装饰器
# 第一个装饰器
# def mk1(fn):
#     def inner():
#         return '哈' + fn() + '哈'
#     return inner
#
# # 第二个装饰器
# def mk2(fn):
#     def inner():
#         return '嘻' + fn() + '嘻'
#     return inner
#
# @mk1
# def test1():     # 被装饰函数1
#     return 'hello'
# # print(test1())
# @mk2
# def test2():    # 被装饰函数2
#     return 'jiuge'
# # print(test2())
#
# @mk1  # 哈嘻python嘻哈
# @mk2  # 嘻python嘻
# def test3():    # 被装饰函数3  ， 多个装饰器，由内到外的装饰; 先模mk2再mk1
#     return 'python'
#
# print(test3())