python装饰器+递归+冒泡排序

冒泡排序

li = [33, 2, 10, 1,23,23523,5123,4123,1,2,0]
for k in range(1,len(li)):
    for i in range(len(li) - k):#当这个for执行完时，最大值被放在了最后一个，所以下次判断时就可以不
        if li[i] > li[i + 1]: #比较最后一个，所以在这里range的循环就应该少一次，所以k就加一，为了完成
            temp = li[i]  #所有的数的比较，所以再建立一个for循环，把k作为变量，循环的范围是1到len（li）
            li[i] = li[i + 1]
            li[i + 1] = temp

print(li)

递归

斐波纳挈数列

    def f4(a1,a2)
        if a1>10000:
            return
        print(a1)
        #a1 = 0,a2 = 1,a3 = 1
        #a1 = 1,a2 = 1,a3 = 2
        a3 = a1 + a2
        f4(a2,a3)

    f4(0,1)

第十个斐波纳挈数

    def f1(taller,a1,a2):
        if taller == 10:
            return a1
        a3 = a1 + a2
        r = f1(taller + 1,a2,a3)
        return r

    feo = f1(1,0,1)
    print(feo)

装饰器

    def outer(func):
        def inner():
            print("hello")
            print("hello")
            print("hello")
            r = func()
            print("end")
            print("end")
            print("end")
            return r
        return inner

    #1、执行outer函数，并且将其下面的的函数名，当作参数
    #2、将outer的返回值重新赋值给f1（f1 = outer的返回值）
    #新f1函数 = inner    执行f1就相当于执行inner（）
    @outer
    def f1():
        print("F1")

    def f2():
        print("F2")

    def f3():
        print("F3")

    def f4():
        print("F4")

    f1()
    f2()
    f3()
    f4()

结果:
　　hello
　　hello
　　hello
　　F1
　　end
　　end
　　end
　　F2
　　F3
　　F4

如果有两个函数名一样的函数，在执行这个函数时，会执行下面那个函数，因为python解释器是从上往下
把代码（函数）放入内存的，所以，同样的函数名会指向最后一个函数。

装饰器的本质是将原函数封装到另一个函数里面，让装饰器里面的函数等于新函数（f1）

    def outer(func):
        def inner():
            print("hello")
            print("hello")
            print("hello")
            r = func()
            print("end")
            print("end")
            print("end")
            return r
        return inner

    #首先，@outer的意思是让它下面的函数当作装饰器的参数，让装饰器函数的返回值等于f1，而装饰器的返回值为
    #inner函数，所以执行f1()函数就是执行inner()    函数，再把inner的返回值赋给f1
    #@outer相当于f1 = outer(f1)

    @outer
    def f1():
        print("F1")    

    f1()

1、定义装饰器，函数

2、应用装饰器

只要函数应用装饰器，那么函数就被重新定义，重新定义为：装饰器的内层函数

带有参数的装饰器

    def outer(func):
        def inner(a1,a2):
            print("hello")
            print("hello")
            print("hello")
            r = func(a1,a2)
            print("end")
            print("end")
            print("end")
            return r
        return inner

    @outer
    def f1(a1,a2):
        print(a1+a2)

接收任意参数的装饰器

    def outer(func):
        def inner(*a1,**a2):#这里的*a1可以接收多个参数
            print("hello")
            print("hello")
            print("hello")
            r = func(*a1,**a2)#这里的*a1，**a1可以接收多个参数，在执行函数是会自动把相应位置的参数传给他
            print("end")  #a1=>*a1=>*a1=>a1,a2=>*a1=>*a1=>a2,python有自带优化机制
            print("end")
            print("end")
            return r
        return inner

    @outer
    def f0(a1):
        print(a1)

    @outer
    def f1(a1, a2):
        print(a1 + a2)

    @outer
    def f2(a1, a2, a3):
        print(a1 + a2 + a3)

    @outer
    def f3(a1, a2, a3, a4):
        print(a1 + a2 + a3 + a4)

    @outer
    def f4(a1, a2, a3, a4, a5):
        print(a1 + a2 + a3 + a4 + a5)

    f0(1)
    f1(1,2)
    f2(1,2,3)
    f3(1,2,3,4)
    f4(1,2,3,4,5)

*a1接受参数放到元组里
**a2接收字典类参数放到字典里

一个函数添加多个装饰器

    def outer(func):
        def inner(*a1,**a2):
            print("hello")                #@outer相当于f1 = outer(f1)
            r = func(*a1,**a2)
            print("end")
            return r
        return inner      

    def outer2(func):
        def inner(*a1,**a2):
            print("gg")
            r = func(*a1,**a2)
            return r
        return inner                    

    @outer2  #在上面的装饰器先输出
    @outer
    def f1(a1, a2):
        print(a1 + a2)

    f1(1,2)

#首先，把f1函数传到outer里面，outer里面的func代指f1函数，而f1函数就是outer函数的返回值，而outer函数的返回值为inner函数，所以执行f1函数，就是执行outer里的inner函数，而把@outer2放在@outer上面就是相当于给f1装饰的函数outer装饰一次，

outer2把outer函数当作func参数，而outer2的返回值为outer2的inner函数，当执行outer函数时，会执行outer2的inner函数，而inner函数中的func又执行了outer函数，而outer函数的返回值为outer函数的inner函数，在outer2里的inner函数里

执行func函数，就是执行了outer函数的返回值，就是执行了outer函数的inner函数，而outer函数里的inner函数有执行了f1函数，所以最后先输出最上面那个装饰器，然后是下面那个装饰器，这就是装饰器的原理

结果： gg
hello
3
end