python項目的單文件生成器（python 批量生成文件夾）

• 1、如何更好地理解Python迭代器和生成器
• 2、閑話python 45: 淺談生成器yield
• 3、python生成器是怎麼使用的
• 4、vs2017如何打包python項目,生成exe文件

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迭代器和生成器？ – 知乎

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)

next(squares)

1

next(squares)

4

list(squares)

[9, 16]

Python不但使用迭代器協議，讓for循環變得更加通用。大部分內置函數，也是使用迭代器協議訪問對象

的。例如， sum函數是Python的內置函數，該函數使用迭代器協議訪問對象，而生成器實現了迭代器協

2017/11/6 如何更好地理解Python迭代器和生成器？ – 知乎

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迭代器和生成器？ – 知乎

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迭代器和生成器？ – 知乎

5/5

本文深入淺出地介紹了Python中，一個容易被大家忽略的重要特性，即Python的生成器。為了講解生成

器，本文先介紹了迭代器協議，然後介紹了生成器函數和生成器表達式，並通過示例演示了生成器的優點

和注意事項。在實際工作中，充分利用Python生成器，不但能夠減少內存使用，還能夠提高代碼可讀性。

掌握生成器也是Python高手的標配。希望本文能夠幫助大家理解Python的生成器

生成器似乎並不是一個經常被開發者討論的語法，因此也就沒有它的大兄弟迭代器那麼著名。大家不討論它並不是說大家都已經對它熟悉到人盡皆知，與之相反，即使是工作多年的開發者可能對生成器的運行過程還是知之甚少。這是什麼原因導致的呢？我猜想大概有以下幾點原因： (1)運行流程不同尋常，(2)日常開發不需要，(3)常常將生成器與迭代器混淆。 生成器的運行流程可以按照協程來理解，也就是說 返回中間結果，斷點繼續運行 。這與我們通常對於程序調用的理解稍有差異。這種運行模式是針對什麼樣的需求呢？ 一般而言，生成器是應用於大量磁碟資源的處理。 比如一個很大的文件，每次讀取一行，下一次讀取需要以上一次讀取的位置為基礎。下面就通過代碼演示具體看看生成器的運行機制、使用方式以及與迭代器的比較。

什麼是生成器？直接用文字描述可能太過抽象，倒不如先運行一段代碼，分析這段代碼的運行流程，然後總結出自己對生成器的理解。

從以上演示可以看出，這段代碼定義了一個函數，這個函數除了yield這個關鍵字之外與一般函數並沒有差異，也就是說生成器的魔法都是這個yield關鍵字引起的。 第一點，函數的返回值是一個生成器對象。 上述代碼中，直接調用這個看似普通的函數，然後將返回值列印出來，發現返回值是一個對象，而並不是普通函數的返回值。 第二點，可以使用next對這個生成器對象進行操作 。生成器對象天然的可以被next函數調用，然後返回在yield關鍵字後面的內容。 第三，再次調用next函數處理生成器對象，發現是從上次yield語句之後繼續運行，直到下一個yield語句返回。

生成器的運行流程確實詭異，下面還要演示一個生成器可以執行的更加詭異的操作：運行過程中向函數傳參。

返回生成器和next函數操作生成器已經並不奇怪了，但是在函數運行過程中向其傳參還是讓人驚呆了。 調用生成器的send函數傳入參數，在函數內使用yield語句的返回值接收，然後繼續運行直到下一個yield語句返回。 以前實現這種運行流程的方式是在函數中加上一個從控制台獲取數據的指令，或者提前將參數傳入，但是現在不用了，send方式使得傳入的參數可以隨著讀取到的參數變化而變化。

很多的開發者比較容易混淆生成器和迭代器，而迭代器的運行過程更加符合一般的程序調用運行流程，因此從親進度和使用熟悉度而言，大家對迭代器更有好感。比如下面演示一個對迭代器使用next方法進行操作。

從以上演示來看，大家或許會認為迭代器比生成器簡單易用得太多了。不過，如果你了解迭代器的實現機制，可能就不會這麼早下結論了。python內置了一些已經實現了的迭代器使用確實方便，但是如果需要自己去寫一個迭代器呢？下面這段代碼就帶大家見識以下迭代器的實現。

