十二天

一、装饰器补充

1.1无参装饰器的用法：

  模板：
  def f1(func):
      def f2(*args,**kwargs)
        res = func(*args,**kwargs)   #这是被装饰的函数，可以在这层函数内为源代码添加新功能
        return res
      return f2

1.2装饰器语法糖：

  def outter(func):
      def wearrpe(*args,**kwargs):     #为原函数添加新功能，不修改函数源代码和调用方式
          name = input("请输入账号：")
          pwd = input("请输入密码：")
          if name == "hu" and pwd =="123":
              res = func(*args,**kwargs)
              return res
          else:
              print("账号密码不存在")
      return wearrpe()
  @outter              #这个步骤是相当于index = outter(index) 
  def index():        #这个为原函数
      print("OK")  

1.3叠加多个装饰器：

  多个装饰器运行顺序：
  def x1(func1):     # func1=y2的内存地址
      def x2(*args,**kwargs):
          print("=========x1")      
          res1 = func(*args,**kwargs)
          print("=============x2")  
          return res1
      return x2
  def y1(func2):     # func2=z2的内存地址
      def y2(*args,**kwargs):
          print("==========y1")      
          res2 = func(*args,**kwargs)
          print("==========y2")      
          return res2
      return y2
  def z1(func3):     # func3=原始的index的内存地址
      def z2(*args,**kwargs):
          print("==========z1")       
          res3 = func(*args,**kwargs)
          print("===========z2")     
          return res3
      return z2


  @x1   # x1(y2的内存地址)======>index=x1的内存地址
  @y1   # y1(z3的内存地址)======>y2的内存地址
  @z1   # z1(最原始的那个index的内存地址)===>z2的内存地址
  def index(x):
      print(x)                
  index(111)
  最后打印结果为：
        =========x1
        ==========y1
        ==========z1
        111
        ===========z2
        ==========y2
        =============x2

二、迭代器：

2.1迭代器的概念：

  器：迭代的工具
  迭代：是一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值
  例：
  while Ture:              #只是单纯的循环，不属于迭代
        print("=====")
  l=[1,2,3]
  count=0
  while count < len(l):     #  迭代
      print(l[count])
      count+=1

  1、为何要有迭代器：
        对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，
        若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

  2、什么是可迭代对象：
        可迭代对象指的是内置有__iter__方法的对象，所有内置数据类型（包括文件）都是可迭代对象
        'hello'.__iter__
        (1,2,3).__iter__
        [1,2,3].__iter__
        {'a':1}.__iter__
        {'a','b'}.__iter__
        open('a.txt').__iter__

  3、什么是迭代器对象：
        可迭代对象执行obj.__iter__()得到的结果就是迭代器对象
        而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象
        文件类型是迭代器对象
        open('a.txt').__iter__()
        open('a.txt').__next__()

  4、注意：
        迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

2.2迭代器对象的使用：

  例：
  dic={'a':1,'b':2,'c':3}
  new_dic = dic.__iter__()        # 得到迭代器对象
  print(new_dic.__next__())       # 从dic中取一个值，等同于next(iter_dic)
  print(new_dic.__next__())       # 从dic中取一个值，等同于next(iter_dic)
  print(new_dic.__next__())       # 从dic中取一个值，等同于next(iter_dic)
  print(new_dic.__next__())       # dic中值已经取完了，报错StopIteration，相当于结束标志
  使用迭代器：
  dic={'a':1,'b':2,'c':3}
  new_dic = dic.__iter__()
  while 1:
      try:                        # 检测以下代码
          k=next(iter_dic)
          print(dic[k])
      except StopIteration:       # 当出现StopIteration时执行下列代码
          break

2.3for循环：

  dic={'a':1,'b':2,'c':3}
  for k in dic:
      print(dic[k])
  for循环的工作原理
  1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic
  2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码
  3: 重复过程2，直到捕捉到异常StopIteration,结束循环

2.4迭代器的优缺点：

  优点：
    - 提供一种统一的、不依赖于索引的迭代方式
    - 惰性计算，节省内存
  缺点：
    - 无法获取长度（只有在next完毕才知道到底有几个值）
    - 一次性的，只能往后走，不能往前退

三、生成器：

3.1什么是生成器：

  只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码
  例：
  def func():
      print('====>first')
      yield 1
      print('====>second')
      yield 2
      print('====>third')
      yield 3
      print('====>end')
  g=func()         # 这时函数已经成了生成器，所以调用函数并不能执行函数内代码
  print(next(g))   # 生成器就是迭代器，所以取值操作和迭代器一样
  print(next(g))   
  print(next(g))