day11 - 15（装饰器、生成器、迭代器、内置函数、推导式）

时间：2023-03-09 07:21:21
day11 - 15（装饰器、生成器、迭代器、内置函数、推导式）

day11:装饰器（装饰器形成、装饰器作用、@语法糖、原则、固定模式）

  1. 装饰器形成：最简单的、有返回值的、有一个参数的、万能参数

  2. 函数起的作用：装饰器用于在已经完成的函数前后增加功能
  3. 语法糖：使代码变得简单
  4. 原则：开放封闭原则，因为已经发布的源码不可以轻易修改，所以使用装饰器在原来的基础上增加功能呢个
  5. 固定模式、万能参数、有返回值
  6.  import time
    
 def timmer(func):
    
     def inner(*args,**kwargs):
    
         start = time.time()
    
         time.sleep(1)
    
         ret = func(*args,**kwargs)
    
         end = time.time() - start
    
         return ret,end
    
     return inner

 @timmer
    
 def func(i):
    
     print(i)
    
     return '***:%s' %i

 res = func('w')
    
 n,t = res
    
 print(n,t)

    固定模式　　

  7. 练习题
    1. 编写装饰器、为多个函加上认证功能() 
       FLAG = False
      
 def timmer(func):
      
     global FALG
      
     def inner (*args,**kwargs):
      
         start = time.time()
      
         if FLAG:
      
             res = func()
      
         else:
      
             res = '登录失败'
      
         return res
      
     return inner

 def Login():
      
     login_user = input('请输入账号：')
      
     login_pass = input('请输入密码：')
      
     with open('user.txt','r',encoding='utf-8') as f:
      
         for i in f:
      
             if 'login_user' in i:
      
                 user_name,user_pass = '|'.join(i)
      
                 break
      
             if login_user == user_name and login_pass == user_pass:
      
                 global FLAG
      
                 FLAG = True
      
             else:
      
                 print('登录失败')
      
                 continue

 @timmer
      
 def func(a,b):
      
     print(a,b)
      
     return '***:%s;***%s' %(a,b)

 while 1:
      
     command = input('请输入操作序号：]\n1:登录\n2:执行')
      
     if command == '':
      
         Logon()
      
     elif command == '':
      
         func()
      
     else:
      
         print('您的输入有误，请重新输入')
      
         continue

      第一题

    2. 编写装饰器，为多个函数加上记录调用功能，要求每次调用函数都将被调用的函数名称写入文件
    3. 编写下载网页内容的函数，要求功能是：用户传入一个url，函数返回下载页面的结果
    4. 为题目3编写装饰器，实现缓存网页内容的功能：

day12:装饰器的进阶（wraps模块、进阶）

  1. wraps模块
    1. 作用：当一个函数被装饰后，使用__name__ 和 __doc__查看函数相关信息时，会查看装饰器的相关信息，wraps的作用就是查看信息时查看的是被点用函数的相关信息
    2. 例子： 
       from functools import wraps

 def timmer(func):
      
     @wraps(func)
      
     def inner(*args,**kwargs):
      
         """这个是inner"""
      
         res = func(*args,**kwargs)
      
         return res
      
     return inner

 @timmer
      
 def func1(a,b):
      
     """这个是func1"""
      
     print(a,b)
      
     return '%s *** %s' % (a,b)

 print(func1.__name__)
      
 print(func1.__doc__)

      wraps例子

  2. 装饰器进阶
    1. 多个函数怎么同时决定是否使用装饰器 
       from functools import wraps
      
 FLAGE = True

 def timmer(flage):
      
     def wrapper(func):
      
         @wraps(func)
      
         def inner(*args,**kwargs):
      
             if flage:
      
                 print('装饰前被执行前做的事')
      
                 res = func(*args,**kwargs)
      
                 print('装饰器被执行后做的事')
      
                 return res
      
             else:
      
                 res = func(*args,**kwargs)
      
                 return res
      
         return inner
      
     return wrapper

 @timmer(FLAGE)
      
 def func1(a,b):
      
     print('执行了，收到了%s 和 %s' %(a,b))
      
     print(func1.__name__)
      
     return 'Ok'

 @timmer(FLAGE)
      
 def func2(a,b):
      
     print('执行了，收到了%s 和 %s' %(a,b))
      
     print(func2.__name__)
      
     return 'Ok'

 print(func1('董','轩'))
      
 print(func2('Python','蟒蛇'))

      多个函数同时装饰

    2. 一个函数被多个装饰器调用 
       def wrapper1(func):
      
     def inner(*args,**kwargs):
      
         print('wrapper1 start')
      
         res = func(*args,**kwargs)
      
         print(res)
      
         print('wrapper1 end')
      
         return res
      
     return inner

 def wrapper2(func):
      
     def inner(*args,**kwargs):
      
         print('wrapper2 start')
      
         res = func(*args,**kwargs)
      
         print(res)
      
         print('wrapper2 end')
      
         return res
      
     return inner

 def wrapper3(func):
      
     def inner(*args,**kwargs):
      
         print('wrapper3 start')
      
         res = func(*args,**kwargs)
      
         print(res)
      
         print('wrapper3 end')
      
         return res
      
     return inner

 @wrapper3
      
 @wrapper2
      
 @wrapper1

 def func():
      
     print(func.__name__)
      
     return 'Func执行完了'

 print(func())

      一个函数被多个装饰器调用