在python中，能被next函數操作的對象一定帶有__next__函數的實現，而能夠被迭代的對象有必須實現__iter__函數。看了這麼一段操作，相信大家對迭代器實現的繁瑣也是深有體會了，那麼生成器的實現是不是會讓你覺得更加簡單易用呢？不過千萬別產生一個誤區，即生成器比迭代器簡單就多用生成器。 在實際開發中，如果遇到與大量磁碟文件或者資料庫操作相關的倒是可以使用生成器。但是在其他的任務中使用生成器難免有炫技，並且使邏輯不清晰而導致可讀性下降的嫌疑。 這大概也能解釋生成器受冷落的原因。不過作為一個專業的開發者，熟悉語言特性是分內之事。

到此，關於生成器的討論就結束了。本文的notebook版本文件在github上的cnbluegeek/notebook倉庫中共享，歡迎感興趣的朋友前往下載。

生成器(generator)概念

生成器不會把結果保存在一個系列中，而是保存生成器的狀態，在每次進行迭代時返回一個值，直到遇到StopIteration異常結束。

生成器語法

生成器表達式： 通列表解析語法，只不過把列表解析的[]換成()

生成器表達式能做的事情列表解析基本都能處理，只不過在需要處理的序列比較大時，列表解析比較費內存。

Python

1

2

3

4

5

6

7

8

9

10

11

gen = (x**2 for x in range(5))

gen

generator object genexpr at 0x0000000002FB7B40

for g in gen:

… print(g, end=’-‘)

…

0-1-4-9-16-

for x in [0,1,2,3,4,5]:

… print(x, end=’-‘)

…

0-1-2-3-4-5-

生成器函數： 在函數中如果出現了yield關鍵字，那麼該函數就不再是普通函數，而是生成器函數。

但是生成器函數可以生產一個無線的序列，這樣列表根本沒有辦法進行處理。

yield 的作用就是把一個函數變成一個 generator，帶有 yield 的函數不再是一個普通函數，Python 解釋器會將其視為一個 generator。

下面為一個可以無窮生產奇數的生成器函數。

Python

1

2

3

4

5

6

7

8

9

10

11

def odd():

n=1

while True:

yield n

n+=2

odd_num = odd()

count = 0

for o in odd_num:

if count =5: break

print(o)

count +=1

當然通過手動編寫迭代器可以實現類似的效果，只不過生成器更加直觀易懂

Python

1

2

3

4

5

6

7

8

9

10

11

class Iter:

def __init__(self):

self.start=-1

def __iter__(self):

return self

def __next__(self):

self.start +=2

return self.start

I = Iter()

for count in range(5):

print(next(I))

題外話： 生成器是包含有__iter()和next__()方法的，所以可以直接使用for來迭代，而沒有包含StopIteration的自編Iter來只能通過手動循環來迭代。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

from collections import Iterable

from collections import Iterator

isinstance(odd_num, Iterable)

True

isinstance(odd_num, Iterator)

True

iter(odd_num) is odd_num

True

help(odd_num)

Help on generator object:

odd = class generator(object)

| Methods defined here:

|

| __iter__(self, /)

| Implement iter(self).

|

| __next__(self, /)

| Implement next(self).

……

看到上面的結果，現在你可以很有信心的按照Iterator的方式進行循環了吧！

在 for 循環執行時，每次循環都會執行 fab 函數內部的代碼，執行到 yield b 時，fab 函數就返回一個迭代值，下次迭代時，代碼從 yield b 的下一條語句繼續執行，而函數的本地變數看起來和上次中斷執行前是完全一樣的，於是函數繼續執行，直到再次遇到 yield。看起來就好像一個函數在正常執行的過程中被 yield 中斷了數次，每次中斷都會通過 yield 返回當前的迭代值。

yield 與 return

在一個生成器中，如果沒有return，則默認執行到函數完畢時返回StopIteration；

Python

1

2

3

4

5

6

7

8

9

10

11

def g1():

… yield 1

…

g=g1()

next(g) #第一次調用next(g)時，會在執行完yield語句後掛起，所以此時程序並沒有執行結束。

1

