Python迭代器,生成器,裝飾器

• 2022 年 3 月 7 日
• 筆記
• Python

迭代器

通常來講從一個對象中依次取出數據，這個過程叫做遍歷，這個手段稱為迭代(重複執行某一段程式碼塊，並將每一次迭代得到的結果作為下一次迭代的初始值)。
可迭代對象(iterable)：是指該對象可以被用於for…in…循環，例如：集合，列表，元祖，字典，字元串，迭代器等。

• 在python中如果一個對象實現了 __iter__方法，我們就稱之為可迭代對象，可以查看set\list\tuple…等源碼內部均實現了__iter__方法

• 如果一個對象未實現__iter__方法，但是對其使用for…in則會拋出TypeError: ‘xxx’ object is not iterable

• 可以通過isinstance(obj,Iterable)來判斷對象是否為可迭代對象。如：

  from collections.abc import Iterable
  # int a
  a = 1
  print(isinstance(a, Iterable))  # False
  
  # str b
  b = "lalalalala"
  print(isinstance(b, Iterable))  # True
  
  # set c
  c = set([1, 2])
  print(isinstance(c, Iterable))  # True
  
  # list d
  
  d = [1,2,3,"a"]
  print(isinstance(d, Iterable)) # True
  
  # dict e
  e = {"a":1,"b":2,"c":333}
  print(isinstance(e, Iterable)) # True
  
  # tuple f
  f = (1,3,4,"b","d",)
  print(isinstance(f, Iterable)) # True我們也可以自己實現__iter__來將一個類實例對象變為可迭代對象：
  

• 我們也可以自己實現__iter__來將一個類實例對象變為可迭代對象：

  自己實現迭代對象的要求
  1、在python中如果一個對象同時實現了__iter__和__next__(獲取下一個值)方法，那麼它就是一個迭代器對象。

  2、可以通過內置函數next(iterator)或實例對象的__next__()方法，來獲取當前迭代的值

  3、迭代器一定是可迭代對象，可迭代對象不一定是迭代器。

  4、如果可迭代對象遍歷完後繼續調用next()，則會拋出：StopIteration異常。

  from collections.abc import Iterator, Iterable
  
  class MyIterator:
      def __init__(self, array_list):
          self.array_list = array_list
          self.index = 0
  
      def __iter__(self):
          return self
  
      def __next__(self):
          if self.index < len(self.array_list):
              val = self.array_list[self.index]
              self.index += 1
              return val
          else:
              raise StopIteration
  
  
  # 父類如果是迭代器，子類也將是迭代器
  class MySubIterator(MyIterator):
      def __init__(self):
          pass
  
  myIterator = MyIterator([1, 2, 3, 4])
  # 判斷是否為可迭代對象
  print(isinstance(myIterator, Iterable))  # True
  # 判斷是否為迭代器
  print(isinstance(myIterator, Iterator))  # True
  
  # 子類實例化
  mySubIterator = MySubIterator()
  print(isinstance(mySubIterator, Iterator))  # True
  # 進行迭代
  
  print(next(myIterator))  # 1
  print(myIterator.__next__())  # 2
  print(next(myIterator))  # 3
  print(next(myIterator))  # 4
  print(next(myIterator))  # raise StopIteration
  

• 迭代器優缺點：

  - 優點：
  	迭代器對象表示的是一個數據流，可以在需要時才去調用next來獲取一個值；因而本身在記憶體中始終只保留一個值，
  	對於記憶體佔用小可以存放無限數據流。
  	優於其他容器需要一次將所有元素都存放進記憶體，如：列表、集合、字典...等。
  - 缺點：
  	1.無法獲取存放的元素長度，除非取完計數。
  	2.取值不靈活，只能向後取值，next()永遠返回的是下一個值；無法取出指定值(無法像字典的key,或列表的下標)，而且迭代器對象的生命周期是一次性的，元素被迭代完則生命周期結束。
  

生成器