day13：（迭代器、生成器）

  1. 迭代器
    1. 从容其中一个一个取值，会把所有数据拿到
    2. 节省内存
    3. 迭代器协议和可迭代协议
    4. 可以被for循环的都是可迭代的
    5. 可迭代的内部都有__iter__方法
    6. 只要是迭代器，一定可以迭代
    7. 可迭代的.__iter__()就可以获取一个迭代器
    8. 迭代器中的__next__()方法可以一个一个的获取值
    9. 检验迭代器和可迭代的方法 
       from collections import Iterable
      
 from collections import Iterator
      
 print(isinstance([],Iterable))
      
 print(isinstance([],Iterator))

      检验方法

  2. 生成器
    1. 只要含有yield关键字的函数都是生成器函数
    2. yield不能和return共用且需要写在函数内
    3. 简单的一个生成器 
       def generator():
      
     print(1)
      
     yield 'a'

 # 取值
      
 ret = generator()
      
 print(ret.__next__())

      简单生成器

day14：（生成器函数进阶、表达式、各种推导式）

  1. 生成器进阶
    1. send：获取下一个值的效果和next基本一致，第一次不能用send
    2. 例子
      1. 获取平均值 
         def average():
        
     sum = 0
        
     count = 0
        
     avg = 0
        
     while True:
        
         num = yield avg
        
         sum += num    #
        
         count += 1    #
        
         avg = sum/count

 avg_g = average()
        
 print(avg_g.__next__())
        
 avg1 = avg_g.send(10)
        
 avg1 = avg_g.send(20)
        
 avg1 = avg_g.send(30)
        
 print(avg1)

        获取平均值

      2. 预激活生成器，就是使用装饰器，让send可以第一次使用 
         def init(func):   #装饰器
        
     def inner(*args, **kwargs):
        
         g = func(*args, **kwargs)    #g = average()
        
         g.__next__()
        
         return g
        
     return inner

 @init
        
 def average():
        
     sum = 0
        
     count = 0
        
     avg = 0
        
     while True:
        
         num = yield avg
        
         sum += num    #
        
         count += 1    #
        
         avg = sum/count

 avg_g = average()   #===> inner
        
 ret = avg_g.send(10)
        
 print(ret)
        
 ret = avg_g.send(20)
        
 print(ret)

        预激生成器的装饰器

      3. 小技巧 
         def generator():
        
     a = 'abcde'
        
     b = ''
        
     for i in a:
        
         yield i
        
     for i in b:
        
         yield i
        
 def generator():
        
     a = 'abcde'
        
     b = ''
        
     yield from a
        
     yield from b

 g = generator()
        
 for i in g:
        
     print(i)

        小技巧

  2. 生成器表达式 
    g = (i for i in range(10))
    
print(g)
    
for i in g:
    
    print(i)
  3. 各种推导式 
     # 列表：
    
     ret = [i*i for i in (1,2,3,4) if i%3 == 0]
    
         print(ret)
    
 例子：
    
 找到嵌套列表中名字含有两个‘e’的所有名字
    
 names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
    
          ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
    
 ret = [name for lst in names for name in lst if name.count('e') ==2]  # 列表
    
 ret = (name for lst in names for name in lst if name.count('e') ==2)　# 字典
    
 for i in ret:
    
     print(i)

 　　
    
 # 字典：
    
     mcase = {'a': 10, 'b': 34}
    
     mcase_frequency = {mcase[k]: k for k in mcase}
    
     print(mcase_frequency)

 #集合推导式，自带结果去重功能
    
 squared = {x**2 for x in [1, -1, 2]}
    
 print(squared)

    各种推导式

day15：（面试题、内置函数）

  1. 面试题 
    一、
    
def demo():
    
    for i in range(4):
    
        yield i

g=demo()

g1=(i for i in g)
    
g2=(i for i in g1)

print(list(g))
    
print(list(g1))
    
print(list(g2))

二、
    
def add(n,i):
    
    return n+i

def test():
    
    for i in range(5):
    
        yield i

g=test()
    
for n in [1,10,5]:
    
    g=(add(n,i) for i in g)

print(list(g))
  2. 内置函数：https://www.processon.com/view/link/5c35f503e4b0641c83d55651

相关文章