詳解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
a: int = 1
print(isinstance(a, Iterable))  # False
b: str = "lalalalala" 
print(isinstance(b, Iterable))  # True
c: set = set([1, 2])
print(isinstance(c, Iterable))  # True

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

class MyIterable:
	def __iter__(self):
		pass


print(isinstance(MyIterable(), Iterable)) # True

• 迭代器：對可迭代對象進行迭代的方式或容器，並且需要記錄當前迭代進行到的位置。

  • 在python中如果一個對象同時實現了__iter__和__next__(獲取下一個值)方法，那么它就是一個迭代器對象。
  • 可以通過內置函數next(iterator)或實例對象的__next__()方法，來獲取當前迭代的值
  • 迭代器一定是可迭代對象，可迭代對象不一定是迭代器。
  • 如果可迭代對象遍歷完后繼續調用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'>

他與普通函數返回值有所不同，普通函數運行到return語句則直接返回代碼不再執行；而生成器對象會運行到yield后返回，再下次調用時從yield語句后繼續執行。如：

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

def gen_generator2():
	yield [1, 2, 3]


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

• yield生成器高級應用：
  • send()方法，傳遞值給yield返回(會立即返回!)；如果傳None，則等同於next(generator)。
    
    借助send我們可以實現一個簡單的生產者-消費者模式如：

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_generator(n, end_case):
	for i in range(n):
		if i == end_case:
			return f'當 i==`{i}`時，中斷程序。'
		else:
			yield i


g = my_generator(5, 2)  # 調用

for _i in g:  # for循環不會顯式觸發異常，故而無法獲取到return的值
	print(_i)

# 輸出：
# 0
# 1

從上面的例子可以看出，for迭代語句不會顯式觸發異常，故而無法獲取到return的值，迭代到2的時候遇到return語句，隱式的觸發了StopIteration異常，就終止迭代了，但是在程序中不會顯示出來。

可以通過next()顯示的觸發StopIteration異常來獲取返回值:

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_generator）
調用方是通過這個 “包裝函數” 來與生成器進行交互的，即“調用方——>委托生成器——>生成器函數”
下面有個例子幫助大家理解（該🌰參考於博客）：

# 子生成器
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

有興趣的同學可以結合圖和下方一起理解：

1. 迭代器（即可指子生成器）產生的值直接返還給調用者
2. 任何使用send()方法發給委派生產器（即外部生產器）的值被直接傳遞給迭代器。如果send值是None，則調用迭代器next()方法；如果不為None，則調用迭代器的send()方法。如果對迭代器的調用產生StopIteration異常，委派生產器恢復繼續執行yield from后面的語句；若迭代器產生其他任何異常，則都傳遞給委派生產器。
3. 子生成器可能只是一個迭代器，並不是一個作為協程的生成器，所以它不支持.throw()和.close()方法,即可能會產生AttributeError 異常。
4. 除了GeneratorExit 異常外的其他拋給委派生產器的異常，將會被傳遞到迭代器的throw()方法。如果迭代器throw()調用產生了StopIteration異常，委派生產器恢復並繼續執行，其他異常則傳遞給委派生產器。
5. 如果GeneratorExit異常被拋給委派生產器，或者委派生產器的close()方法被調用，如果迭代器有close()的話也將被調用。如果close()調用產生異常，異常將傳遞給委派生產器。否則，委派生產器將拋出GeneratorExit 異常。
6. 當迭代器結束並拋出異常時，yield from表達式的值是其StopIteration 異常中的第一個參數。
7. 一個生成器中的return expr語句將會從生成器退出並拋出 StopIteration(expr)異常。

• ⭐️裝飾器(非常實用！)
  講裝飾器之前要先了解兩個概念：
  • 對象引用 ：對象名僅僅只是個綁定內存地址的變量

def func():   # 函數名僅僅只是個綁定內存地址的變量       
	print("i`m running") 
                     
# 這是調用                       
func()  # i`m running
# 這是對象引用，引用的是內存地址        
func2 = func  
print(func2 is func)  # True
# 通過引用進行調用  
func2()  # i`m running

• 閉包：定義一個函數A，然后在該函數內部再定義一個函數B，並且B函數用到了外邊A函數的變量

def out_func():
	out_a = 10

	def inner_func(inner_x):
		return out_a + inner_x

	return inner_func


out = out_func()
print(out)  # <function out_func.<locals>.inner_func at 0x7ff378af5c10> out_func返回的是inner_func的內存地址
print(out(inner_x=2))  # 12

裝飾器和閉包不同點在於：裝飾器的入參是函數對象，閉包入參是普通數據對象

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

