python装饰器功能是冒泡排序怎么做_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)

递归

斐波纳挈数列

deff4(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)

第十个斐波纳挈数

deff1(taller,a1,a2):

if taller == 10:

returna1

a3 = a1 +a2

r = f1(taller + 1,a2,a3)

returnr

feo = f1(1,0,1)

print(feo)

装饰器

defouter(func):

definner():

print("hello")

print("hello")

print("hello")

r =func()

print("end")

print("end")

print("end")

returnr

returninner

#1、执行outer函数，并且将其下面的的函数名，当作参数

#2、将outer的返回值重新赋值给f1(f1 = outer的返回值)

#新f1函数 = inner 执行f1就相当于执行inner()

@outer

deff1():

print("F1")

deff2():

print("F2")

deff3():

print("F3")

deff4():

print("F4")

f1()

f2()

f3()

f4()

结果:

hello

hello

hello

F1

end

end

end

F2

F3

F4

如果有两个函数名一样的函数，在执行这个函数时，会执行下面那个函数，因为python解释器是从上往下

把代码(函数)放入内存的，所以，同样的函数名会指向最后一个函数。

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

defouter(func):

definner():

print("hello")

print("hello")

print("hello")

r =func()

print("end")

print("end")

print("end")

returnr

returninner

#首先，@outer的意思是让它下面的函数当作装饰器的参数，让装饰器函数的返回值等于f1，而装饰器的返回值为

#inner函数，所以执行f1()函数就是执行inner() 函数，再把inner的返回值赋给f1

#@outer相当于f1 = outer(f1)

@outer

deff1():

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