python迭代器、生成器和裝飾器
文章目錄
生成器
通過列表生成式，我們可以直接建立一個列表。但是，受到記憶體限制，列表容量肯定是有限的。而且，建立一個包含100萬個元素的列表，不僅佔用很大的儲存空間，如果我們僅僅需要訪問前面幾個元素，那後面絕大多數元素佔用的空間都白白浪費了。
所以，如果列表元素可以按照某種演算法推算出來，那我們是否可以在迴圈的過程中不斷推算出後續的元素呢？這樣就不必建立完整的list，從而節省大量的空間。在Python中，這種一邊迴圈一邊計算的機制，稱為生成器：generator。
要建立一個generator，有很多種方法。第一種方法很簡單，只要把一個列表生成式的[]改成()，就建立了一個generator：
生成器表示式(generator expression)
L = [x + 1 for x in range(10)]
print(L)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
列表生成式複習
實現列表元素加1，列表生成式與其它方法比較：
#普通方法1
b = []
for i in range(10):
b.append(i+1)
print(b)
#普通方法2
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for index,i in enumerate(a):
a[index] +=1
print(a) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
g = (x + 1 for x in range(10))
print(g)
<generator object <genexpr> at 0x7fe03ad859a8>
建立L和g的區別僅在於最外層的[]和()，L是一個list，而g是一個generator。
我們可以直接打印出list的每一個元素，但我們怎麼打印出generator的每一個元素呢？
如果要一個一個打印出來，可以通過next()函式（or __next__()）獲得generator的下一個返回值：
next(g)
1
next(g)
2
next(g)
3
g.__next__()
4
g.__next__()
5
generator儲存的是演算法，每次呼叫next(g)，就計算出g的下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，丟擲StopIteration的錯誤
上面這種不斷呼叫next(g)實在是太變態了，正確的方法是使用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關鍵字定義的函式物件，因此，生成器也是一個函式。生成器用於生成一個值得序列，以便在迭代器中使用。
"""
第一是直接作為指令碼執行，
第二是import到其他的python指令碼中被呼叫（模組重用）執行。
因此if __name__ == '__main__': 的作用就是控制這兩種情況執行程式碼的過程，
在if __name__ == '__main__':下的程式碼只有在第一種情況下（即檔案作為指令碼直接執行）才會被執行，而import到其他指令碼中是不會被執行的。
"""
def myYield(n):
while n>0:
print('開始生成。。。')
yield n
print('完成一次。。。')
n -= 1
if __name__ == '__main__':
a = myYield(3)
print('已經例項化生成器物件')
# a.__next__()
# print('第二次呼叫__next__()方法：')
# a.__next__()
已經例項化生成器物件
yield 語句是生成器中的關鍵語句，生成器在例項化時並不會被執行，而是等待呼叫其__next__()方法才開始執行。並且當程式執行完yield語句後就會“吼（hold）住”，即保持當前狀態且停止執行，等待下一次遍歷時才恢復執行。
程式執行的結果中的空行後的輸出“已經例項化生成器物件”之前，已經例項化了生成器物件，但生成器並沒有執行（沒有輸出‘開始生成’）。當第一次手工呼叫__next__()方法之後，才輸出‘開始生成’，標誌著生成器已經執行，而在輸出‘’第二次呼叫__next__()方法‘’之前並沒有輸出‘完成一次’，說明yield語句執行之後就立即停止了。而第二次呼叫__next__()方法之後，才輸出‘完成一次’，說明生成器的回覆執行是從yield語句之後開始執行的
return_value = a.__next__()
print(return_value)
開始生成。。。
3
print('第二次呼叫__next__()方法：')
第二次呼叫__next__()方法：
return_value = a.__next__()
print(return_value)
完成一次。。。
開始生成。。。
2
著名的斐波拉契數列（Fibonacci），除第一個和第二個數外，任意一個數都可由前兩個數相加得到：
斐波拉契數列用列表生成式寫不出來，但是，用函式把它打印出來卻很容易：
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return 'done'
注意，賦值語句：
a, b = b, a + b
相當於：
t = (b, a + b) # t是一個tuple
a = t[0]
b = t[1]
上面的函式可以輸出斐波那契數列的前N個數：
fib(5)
1
1
2
3
5
'done'
上面的函式和generator僅一步之遙。要把fib函式變成generator，只需要把print(b)改為yield b就可以了：
def fib(max):
n,a,b = 0,0,1
while n < max:
#print(b)
yield b
a,b = b,a+b
n += 1
return 'well done'
這裡，最難理解的就是generator和函式的執行流程不一樣。函式是順序執行，遇到return語句或者最後一行函式語句就返回。而變成generator的函式，在每次呼叫next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。
f = fib(5)
print(f)
print(list(f))
#重新例項化生成器物件
f = fib(5)
<generator object fib at 0x7fe038493840>
[1, 1, 2, 3, 5]
print(f.__next__())
print(f.__next__())
print("乾點別的事")
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
1
1
乾點別的事
2
3
5
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-18-9609f54647c6> in <module>
5 print(f.__next__())
6 print(f.__next__())
----> 7 print(f.__next__())
StopIteration: well done
用for迴圈呼叫generator時，發現拿不到generator的return語句的返回值。如果想要拿到返回值，必須捕獲StopIteration錯誤，返回值包含在StopIteration的value中：
g = fib(6)
while True:
try:
x = next(g)
print('g:', x)
except StopIteration as e:
print('Generator return value:', e.value)
break
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: well done
from itertools import islice
def fib():
a,b = 0,1
while True:
yield b
a,b = b,a+b
f = fib()
print(list(islice(f ,0,10)))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
生成器在Python中是一個非常強大的程式設計結構，可以用更少地中間變數寫流式程式碼，此外，相比其它容器物件它更能節省記憶體和CPU，當然它可以用更少的程式碼來實現相似的功能。現在就可以動手重構你的程式碼了，但凡看到類似
def something():
result= []
for ... in ...：
result.append(x)
return result
都可以用生成器函式來替換：
def iter_something():
result = []
for ... in ...：
yield x
楊輝三角
期待輸出:
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
def triangles():
result = [1]
while True:
yield result
result = [1] + [result[i] + result[i+1] for i in range(len(result)-1)] + [1]
n = 0
results = []
for t in triangles():
print(t)
results.append(t)
n = n + 1
if n == 10:
break
if results == [
[1],
[1, 1],
[1, 2, 1],
[1, 3, 3, 1],
[1, 4, 6, 4, 1],
[1, 5, 10, 10, 5, 1],
[1, 6, 15, 20, 15, 6, 1],
[1, 7, 21, 35, 35, 21, 7, 1],
[1, 8, 28, 56, 70, 56, 28, 8, 1],
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
]:
print('測試通過!')
else:
print('測試失敗!')
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
測試通過!
迭代器
迭代器概述
可以直接作用於for迴圈的資料型別有以下幾種：
- 一類是集合資料型別,如list,tuple,dict,set,str等
- 一類是generator ，包括生成器和帶yeild的generator function
這些可以 直接作用於for迴圈的物件統稱為可迭代物件：Iterable
可以被next()函式呼叫並不斷返回下一個值的物件稱為迭代器：Iterator
a = [i for i in range(10)]
next(a)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-23-8981550fe3e0> in <module>
1 a = [i for i in range(10)]
----> 2 next(a)
TypeError: 'list' object is not an iterator
list，dict，str雖然是Iterable，卻不是Iterator
from collections import Iterator
from collections import Iterable
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))
print(isinstance({},Iterable))
print(isinstance('abc',Iterable))
False
True
True
True
生成器就是一個迭代器
a = (i for i in range(10))
print(next(a))
print(isinstance(a,Iterator))
0
True
iter()函式 建立迭代器
iter（iterable）#一個引數，要求引數為可迭代的型別
把list、dict、str等Iterable變成Iterator可以使用iter()函式：
print(isinstance({},Iterator))
print(isinstance('abc',Iterator))
print(isinstance(iter({}),Iterator))
print(isinstance(iter('abc'),Iterator))
False
False
True
True
你可能會問，為什麼list、dict、str等資料型別不是Iterator？
這是因為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=',')
1,2,3,4,5,
實際上完全等價於：
# 首先獲得Iterator物件:
it = iter([1, 2, 3, 4, 5])
# 迴圈:
while True:
try:
# 獲得下一個值:
x = next(it)
print(x,end=',')
except StopIteration:
# 遇到StopIteration就退出迴圈
break
1,2,3,4,5,
建立一個迭代器(類)
把一個類作為一個迭代器使用需要在類中實現兩個方法 __iter__() 與 __next__() 。
如果你已經瞭解的面向物件程式設計，就知道類都有一個建構函式，Python 的建構函式為 __init__(), 它會在物件初始化的時候執行
__iter__() 方法返回一個特殊的迭代器物件， 這個迭代器物件實現了 __next__() 方法並通過 StopIteration 異常標識迭代的完成。
from itertools import islice
class Fib:
def __init__(self):
self.prev = 0
self.curr = 1
def __iter__(self):
return self
def __next__(self):
self.prev,self.curr = self.curr,self.prev+self.curr
return self.curr
f = Fib()
print(list(islice(f ,0,10)))
[1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Fib既是一個可迭代物件（因為它實現了 __iter__方法），又是一個迭代器（因為實現了 __next__方法)
StopIteration
StopIteration 異常用於標識迭代的完成，防止出現無限迴圈的情況，在 next() 方法中我們可以設定在完成指定迴圈次數後觸發 StopIteration 異常來結束迭代。
在 20 次迭代後停止執行：
class MyNumbers:
def __init__(self):
self.a = 1
def __iter__(self):
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = MyNumbers()
# myiter = iter(myclass)
for x in myiter:
print(x,end=",")
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
內建迭代器工具
比如 itertools 函式返回的都是迭代器物件
count無限迭代器
from itertools import count
counter = count(start=10)
print(next(counter))
print(next(counter)) #python內建函式next()對itertools建立的迭代器進行迴圈
10
11
cycle 無限迭代器，從一個有限序列中生成無限序列：
from itertools import cycle
colors = cycle(['red','black','blue'])
print(next(colors))
print(next(colors))
print(next(colors))
print(next(colors))
print(next(colors))
red
black
blue
red
black
itertools的子模組 islice 控制無限迭代器輸出的方式
islice的第二個引數控制何時停止迭代，迭代了11次後停止，從無限的序列中生成有限序列：
from itertools import count
counter = count(start=10)
i=4
print(next(counter))
while i > 0:
print(next(counter))
i -= 1
10
11
12
13
14
from itertools import count
for i in count(10):
if i > 14 :
break
else:
print(i)
10
11
12
13
14
from itertools import islice
from itertools import count
for i in islice(count(10),5):
print(i)
10
11
12
13
14
from itertools import cycle
from itertools import islice
colors = cycle(['red','black','blue'])
limited = islice(colors,0,4)
for x in limited:
print(x)
red
black
blue
red
裝飾器
器，代表函式的意思
裝飾器：本質是函式（裝飾其他函式）就是為其他函式新增附加功能
每個人都有的內褲主要功能是用來遮羞，但是到了冬天它沒法為我們防風禦寒，咋辦？我們想到的一個辦法就是把內褲改造一下，讓它變得更厚更長，這樣一來，它不僅有遮羞功能，還能提供保暖，不過有個問題，這個內褲被我們改造成了長褲後，雖然還有遮羞功能，但本質上它不再是一條真正的內褲了。於是聰明的人們發明長褲，在不影響內褲的前提下，直接把長褲套在了內褲外面，這樣內褲還是內褲，有了長褲後寶寶再也不冷了。裝飾器就像我們這裡說的長褲，在不影響內褲作用的前提下，給我們的身子提供了保暖的功效。
原則：
- 1 不能修改被裝飾的函式的原始碼
- 2 不能修改被裝飾的函式的呼叫方式
實現裝飾器知識儲備：
-
1 函式即“”變數“”
-
2 高階函式
a 把一個函式名當做實參傳給另一個函式
b 返回值中包含函式名
高階函式
import time
def bar():
time.sleep(3)
print('in the bar')
def test2(func):
print(func)
return func
print(test2(bar)) #呼叫test2，列印bar的記憶體地址，返回bar的記憶體地址，又列印
<function bar at 0x7fe03849e620>
<function bar at 0x7fe03849e620>
bar=test2(bar) # 返回的bar的記憶體地址，賦值給bar
bar() #run bar
<function bar at 0x7fe03849e620>
in the bar
巢狀函式
x = 0
def grandpa():
x = 1
print(x)
def dad():
x =2
print(x)
def son():
x =3
print(x)
son()
dad()
grandpa()
1
2
3
高階函式+巢狀函式 = 裝飾器
import time
def timer(func
相關推薦
python迭代器、生成器和裝飾器
文章目錄
生成器
生成器表示式(generator expression)
通過使用yield關鍵字定義
迭代器
迭代器概述
iter()函式 建立迭代器
建立一個迭代器(類)
內建迭代器
python迭代器、生成器和yield語句
一、迭代器(iterator)迭代器：是一個實現了迭代器協議的物件，Python中的迭代器協議就是有next方法的物件會前進到下一結果，而在一系列結果的末尾是，則會引發StopIteration。任何這類的物件在Python中都可以用for迴圈或其他遍歷工具迭代，迭代工具內部
四.Python叠代器生成器和裝飾器
div 惰性 python 附加 next lee 裝飾器 生成 star 叠代器
叠代是Python最強大的功能之一，是訪問集合元素的一種方式。
叠代器是一個可以記住遍歷的位置的對象。
叠代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。叠代器只能往前不會後
初學Python——列表生成式、生成器和叠代器
過程 100萬 import 通過 str __next__ 出現 tor 創建 一、列表生成式
假如現在有這樣一個需求：快速生成一個列表[1，2，3，4，5，6，7，8，9，10]，該如何實現？
在不知道列表生成式的情況下，可能會這樣寫：
a=[1,2,3,4,5,6,
搞清楚 Python 的迭代器、可迭代物件、生成器
很多夥伴對 Python 的迭代器、可迭代物件、生成器這幾個概念有點搞不清楚，我來說說我的理解，希望對需要的朋友有所幫助。
1 迭代器協議
迭代器協議是核心，搞懂了這個，上面的幾個概念也就很好理解了。
所謂迭代器協議，就是要求一個迭代器必須要實現如下兩個方法
iterator.__iter__(
完全理解Python迭代物件、迭代器、生成器
本文源自RQ作者的一篇博文，原文是Iterables vs. Iterators vs. Generators，俺寫的這篇文章是按照自己的理解做的參考翻譯，算不上是原文的中譯版本，推薦閱讀原文，謝謝網友指正。
在瞭解Python的資料結構時，容器(container)、可迭代物件(ite
一篇文章讓你吃透Python迭代物件、迭代器、生成器
在瞭解Python的資料結構時，容器(container)、可迭代物件(iterable)、迭代器(iterator)、生成器(generator)、列表/集合/字典推導式(list,set,dict comprehension)眾多概念參雜在一起，難免讓初學者一頭霧水，我將
python迭代器，生成器，裝飾器
1.1迭代器
什麼是迭代器：
迭代器是一個可以記住遍歷的位置物件
迭代器物件從集合的第一個元素元素開始訪問，直到所有元素被訪問完結束，迭代器只能往前不會後退。
迭代器有兩個基本方法:iter ,next 方法
內建函式iter(),next() 本質上都
Python：迭代器、可迭代物件、生成器
1、什麼叫迭代
現在，我們已經獲得了一個新線索，有一個叫做“可迭代的”概念。
首先，我們從報錯來分析，好像之所以1234不可以for迴圈，是因為它不可迭代。那麼如果“可迭代”，就應該可以被for迴圈了。
這個我們知道呀，字串、列表、元組、字典、集合都可以被for迴圈，說明他們都是可迭代的
Python迭代器&生成器&裝飾器
1. 迭代器
1.1 可迭代物件（Iterator）
迭代器協議：某物件必須提供一個__next__()方法，執行方法要麼返回迭代中的下一項，要麼引起一個Stopiteration異常，以終止迭代（只能往後走，不能往前退）
協議是一種規範，可迭代物件實現了迭代器協議，python的內部工具（如for迴圈、su
Python之叠代器，生成器與裝飾器
新的 訪問 所有 image ges 中斷 往回 並發 函數調用 1》叠代器原理及使用： 1>原理： 叠代器是訪問集合元素的一種方式，叠代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束；叠代器只能往前不會後退，不過
Python-叠代器&生成器&裝飾器&軟件目錄結構規範-Day5
添加 regex 3.6 back 斐波拉契數列 場景 開發 要求 網站 目錄Day-Python-叠代器&生成器 21、生成器 21.1、生成器引入 21.2、生成器作用 31.3、創建生成器的方法 31.4、用函數來實現復雜的生成器 51.5、把函數變成生成器通
Python高級用法總結--(列表推導式，叠代器，生成器，裝飾器)
方法 叠代器 裝飾 理解 函數調用 循環 一維數組 信息 可叠代對象 列表推導式（list comprehensions）
場景1：將一個三維列表中所有一維數據為a的元素合並，組成新的二維列表。
最簡單的方法：新建列表，遍歷原三維列表，判斷一維數組是否為a，若為a，則將該元
迭代器、可迭代物件、生成器
迭代器與可迭代物件
1、定義：
可迭代物件：大部分容器如 list，truples，str，sets是可迭代物件，但是他們不是迭代器。可迭代物件實現了__iter__方法，返回一個迭代器，或者使用iter(“可迭代物件”)返回一個迭代器。
迭代器：迭代器提供了一
python叠代器，生成器，裝飾器
分享圖片 不能 動態 *args user 效率問題 格式 next 兩種
1.1叠代器
什麽是叠代器：
叠代器是一個可以記住遍歷的位置對象
叠代器對象從集合的第一個元素元素開始訪問，直到所有元素被訪問完結束，叠代器只能往前不會後退。
叠代器有兩個基本方法:iter
迭代器，生成器與裝飾器
迭代：類似於迴圈，每一次重複的過程被稱為一次迭代的過程，而每一次迭代得到的結果會被用來作為
下一次迭代的初始值，提供迭代方法的容器稱為迭代器，通常接觸的迭代器有序列（列表、元組、字串），
還有字典也是迭代器，都支援迭代的操作。
關於迭代，python提供了兩個BIF：i
python 函數名 、閉包 裝飾器 day13
設計 fun int ner 數據 .html post open inner 1，函數名的使用。
函數名是函數的名字，本質就是變量，特殊的變量。函數名（）加括號就是執行此函數。
1，單獨打印函數名就是此函數的內存地址。
def func1():
print(
Python全棧__函數的有用信息、帶參數的裝飾器、多個裝飾器裝飾一個函數
G1 lee 參數 sed 信息 back red cdc subclass 1、函數的有用信息
代碼1：
1 def login(username, password):
2 """
3 此函數需要用戶名，密碼兩個參數，完成的是登
Python-23_裝飾器-04_練習---無參裝飾器、有參裝飾器
一、無參裝飾器：
京東後端程式簡寫，並加上驗證功能：編寫一個裝飾器，提供驗證功能：
# 使用者資訊表：
user_list=[
{'name':'new1','passwd':'123'},
{'name':'new2','passwd':'123'},
{'name':'n
10-5裝飾器進階_帶參數的裝飾器、多個裝飾器裝飾同一個函數
image star 結果 一個 -- sta highlight 是否 bsp 帶參數的裝飾器
只用在裝飾器最外層嵌套一個即可，以達到輕易控制裝飾器函數是否執行的作用
import time
flag = False
def timmer_outer(flag):