生成器

通過列表生成式，可以直接建立一個列表，因為記憶體限制，列表容量肯定是有限的，而且建立一個包含100W個元素的列表，不僅佔用很大的儲存空間，如果我們僅僅需要訪問前面幾個元素，那後面絕大多數佔用的空間都白白浪費了。

所以我們不必建立完整的list，從而節省大量的空間，在Python中，這種一邊迴圈一邊計算的機制，成為生成器：generator

建立list和generator的區別僅在於最外成的[]和()

直接打印出list的每一個元素；通過next()函式或者__next()__獲取generator的下一個返回值

generator儲存的是演算法，每次呼叫next()就計算出下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，丟擲StopIteration的錯誤。

也可以使用for迴圈，因為generator也是可迭代物件；

g = (x * x for x in range(10))
for n in g:
    print(n, end=",")   # 0,1,4,9,16,25,36,49,64,81,

所以我們建立一個generator後，基本上永遠不會呼叫next(),而是通過for迴圈來迭代，並且不需要關心StopIteration的錯誤

通過使用yield關鍵字定義

生成器物件通過yield關鍵字定義的函式物件，因此，生成器也是一個函式。生成器用於一個值的序列，以便在迭代器中使用。

def myYield(n):
    while
 
 n > 0:
        print("開始生成...")
        yield n
        print("完成一次...")
        n -= 1
if __name__ == '__main__':
    test = myYield(3)
    for i in test:
        print(i)
"""開始生成...
3
完成一次...
開始生成...
2
完成一次...
開始生成...
1
完成一次...
"""

yield 語句是生成器中的關鍵語句，生成器在例項化時並不會被執行，而是等待呼叫其__next__()方法才開始執行。並且當程式執行完yield語句後就會“吼（hold）住”，即保持當前狀態且停止執行，等待下一次遍歷時才恢復執行。

著名的斐波拉契數列（Fibonacci），除第一個和第二個數外，任意一個數都可由前兩個數相加得到：

斐波拉契數列用列表生成式寫不出來，但是，用函式把它打印出來卻很容易：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b, end=";")
        a, b = b, a+b
        n += 1
fib(10)  # 1;1;2;3;5;8;13;21;34;55;

生成器的方式

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a+b
        n += 1
a = fib(10)
b = [i for i in a]
print(b)   # [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

這裡，最難理解的就是generator和函式的執行流程不一樣。函式是順序執行，遇到return語句或者最後一行函式語句就返回。而變成generator的函式，在每次呼叫next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

生成器使用例項

#encoding:utf-8
import time
import random

food = ["韭菜雞蛋","豬肉白菜","豬肉薺菜","羊肉白菜","豬肉大蔥","蝦仁海鮮"]
def consumer(name):
    print("%s 準備吃包子啦！" % name)
    while True:
        baozi = yield "n"
        print("[%s]餡包子來了,被[%s]吃了!" % (baozi, name))

def producer(name):
    c1 = consumer('大兒子')
    c2 = consumer('小兒子')
    c1.__next__()
    c2.__next__()
    print("%s開始準備做包子啦" % name)
    for i in range(6):
        print("第%d次做了%s個包子" % (i + 1, len(food)))
        time.sleep(random.randint(1, 3))
        f1 = food[i]
        c1.send(f1)
        food.append(f1)
        # 對列表隨機排序
        random.shuffle(food)
        c2.send(food[i])

producer('老子')
"""
大兒子 準備吃包子啦！
小兒子 準備吃包子啦！
老子開始準備做包子啦
第1次做了6個包子
[韭菜雞蛋]餡包子來了,被[大兒子]吃了!
[蝦仁海鮮]餡包子來了,被[小兒子]吃了!
第2次做了7個包子
[豬肉大蔥]餡包子來了,被[大兒子]吃了!
[蝦仁海鮮]餡包子來了,被[小兒子]吃了!
第3次做了8個包子
[韭菜雞蛋]餡包子來了,被[大兒子]吃了!
[韭菜雞蛋]餡包子來了,被[小兒子]吃了!
第4次做了9個包子
[韭菜雞蛋]餡包子來了,被[大兒子]吃了!
[蝦仁海鮮]餡包子來了,被[小兒子]吃了!
第5次做了10個包子
[豬肉大蔥]餡包子來了,被[大兒子]吃了!
[豬肉大蔥]餡包子來了,被[小兒子]吃了!
第6次做了11個包子
[蝦仁海鮮]餡包子來了,被[大兒子]吃了!
[豬肉大蔥]餡包子來了,被[小兒子]吃了!
"""

迭代器

可以直接作用於for迴圈的資料型別有以下幾種

1:集合資料型別，如list,tuple,dict,set,str等

2:generator，包括生成器和帶yield的generator frunction

這些可以 直接作用於for迴圈的物件統稱為可迭代物件：Iterable

list，dict，str雖然是Iterable，卻不是Iterator

from collections import Iterable
from collections import Iterator
print(isinstance([],Iterator))  # False
print(isinstance([],Iterable))  # True 
print(isinstance({},Iterable))  # True
print(isinstance('abc',Iterable))  # True

iter()函式 建立迭代器

