python -- 迭代器和装饰器

迭代器和装饰器在python中的使用十分常见，下面是个人对迭代器和装饰器的理解

迭代器

　　1、迭代器 iter 的特点：

　　　　(1).访问者不需要关心迭代器的内部结构，仅需要通过__next__()方法不断去取下一个内容
　　　　(2).不能随机访问集合(不是set，只是一些元素的聚集体)中的某个值，只能从头到尾依次访问
　　　　(3).访问到一半时不能后退(过去的就过去了，不能回头)
　　　　(4).便于循环比较大的数据集合，节省内存(每次需要了指定数据时，才把该读取到内存中，eg：迭代文件时，内存中每一时刻都只有文件的一行)

a = iter(['root','admin','python','ruby' ])    #生成一个迭代器
print(a.__next__())   
print(a.__next__())      #只有一个__next__() 方法
print('waitting!')    #在第二代的过程中，能停下来做其他的事
print(a.__next__())     
print(a.__next__())
#print(a.__next__())    #报错 超出迭代器范围

　　常见迭代器使用：
　　　　读文件时：
　　　　　　with open('a*.txt','r+') as f:
　　　　　　　　for line in f:
　　　　　　　　...
　　　　这里的for i in f：就是用的迭代器，避免依次把文件内容全部读取到内存中，节省内存。

在介绍迭代器时，还有个概念要明白，何为生成器

　　生成器 generator
　　定义： 一个函数调用时返回一个迭代器，那么这个函数就叫做生成器，如果函数中包含了yield语法，那么这个函数就会变成一个生成器（保存函数的中断状态）

>>> 
>>> def test_yeild(n):
    while n > 0:
        n -= 2
        yield 10
        print('注意何时打印这句话...')

        
>>> t = test_yeild(12)      # 与普通函数不同，这里只是生成一个迭代器，不会跳到‘函数体’里面去(执行函数体)，而是等待迭代器的__next__()方法
>>> t.__next__()
10                # 返回yield后面的值，并在执行完yield后 暂停程序 ，等待下一次__next__()，然后接着从暂停的地方开始运行
>>> t.__next__()          
注意何时打印这句话...
10
>>> t.__next__()
注意何时打印这句话...
10
>>> t.__next__()
注意何时打印这句话...
10
>>> t.__next__()
注意何时打印这句话...
10
>>> t.__next__()
注意何时打印这句话...
10
>>> t.__next__()
注意何时打印这句话...
Traceback (most recent call last):
  File "<pyshell#162>", line 1, in <module>
    t.__next__()
StopIteration
>>> 

yield 可以返回一个值，也可以接收一个值，给yield传值用send()

看下面例子，用yield做了个简单的异步操作：

import time

def consumer(name):
    print("%s 准备吃包子啦！" %name)
    while 1:
        baozi = yield
        print("包子[%s]来了，被[%s]吃了" %(baozi,name))
        
def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("%s开始准备做包子啦!" %name)
    for i in range(3):
        time.sleep(1)        #执行时为了更清楚的看到过程
        print("做了2个包子")
        c.send(i)
        c2.send(i)
              
producer('root')

A 准备吃包子啦！
B 准备吃包子啦！
root开始准备做包子啦!
做了2个包子
包子[0]来了，被[A]吃了
包子[0]来了，被[B]吃了
做了2个包子
包子[1]来了，被[A]吃了
包子[1]来了，被[B]吃了
做了2个包子
包子[2]来了，被[A]吃了
包子[2]来了，被[B]吃了

　　

def account(money):
    while money > 0:
        out_money = yield 
        money -= out_money
        #yield 300
        print('又来取钱了！取了%s' %out_money)
        
atm = account(1500)
atm.__next__()
for i in range(5):
    atm.send(300)
    #在第一次用__next__()方法启动迭代器后，每次调用迭代器，就会自动执行__next__()方法
    

装饰器

　　装饰器基本功能：对已有函数进行扩展

　　（个人初步理解，可能错误）
　　装饰器执行过程：
　　　　1.在调用被装饰器装饰的函数时，先把被装饰器装饰的函数（装饰器下一行代码中函数）的函数名传递给装饰器从内到外第二层定义的函数
　　　　2.把被装饰器装饰的函数的实参传递给装饰器最内层函数
　　　　3.在装饰器内部实现被装饰器装饰的函数的调用

　简单装饰器：

def login(func):
    def inner(*args,**kwargs):
        print("我是做身份验证的，验证成功才能调用函数")
        print(args,kwargs)
        func(*args,**kwargs)
        #return func(*args,**kwargs)
    return inner
    #若传进来的是函数名，那么没有执行'()'的话，即是函数的内存地址

#@login    #(装饰器)程序一执行，就会调用装饰器的函数
def home(name):
    print("welcome [%s] vidited the home page" %name)

@login   #@符号的作用: 相当于执行 tv = login(tv) 
#def tv(name,passwd=123):
def tv(*args,**kwargs):
    print("welcome [%s] vidited the tv page" %args )
    #若这里有返回值，则仅需要在inner里面返回函数结果
#@login
def movices(name):
    print("welcome [%s] vidited the movices page" %name)
    
tv('root')
tv('xtsec',passwd=123)

复杂装饰器：

'''
调用装饰器时(eg：@login(f1,f2))，传递多个参数的装饰器(三层装饰器)
'''
def before():
    print("执行要装饰的函数之前执行")

def affter():
    print("执行要装饰的函数之后执行")      #没有return的函数默认返回None

def test_ge(before1,affter1):
    def login(func):
        def inner(*args,**kwargs):
            result_before = before1()
            if(result_before != None):     
                return '执行before条件未成功！'    #这里运行就表示before函数没有正确运行结束，所以表示验证没通过
            ret = func(*args,**kwargs)
            if(ret != None):
                return '执行被修饰函数不成功！'    #若前面验证通过，且装饰器正确执行，到这里整个装饰器运行结束
            result_afftr = affter1()
            if(result_afftr != None):
                return '执行时不满足要求！'     #若前面装饰器修身的函数没正确运行，就会到这里，常用来返回错误信息
            return ret
        return inner
    return login

def home(name):
    print("welcome [%s] vidited the home page" %name)

29 '''
30 接下来这一行有三个操作：
31 1.调用函数 test_ge(before, affter)
32 2.@login   login为调用test_ge(before, affter)的返回值
33 3.新tv = inner    login()的返回值
34 '''
@test_ge(before, affter)   
def tv(*args,**kwargs):
    print("welcome [%s] vidited the tv page" %args )
    return 1

def movices(name):
    print("welcome [%s] vidited the movices page" %name)


tv('root',passwd='admin')   
    #在这里执行tv()时，事实上时执行新的tv()，即是inner()
a = before()
print(type(a),a)
if a == None:
    print('110')

在日常使用中，一般就用普通的装饰器，复杂度这个最好明白运行原理即过程