叠加多个装饰器的加载、运行分析

def deco1(func1): # func1的内存地址 =

def (*args,**):

print('运行==>deco1.')

res1=func1(*参数,**)

资源1

def deco2(func2): # func2的内存地址 =

def (*args,**):

print('运行==>deco2.')

res2=func2(*参数,**)

资源2

def deco3(x):

def (func3): # func3=被装饰对象的索引函数的内存地址

def (*args,**):

print('运行==>deco3..')

res3=func3(*参数,**)

资源3

# 加载顺序自下而上（明白）

@deco1#index=deco1(内存地址)===>index=内存地址

@deco2#index=deco2(内存地址)===>index=内存地址

@deco3(111) # ===>@===>index=(index) ===>index=的内存地址

定义索引（x，y）：

print('来自索引 %s:%s' %(x,y))

# 执行顺序是从上到下，即-》-》

索引(1,2) # (1,2)

产量表达式

一：

# def 狗(名字):

#print('刀哥%s可以吃饭了...' %name)

#虽然正确：

## x 获取yield收到的值

#x = 产量 # x = '肉包子'

#print('刀哥%s吃了%s' %(name,x))

# g=狗('亚历克斯')

# g.send(None) # 相当于 next(g)

# g.send(['一根骨头','aaa'])

# # g.send('肉包子')

# # g.send('一起畅饮')

# # g.close()

# # g.send('1111') # 关闭后无法传递值

＃ 二：

def 狗（名字）：

=[]

print('刀哥%s可以吃饭了...' %name)

而真实：

#x 获取yield收到的值

x = 产量 # x = '肉包子'

print('刀哥%s吃了%s' %(name,x))

.(x) # ['一根骨头','肉包子']

# g=狗('亚历克斯')

# res=g.send(None) # next(g)

# 打印(res)

# res=g.send('一根骨头')

# 打印(res)

# res=g.send('肉包子')

# 打印(res)

# # g.send('一起畅饮')

def 函数():

打印（'开始......'）

x=产量 1111 # x='xxxxx'

print('哈哈哈哈哈哈')

print('哈哈哈哈哈哈')

print('哈哈哈哈哈哈')

print('哈哈哈哈哈哈')

产量 22222

g=func()

res=下一个(g)

打印（解析）

res=g.send('xxxxx')

打印（解析）

三元表达式

针对以下需求

# def 函数(x,y):

#如果 x > y：

＃ X

＃别的：

# y

# res=func(1,2)

# 打印(res)

#三元表达式

# 语法格式： 条件成立时返回的值 if 条件 else 条件不成立时返回的值

x=1

y=2

# res=x 如果 x > y 否则 y

# 打印(res)

res= if 'egon' == 'egon' else

打印（解析）

# 应用实例

def 函数():

# 如果 1 > 3:

#x=1

＃别的：

#x=3

x = 1 如果 1 > 3 否则 3

生成式

1.列表生成公式

l = ['', '', '', "", 'egon']

# new_l=[]

# l 中的名称：

#if 名称。('dsb'):

#new_l.（名称）

# new_l=[l 中名称的名称 if name.('dsb')]

# new_l=[l 中名称的名称]

# 打印（new_l）

# 将所有小写字母转换为大写

# new_l=[name.upper() for name in l]

# 打印（new_l）

# 从所有名称中删除后缀 _dsb

# new_l=[name.('_dsb','') for name in l]

# 打印（new_l）

# 2. 字典生成

# 键=['姓名','年龄','']

# dic={key:None 用于键中的键}

# 打印（迪克）

# items=[('姓名','埃贡'),('年龄',18),('','男')]

# res={k:v for k,v in items if k != ''}

# 打印(res)

# 3.设置生成公式

# 键=['姓名','年龄','']

# set1={键为键中的键}

# 打印（集合1，类型（集合1））

# 4. 生成器表达式

# g=(i for i in range(10) if i > 3)

#！ ！ ！ ！ ！ ！ ！ ！ ！ ！ ！ 强调！ ！ ！ ！ ！ ！ ！ ！ ！ ！ ！ ！ ！ ！ ！

# 此时g内部没有值

# 打印（g，类型（g））

# 打印（g）

# 打印（下一个（g））

# 打印（下一个（g））

# 打印（下一个（g））

# 打印（下一个（g））

# 打印（下一个（g））

# 打印（下一个（g））

# 打印（下一个（g））

with open('notes.txt', mode='rt', ='utf-8') as f:

#方法一：

#res=0

# 对于 f 中的行：

#res+=len(行)

# 打印(res)

# 方法2：

# res=sum([len(line) for line in f])

# 打印(res)

# 方法三：最有效

# res = sum((len(line) for line in f))

# 上面可以简写如下

res = sum(len(line) 对于 f 中的行)

打印（解析）

函数递归

1：递归的定义

# 函数的递归调用：嵌套函数调用的一种特殊形式

# 具体指：

#在调用函数的过程中，直接或间接调用了自身

# 直接调用自身

# def f1():

#print('是我，我还是我')

#f1()

#f1()

# 间接调用自身

# def f1():

#print('====>f1')

#f2()

# def f2():

#print('====>f2')

#f1()

#f1()

# 循环一段代码有两种选择

# 方法一：while、for循环

# 当为真时：

#打印(1111)

#打印(2222)

#打印(3333)

# 方法二：递归的本质是循环：

# def f1():

#打印(1111)

#打印(2222)

#打印(3333)

#f1()

#f1()

#2：需要强调的一点是：

# 递归调用不应该无限期地调用。 当满足某些条件时，递归调用必须结束。

# n=0

# 当 n < 10 时：

#打印（n）

#n+=1

# def f1(n):

#如果 n == 10:

#

#打印（n）

#n+=1

#f1(n)

#f1(0)

# 三：两阶段递归

# ：逐层调用

# 递归：当满足一定的结束条件时，递归调用结束，然后逐层返回。

# 年龄(5) = 年龄(4) + 10

# 年龄(4) = 年龄(3) + 10

# 年龄(3) = 年龄(2) + 10

# 年龄(2) = 年龄(1) + 10

# 年龄(1) = 18

# def 年龄(n):

#如果 n == 1:

#18

# 年龄(n-1) + 10

# 资源=年龄(5)

# 打印（解析）

# 四：递归应用

l=[1,2,[3,[4,[5,[6,[7,[8,[9,10,11,[12,[13,]]]]]]]]]]]

def f1(列表1):

对于列表 1 中的 x：

如果 type(x) 是列表：

# 如果是列表，则应该再次循环判断，即重新运行自己的代码。

f1(x)

别的：

打印（x）

f1(l)