iter(iterable) #一個引數，要求引數為可迭代的型別

把list、dict、str等Iterable變成Iterator可以使用iter()函式：

from collections import Iterator
print(isinstance(iter([]), Iterator))  # True
print(isinstance(iter({}), Iterator))  # True
print(isinstance(iter('abc'), Iterator))  # True

Python的Iterator物件表示的是一個數據流，Iterator物件可以被next()函式呼叫並不斷返回下一個資料，直到沒有資料時丟擲StopIteration錯誤。可以把這個資料流看做是一個有序序列，但我們卻不能提前知道序列的長度，只能不斷通過next()函式實現按需計算下一個資料，所以Iterator的計算是惰性的，只有在需要返回下一個資料時它才會計算。

Iterator甚至可以表示一個無限大的資料流，例如全體自然數。而使用list是永遠不可能儲存全體自然數的。

小結

凡是可作用於for迴圈的物件都是Iterable型別；

凡是可作用於next()函式的物件都是Iterator型別，它們表示一個惰性計算的序列；

集合資料型別如list、dict、str等是Iterable但不是Iterator，不過可以通過iter()函式獲得一個Iterator物件

Python的for迴圈本質上就是通過不斷呼叫next()函式實現的

for x in [1, 2, 3, 4, 5]:
    print(x, end=",")
print("\n")
it = iter([1, 2, 3, 4, 5])
while True:
    try:
        x = next(it)
        print(x, end=",")
    except StopIteration:
        break

建立一個迭代器(類)

把一個類作為一個迭代器使用需要在類中實現兩個方法__iter__()與__next__().

__iter__()方法返回一個特殊的迭代器物件，這個迭代器物件實現__next__() 方法並通過StopIteration異常標識迭代的完成。

from itertools import islice

class Fib:
    def __init__(self):
        self.pre = 0
        self.curr = 1
    def __iter__(self):
        return self
    def __next__(self):
        self.pre, self.curr = self.curr, self.pre+self.curr
        return self.pre
f = Fib()
print(list(islice(f, 0, 10)))   # [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

內建迭代器工具

count無限迭代器

from itertools import count
counter = count(start=10)
print(next(counter))    # 10
print(next(counter))   # 11

cycle無限迭代器，從一個有限序列中生成無限序列

from itertools import cycle
counter = cycle([1, 2, 3])
print(next(counter))  # 1
print(next(counter))  # 2
print(next(counter))  # 3
print(next(counter))  # 1

itertools的子模組islice控制無限迭代器輸出的方式

islice的第二個引數控制何時停止迭代，從無限的序列中生成有限序列

from itertools import islice, count
for i in islice(count(10), 5):
    print(i)

裝飾器

函式即“”變數“”

高階函式

把一個函式名當做實參傳給另一個函式

返回值中包含函式名

高階函式+巢狀函式=裝飾器

import time
def timer(func):
    def deco(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)
        stop_time = time.time()
        print("the func run time is %s"%(stop_time - start_time))
    return deco

@timer
def test_1():
    time.sleep(1)
    print("in the test_1")

@timer
def test_2():
    time.sleep(1)
    print("in the test_2")

test_1()
test_2()
"""
in the test_1
the func run time is 1.0200583934783936
in the test_2
the func run time is 1.0000574588775635
"""

類裝飾器

類裝飾器具有靈活度大，高內聚，封裝性等優點。使用類裝飾器主要依靠類的__call__方法

class Foo():
    def __init__(self, func):
        self._func = func
    def __call__(self, *args, **kwargs):
        print("class running")
        self._func()
        print("class end")
@Foo
def bar():
    print("bar")
bar()

裝飾器可以把與業務邏輯無關的程式碼抽離出來，讓程式碼保持乾淨清爽，而且裝飾器還能被多個地方重複利用。比如一個爬蟲網頁的函式，如果該 URL 曾經被爬過就直接從快取中獲取，否則爬下來之後加入到快取，防止後續重複爬取。

import urllib.request as urlib
def cache(func):
    saved = {}
    def wrapper(url):
        if url in saved:
            return saved[url]
        else:
            page = func(url)
            saved[url] = page
            return page
    return wrapper

@cache
def web(url):
    return urlib.urlopen(url).read()

帶引數的decorator

import functools
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print("%s %s()" %(text, func.__name__))
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log("execute")
def now():
    print("2015-3-25")
    
now()
print(now.__name__)

例項-登入認證

import functools

user, passwd = "test", "123456"
def auth(auth_type):
    def decotator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if auth_type == "local":
                username = input("請輸入使用者名稱:").strip()
                password = input("請輸入密碼:").strip()
                if user == username and passwd == password:
                    print("\033[32;1mUser has passed authentication\033[0m")
                    res = func(*args, **kwargs)
                    print("--after authentication--")
                    return res
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == "ldap":
                res = func(*args, **kwargs)
                print("ldap都不會")
                return res
        return wrapper
    return decotator
def index():
    print("welcome to index page")
@auth(auth_type="local")
def home():
    print("welcome to home page")
@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs page")
index()
home()
bbs()

轉自: https://blog.csdn.net/sunchengquan/article/details/84494101