day14

                                        拓展：2个装饰器

def outer1(func):                                     #print('第1个装饰器')

    def inner1(*args,**kwargs):

      print('第2个装饰器的inner1')

    func()

    print('第一个装饰期的inner1end')

return inner1

def outer2(func):   

    def inner2(*args,**kwargs):

      print('第2个装饰器的inner2')                   #print('第2个装饰器')

      func()

      print('第2个装饰器的inner2end')                

return inner2

@outer1                             #fn = outer1(fn) = outer1(outer2.inner) = outer1.inner

@outer2                             #fn = outer2(fn) = outer2.ineer

def fn():

    print('执行')

fn()

 

                     带参装饰器

通常为被装饰的函数添加新功能，需要外界参数

1.outer参数固定为func

2.inner参数固定同被装饰的函数，也不能添加新参数

3.可借助函数的嵌套定义外层给内层传参

def wrap(info)

   def outer(func):

      def inner(*args,**kwargs):

          print('新：拓展的新功能，可能参数%s' % info)

          res = func(*args,**kwargs)

          return res

      return inner

    return outer

@wrap('外部参数')

def fn():

    pass

                  

             可迭代对象，迭代器对象

可迭代对象：可以通过方法得到迭代器对象，用_iter_()得到迭代器对象

迭代器对象：可以不用依赖索引取值的容器，用_next_()取值

缺点:只能从前往后依次取值

迭代器对象._iter_()得到自身

               

              

                                  for循环迭代器

 

# 直接用while True循环在迭代器对象中通过 __next__() 取值，终究会有取空的时候，取空再取值，报StopIteration异常
ls = [3, 1, 2, 3, 5]
iterator = ls.__iter__()
while True:
    try:
        print(iterator.__next__())
    except StopIteration:
        # print('取空了')
        break
        
#for循环就是对while取迭代器对象的封装        
for v in ls:
    print(v)
    
for v in ls.__iter__():  # 可迭代对象.__iter__() => 迭代器对象
    print(v)
    
iterator = ls.__iter__()    
for v in iterator:  # 迭代器对象.__iter__() => 自身
    print(v)
​
    
# for循环迭代器的工作原理：
# for v in obj: pass
# 1）获取obj.__iter__()的结果，就是得到要操作的 迭代器对象
# 2）迭代器对象通过__next__()方法进行取值，依次将当前循环的取值结果赋值给v
# 3）当取值抛异常，自动处理StopIteration异常结束取值循环

 

 

                       枚举对象

# 给可迭代器对象及迭代器对象添加迭代索引
s = 'abc'
for v in enumerate(s):
    print(v)  # (0 'a') | (1 'b') | (2 'c')

               生成器

# 生成器：自定义的迭代器对象
# -- 就是用函数语法来声明生成器，用yield关键字取代return关键字来返回值，参数没有多少变化

# 总结：有yield关键字的函数，函数名() 不是调用函数，而是生成得到 生成器对象，生成器对象就是迭代器对象，可以通过 __next__() 进行取值

# 执行流程:
def fn():
yield 1
yield 3
yield 5
obj = fn()
obj.__next__() # 从开始往下执行，遇到第一个yield停止，拿到yield的返回值
obj.__next__() # 从上一次停止的yield往下执行，在再遇到的yield时停止，拿到当前停止的yield的返回值
# ... # 以此类推，直到无法获得下一个yield，抛StopIteration异常

# 可以直接被for循环遍历
for v in fn():
print v