python中的生成器
❶ python迭代器和生成器區別是什麼
python中迭代器和生成器的區別
1、共同點
生成器是一種特殊的迭代器。
相關推薦:《Python視頻教程》
2、不同點
a、語法上:
生成器是通過函數的形式中調用 yield 或()的形式創建的。
迭代器可以通過 iter() 內置函數創建。
b、用法上:
生成器在調用next()函數或for循環中,所有過程被執行,且返回值。
迭代器在調用next()函數或for循環中,所有值被返回,沒有其他過程或動作。
❷ Python中生成器表達式的理解
9.11. 生成器表達式
有時簡單的生成器可以用簡潔的方式調用,就像不帶中括弧的鏈表推導式。這些表達式是為函數調用生成器而設計的。生成器表達式比完整的生成器定義更簡潔,但是沒有那麼多變,而且通常比等價的鏈表推導式更容易記。
例如:
>>> sum(i*i for i in range(10)) # sum of squares
285
>>> xvec = [10, 20, 30]
>>> yvec = [7, 5, 3]
>>> sum(x*y for x,y in zip(xvec, yvec)) # dot proct
260
>>> from math import pi, sin
>>> sine_table = {x: sin(x*pi/180) for x in range(0, 91)}
>>> unique_words = set(word for line in page for word in line.split())
>>> valedictorian = max((student.gpa, student.name) for student in graates)
>>> data = 'golf'
>>> list(data[i] for i in range(len(data)-1, -1, -1))
['f', 'l', 'o', 'g']
Footnotes
[1] 有一個例外。模塊對象有一個隱秘的只讀對象,名為 __dict__ ,它返回用於實現模塊命名空間的字典,命名 __dict__ 是一個屬性而非全局命名。顯然,使用它違反了命名空間實現的抽象原則,應該被嚴格限制於調試中。
❸ Python中如何使生成器函數來用元組返回一個字元串大寫字母個數和小寫字母個數
#如何使生成器函數來用元組返回一個字元串大寫字母個數和小寫字母個數
def getUorL(s):
# [A-Z]是匹配內容,str是待匹配的對象
rtn = f"大寫字母個數: {len(re.findall('[A-Z]',s))}"
yield rtn
# [a-z]是匹配內容,str_是待匹配的對象
rtn = f"小寫字母個數: {len(re.findall('[a-z]',s))}"
yield rtn
str = "10ABC23sD~45ffe67e;oo++"
#第一次返回大寫
g = getUorL(str)
print(next(g))
#第二次返回小寫
print(next(g))
❹ Python中生成器的理解
9.10. 生成器
Generator 是創建迭代器的簡單而強大的工具。它們寫起來就像是正規的函數,需要返回數據的時候使用 yield 語句。每次 next() 被調用時,生成器回復它脫離的位置(它記憶語句最後一次執行的位置和所有的數據值)。以下示例演示了生成器可以很簡單的創建出來:
前一節中描述了基於類的迭代器,它能作的每一件事生成器也能作到。因為自動創建了 __iter__() 和 __next__() 方法,生成器顯得如此簡潔。
另一個關鍵的功能在於兩次執行之間,局部變數和執行狀態都自動的保存下來。這使函數很容易寫,而且比使用 self.index 和 self.data 之類的方式更清晰。
除了創建和保存程序狀態的自動方法,當發生器終結時,還會自動拋出 StopIteration 異常。綜上所述,這些功能使得編寫一個正規函數成為創建迭代器的最簡單方法。
Generator 是創建迭代器的簡單而強大的工具。它們寫起來就像是正規的函數,需要返回數據的時候使用 yield 語句。每次 next() 被調用時,生成器回復它脫離的位置(它記憶語句最後一次執行的位置和所有的數據值)。以下示例演示了生成器可以很簡單的創建出來:
前一節中描述了基於類的迭代器,它能作的每一件事生成器也能作到。因為自動創建了 __iter__() 和 __next__() 方法,生成器顯得如此簡潔。
另一個關鍵的功能在於兩次執行之間,局部變數和執行狀態都自動的保存下來。這使函數很容易寫,而且比使用 self.index 和 self.data 之類的方式更清晰。
除了創建和保存程序狀態的自動方法,當發生器終結時,還會自動拋出 StopIteration 異常。綜上所述,這些功能使得編寫一個正規函數成為創建迭代器的最簡單方法。
❺ 詳解Python中的協程,為什麼說它的底層是生成器
協程又稱為是微線程,英文名是Coroutine。它和線程一樣可以調度,但是不同的是線程的啟動和調度需要通過操作系統來處理。並且線程的啟動和銷毀需要涉及一些操作系統的變數申請和銷毀處理,需要的時間比較長。而協程呢,它的調度和銷毀都是程序自己來控制的,因此它更加輕量級也更加靈活。
協程有這么多優點,自然也會有一些缺點,其中最大的缺點就是需要編程語言自己支持,否則的話需要開發者自己通過一些方法來實現協程。對於大部分語言來說,都不支持這一機制。go語言由於天然支持協程,並且支持得非常好,使得它廣受好評,短短幾年時間就迅速流行起來。
對於Python來說,本身就有著一個GIL這個巨大的先天問題。GIL是Python的全局鎖,在它的限制下一個Python進程同一時間只能同時執行一個線程,即使是在多核心的機器當中。這就大大影響了Python的性能,尤其是在CPU密集型的工作上。所以為了提升Python的性能,很多開發者想出了使用多進程+協程的方式。一開始是開發者自行實現的,後來在Python3.4的版本當中,官方也收入了這個功能,因此目前可以光明正大地說,Python是支持協程的語言了。
生成器(generator)
生成器我們也在之前的文章當中介紹過,為什麼我們介紹協程需要用到生成器呢,是因為Python的協程底層就是通過生成器來實現的。
通過生成器來實現協程的原因也很簡單,我們都知道協程需要切換掛起,而生成器當中有一個yield關鍵字,剛好可以實現這個功能。所以當初那些自己在Python當中開發協程功能的程序員都是通過生成器來實現的,我們想要理解Python當中協程的運用,就必須從最原始的生成器開始。
生成器我們很熟悉了,本質上就是帶有yield這個關鍵詞的函數。
async,await和future
從Python3.5版本開始,引入了async,await和future。我們來簡單說說它們各自的用途,其中async其實就是@asyncio.coroutine,用途是完全一樣的。同樣await代替的是yield from,意為等待另外一個協程結束。
我們用這兩個一改,上面的代碼就成了:
async def test(k):
n = 0
while n < k:
await asyncio.sleep(0.5)
print('n = {}'.format(n))
n += 1
由於我們加上了await,所以每次在列印之前都會等待0.5秒。我們把await換成yield from也是一樣的,只不過用await更加直觀也更加貼合協程的含義。
Future其實可以看成是一個信號量,我們創建一個全局的future,當一個協程執行完成之後,將結果存入這個future當中。其他的協程可以await future來實現阻塞。我們來看一個例子就明白了:
future = asyncio.Future()
async def test(k):
n = 0
while n < k:
await asyncio.sleep(0.5)
print('n = {}'.format(n))
n += 1
future.set_result('success')
async def log():
result = await future
print(result)
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait([
log(),
test(5)
]))
loop.close()
在這個例子當中我們創建了兩個協程,第一個協程是每隔0.5秒print一個數字,在print完成之後把success寫入到future當中。第二個協程就是等待future當中的數據,之後print出來。
在loop當中我們要調度執行的不再是一個協程對象了而是兩個,所以我們用asyncio當中的wait將這兩個對象包起來。只有當wait當中的兩個對象執行結束,wait才會結束。loop等待的是wait的結束,而wait等待的是傳入其中的協程的結束,這就形成了一個依賴循環,等價於這兩個協程對象結束,loop才會結束。
總結
async並不只是可以用在函數上,事實上還有很多其他的用法,比如用在with語句上,用在for循環上等等。這些用法比較小眾,細節也很多,就不一一展開了,大家感興趣的可以自行去了解一下。
不知道大家在讀這篇文章的過程當中有沒有覺得有些費勁,如果有的話,其實是很正常的。原因也很簡單,因為Python原生是不支持協程這個概念的,所以在一開始設計的時候也沒有做這方面的准備,是後來覺得有必要才加入的。那麼作為後面加入的內容,必然會對原先的很多內容產生影響,尤其是協程藉助了之前生成器的概念來實現的,那麼必然會有很多耦合不清楚的情況。這也是這一塊的語法很亂,對初學者不友好的原因。
❻ 如何更好地理解Python迭代器和生成器
Python這門語言中,生成器毫無疑問是最有用的特性之一。與此同時,也是使用的最不廣泛的Python特
性之一。究其原因,主要是因為,在其他主流語言裡面沒有生成器的概念。正是由於生成器是一
個「新」的東西,所以,它一方面沒有引起廣大工程師的重視,另一方面,也增加了工程師的學習成本,
最終導致大家錯過了Python中如此有用的一個特性。
我的這篇文章,希望通過簡單易懂的方式,深入淺出地介紹Python的生成器,以改變「如此有用的特性卻
使用極不廣泛」的現象。本文的組織如下:在第1章,我們簡單地介紹了Python中的迭代器協議;在本文
第2章,將會詳細介紹生成器的概念和語法;在第3章,將會給出一個有用的例子,說明使用生成器的好
處;在本文最後,簡單的討論了使用生成器的注意事項。
1. 迭代器協議
由於生成器自動實現了迭代器協議,而迭代器協議對很多人來說,也是一個較為抽象的概念。所以,為了
更好的理解生成器,我們需要簡單的回顧一下迭代器協議的概念。
1. 迭代器協議是指:對象需要提供next方法,它要麼返回迭代中的下一項,要麼就引起一個
StopIteration異常,以終止迭代
2. 可迭代對象就是:實現了迭代器協議的對象
3. 協議是一種約定,可迭代對象實現迭代器協議,Python的內置工具(如for循環,sum,min,max函
數等)使用迭代器協議訪問對象。
舉個例子:在所有語言中,我們都可以使用for循環來遍歷數組,Python的list底層實現是一個數組,所
以,我們可以使用for循環來遍歷list。如下所示:
>>> for n in [1, 2, 3, 4]:
... print n
但是,對Python稍微熟悉一點的朋友應該知道,Python的for循環不但可以用來遍歷list,還可以用來遍歷
文件對象,如下所示:
>>> with open(『/etc/passwd』) as f: # 文件對象提供迭代器協議
... for line in f: # for循環使用迭代器協議訪問文件
... print line
...
為什麼在Python中,文件還可以使用for循環進行遍歷呢?這是因為,在Python中,文件對象實現了迭代
器協議,for循環並不知道它遍歷的是一個文件對象,它只管使用迭代器協議訪問對象即可。正是由於
Python的文件對象實現了迭代器協議,我們才得以使用如此方便的方式訪問文件,如下所示:
>>> f = open('/etc/passwd')
>>> dir(f)
['__class__', '__enter__', '__exit__', '__iter__', '__new__', 'writelines', '...'
2. 生成器
Python使用生成器對延遲操作提供了支持。所謂延遲操作,是指在需要的時候才產生結果,而不是立即產
生結果。這也是生成器的主要好處。
Python有兩種不同的方式提供生成器:
2017/11/6 如何更好地理解Python迭代器和生成器? - 知乎
https://www.hu.com/question/20829330 2/5
1. 生成器函數:常規函數定義,但是,使用yield語句而不是return語句返回結果。yield語句一次返回一
個結果,在每個結果中間,掛起函數的狀態,以便下次重它離開的地方繼續執行
2. 生成器表達式:類似於列表推導,但是,生成器返回按需產生結果的一個對象,而不是一次構建一個
結果列表
2.1 生成器函數
我們來看一個例子,使用生成器返回自然數的平方(注意返回的是多個值):
def gensquares(N):
for i in range(N):
yield i ** 2
for item in gensquares(5):
print item,
使用普通函數:
def gensquares(N):
res = []
for i in range(N):
res.append(i*i)
return res
for item in gensquares(5):
print item,
可以看到,使用生成器函數代碼量更少。
2.2 生成器表達式
使用列表推導,將會一次產生所有結果:
>>> squares = [x**2 for x in range(5)]
>>> squares
[0, 1, 4, 9, 16]
將列表推導的中括弧,替換成圓括弧,就是一個生成器表達式:
>>> squares = (x**2 for x in range(5))
>>> squares>>> next(squares)
0
>>> next(squares)
1
>>> next(squares)
4
>>> list(squares)
[9, 16]
Python不但使用迭代器協議,讓for循環變得更加通用。大部分內置函數,也是使用迭代器協議訪問對象
的。例如, sum函數是Python的內置函數,該函數使用迭代器協議訪問對象,而生成器實現了迭代器協
2017/11/6 如何更好地理解Python迭代器和生成器? - 知乎
https://www.hu.com/question/20829330 3/5
議,所以,我們可以直接這樣計算一系列值的和:
>>> sum(x ** 2 for x in xrange(4))
而不用多此一舉的先構造一個列表:
>>> sum([x ** 2 for x in xrange(4)])
2.3 再看生成器
前面已經對生成器有了感性的認識,我們以生成器函數為例,再來深入探討一下Python的生成器:
1. 語法上和函數類似:生成器函數和常規函數幾乎是一樣的。它們都是使用def語句進行定義,差別在
於,生成器使用yield語句返回一個值,而常規函數使用return語句返回一個值
2. 自動實現迭代器協議:對於生成器,Python會自動實現迭代器協議,以便應用到迭代背景中(如for
循環,sum函數)。由於生成器自動實現了迭代器協議,所以,我們可以調用它的next方法,並且,
在沒有值可以返回的時候,生成器自動產生StopIteration異常
3. 狀態掛起:生成器使用yield語句返回一個值。yield語句掛起該生成器函數的狀態,保留足夠的信息,
以便之後從它離開的地方繼續執行
3. 示例
我們再來看兩個生成器的例子,以便大家更好的理解生成器的作用。
首先,生成器的好處是延遲計算,一次返回一個結果。也就是說,它不會一次生成所有的結果,這對於大
數據量處理,將會非常有用。
大家可以在自己電腦上試試下面兩個表達式,並且觀察內存佔用情況。對於前一個表達式,我在自己的電
腦上進行測試,還沒有看到最終結果電腦就已經卡死,對於後一個表達式,幾乎沒有什麼內存佔用。
sum([i for i in xrange(10000000000)])
sum(i for i in xrange(10000000000))
除了延遲計算,生成器還能有效提高代碼可讀性。例如,現在有一個需求,求一段文字中,每個單詞出現
的位置。
不使用生成器的情況:
def index_words(text):
result = []
if text:
result.append(0)
for index, letter in enumerate(text, 1):
if letter == ' ':
result.append(index)
return result
使用生成器的情況:
2017/11/6 如何更好地理解Python迭代器和生成器? - 知乎
https://www.hu.com/question/20829330 4/5
def index_words(text):
if text:
yield 0
for index, letter in enumerate(text, 1):
if letter == ' ':
yield index
這里,至少有兩個充分的理由說明 ,使用生成器比不使用生成器代碼更加清晰:
1. 使用生成器以後,代碼行數更少。大家要記住,如果想把代碼寫的Pythonic,在保證代碼可讀性的前
提下,代碼行數越少越好
2. 不使用生成器的時候,對於每次結果,我們首先看到的是result.append(index),其次,才是index。
也就是說,我們每次看到的是一個列表的append操作,只是append的是我們想要的結果。使用生成
器的時候,直接yield index,少了列表append操作的干擾,我們一眼就能夠看出,代碼是要返回
index。
這個例子充分說明了,合理使用生成器,能夠有效提高代碼可讀性。只要大家完全接受了生成器的概念,
理解了yield語句和return語句一樣,也是返回一個值。那麼,就能夠理解為什麼使用生成器比不使用生成
器要好,能夠理解使用生成器真的可以讓代碼變得清晰易懂。
4. 使用生成器的注意事項
相信通過這篇文章,大家已經能夠理解生成器的作用和好處。但是,還沒有結束,使用生成器,也有一點
注意事項。
我們直接來看例子,假設文件中保存了每個省份的人口總數,現在,需要求每個省份的人口佔全國總人口
的比例。顯然,我們需要先求出全國的總人口,然後在遍歷每個省份的人口,用每個省的人口數除以總人
口數,就得到了每個省份的人口佔全國人口的比例。
如下所示:
def get_province_population(filename):
with open(filename) as f:
for line in f:
yield int(line)
gen = get_province_population('data.txt')
all_population = sum(gen)
#print all_population
for population in gen:
print population / all_population
執行上面這段代碼,將不會有任何輸出,這是因為,生成器只能遍歷一次。在我們執行sum語句的時候,
就遍歷了我們的生成器,當我們再次遍歷我們的生成器的時候,將不會有任何記錄。所以,上面的代碼不
會有任何輸出。
因此,生成器的唯一注意事項就是:生成器只能遍歷一次。
5. 總結
2017/11/6 如何更好地理解Python迭代器和生成器? - 知乎
https://www.hu.com/question/20829330 5/5
本文深入淺出地介紹了Python中,一個容易被大家忽略的重要特性,即Python的生成器。為了講解生成
器,本文先介紹了迭代器協議,然後介紹了生成器函數和生成器表達式,並通過示例演示了生成器的優點
和注意事項。在實際工作中,充分利用Python生成器,不但能夠減少內存使用,還能夠提高代碼可讀性。
掌握生成器也是Python高手的標配。希望本文能夠幫助大家理解Python的生成器
❼ python編寫中為什麼要使用生成器表達式
就像生成器函數,生成器表達式是一種對內存空間的優化:它們不需要像方括弧的列表推導一樣,一次構造出整個結果列表。與生成器函數一樣,它們將生成結果的過程拆分成更小的時間片:它們會一部分一部分地產生結果,而不是讓調用者在一次調用中等待整個集合被創建出來。
另一方面,生成器表達式在實際中運行起來可能比列表推導稍慢一些,所以它們可能只對那些結果集合非常大的運算或者不能等待全部數據產生的應用來說是最優選擇。
❽ python生成器主要用在哪裡
就是生成相關數據,比如破解wifi密碼,生成很多密碼,通過python一個個試。
❾ python 生成器和迭代器的區別
1、迭代器(iterator)是一個實現了迭代器協議的對象,python的一些內置數據類型(列表,數組,字元串,字典等)都可以通過for語句進行迭代,我們也可以自己創建一個容器,實現了迭代器協議,可以通過for,next方法進行迭代,在迭代的末尾,會引發stopIteration異常。
2、生成器(generator)是通過yield語句快速生成迭代器,可以不用iter和next方法
yield可以使一個普通函數變成一個生成器,並且相應的next()方法返回是yield後的值。一種更直觀的解釋是:程序執行到yield時會返回結果並暫停,再次調用next時會從上次暫停的地方繼續開始執行。
顯然,生成器自身有構成一個迭代器,每次迭代時使用一個yield返回 的值,一個生成器中可以有多個yield的值
❿ 如何更好地理解Python迭代器和生成器
在Python這門語言中,生成器毫無疑問是最有用的特性之一。與此同時,也是使用的最不廣泛的Python特性之一。究其原因,主要是因為,在其他主流語言裡面沒有生成器的概念。正是由於生成器是一個「新」的東西,所以,它一方面沒有引起廣大工程師的重視,另一方面,也增加了工程師的學習成本,最終導致大家錯過了Python中如此有用的一個特性。
我的這篇文章,希望通過簡單易懂的方式,深入淺出地介紹Python的生成器,以改變「如此有用的特性卻使用極不廣泛」的現象。本文的組織如下:在第1章,我們簡單地介紹了Python中的迭代器協議;在本文第2章,將會詳細介紹生成器的概念和語法;在第3章,將會給出一個有用的例子,說明使用生成器的好處;在本文最後,簡單的討論了使用生成器的注意事項。
1. 迭代器協議
由於生成器自動實現了迭代器協議,而迭代器協議對很多人來說,也是一個較為抽象的概念。所以,為了更好的理解生成器,我們需要簡單的回顧一下迭代器協議的概念。
迭代器協議是指:對象需要提供next方法,它要麼返回迭代中的下一項,要麼就引起一個StopIteration異常,以終止迭代
可迭代對象就是:實現了迭代器協議的對象
協議是一種約定,可迭代對象實現迭代器協議,Python的內置工具(如for循環,sum,min,max函數等)使用迭代器協議訪問對象。
舉個例子:在所有語言中,我們都可以使用for循環來遍歷數組,Python的list底層實現是一個數組,所以,我們可以使用for循環來遍歷list。如下所示:
>>> for n in [1, 2, 3, 4]:
... print n
但是,對Python稍微熟悉一點的朋友應該知道,Python的for循環不但可以用來遍歷list,還可以用來遍歷文件對象,如下所示:
>>> with open(『/etc/passwd』) as f: # 文件對象提供迭代器協議
... for line in f: # for循環使用迭代器協議訪問文件
... print line
...
為什麼在Python中,文件還可以使用for循環進行遍歷呢?這是因為,在Python中,文件對象實現了迭代器協議,for循環並不知道它遍歷的是一個文件對象,它只管使用迭代器協議訪問對象即可。正是由於Python的文件對象實現了迭代器協議,我們才得以使用如此方便的方式訪問文件,如下所示:
>>> f = open('/etc/passwd')
>>> dir(f)
['__class__', '__enter__', '__exit__', '__iter__', '__new__', 'writelines', '...'
2. 生成器
Python使用生成器對延遲操作提供了支持。所謂延遲操作,是指在需要的時候才產生結果,而不是立即產生結果。這也是生成器的主要好處。
Python有兩種不同的方式提供生成器:
生成器函數:常規函數定義,但是,使用yield語句而不是return語句返回結果。yield語句一次返回一個結果,在每個結果中間,掛起函數的狀態,以便下次重它離開的地方繼續執行
生成器表達式:類似於列表推導,但是,生成器返回按需產生結果的一個對象,而不是一次構建一個結果列表
2.1 生成器函數
我們來看一個例子,使用生成器返回自然數的平方(注意返回的是多個值):
def gensquares(N):
for i in range(N):
yield i ** 2
for item in gensquares(5):
print item,
使用普通函數:
def gensquares(N):
res = []
for i in range(N):
res.append(i*i)
return res
for item in gensquares(5):
print item,
可以看到,使用生成器函數代碼量更少。
2.2 生成器表達式
使用列表推導,將會一次產生所有結果:
>>> squares = [x**2 for x in range(5)]
>>> squares
[0, 1, 4, 9, 16]
將列表推導的中括弧,替換成圓括弧,就是一個生成器表達式:
>>> squares = (x**2 for x in range(5))
>>> squares
<generator object at 0x00B2EC88>
>>> next(squares)
0
>>> next(squares)
1
>>> next(squares)
4
>>> list(squares)
[9, 16]
Python不但使用迭代器協議,讓for循環變得更加通用。大部分內置函數,也是使用迭代器協議訪問對象的。例如, sum函數是Python的內置函數,該函數使用迭代器協議訪問對象,而生成器實現了迭代器協議,所以,我們可以直接這樣計算一系列值的和:
>>> sum(x ** 2 for x in xrange(4))
而不用多此一舉的先構造一個列表:
>>> sum([x ** 2 for x in xrange(4)])
2.3 再看生成器
前面已經對生成器有了感性的認識,我們以生成器函數為例,再來深入探討一下Python的生成器:
語法上和函數類似:生成器函數和常規函數幾乎是一樣的。它們都是使用def語句進行定義,差別在於,生成器使用yield語句返回一個值,而常規函數使用return語句返回一個值
自動實現迭代器協議:對於生成器,Python會自動實現迭代器協議,以便應用到迭代背景中(如for循環,sum函數)。由於生成器自動實現了迭代器協議,所以,我們可以調用它的next方法,並且,在沒有值可以返回的時候,生成器自動產生StopIteration異常
狀態掛起:生成器使用yield語句返回一個值。yield語句掛起該生成器函數的狀態,保留足夠的信息,以便之後從它離開的地方繼續執行
3. 示例
我們再來看兩個生成器的例子,以便大家更好的理解生成器的作用。
首先,生成器的好處是延遲計算,一次返回一個結果。也就是說,它不會一次生成所有的結果,這對於大數據量處理,將會非常有用。
大家可以在自己電腦上試試下面兩個表達式,並且觀察內存佔用情況。對於前一個表達式,我在自己的電腦上進行測試,還沒有看到最終結果電腦就已經卡死,對於後一個表達式,幾乎沒有什麼內存佔用。
sum([i for i in xrange(10000000000)])
sum(i for i in xrange(10000000000))
除了延遲計算,生成器還能有效提高代碼可讀性。例如,現在有一個需求,求一段文字中,每個單詞出現的位置。
不使用生成器的情況:
def index_words(text):
result = []
if text:
result.append(0)
for index, letter in enumerate(text, 1):
if letter == ' ':
result.append(index)
return result
使用生成器的情況:
def index_words(text):
if text:
yield 0
for index, letter in enumerate(text, 1):
if letter == ' ':
yield index
這里,至少有兩個充分的理由說明 ,使用生成器比不使用生成器代碼更加清晰:
使用生成器以後,代碼行數更少。大家要記住,如果想把代碼寫的Pythonic,在保證代碼可讀性的前提下,代碼行數越少越好
不使用生成器的時候,對於每次結果,我們首先看到的是result.append(index),其次,才是index。也就是說,我們每次看到的是一個列表的append操作,只是append的是我們想要的結果。使用生成器的時候,直接yield index,少了列表append操作的干擾,我們一眼就能夠看出,代碼是要返回index。
這個例子充分說明了,合理使用生成器,能夠有效提高代碼可讀性。只要大家完全接受了生成器的概念,理解了yield語句和return語句一樣,也是返回一個值。那麼,就能夠理解為什麼使用生成器比不使用生成器要好,能夠理解使用生成器真的可以讓代碼變得清晰易懂。
4. 使用生成器的注意事項
相信通過這篇文章,大家已經能夠理解生成器的作用和好處。但是,還沒有結束,使用生成器,也有一點注意事項。
我們直接來看例子,假設文件中保存了每個省份的人口總數,現在,需要求每個省份的人口佔全國總人口的比例。顯然,我們需要先求出全國的總人口,然後在遍歷每個省份的人口,用每個省的人口數除以總人口數,就得到了每個省份的人口佔全國人口的比例。
如下所示:
def get_province_population(filename):
with open(filename) as f:
for line in f:
yield int(line)
gen = get_province_population('data.txt')
all_population = sum(gen)
#print all_population
for population in gen:
print population / all_population
執行上面這段代碼,將不會有任何輸出,這是因為,生成器只能遍歷一次。在我們執行sum語句的時候,就遍歷了我們的生成器,當我們再次遍歷我們的生成器的時候,將不會有任何記錄。所以,上面的代碼不會有任何輸出。
因此,生成器的唯一注意事項就是:生成器只能遍歷一次。
5. 總結
本文深入淺出地介紹了Python中,一個容易被大家忽略的重要特性,即Python的生成器。為了講解生成器,本文先介紹了迭代器協議,然後介紹了生成器函數和生成器表達式,並通過示例演示了生成器的優點和注意事項。在實際工作中,充分利用Python生成器,不但能夠減少內存使用,還能夠提高代碼可讀性。掌握生成器也是Python高手的標配。希望本文能夠幫助大家理解Python的生成器。