本文章在博客園也系本人發表 點擊查看
1.生成器：
1.1 起源：
如果列表中有一萬個元素，我們只想要訪問前面幾個元素，對其進行相關操作，通過for循環方式效率太低，並且後面的元素會浪費內存，還會受到內存限制，所以產生生成器來解決這個問題。
1.2 啥是生成器：
通過某種算法推演出我們所需要的內容，而不必創建所有的列表元素。這種一邊循環一遍計算的機制叫做生成器（generator）。通過使用yield返回值函數，每次調用yield都會暫停，將值返回出去進行計算處理。生成器類似於返回值爲數組的一個函數，這個函數可以接受參數，可以被調用，但是，不同於一般的函數會一次性返回包括了所有數值的數組，生成器一次只能產生一個值，這樣消耗的內存數量將大大減小。生成器也是一個更加複雜的迭代器。
1.3 創建生成器：
方法一：把列表生成式的 [ ] 改爲 ( ) 即可。
generator_item = ( i*i for i in range(10)) 輸出：<generator object <genexpr> at 0x000002A4CBF9EBA0>
如果要一個個打印出來，可以通過next（）函數獲得generator的下一個返回值
print(next(generator_item)) ==> 1
print(next(generator_item)) ==> 4
print(next(generator_item)) ==> 9
......
通過這種方式（調用next（）方法） ，最後會報錯 StopIteration ，所以一般不用這種方法，一般用for循環遍歷生成器
方法二：通過函數的形式創建，典型例子，斐波那契數列
def fib(max):
n,a,b =0,0,1
while n < max:
yield b
a,b =b,a+b
n = n+1
return 'done'
g = fib(6)
while True:
try:
x = next(g)
print('generator: ',x)
except StopIteration as e:
print("生成器返回值：",e.value)
break
1.4 生成器的方法：
send（）
throw（）
close（）
1.5 生成器工作流程
（1）生成器(generator)能夠迭代的關鍵是它有一個next()方法，
工作原理就是通過重複調用next()方法，直到捕獲一個異常。
（2）帶有 yield 的函數不再是一個普通函數，而是一個生成器generator。
可用next()調用生成器對象來取值。next 兩種方式 t.__next__() | next(t)。
可用for 循環獲取返回值（每執行一次，取生成器裏面一個值）
（基本上不會用next()來獲取下一個返回值，而是直接使用for循環來迭代）。
（3）yield相當於 return 返回一個值，並且記住這個返回的位置，下次迭代時，代碼從yield的下一條語句開始執行。
（4）.send() 和next()一樣，都能讓生成器繼續往下走一步（下次遇到yield停），但send()能傳一個值，這個值作爲yield表達式整體的結果——換句話說，就是send可以強行修改上一個yield表達式值。比如函數中有一個yield賦值，a = yield 5，第一次迭代到這裏會返回5，a還沒有賦值。第二次迭代時，使用.send(10)，那麼，就是強行修改yield 5表達式的值爲10，本來是5的，那麼a=10
感受下yield返回值的過程（關注點：每次停在哪，下次又開始在哪）及send()傳參的通訊過程，
思考None是如何產生的（第一次取值：yield 返回了 i 值 0，停在yield i，temp沒賦到值。第二次取值，開始在print，temp沒被賦值，故打印None，i加1，繼續while判斷，yield 返回了 i 值 1，停在yield i）
2. 迭代器：（迭代就是循環）
2.1 定義：迭代器包含有next方法的實現，在正確的範圍內返回期待的數據以及超出範圍後能夠拋出StopIteration的錯誤停止迭代。
2.2 我們已經知道，可以直接作用於for循環的數據類型有以下幾種：
一類是集合數據類型，如list,tuple,dict,set,str等
一類是generator，包括生成器和帶yield的generator function
這些可以直接作用於for 循環的對象統稱爲可迭代對象：Iterable
可以使用isinstance()判斷一個對象是否爲可Iterable對象
生成器不但可以作用於for循環，還可以被next()函數不斷調用並返回下一個值，直到最後拋出StopIteration錯誤表示無法繼續返回下一個值
使用iter()函數可以將序列轉化爲迭代器
2.3 小結
- 凡是可作用於
for循環的對象都是Iterable類型； - 凡是可作用於
next()函數的對象都是Iterator類型，它們表示一個惰性計算的序列； - 集合數據類型如
list、dict、str等是Iterable但不是Iterator，不過可以通過iter()函數獲得一個Iterator對象
3. with上下文管理器
一些不得不知道的知識：
上下文管理協議：context mangement protocol。協議，包含了某些方法，大家都應該跟着去做的。在這裏就是 __enter__和__exit__兩個方法。
上下文管理器：支持上下文管理協議的對象，這種對象實現了__enter__和__exit__方法。
as的作用：將返回的對象賦給一個變量，以方便以後的使用。
with是一個對象
運行步驟：
1.當進入語句塊時，先執行__enter__方法，把文件打開，並返回該文件對象
2.執行代碼塊內容
3.離開代碼塊的時候，執行__exit__方法，關閉文件。
在執行過程中，無論遇到什麼異常，都是要離開代碼塊的，這個時候就由__exit__方法接管了。可以在__exit__中定義，讓異常顯示出來。
with 上下文管理器 as target:
代碼語句體
本文中的函數裝飾器引用自菜鳥教程中的筆記
4.裝飾器
定義：他們是修改其他函數的功能的函數。
作用：他們有助於讓我們的代碼更簡短，也更Pythonic（Python範兒）。
講 Python 裝飾器前，我想先舉個例子，雖有點污，但跟裝飾器這個話題很貼切。
每個人都有的內褲主要功能是用來遮羞，但是到了冬天它沒法爲我們防風禦寒，咋辦？我們想到的一個辦法就是把內褲改造一下，讓它變得更厚更長，這樣一來，它不僅有遮羞功能，還能提供保暖，不過有個問題，這個內褲被我們改造成了長褲後，雖然還有遮羞功能，但本質上它不再是一條真正的內褲了。於是聰明的人們發明長褲，在不影響內褲的前提下，直接把長褲套在了內褲外面，這樣內褲還是內褲，有了長褲後寶寶再也不冷了。裝飾器就像我們這裏說的長褲，在不影響內褲作用的前提下，給我們的身子提供了保暖的功效。
談裝飾器前，還要先要明白一件事，Python 中的函數和 Java、C++不太一樣，Python 中的函數可以像普通變量一樣當做參數傳遞給另外一個函數，例如：
def foo():
print("foo")
def bar(func):
func()
bar(foo)
正式回到我們的主題。裝飾器本質上是一個 Python 函數或類，它可以讓其他函數或類在不需要做任何代碼修改的前提下增加額外功能，裝飾器的返回值也是一個函數/類對象。它經常用於有切面需求的場景，比如：插入日誌、性能測試、事務處理、緩存、權限校驗等場景，裝飾器是解決這類問題的絕佳設計。有了裝飾器，我們就可以抽離出大量與函數功能本身無關的雷同代碼到裝飾器中並繼續重用。概括的講，裝飾器的作用就是爲已經存在的對象添加額外的功能。
先來看一個簡單例子，雖然實際代碼可能比這複雜很多：
def foo():
print('i am foo')
現在有一個新的需求，希望可以記錄下函數的執行日誌，於是在代碼中添加日誌代碼：
def foo():
print('i am foo')
logging.info("foo is running")
如果函數 bar()、bar2() 也有類似的需求，怎麼做？再寫一個 logging 在 bar 函數裏？這樣就造成大量雷同的代碼，爲了減少重複寫代碼，我們可以這樣做，重新定義一個新的函數：專門處理日誌 ，日誌處理完之後再執行真正的業務代碼
def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()
def foo():
print('i am foo')
use_logging(foo)
這樣做邏輯上是沒問題的，功能是實現了，但是我們調用的時候不再是調用真正的業務邏輯 foo 函數，而是換成了 use_logging 函數，這就破壞了原有的代碼結構， 現在我們不得不每次都要把原來的那個 foo 函數作爲參數傳遞給 use_logging 函數，那麼有沒有更好的方式的呢？當然有，答案就是裝飾器。
簡單裝飾器
def use_logging(func):
def wrapper():
logging.warn("%s is running" % func.__name__)
return func() # 把 foo 當做參數傳遞進來時，執行func()就相當於執行foo()
return wrapper
def foo():
print('i am foo')
foo = use_logging(foo) # 因爲裝飾器 use_logging(foo) 返回的時函數對象 wrapper，這條語句相當於 foo = wrapper
foo() # 執行foo()就相當於執行 wrapper()
use_logging 就是一個裝飾器，它一個普通的函數，它把執行真正業務邏輯的函數 func 包裹在其中，看起來像 foo 被 use_logging 裝飾了一樣，use_logging 返回的也是一個函數，這個函數的名字叫 wrapper。在這個例子中，函數進入和退出時 ，被稱爲一個橫切面，這種編程方式被稱爲面向切面的編程。
@ 語法糖
如果你接觸 Python 有一段時間了的話，想必你對 @ 符號一定不陌生了，沒錯 @ 符號就是裝飾器的語法糖，它放在函數開始定義的地方，這樣就可以省略最後一步再次賦值的操作。
def use_logging(func):
def wrapper():
logging.warn("%s is running" % func.__name__)
return func()
return wrapper
@use_logging
def foo():
print("i am foo")
foo()
如上所示，有了 @ ，我們就可以省去foo = use_logging(foo)這一句了，直接調用 foo() 即可得到想要的結果。你們看到了沒有，foo() 函數不需要做任何修改，只需在定義的地方加上裝飾器，調用的時候還是和以前一樣，如果我們有其他的類似函數，我們可以繼續調用裝飾器來修飾函數，而不用重複修改函數或者增加新的封裝。這樣，我們就提高了程序的可重複利用性，並增加了程序的可讀性。
裝飾器在 Python 使用如此方便都要歸因於 Python 的函數能像普通的對象一樣能作爲參數傳遞給其他函數，可以被賦值給其他變量，可以作爲返回值，可以被定義在另外一個函數內。
*args、**kwargs
可能有人問，如果我的業務邏輯函數 foo 需要參數怎麼辦？比如：
def foo(name):
print("i am %s" % name)
我們可以在定義 wrapper 函數的時候指定參數：
def wrapper(name):
logging.warn("%s is running" % func.__name__)
return func(name)
return wrapper
這樣 foo 函數定義的參數就可以定義在 wrapper 函數中。這時，又有人要問了，如果 foo 函數接收兩個參數呢？三個參數呢？更有甚者，我可能傳很多個。當裝飾器不知道 foo 到底有多少個參數時，我們可以用 *args 來代替：
def wrapper(*args):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper
如此一來，甭管 foo 定義了多少個參數，我都可以完整地傳遞到 func 中去。這樣就不影響 foo 的業務邏輯了。這時還有讀者會問，如果 foo 函數還定義了一些關鍵字參數呢？比如：
def foo(name, age=None, height=None):
print("I am %s, age %s, height %s" % (name, age, height))
這時，你就可以把 wrapper 函數指定關鍵字函數：
def wrapper(*args, **kwargs):
# args是一個數組，kwargs一個字典
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapper
帶參數的裝飾器
裝飾器還有更大的靈活性，例如帶參數的裝飾器，在上面的裝飾器調用中，該裝飾器接收唯一的參數就是執行業務的函數 foo 。裝飾器的語法允許我們在調用時，提供其它參數，比如@decorator(a)。這樣，就爲裝飾器的編寫和使用提供了更大的靈活性。比如，我們可以在裝飾器中指定日誌的等級，因爲不同業務函數可能需要的日誌級別是不一樣的。
def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
elif level == "info":
logging.info("%s is running" % func.__name__)
return func(*args)
return wrapper
return decorator
@use_logging(level="warn")
def foo(name='foo'):
print("i am %s" % name)
foo()
上面的 use_logging 是允許帶參數的裝飾器。它實際上是對原有裝飾器的一個函數封裝，並返回一個裝飾器。我們可以將它理解爲一個含有參數的閉包。當我 們使用@use_logging(level="warn")調用的時候，Python 能夠發現這一層的封裝，並把參數傳遞到裝飾器的環境中。
@use_logging(level="warn") 等價於 @decorator
類裝飾器
沒錯，裝飾器不僅可以是函數，還可以是類，相比函數裝飾器，類裝飾器具有靈活度大、高內聚、封裝性等優點。使用類裝飾器主要依靠類的__call__方法，當使用 @ 形式將裝飾器附加到函數上時，就會調用此方法。
class Foo(object):
def __init__(self, func):
self._func = func
def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')
@Foo
def bar():
print ('bar')
bar()
functools.wraps
使用裝飾器極大地複用了代碼，但是他有一個缺點就是原函數的元信息不見了，比如函數的docstring、__name__、參數列表，先看例子：
# 裝飾器
def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ # 輸出 'with_logging'
print func.__doc__ # 輸出 None
return func(*args, **kwargs)
return with_logging
# 函數
@logged
def f(x):
"""does some math"""
return x + x * x
logged(f)
不難發現，函數 f 被with_logging取代了，當然它的docstring，__name__就是變成了with_logging函數的信息了。好在我們有functools.wraps，wraps本身也是一個裝飾器，它能把原函數的元信息拷貝到裝飾器裏面的 func 函數中，這使得裝飾器裏面的 func 函數也有和原函數 foo 一樣的元信息了。
from functools import wraps
def logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ # 輸出 'f'
print func.__doc__ # 輸出 'does some math'
return func(*args, **kwargs)
return with_logging
@logged
def f(x):
"""does some math"""
return x + x * x
裝飾器順序
一個函數還可以同時定義多個裝飾器，比如：
@a
@b
@c
def f ():
pass
它的執行順序是從裏到外，最先調用最裏層的裝飾器，最後調用最外層的裝飾器，它等效於
f = a(b(c(f)))