前引：
上节课思考：多个装饰器的加载和运行分析
def deco1(func1): #func1=warpper2
def wrapper1(*args,**kwargs):
print('正在运行===>deco1.wrapper1')
res1=func1(*args,**kwargs)
return res1
return wrapper1
def deco2(func2):#func2=warpper3
def wrapper2(*args,**kwargs):
print('正在运行===>deco2.wrapper2')
res2=func2(*args,**kwargs)
return res2
return wrapper2
def deco3(x):
def outter3(func3): #func3=index
def wrapper3(*args,**kwargs):
print('正在运行===>deco3.outter3.wrapper3')
res3=func3(*args,**kwargs)
return res3
return wrapper3
return outter3
@deco1
#@deco1 ==>warpper2=deco1(warpper2) ==>warpper2=warpper1
@deco2
#@deco2 ==>warpper3=deco2(warpper3) ==>warpper3=warpper2
@deco3(111)
#deco3(111)=outter3 @outter3==>index = outter3(index)==>index = warpper3
#装饰器的加载顺序，从下到上
#运行顺序，从上到下
def index(x,y):
print('from index %s:%s' %(x,y))
一、yield表达式
1 yield表达式基本用法
yield关键字只要出现在函数中，调用这个函数不会执行，会返回一个生成器（自定义迭代器），这里可以对yield传值，在函数内通过一个变量接受这个值
def func(name):
while True:
print(f"我是{name}")
x = yield
print(f"我爱吃{x}")
g = func("hz")
#给函数传参hz调用函数，此时发现函数内有yield关键字，挂起函数，函数调用的返回值是生成器
g.__next__()#执行迭代器功能查找下一个值，运行函数至yield处
g.send("水果")#给yield传值
#注意：这不是yield的返回值，返回值在函数定义的时候就写好了
g.send("巧克力")#给yield传值
>>>我是hz
>>>我爱吃水果
>>>我是hz
>>>我爱吃巧克力
>>>我是hz
二、三元表达式
三元表达式是一种代码简写的方式
语法格式：条件成立时运行的代码 if 条件 else 条件不成立时运行的代码
x= 1
y =2
if x > y :
print(x)
else:
print(y)
>>>2
print(x if x>y else y)
>>>2
print(x) if x>y else print(y)
>>>2
三、生成式
1 列表生成式
l = ["a","b","c2","adsa","z"]
#需求：把列表内长度大于1的值添加到新列表new_l中
#基础做法：
for i in l :
if len(i)>1:
new_l.append(i)
#列表生成式做法：
new_l = [i for i in l if len(i)>1]
2 字典生成式
d = {"a":1,"b":2,"c":3}
#生成一个新的字典，key是d中的所有key，value为none
#基础做法：
new_d = {}
for i in d:
new_d[i] = None
#字典生成式做法：
new_d = {key:None for key in d }
3 集合生成式
#生成一个含有数字1-9的集合
#基础做法：
set1 = set()
print(type(set1))
for i in range(1,10):
set1.add(i)
#集合生成式做法：
s ={i for i in range(1,10)}
4 生成器表达式
#生成一个生成器 g = (i for i in range(10) if i >3) #此刻g内部一个值都没
四、函数的递归
1 递归的定义
是函数嵌套的一种特殊形式
在调用一个函数的过程中间接或者直接调用了本身
#直接调用本身
def foo():
foo()
foo()
#间接调用本身
def f1():
f2()
def f2():
f1()
f1()
2 详解递归
如果我们执行了上述代码会发现pycharm在1000次左右递归后报错，因为递归本身是一种很危险的行为，如果我们对递归不做任何处理让他永久的调用下去会直接造成内存溢出。
#需求：生成一个含有1-10的列表
#for循环方式
l=[]
for i in range(1,11):
l.append(i)
#函数递归方式
def appen(n):
if n == 11:
return
else:
l.append(n)
n+=1
appen(n)
appen(1)
递归的两个阶段
回溯：一层一层调用下去
#运行递归函数的过程
def func ():
func()
func()
递推：满足某种结束条件，结束递归调用，然后一层一层返回
来源：https://www.cnblogs.com/hz2lxt/p/12566688.html