冒泡排序、递归和简单装饰器

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

def f1():
return "F1"
# f1 = 函数
#f1 =>代指函数
# f1() => 执行函数
def f2 (arg):
arg()
return "F2"


# x = 123
#f1 = f1 函数
#f2 = f2 函数

#f2(x）
#执行f2函数，f1 函数当参数

f2(f1)

冒泡排序：

1.算法描述：
（1）共循环 n-1 次
（2）每次循环中，如果 前面的数大于后面的数，就交换
（3）设置一个标签，如果上次没有交换，就说明这个是已经好了的。

示例：

例1：
li = [23,76,99,22,85,53,86,3,25,565,74]
法一
for k in range(1,len(li)):
    for i in range(len(li)-k):

        if li[i] > li[i + 1]:
            temp = li[i]
            li[i] =li[i + 1]
            li[i + 1] = temp
print(li)

法二：
for k in range(1,len(li)):
    for i in range(len(li)-k):

        if li[i] > li[i + 1]:
            temp = li[i]
            li[i] = li[i + 1]
            li[i + 1] = temp
print(li)


例2：
k = [1,2,3,6,5,4]
for i in range(len(k)):
    for j in range(i):
        if k[j] > k[j + 1]:
            k[j], k[j + 1] = k[j + 1], k[j]
print(k)

递归

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

示例：

def f4(a1,a2):
    if a1 > 100:
        return
    print(a1)
    a3 = a1 + a2
    f4(a2,a3)

f4(0,1)

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

def k(a,b,n):
    print(a)
    if n == 10:
        return a
    c = a + b
    a = k(b,c,n + 1)
    return a
k(0,1,1)
运算结果：

0
1
1
2
3
5
8
13
21
34

装饰器

装饰器就是把函数的名字传入进去, 在执行函数之前, 进行一些提前的处理.
装饰器本身就是一个函数, 将所装饰的函数, 作为一个参数传进来,
然后在执行这个函数之前, 进行一个处理,这就是装饰器. 所以和正常函数执行顺序是一样的..

一个装饰器：

#有参数的装饰器
def outer(func):
    def inner(a1,a2):
        print("1234")
        # ret = func(a1,a2)
        print("456")
        ret = func(a1,a2) #执行index函数
        return ret
    return inner


@outer
def index(a1,a2):
    print("非常复杂")
    return a1 + a2

#只要函数应用装饰器，那么函数就被重新定义，重新定义为：装饰器的内层函数
index(1,2)

#万能的装逼器

  
def outer(func):
    def inner(*arg,**kwargs):
        print("1234")
        # ret = func(a1,a2)
        print("456")
        ret = func(*arg,**kwargs) #执行index函数
        return ret
    return inner


@outer
# @outer
# 1、执行outer函数，将index作为参数传递
# 2、将outer的返回值，重新赋值给index

def index(a1,a2):
    print("非常复杂")
    return a1 + a2

#只要函数应用装饰器，那么函数就被重新定义，重新定义为：装饰器的内层函数
index(1,2,)

多个装饰器：

    #两个装饰器
    
    
def outer_0(func):
    def inner(*arg,**kwargs):
        print("3.5")
        ret = func(*arg,**kwargs)
        return ret
    return inner

def outer(func):
    def inner(*arg,**kwargs):
        print("1234")
        # ret = func(a1,a2)
        print("456")
        ret = func(*arg,**kwargs) #执行index函数
        return ret
    return inner

@outer_0
@outer
def index(a1,a2):
    print("非常复杂")
    return a1 + a2

#只要函数应用装饰器，那么函数就被重新定义，重新定义为：装饰器的内层函数
index(1,2,)

@outer
def f1(a1,a2,a3):
    print("f1")
    return f1

f1(6,7,8)