装饰器补充-生成器-函数递归

目录:

一.  上节课补充

二.  yield表达式

三.  三元表达式

四.  生成器

五.  函数的递归

 

 

 

一.  上节课补充

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

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 dog(name):
    print('道哥%s准备吃东西了...' % name)
    while True:
        # x拿到的是yield接收到的值
        x = yield  # x = '一根骨头'
        print('道哥%s吃了 %s' % (name, x))


g = dog('alex')

g.send(None)  # 等同于next(g)，先完成初始化

g.send('一根骨头')
# g.send('一根骨头','肉包子')    # 不能传2个值，会报错：TypeError: send() takes exactly one argument (2 given)
g.send(['一根骨头','肉包子'])    # 可以放到列表里传输，列表算是一个值
g.send('肉包子')
g.send('一桶泔水')
# g.close()
# g.send('1111') # 关闭之后无法传值

2. 综合应用

def dog(name):
    food_list = []
    print('大哥%s准备吃东西了...' % name)
    while True:
        # x拿到的是yield接收到的值
        # x = yield 111 # x = ['一根骨头','肉包子']
        x = yield food_list # x = ['一根骨头','肉包子']
        print('大哥%s抽了 %s' % (name, x))
        food_list.append(x)


g = dog('egon')

res = g.send(None)  # 等同于next(g)，先完成初始化
print(res)

res = g.send(['一个鞭炮','一根烟'])
print(res)

res = g.send('一个地雷')
print(res)

def func():
    print('start...')
    x = yield 111
    print('H哈哈')
    print('H哈哈')
    print('H哈哈')
    yield 222

g = func()
res = next(g)
print(res)

res = g.send('xxxx')
print(res)

三.  三元表达式

1. 普通的表达式

def func(x,y):
    if x > y:
        return x
    else:
        return y

res = func(1,2)
print(res)

2. 三元表达式

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

x = 1
y = 2

res = x if x > y else y
print(res)



Jack = 18
Mack = 80

res = 'Jack是孙子' if Jack < mack else 'mack是爷爷'
print(res)

四.  生成器

1. 列表生成式

原代码：

l = ['alex_dsb','lxx_dsb','wxx_dsb','xxq','egon_dsb']
new_l = []
for name in l:
    if name.endswith('dsb'):
        new_l.append(name)

改进后：

l = ['egon_is_sb','egon_is_dsb','egon_is_superdsb','xxq','egon_dsb']

new_l = [name for name in l]  # 最基础的列表生成式
new_l = [name for name in l if name.endswith('sb')]

print(new_l)

把所有小写字母变成大写

l = ['egon_is_sb','egon_is_dsb','egon_is_superdsb','xxq','egon_dsb']
new_l = [name.upper() for name in l ]
print(new_l)

去掉所有名字的_sb后缀

l = ['egon_is_sb','egon_is_sb','egon_is_superd_sb','xxq','egon_sb']

new_l = [name.replace('_sb','') for name in l]
print(new_l)

2. 字典生成式

keys = ['name','age','gender']

dic = {key:None for key in keys}
print(dic)
items = [('name','egon'),('age',18),('gender','male')]

dict = {k:v for k,v in items if k!='gender'}
print(dict)

3. 集合生成式

keys = ['name','age','gender']
set1 = {key for key in keys}
print(set1,type(set1))

4. 元组生成式（没有元组生成式）

g = (i for i in range(10) if i > 3)
print(g,type(g))

# 输出：<generator object <genexpr> at 0x01D63450> <class 'generator'>

5. 生成器表达式

g = (i for i in range(10) if i > 3)
# ！！！！！！！强调！！！！！！！
# 此时g的内部，一个值都没有
# 只有next的时候，才会产生一个值

print(g)
print(next(g))
print(next(g))
print(next(g))
print(next(g))

方式一：

with open(r'内容.txt',mode='rt',encoding='UTF-8') as f:
    res = 0
    for line in f:
        res += len(line)
    print(res)

方式二：

with open(r'内容.txt',mode='rt',encoding='UTF-8') as f:

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

方式三：效率高

with open(r'内容.txt', mode='rt', encoding='UTF-8') as f:
    # g = (len(line) for line in f)
    # print(g)
    # res = sum(g)
    # print(res)
    # res = sum((len(line) for line in f))
    # 上述可以简写为如下格式
    res = sum(len(line) for line in f)
    print(res)

五.  函数的递归

1. 递归的定义

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

具体是指：在调用一个函数的过程当中，又直接或者间接地调用到了本身

Python对递归调用循环调用的次数有限制，为1000次

1)调用的例子：

直接调用本身

def f1():
    print('是我')
    f1()

f1()

间接调用本身

def f1():
    print('我是f1')
    f2()

def f2():
    print('我是f12')
    f1()

f1()

2)一段代码的循环运行方案有2种

方式1：while、for循环

while True:
    print(111)
    print(222)
    print(333)

方式2：while、for循环

def f1():递归的本质，就是循环
    print(111)
    print(222)
    print(333)
    f1()

f1

2. 需要强调的一点是：

Python没有尾递归优化（了解）

递归调用不应该无限地调用下去，必须在满足某种条件下，结束递归

n = 0
while n < 10:
    print(n)
    n += 1
def func(n):
    if n == 10:
        return
    print(n)
    n += 1
    func(n)

func(0)

3. 递归的2个阶段

1.回溯：一层一层调用下去

2.递推：满足某种结束条件，结束递归调用，然后一层一层返回

# age(5) = age(4) + 10
# age(4) = age(3) + 10
# age(3) = age(2) + 10
# age(2) = age(1) + 10
# age(1) = 18
def age(n):
    if n == 1:
        return 18

    return age(n-1) + 10

res = age(5)
print(res)

4. 递归的应用

l = [1, 2, [3, [4, [5, [6, [7, [8, [9, 10, 11]]]]]]]]
# l = [1,2,[3,4]]
def f1(list1):
    for x in list1:
        if type(x) is list:
            # 如果是列表，应该再循环、再判断，即 重新运行本身的代码
            f1(x)
            # for a in x:
            #     if type(a) is list:
            #         pass
            #     else:
            #         print(a)
        else:
            print(x)

f1(l)