定義：在Python中，一邊循環一邊計算的機制，稱為生成器：generator；同時生成器對象也是迭代器對象，所以他有迭代器的特性；
例如支援for循環、next()方法…等
作用：對象中的元素是按照某種演算法推算出來的，在循環的過程中不斷推算出後續的元素，這樣就不必創建完整的list，從而節省大量的空間。 簡單生成器：通過將列表生成式[]改成()即可得到一個生成器對象。

# 列表生成式
_list = [i for i in range(10)]
print(type(_list))  # <class 'list'>
print(_list)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 生成器
_generator = (i for i in range(10))
print(type(_generator))  # <class 'generator'>
print(_generator)  # <generator object <genexpr> at 0x7fbcd92c9ba0>

# 生成器對象取值
print(_generator.__next__())  # 0
print(next(_generator)) # 1
# 注意從第三個元素開始了！
for x in _generator:
    print(x)  # 2，3，4，5，6，7，8，9

因為生成器對象也有迭代器的特性，所以元素迭代完後繼續調用next()方法則會引發StopIteration。
函數對象生成器：帶yield語句的函數對象的返回值則是個生成器對象。

def gen_generator():
    yield 1
def func():
    return 1
print(gen_generator(), type(gen_generator()))  
# <generator object gen_generator at 0x7fe68b2c8b30> <class 'generator'>
print(func(), type(func()))  
# 1 <class 'int'>

def gen_generator():
    yield "start"
    for i in range(2):
        yield i
    yield "finish"

gen = gen_generator()
print("從gen對象中取出第一個值",next(gen))
print("從gen對象中取出第二個值",next(gen))
print("從gen對象中取出第三個值",next(gen))
print("從gen對象中取出第四個值",next(gen))

#
#從gen對象中取出第一個值 start
#從gen對象中取出第二個值 0
#從gen對象中取出第三個值 1
#從gen對象中取出第四個值 finish
#
# StopIteration
#print("從gen對象中取出五個值",next(gen)) 

#就相當於
#gen2 = (i for i in ["start",1,2,"finish"])

注意：yield 一次只會返回一個元素，即使返回的元素是個可迭代對象，也是一次性返回

def gen_generator2():
    yield [1, 2, 3]
 
 
s = gen_generator2()
print(next(s))  # [1, 2, 3]

yield生成器高級應用： send()方法，傳遞值給yield返回(會立即返回!)；

如果傳None，則等同於next(generator)。

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print(f'[CONSUMER] Consuming get params.. ({n})')
        if n == 3:
            r = '500 Error'
        else:
            r = '200 OK'
def produce(c):
    c.send(None)  # 啟動生成器
    n = 0
    while n < 5:
        n = n + 1
        print(f'[PRODUCER] Producing with params.. ({n})')
        r = c.send(n)  # 一旦n有值，則切換到consumer執行
        print(f'[PRODUCER] Consumer return : [{r}]')
        if not r.startswith('200'):
            print("消費者返回服務異常，則結束生產，並關閉消費者")
            c.close()  # 關閉生成器
            break
consume = consumer()
produce(consume)

[PRODUCER] Producing with params.. (1)
[CONSUMER] Consuming get params.. (1)
[PRODUCER] Consumer return : [200 OK]
[PRODUCER] Producing with params.. (2)
[CONSUMER] Consuming get params.. (2)
[PRODUCER] Consumer return : [200 OK]
[PRODUCER] Producing with params.. (3)
[CONSUMER] Consuming get params.. (3)
[PRODUCER] Consumer return : [500 Error]
消費者返回服務異常，則結束生產，並關閉消費者

yield from iterable 語法，基本作用為：返回一個生成器對象，提供一個「數據傳輸的管道」，
yield from iterable 是 for item in iterable: yield item的縮寫；
並且內部幫我們實現了很多異常處理，簡化了編碼複雜度。 yield 無法獲取生成器return的返回值：