裝飾器內部的執行邏輯：

"""
>  1. def login_check(func):  ==>將login_check函數加載到內存
>  ....
>  @login_check  ==>此處已經在內存中將login_check這個函數執行了！；並不需要等edit_config()實例化調用
>  2. 上例@login_check內部會執行以下操作：
>	  2.1 執行login_check函數，並將 @login_check 下面的 函數(edit_config) 作為login_check函數的參數，即：@login_check 等價於 login_check(edit_config)
>     2.2 內部就會去執行：
      def wrapper(*args):
          # 校驗session...
          return func(request, *args, **kwargs)   # func是參數，此時 func 等於 edit_config，此處相當於edit_config(request, *args, **kwargs)
      return wrapper     # 返回的 wrapper，wrapper代表的是函數對象，非函數實例化對象
      2.3 其實就是將原來的 edit_config 函數塞進另外一個函數中,另一個函數當中可以做一些操作；再執行edit_config
      2.4 將執行完的 login_check 函數返回值(也就是 wrapper對象)將此返回值再重新賦值給新 edit_config，即：
      2.5 新edit_config = def wrapper:
             # 校驗session...
            return 原來edit_config(request, *args, **kwargs) 
>  3. 也就是新edit_config()=login_check(edit_config):wrapper(request, *args, **kwargs):return edit_config(request, *args, **kwargs) 有點繞，大家看步驟細細理解。
"""

同樣一個函數也可以使用多個裝飾器進行裝飾，執行順序從上到下

from functools import wraps

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}")


@w3
def f2():
	print(f"i`m f2, at {f2}")

# ====================== 實例化階段 =====================
f1()
# 這里是第二個校驗
# 這里是第一個校驗
# i`m f1, at <function f1 at 0x7febc52f5e50>
f2()
# 這里是第三個校驗
# i`m f2, at <function w3.<locals>.inner at 0x7febc52f5f70>

有同學可能要好奇 為什么f1對象打印的是“<function f1 at 0x7febc52f5e50>”，f2對象打印的是“<function w3. .wrapper at 0x7febc52f5f70>”（也就是步驟2.5造成的，賦的值是wrapper對象），這就跟w1和w2 內部wrapper使用的wraps裝飾器有關系了。
wraps的作用是：被修飾的函數（也就是里面的func）的一些屬性值賦值給修飾器函數（wrapper）包括元信息和“函數對象”等。

同時裝飾器也可以接受參數：

def decorator_get_function_duration(enable):
	"""
	:param enable:  是否需要統計函數執行耗時
	:return: 
	"""
	print("this is decorator_get_function_duration")

	def inner(func):
		print('this is inner in decorator_get_function_duration')

		@wraps(func)
		def wrapper(*args, **kwargs):
			print('this is a wrapper in decorator_get_function_duration.inner')
			if enable:
				start = time.time()
				print(f"函數執行前：{start}")
				result = func(*args, **kwargs)
				print('[%s]`s enable was %s it`s duration : %.3f s ' % (func.__name__, enable, time.time() - start))
			else:
				result = func(*args, **kwargs)
			return result

		return wrapper

	return inner


def decorator_1(func):
	print('this is decorator_1')

	@wraps(func)
	def wrapper(*args, **kwargs):
		print('this is a wrapper in decorator_1')
		return func(*args, **kwargs)

	return wrapper


def decorator_2(func):
	print('this is decorator_2')

	@wraps(func)
	def wrapper(*args, **kwargs):
		print('this is a wrapper in decorator_2')
		return func(*args, **kwargs)

	return wrapper


@decorator_1 # 此處相當:decorator_1(decorator_2(decorator_get_function_duration(enable=True)(fun)))
@decorator_2 # = decorator_2(decorator_get_function_duration(enable=True)(fun))
@decorator_get_function_duration(enable=True)  # = decorator_get_function_duration(enable=True)(fun)
def fun():
	time.sleep(2)
	print("fun 執行完了～")


fun()
# ======== enable=False ============
"""
this is decorator_get_function_duration
this is inner in decorator_get_function_duration
this is decorator_2
this is decorator_1
this is a wrapper in decorator_1
this is a wrapper in decorator_2
this is a wrapper in decorator_get_function_duration.inner
fun 執行完了～
"""
# ======== enable=True ============
"""
this is decorator_get_function_duration
this is inner in decorator_get_function_duration
this is decorator_2
this is decorator_1
this is a wrapper in decorator_1
this is a wrapper in decorator_2
this is a wrapper in decorator_get_function_duration.inner
函數執行前：1634635708.648994
fun 執行完了～
[fun]`s enable was True it`s duration : 2.002 s 
"""