冒泡排序
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