迭代器、生成器、裝飾器學習總結

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

總結：用裝飾器修飾類，和修飾函數相似，只是在建立裝飾器裏函數返回的類型不一樣而已。