Python 从零学起（纯基础） 笔记 之 迭代器、生成器和修饰器

Python的迭代器、 生成器和修饰器

---

1、 迭代器是访问集合元素的一种方式，从第一个到最后，只许前进不许后退。

优点：不要求事先准备好整个迭代过程中的所有元素，仅仅在迭代到某个元素时才计算该元素，而在这之前或者之后，元素可以不存在或被销毁。

特点：

• 访问者是不需要关心迭代器内部的结构，仅需要通过next()方法不断去取下一个内容。
• 不能随机访问集合中的某个值，只能从头到尾依次访问。
• 访问到一半时不能往回退
• 便于循环比较大的数据集合，节省内存

 names = iter(['alex','jack','list'])
 print(names)
 print(names.__next__())
 print(names.__next__())
 print(names.__next__())

结果：

<list_iterator object at 0x005CC410>

alex

jack

list

2、  生成器

定义：

　　一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator），如果函数中包含yield语法，那这个函数就会发生生成器。

作用：

　　这个yield的主要效果，就是可以使函数中断，并保存中断状态，中断后，代码可以继续往下执行，过一段时间还可以再重新调用这个函数，从上次yield的下一句开始执行。

例1：

 def cash_money(amount):
     while amount > 0:
         amount -= 100
         yield 100
         print("取钱啦again")
 atm = cash_money(500)
 print(type(atm))
 print(atm.__next__())
 print(atm.__next__())
 print("go to 相声")
 print(atm.__next__())

结果：

<class 'generator'>

100

取钱啦again

100

go to 相声

取钱啦again

100

一共五百块，先去两百块钱，然后去听相声，之后在回来取100 。 一个循环我可以先跳出去做其他事，然后再回来继续做这件事。

例2：用yield实现单线程中的异步

 import time
 def consumer(name):
     print("%s 准备吃包子啦！"%name)
     while True:
         baozi=yield #接收别人发送给他的值
         print("包子%s 来了，被%s吃了！" % (baozi,name))

 def producer(name):
     c = consumer('A')
     c2 = consumer('B')
     c.__next__()
     c2.__next__()
     print("准备做包子啦")
     for i in range(10):
         time.sleep(1)
         print("I finished two baozi!")
         c.send('Alex')#通过send给yield发送i
         c2.send(i)

 producer("Young")

可以设置断点，单步运行查看程序运行的过程

3、  装饰器

开放封闭原则：已实现的功能代码不允许被修改，但是可以被扩展

开放：对扩展开放

封闭：以实现的功能代码块

没有使用装饰器

 def login(func):
     print("登录验证.")
     return func

 def home(name):
     print("Welcome [%s] to home page"%name)
 def tv(name):
     print("Welcome [%s] to tv page"%name)
 def movie(name):
     print("Welcome [%s] to movie page"%name)
 tv = login(tv)
 tv("Young")

结果：

登录验证.

Welcome [Young] to tv page

使用装饰器：

 def login(func):
     def inner(arg):
         print("登录验证.")
         func(arg)
     return inner

 def home(name):
     print("Welcome [%s] to home page"%name)

 @login  # 程序一执行就相当于执行tv = login(tv)
 def tv(name):
     print("Welcome [%s] to tv page"%name)
 def movie(name):
     print("Welcome [%s] to movie page"%name)
 #tv = login(tv)#相当于@login
 tv("Young")

返回值

 def login(func):
     def inner(*args,**kwagrs):
         print("登录验证.")
         return func(*args,**kwagrs)
     return inner

 def home(name):
     print("Welcome [%s] to home page"%name)

 @login  # 程序一执行就相当于执行tv = login(tv)
 def tv(name,passwd=123):
     print("Welcome [%s] to tv page"%name)
     return 4
 @login
 def movie(name):
     print("Welcome [%s] to movie page"%name)
 #tv = login(tv)#相当于@login
 ret = tv("Young",passwd=123)
 print(ret)
 movie("Young")

以下部分一是对上述内容中装饰器的解释和补充，另一个视为下面的复杂应用做铺垫。

 def w1(main_func):
     def outer(request,kargs):
         print('before')
         main_func(request,kargs)
         print('after')
     return outer
 @w1
 def show():
     pass

解析：

首先开始执行@w1，然后执行def  w1(main_func):。

对于def  w1(main_func): 主要包括两部分内容 def outer(request,kargs): 和 return outer 两个部分，对于def outer(request,kargs): 只是函数定义，没有调用，所以不会执行函数内容；然后执行return outer 返回outer。然后show函数被重新定义，即w1(show)的返回值outer = 新 show 。

以下内容详细看看（作为理解即可，很多时候用不到）：

 def Filter(before_func,after_func):
     def outer(main_func):
         def wrapper(request,kargs):
             before_func(request,kargs)
             main_func(request,kargs)
             after_func(request,kargs)
         return wrapper
     return outer

 @Filter(before,after)
 def Index(request,kargs):
     print('Index') 

1. 执行Filter(before,after)，注意是Filter而不是@，而Filter()的内容是def outer()和return outer（注：这里outer并没有被调用，所以函数的内容并没有执行）
2. 因为1、  的返回值是outer ，所以开始执行@outer，@outer会将index作为参数，开始执行到def  outer()：（但是wrapper函数内容并没有执行），接下来执行return wrapper ，即返回值是wrapper
3. 此时新的Insex = wrapper，   最后执行的Index=新Index