next(g) #程序試圖從yield語句的下一條語句開始執行，發現已經到了結尾，所以拋出StopIteration異常。

Traceback (most recent call last):

File “stdin”, line 1, in module

StopIteration

如果遇到return,如果在執行過程中 return，則直接拋出 StopIteration 終止迭代。

Python

1

2

3

4

5

6

7

8

9

10

11

12

def g2():

… yield ‘a’

… return

… yield ‘b’

…

g=g2()

next(g) #程序停留在執行完yield ‘a’語句後的位置。

‘a’

next(g) #程序發現下一條語句是return，所以拋出StopIteration異常，這樣yield ‘b’語句永遠也不會執行。

Traceback (most recent call last):

File “stdin”, line 1, in module

StopIteration

如果在return後返回一個值，那麼這個值為StopIteration異常的說明，不是程序的返回值。

生成器沒有辦法使用return來返回值。

Python

1

2

3

4

5

6

7

8

9

10

11

def g3():

… yield ‘hello’

… return ‘world’

…

g=g3()

next(g)

‘hello’

next(g)

Traceback (most recent call last):

File “stdin”, line 1, in module

StopIteration: world

生成器支持的方法

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

help(odd_num)

Help on generator object:

odd = class generator(object)

| Methods defined here:

……

| close(…)

| close() – raise GeneratorExit inside generator.

|

| send(…)

| send(arg) – send ‘arg’ into generator,

| return next yielded value or raise StopIteration.

|

| throw(…)

| throw(typ[,val[,tb]]) – raise exception in generator,

| return next yielded value or raise StopIteration.

……

close()

手動關閉生成器函數，後面的調用會直接返回StopIteration異常。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

def g4():

… yield 1

… yield 2

… yield 3

…

g=g4()

next(g)

1

g.close()

next(g) #關閉後，yield 2和yield 3語句將不再起作用

Traceback (most recent call last):

File “stdin”, line 1, in module

StopIteration

send()

生成器函數最大的特點是可以接受外部傳入的一個變數，並根據變數內容計算結果後返回。

這是生成器函數最難理解的地方，也是最重要的地方，實現後面我會講到的協程就全靠它了。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

def gen():

value=0

while True:

receive=yield value

if receive==’e’:

break

value = ‘got: %s’ % receive

g=gen()

print(g.send(None))

print(g.send(‘aaa’))

print(g.send(3))

print(g.send(‘e’))

執行流程：

通過g.send(None)或者next(g)可以啟動生成器函數，並執行到第一個yield語句結束的位置。此時，執行完了yield語句，但是沒有給receive賦值。yield value會輸出初始值0注意：在啟動生成器函數時只能send(None),如果試圖輸入其它的值都會得到錯誤提示信息。

通過g.send(『aaa』)，會傳入aaa，並賦值給receive，然後計算出value的值，並回到while頭部，執行yield value語句有停止。此時yield value會輸出」got: aaa」，然後掛起。

通過g.send(3)，會重複第2步，最後輸出結果為」got: 3″

當我們g.send(『e』)時，程序會執行break然後推出循環，最後整個函數執行完畢，所以會得到StopIteration異常。

最後的執行結果如下：

Python

1

2

3

4

5

6

7

got: aaa

got: 3

Traceback (most recent call last):

File “h.py”, line 14, in module

print(g.send(‘e’))

StopIteration

throw()

用來向生成器函數送入一個異常，可以結束系統定義的異常，或者自定義的異常。

throw()後直接跑出異常並結束程序，或者消耗掉一個yield，或者在沒有下一個yield的時候直接進行到程序的結尾。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

def gen():

while True:

try:

yield ‘normal value’

yield ‘normal value 2’

print(‘here’)

except ValueError:

print(‘we got ValueError here’)

except TypeError:

break

g=gen()

print(next(g))

print(g.throw(ValueError))

print(next(g))

print(g.throw(TypeError))

輸出結果為：

Python

1

2

3

4

5

6

7

8

normal value

we got ValueError here

normal value

normal value 2

Traceback (most recent call last):

File “h.py”, line 15, in module

print(g.throw(TypeError))

StopIteration

解釋：

print(next(g))：會輸出normal value，並停留在yield 『normal value 2』之前。

