迭代器、生成器、装饰器学习总结

1、迭代器：

一、什么是迭代器？

      在python中,迭代器是一个能够记住遍历位置的对象，迭代器对象从集合的第一个元素开始访问，直到全部的元素都被访问完，迭代器只能往前不会后退。简单来说咱们见的比较多的是for 循环来遍历列表、元组、字符串等容器，这个就是迭代器的使用,因此说，迭代器简单能够理解成咱们平时要从柜子里取东西时的动做。

二、两个内置迭代器协议方法：

 a、方法iter():返回对象自己，是for循环语句使用迭代器的要求。

 b、方法next()：用于返回容器中下一个元素（所谓容器，简单理解就是一个存储东西的柜子，要用的话，就能够拿出来，在python 中咱们使用for语句来循环遍从来取出使用）或者数据，当使用完容器中的数据时就会引起StopIteration错误。

三、建立并使用迭代器：

 1 class Use:    #定义了迭代器类
 2     def __init__(self,x=2,max=50):        #定义构造方法
 3         self.__mul,self.__x=x,x      #初始化私有的实例属性
 4         self.__max=max
 5     def __iter__(self):       #定义迭代器协议方法
 6         return self           #返回类的自身
 7     def __next__(self):       #定义迭代器协议方法
 8         if self.__x and self.__x != 1:
 9           self.__mul  *= self.__x
10           if self.__mul <= self.__max:
11               return self.__mul
12           else:
13               raise StopIteration
14         else:
15              raise StopIteration
16 
17 if __name__ == '__main__':
18     my=Use()
19     for i in my:
20         print(i)
21 
22             

注意：当在python 中使用迭代器类时，必定要在某个条件下引起StopIteration错误，这样能够结束遍历循环，不然会产生死循环

四、使用内置迭代器方法iter():

a、iter(iterable),只有一个参数iterable，要求参数为可迭代的类型，也可使用各类序列类型，演示以下;

list=[1,2,3,4]
it = iter(list)  #建立迭代器对象
for i in it:     #遍历 迭代器中的数据
    print(i)     #显示迭代效果

b、iter(callable,sentinel),第一个参数callable表示可调用类型，通常为函数；第二参数sentine是一个标记，当第一个参数（函数）的返回值等于第二个参数的值时，迭代或者遍历会立刻中止。演示以下：

class Count:    #定义类Count
    def __init__(self,x=0):   # 定义构造方法
        self.x=x
count = Count()
def use_iter():
    count.x +=2
    return count.x
for i in iter(use_iter,12):    #经过迭代遍历方法iter()产生的迭代器
    print(i)

五、方法next()的使用：

string='i like it'
it = iter(string)
while True:
    try:
        each=next(it) #读取字符中的每个元素，并使用try  except 结构来检查是否有异常发生，当try里面出现异常时，就会执行下面的except的语句
    except StopIteration:
        break
    print(each)

2、生成器：

一、什么是生成器?

      在python 中，使用关键字yield定义的函数就称为生成器，经过使用生成器，能够生成一个值序列为用于迭代，而且这个值序列不是一次生成的，而是使用一个，再生成一个，最大的好处是可使程序节约大量的内存。

二、生成器的运行机制：

     在python程序中，生成器是一个记住上一次返回时在函数体中位置的函数，。对生成器函数的第二次（或第n次）调用，跳转至该函数中间，而上次调用的全部布局变量都保持不变。生成器不只记住了它的数据状态，还记住了它在流控制构造（在命令式编程中，这种构造不仅是数据值）的中的位置。

     生成器的特色以下：

           a、生成器是一个函数，并且函数的参数都会保留

           b、当迭代到下一次调用时，所使用的参数都是第一次所保留的。也就是说，在整个函数调用中的参数都是第一次所调用时保留的，而不是新建立的

      在python程序中，使用关键字yield定义生成器。当向生成器索要一个数时，生成器就会执行。直至出现yield语句时，生成器才把yield的参数传给你，以后生成器就不会往下继续运行。当向生成器索要一个数时,它会从上次的状态开始运行，直至出现yield语句时，才把参数传给你，而后停下，如此反复，直至退出函数为止

三、使用yield生成器：