def my_generator2(n, end_case):
    for i in range(n):
        if i == end_case:
            return f'當 i==`{i}`時，中斷程式。'
        else:
            yield i
g = my_generator2(5, 2)  # 調用
try:
    print(next(g))  # 0
    print(next(g))  # 1
    print(next(g))  # 此處要觸發end_case了
except StopIteration as exc:
    print(exc.value)  # 當 i==`2`時，中斷程式。

使用yield from 可以簡化成：

def my_generator3(n, end_case):
    for i in range(n):
        if i == end_case:
            return f'當 i==`{i}`時，中斷程式。'
        else:
            yield i
def wrap_my_generator(generator):  # 將my_generator的返回值包裝成一個生成器
    result = yield from generator
    yield result
g = my_generator3(5, 2)  # 調用
for _ in wrap_my_generator(g):
    print(_)
# 輸出：
# 0
# 1
# 當 i==`2`時，中斷程式。

"""
yield from 有以下幾個概念名詞：
1、調用方：調用委派生成器的客戶端（調用方）程式碼（上文中的wrap_my_generator(g)）
2、委託生成器：包含yield from表達式的生成器函數(包裝)，作用就是提供一個數據傳輸的管道（上文中的wrap_my_generator）
3、子生成器：yield from後面加的生成器函數對象（上文中的my_generator3的實例對象g）
調用方是通過這個 「包裝函數」 來與生成器進行交互的，即「調用方——>委託生成器——>生成器函數」
下面有個例子幫助大家理解
"""

# 子生成器
def average_gen():
    total = 0
    count = 0
    average = 0
    while True:
        new_num = yield average
        if new_num is None:
            break
        count += 1
        total += new_num
        average = total / count
    # 每一次return，都意味著當前協程結束。
    return total, count, average

# 委託生成器
def proxy_gen():
    while True:
        # 只有子生成器要結束（return）了，yield from左邊的變數才會被賦值，後面的程式碼才會執行。
        total, count, average = yield from average_gen()
        print("總共傳入 {} 個數值， 總和：{}，平均數：{}".format(count, total, average))

# 調用方
def main():
    calc_average = proxy_gen()
    next(calc_average)  # 激活協程
    calc_average.send(10)  # 傳入：10
    calc_average.send(None)  # 結束協程 send(None)等於next(calc_acerage)，也就是會走到average_gen裡面的return語句
    print("================== 重開協程 ===================")
    calc_average.send(20)  # 傳入：20
    calc_average.send(30)  # 傳入：30
    calc_average.send(None)  # 結束協程

if __name__ == '__main__':
    main()
# 輸出：
# 總共傳入 1 個數值， 總和：10，平均數：10.0
# ================== 重開協程 ===================
# 總共傳入 2 個數值， 總和：50，平均數：25.0

裝飾器

一句話來解釋裝飾器，就是函數的嵌套調用

主要應用在3個方面：

• 列印程式的執行時間
• 收集程式的執行日誌
• 用於介面訪問鑒權

先看一個簡單的例子

def decorator_get_function_name(func):
    """
    獲取正在運行函數名
    :return:
    """

    def wrapper(*arg):
        """
        wrapper
        :param arg:
        :return:
        """
        print(f"當前運行方法名：{func.__name__}  with  params: {arg}")
        return func(*arg)

    return wrapper


# @func_name是python的語法糖
@decorator_get_function_name
def test_func_add(x, y):
    print(x + y)


def test_func_sub(x, y):
    print(x - y)


test_func_add(1, 2)
# 輸出：
# 當前運行方法名：test_func_add  with  params: (1, 2)
# 3
# 不使用語法糖的話也可以用以下方法，效果是一樣的
decorator_get_function_name(test_func_sub)(3, 5)
# 還記得前文講的引用嗎？我們還可以換種寫法達到跟👆一樣的效果
dec_obj = decorator_get_function_name(test_func_sub)  # 這裡等同於wrapper對象
dec_obj(3,5)  # 這裡等同於wrapper(3,5)
# 輸出：
# 當前運行方法名：test_func_sub  with  params: (3, 5)
# -2

