迭代器/生成器/装饰器

列表生成式，迭代器&生成器

生成器

列表生成式

列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],我要求你把列表里的每个值加1

a = [1,3,4,6,7,7,8,9,11]
for index,i in enumerate(a):
    a[index] +=1
print(a)

>>> a = [i+1 for i in range(10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

生成器只有在调用时才会生成相应的数据. 只记录当前位置没有上一个

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>
>>> next(g)

 0

 >>> g.__next__()

 1

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

 g = (x * x for x in range(10))
 for n in g:
    print(n)

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

def fib(max):
    n, a, b =0,0,1
    while n <max:
            yield (b)
            a,b=b,a+b,
            n=n+1
a=fib(10)
print(a.__next__())
//期间可以做别的事
print(a.__next__())
//期间可以做别的事
print(a.__next__())

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

生成器next取完报错解决

a=fib(10)
for i in a :
    print(i)
while True:
    try:
        print(next(a))
    except Exception as e :
        print("已经取完了")
        break

还可通过yield实现在单线程的情况下实现并发运算的效果

#_*_coding:utf-8_*_
__author__ = 'Alex Li'

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("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("alex")

通过生成器实现协程并行运算

生成器函数：常规定义函数，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果。生成器的好处，就是一下子不会在内存中生成太多的数据

python中提供的生成器：1.生成器函数    2.生成器表达式

生成器的本质：就是一个迭代器

def func():
    print('aaaaaaaaaaa')
    a = 1
    yield a  # 返回第一个值
    print('bbbbbb')
    yield 12  # 返回第二个值

ret = func()  # 得拿到一个生成器, 不会有任何执行
# print(ret)#返回的是一个地址
print(next(ret))  # 取第一个值
print(next(ret))  # 取第二个值
# print(next(ret))  # 取第三个值，会报错，因为没有yield第三个值

假如我想让工厂给学生做校服，生产2000000件衣服，我和工厂一说，工厂应该是先答应下来，然后再去生产，我可以一件一件的要，也可以根据学生一批一批的找工厂拿。

def make_cloth():
    for i in range(1,20000):
        yield '第%s件衣服'%(i)
ret = make_cloth()
print(next(ret))
print(next(ret))
print(next(ret))
for i in range(100):
    print(next(ret))
//range(10) 循环从0到9
//range(1，10) 循环从，到9

# 必须先用next再用send
def average():
    total=0 #总数
    day=0 #天数
    average=0 #平均数
    while True:
        day_num = yield average   #average=0  #=10   20    30
        total += day_num          # =10              30     60
        day += 1                  #1                   2     3
        average = total/day        #10                 15     20
avg=average() #直接返回生成器
next(avg)#激活生成器，avg.send(),什么都不传的时候send和next的效果一样
print(avg.send(10))
print(avg.send(20))#send   1.传值 2.next
print(avg.send(30))
//10.0  15.0  20.0

yield  from

def func():
    for i in 'AB':
        yield i
    yield from 'AB'
    yield from [1,2,3]

g=func()
print(next(g)) //a
print(next(g)) //b
print(next(g)) //a
print(list(g)) //['B', 1, 2, 3]
yield from 'AB'
就相当于上面的for循环，吧循环简化了

生成器面试题

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

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

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

print(list(g))

python生成器之面试题
1.0
有一个有意思的python面试题，是下面的这个样子

def add(a,b):                     #普通求和函数
    return a + b
def test():                       #生成器函数
    for r in range(4):
        yield r
g=test()
for n in [2,10]:
    g=(add(n,i) for i in g)
print(list(g))
----------------------------------------------------------------------------------------------
1.1：代码块注释如下（还是上面的内容，只是注释加多了）
def add(a,b):                     #普通求和函数
    return a + b
def test():                       #生成器函数
    for r in range(4):
        yield r
g=test()                          #获取生成器对象，后面的操作都指向这个对象，这和直接执行fun()函数销效果是不一样的
for n in [2,10]:                  #因为前面已经定义了生成器g,这个for循环的代码块等于是重新定义了变量g,
    g=(add(n,i) for i in g)       #重新定义的这个变量g也是一个生成器，使用推导式定义的生成器
print(list(g))                    #list自带for方法，所以list(g)会一次性把上面列表生成器的值拿完
------------------------------------------------------------------------------------------------
1.2：代码简化（对上面的代码做了简化，但是都是等效的，主要是对for循环做了简化）
def add(a,b):            #普通求和函数
    return a + b
def test():              #生成器函数
    for r in range(4):
        yield r
g=test()
n=2
g=(add(n,i) for i in g)
n=10
g=(add(n,i) for i in g)
print(list(g))
--------------------------------------------------------------------------------------------------
1.3：代码简化（对上面的代码做了简化，但是都是等效的，主要是对n重新赋值的过程做了简化）
def add(a,b):            
    return a + b
def test():             
    for r in range(4):
        yield r
g=test()
n=10                                  #和上面的代码做比较，n重新赋值了两次，第二次已经把一次的赋值覆盖掉了，但是g因为前面做过定义，需要带入
g=(add(n,i) for i in (add(n,i) for i in g))
print(list(g))
--------------------------------------------------------------------------------------------------
1.3：代码简化（对上面的代码做了简化，但是都是等效的,带入数字10）

def add(a,b):            

    return a + b
def test():             
    for r in range(4):
        yield r
g=test()
                                 
g=(add(10,i) for i in (add(10,i) for i in g))
print(list(g))
#因为for循环自带__next__方法，所以for循环作用于生成器的时候也是一次性遍历完的，并不需要单独的在一个一个执行next
#分别带入i值0,1,2,3，可以生成g的一个生成器结果，再通过list(g)一次性拿完
-----------------------------------------------------------------------------------------------

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(g1))// 0 1 2 3
print(list(g2))//取完了

 

二 迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

可以使用isinstance()判断一个对象是否是Iterable对象：

from collections import Iterable
isinstance([], Iterable)
isinstance({}, Iterable)
isinstance('abc', Iterable)
isinstance((x for x in range(10)), Iterable)
isinstance(100, Iterable) //Fales

*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可以通过dir（obj）查看有什么方法

from collections import Iterator
isinstance((x for x in range(10)), Iterator)//1
>>> isinstance([], Iterator)//2
>>> isinstance({}, Iterator)//2
isinstance('abc', Iterator)//2

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

isinstance(iter([]), Iterator)

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

小结

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
for 循环 就是迭代器

 

三、装饰器

1.为什么要使用装饰器呢？

　　装饰器的功能：在不修改原函数及其调用方式的情况下对原函数功能进行扩展

　　装饰器的本质：就是一个闭包函数

　　那么我们先来看一个简单的装饰器：实现计算每个函数的执行时间的功能

1

import time
def timer(func):
    def deco():
        star_time=time.time()
        func()
        stop_time=time.time()
        print("shijian",stop_time-star_time)
    return deco
@timer
def text1():
    time.sleep(3)
    print("in the text1")

def text2():
    time.sleep(3)
    print("in the text2")
# text1=timer(text1) 传tex1 因为内部需要调用func
text1()

2.以上的装饰器都是不带参数的函数，现在装饰一个带参数的该怎么办呢?

import time
def timer(func):
    def deco(aaa):
        star_time=time.time()
        func(aaa)
        stop_time=time.time()
        print("shijian",stop_time-star_time)
    return deco

def text1():
    time.sleep(3)
    print("in the text1")
@timer
def text2(name):
    time.sleep(3)
    print("in the text2",name)
# text2=timer(text2())
text2("name")

3.以上的装饰器都是带一个参数的函数，现在装饰参数不固定的该怎么办呢?

import time
def timer(func):
    def deco(*args,**kwargs):
        star_time=time.time()
        func(*args,**kwargs)
        stop_time=time.time()
        print("shijian",stop_time-star_time)
    return deco
@timer
def text1():
    time.sleep(3)
    print("in the text1")
@timer//=text2=timer(text2())
def text2(name):
    time.sleep(3)
    print("in the text2",name)
# text2=timer(text2())
text1()
text2("name")

4。装饰器高潮根据不同的参数需求判断

user,pwd='look','000'

def auth(auths):
    def out_wra(func):
        def wra(*args, **kwargs):
            print("wra",*args,*kwargs)
            if auths=="loca1":
                username = (input("name"))
                password = (input("wod"))
                if username == user and password == pwd:
                    print("验证成功")
                    res = func(*args, **kwargs)
                    return res
                else:
                    print("name or wod 错误")
            else:
                pass
        return wra
    return out_wra
def index():
    print("welcome to index")
@auth(auths="loca1")
def home(auth="loca"):
    print("welcom to home")
    return "homea"
@ auth(auths="loca2")
def bbs():
    print("welcom  to bbs")

 

2、开放封闭原则

1.对扩展是开放的

2.对修改是封闭的