def fib(max):
    a,b = 1,1
    while a < max:
        yield a   #程序运行到这里就不会往下继续执行了，因此第一次a =1,b=1,当第二次遍历函数时fib（）时，a ,b 的值仍是上次的值，并且会跳到这里，而后执行到下面的语句
        a,b = b,a+b
for n in fib(15):
    print(n)     #这里打印的值实际上是a的值

执行结果：

1
1
2
3
5
8
13

说明：在Python中，当函数定义里面使用了关键字yield，那么这个函数就是一个生成器；它的执行会和其余普通的函数有不少不一样，该函数返回的是一个对象，而不是像日常函数所用的return语句那样，能获得结果。若是想取得值，还须要调用next()函数。  

四、建立生成器：

def haha(n):
    while n > 0:
        print('开始生成......')
        yield n #定义一个生成器
        print('完成一次......')
        n -=1
if __name__ == '__main__':     #当导入模块时不运行，不然会运行下面的代码
    for i in haha(4):
        print('遍历获得的值',i)
    print()
    tutu=haha(3)
    print('已经实例化生成器对象')
    tutu.__next__() #直接遍历本身建立的生成器
    print('第二次调用__next__()方法')
    tutu.__next__()  #以手工方式获取生成器产生的数值序列

运行结果：

开始生成......
遍历获得的值 4
完成一次......
开始生成......
遍历获得的值 3
完成一次......
开始生成......
遍历获得的值 2
完成一次......
开始生成......
遍历获得的值 1
完成一次......

已经实例化生成器对象
开始生成......
第二次调用__next__()方法
完成一次......
开始生成......

注意：生成器在实例化时，不会当即执行，而是等候其调用方法__next__()才开始运行。

3、装饰器：

一、什么是装饰器？

      在python程序中，经过使用装饰器能够给函数或类加强功能，而且还能够快速地给不一样的函数或类插入相同的功能，也就是说，装饰器是一种实现代码的实现方式

二、建立装饰器

      要想在Python程序中使用装饰器，须要使用一个特殊的符号 "@" 来实现。在定义装饰器装饰函数时或类时，使用"@装饰器名称"的形式将符号 “@”放在函数或类的定义行以前。例如，有一个装饰器名称为"haha",当须要在函数中使用装饰器功能时，可使用以下形式定义这个函数：

                    @  haha

                     def tutu():

                           pass

       在pytnon程序中使用装饰器后，上面的代码定义的函数tutu()能够只定义本身所需的功能，而装饰器所定义的功能会自动插入到函数中去，这样就能够节省大量具备相同功能的函数或类的代码。

三、使用装饰器 装饰函数：

def zz(fun):    #定义一个装饰器函数
    def hh(*args,**bian):  #这里第一个参数表示把args这个参数打包或者解包，第个参数是把传输进来的实参进行打包成字典的形
        print('开始运行...')
        fun(*args,**bian)    #使用被装饰函数
        print("运行结束。。。。")
    return hh
@zz      #装饰函数语句
def demo(x):   #定义普通函数，它被装饰器装饰
    a=[]       #定义空列表
    for i in range(x):
        a.append(i)    #将i添加到列表末尾
    print(a)
@zz
def hello(name):
    print('hello',name)
if __name__ == '__main__':
    demo(5)
    print()
    hello('haha')

执行结果：

开始运行...
[0, 1, 2, 3, 4]
运行结束。。。。

开始运行...
hello haha
运行结束。。。。

总结：当通常函数被装饰器修饰时，会把装饰器函数的功能插入到普通函数中去。

四、使用装饰器修饰类：

def zz(myclass):    # 定义一个可以装饰类的装饰器zz
    class Haha:
        #定义一个内嵌类Haha来代替被装饰的类
        def __init__(self,z=0):
            self.z=0
            self.haha=myclass()
            #实例化被修饰的类
        def tutu(self):
            self.haha.tutu()
            print('z轴的坐标：',self.z)
    return Haha
@zz
class Hoho:
    def __init__(self,x=0,y=0):
        self.x=0
        self.y=0
    def tutu(self):
        print('x轴的坐标：',self.x)
        print('y轴的坐标：',self.y)
if __name__ == '__main__':
    coor=Hoho()
    coor.tutu()

运行结果：

x轴的坐标： 0
y轴的坐标： 0
z轴的坐标： 0

总结：用装饰器修饰类，和修饰函数相似，只是在建立装饰器里函数返回的类型不一样而已。