递归&冒泡&装饰器

• 递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

#lambda：
func = lambda x,y:9+x
参数：x,y
函数体:9+x
函数名:func

扩展：函数名可以当做参数传递 

函数名（）：执行函数

函数名：代指函数

def f1():
    return "F1"

#f1 ==>代指函数
#f1() ==>执行函数

示例：

def f3(arg):
    arg()

def x():
    print("xxx")

f3(x)
#打印结果：xxx

def f1():
    return "F1"

def f2(arg):
    arg()
    return "F2"

r = f2(f1)
print(r)
#打印结果:F2

# #f1 =>函数
# #f2 =>执行函数
# #f2(f1) =>执行f2函数，实际参数是f1函数

#斐波那契
def f(a1,a2):
if a1 > 100:
return
print(a1)
a3 = a1 + a2
f(a2,a3)
f(0,1)
#打印结果：
1
2
5
13
34
89

练习：写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。

def f(depth,a1,a2):
    if depth == 10:
        return a1
    a3 = a1 + a2
    r = f(depth+1,a2,a3)
    return r
ret = f(1,0,1)
print(ret)
#打印结果：34

冒泡排序：

    冒泡，原理是临近的数字两两进行比较，按照从小到大的顺序进行交换，这样交换一次之后，最大的数字就被交换到了最后一位。

    将列表中的数字按从小到大的顺序排列：

    然后再从头开始进行两两比较。

示例：

li = [33,2,10,1]
for j in range(1,len(li)):
    for i in range(len(li) - j):
        if li[i] > li[i + 1]:
            temp = li[i]
            li[i] = li[i + 1]
            li[i + 1] = temp
print(li)
#打印结果：[1, 2, 10, 33]

•  装饰器

    装饰器本质上是一个函数，该函数用来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能，装饰器的返回值也是一个函数对象。也就是说装饰器的作用就是为已经存在的对象添加额外的功能。 当使用@将装饰器附加到函数上时，就会调用此方法。

单层装饰器：

def outer(func):
    def inner():
        print("hello")
        r = func()
        print("end")
        return r
    return inner
@outer
def f1():
    print("F1")
f1()
#打印结果：
hello
F1
end


#1、执行outer函数，是将下面的函数名，当做outer函数的参数
#2、将outer的返回值重新赋值给f1，意思就是f1 = outer的返回值

双层装饰器：

注：对参数数量不确定的函数进行装饰，参数用（*args,**kwargs），自动适应参数数量。

和单层装饰器原理一样，只是在原有基础上又多了一个装饰器。示例：

def outer1(func):
    def inner(*args,**kwargs):
        print("123")
        ret = func(*args,**kwargs)
        print("123")
        return ret
    return inner
def outer2(func):
    def inner(*args,**kwargs):
        print("456")
        ret = func(*args,**kwargs)
        print("456")
        return ret
    return inner
@outer1
@outer2
def f():
    
    return "ok"

r = f()
print(r)

#打印结果：
123
456
456
123
ok

# 1、执行outer2函数，将f作为outer2函数的参数，将f赋值给func
# 2、得到返回值inner，重新赋值给f：f = inner  ==>  f() = inner()
# 3、执行outer1函数，将整个inner函数作为outer1函数的参数
# 4、得到返回值inner，再重新赋值给f：f == inner  ==> f() = inner()
# 5、因为装饰器只有两层，就不用再执行下一个装饰器函数，如果更多层就继续循环以上程序过程
# 6、下面就执行最终的inner函数，执行func函数时，就是执行最原始的f函数