由於執行了g.throw(ValueError)，所以會跳過所有後續的try語句，也就是說yield 『normal value 2』不會被執行，然後進入到except語句，列印出we got ValueError here。然後再次進入到while語句部分，消耗一個yield，所以會輸出normal value。

print(next(g))，會執行yield 『normal value 2』語句，並停留在執行完該語句後的位置。

g.throw(TypeError)：會跳出try語句，從而print(『here』)不會被執行，然後執行break語句，跳出while循環，然後到達程序結尾，所以跑出StopIteration異常。

下面給出一個綜合例子，用來把一個多維列表展開，或者說扁平化多維列表)

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

def flatten(nested):

try:

#如果是字元串，那麼手動拋出TypeError。

if isinstance(nested, str):

raise TypeError

for sublist in nested:

#yield flatten(sublist)

for element in flatten(sublist):

#yield element

print(‘got:’, element)

except TypeError:

#print(‘here’)

yield nested

L=[‘aaadf’,[1,2,3],2,4,[5,[6,[8,[9]],’ddf’],7]]

for num in flatten(L):

print(num)

如果理解起來有點困難，那麼把print語句的注釋打開在進行查看就比較明了了。

總結

按照鴨子模型理論，生成器就是一種迭代器，可以使用for進行迭代。

第一次執行next(generator)時，會執行完yield語句後程序進行掛起，所有的參數和狀態會進行保存。再一次執行next(generator)時，會從掛起的狀態開始往後執行。在遇到程序的結尾或者遇到StopIteration時，循環結束。

可以通過generator.send(arg)來傳入參數，這是協程模型。

可以通過generator.throw(exception)來傳入一個異常。throw語句會消耗掉一個yield。可以通過generator.close()來手動關閉生成器。

next()等價於send(None)

可以使用PyInstaller把python程序打包成exe，安裝使用pip install pyinstaller，使用時，使用pyinstaller打包，參數如下

-F, –onefile 打包一個單個文件，如果你的代碼都寫在一個.py文件的話，可以用這個，如果是多個.py文件就別用

-D, –onedir 打包多個文件，在dist中生成很多依賴文件，適合以框架形式編寫工具代碼，我個人比較推薦這樣，代碼易於維護

-K, –tk 在部署時包含 TCL/TK

-a, –ascii 不包含編碼.在支持Unicode的python版本上默認包含所有的編碼.

-d, –debug 產生debug版本的可執行文件

-w,–windowed,–noconsole 使用Windows子系統執行.當程序啟動的時候不會打開命令行(只對Windows有效)

-c,–nowindowed,–console

使用控制檯子系統執行(默認)(只對Windows有效)

pyinstaller -c xxxx.py

pyinstaller xxxx.py –console

-s,–strip 可執行文件和共享庫將run through strip.注意Cygwin的strip往往使普通的win32 Dll無法使用.

-X, –upx 如果有UPX安裝(執行Configure.py時檢測),會壓縮執行文件(Windows系統中的DLL也會)(參見note)

-o DIR, –out=DIR 指定spec文件的生成目錄,如果沒有指定,而且當前目錄是PyInstaller的根目錄,會自動創建一個用於輸出(spec和生成的可執行文件)的目錄.如果沒有指定,而當前目錄不是PyInstaller的根目錄,則會輸出到當前的目錄下.

-p DIR, –path=DIR 設置導入路徑(和使用PYTHONPATH效果相似).可以用路徑分割符(Windows使用分號,Linux使用冒號)分割,指定多個目錄.也可以使用多個-p參數來設置多個導入路徑，讓pyinstaller自己去找程序需要的資源

–icon=FILE.ICO

將file.ico添加為可執行文件的資源(只對Windows系統有效)，改變程序的圖標 pyinstaller -i ico路徑 xxxxx.py

–icon=FILE.EXE,N 將file.exe的第n個圖標添加為可執行文件的資源(只對Windows系統有效)

-v FILE, –version=FILE 將verfile作為可執行文件的版本資源(只對Windows系統有效)

-n NAME, –name=NAME 可選的項目(產生的spec的)名字.如果省略,第一個腳本的主文件名將作為spec的名字