常用於如鑒權校驗，例如筆者會用於登陸校驗：

def login_check(func):
    def wrapper(request, *args, **kwargs):
        if not request.session.get('login_status'):
            return HttpResponseRedirect('/api/login/')
        return func(request, *args, **kwargs)
    return wrapper

@login_check
def edit_config():
    pass

多個裝飾器事例

def w1(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("這裡是第一個校驗")
        return func(*args, **kwargs)

    return wrapper


def w2(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("這裡是第二個校驗")
        return func(*args, **kwargs)

    return wrapper


def w3(func):
    def wrapper(*args, **kwargs):
        print("這裡是第三個校驗")
        return func(*args, **kwargs)

    return wrapper


@w2  # 這裡其實是w2(w1(f1))
@w1  # 這裡是w1(f1)
def f1():
    print(f"i`m f1, at {f1}")

f1()

這裡是第二個校驗
這裡是第一個校驗
i`m f1, at <function f1 at 0x113fe83a0>

注意：寫一個decorator的時候，最好在實現之前加上functools的wrap，它能保留原有函數的名稱和函數屬性

#不加wraps
def my_decorator(func):
    def wrapper(*args, **kwargs):
        '''decoratord'''
        print('Calling decorated function...')
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def example():
    """Docstring"""
    print('Called example function')

print(example.__name__, example.__doc__)

# 加wraps
import functools


def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        '''decorator'''
        print('Calling decorated function...')
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def example():
    """Docstring"""
    print('Called example function')

print(example.__name__, example.__doc__)

##########################
wrapper decoratord
example Docstring

日誌列印事例

from functools import wraps

# 這是裝飾函數
def logger(func):

    @wraps(func)
    def wrapper(*args, **kw):
        print('我準備開始計算：{} 函數了:'.format(func.__name__))

        # 真正執行的是這行。
        func(*args, **kw)

        print('啊哈，我計算完啦。給自己加個雞腿！！')
    return wrapper

@logger
def add(x, y):
    print('{} + {} = {}'.format(x, y, x+y))

add(200, 50)

##########################
我準備開始計算：add 函數了:
200 + 50 = 250
啊哈，我計算完啦。給自己加個雞腿！！

帶參數的裝飾器實現

from functools import wraps

def say_hello(contry):

    @wraps(contry)
    def wrapper(func):
        def deco(*args, **kwargs):
            if contry == "china":
                print("你好!")
            elif contry == "america":
                print('hello.')
            else:
                return

            # # 真正執行函數的地方
            func(*args, **kwargs)
        return deco
    return wrapper


@say_hello("china")
def chinese():
    print("我來自中國。")


@say_hello("america")
def american():
    print("I am from America.")

chinese()
american()

#######################
你好!
我來自中國。
hello.
I am from America.

裝飾器類

以上都是基於函數實現的裝飾器，在閱讀別人程式碼時，還可以時常發現還有基於類實現的裝飾器。

基於類裝飾器的實現，必須實現 call 和 __init__兩個內置函數。
init ：接收被裝飾函數
call ：實現裝飾邏輯。

1、不帶參數

class logger(object):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("[INFO]: the function {func}() is running..."\
            .format(func=self.func.__name__))
        return self.func(*args, **kwargs)


@logger
def say(something):
    print("say {}!".format(something))

say("hello")

################
[INFO]: the function say() is running...
say hello!

2、帶參數的類

#帶參數裝飾器

class logger(object):
    def __init__(self,level='INFO'):
        self.level = level

    def __call__(self,func):
        def wrapper(*args, **kwargs):
            print("[{level}]: the function {func}() is running..." \
                  .format(level=self.level, func=func.__name__))
            func(*args,**kwargs)
        return wrapper

@logger(level='WARNING')
def say(something):
    print("say {}!".format(something))

say("hello")

#########################
[WARNING]: the function say() is running...
say hello!