完全理解 Python 迭代對象、迭代器、生成器

點擊

上方藍字

，快速關注我們）

編譯：伯樂在線/劉志軍 ，微信公號：Python之禪（ID：VTtalk）

foofish.net/iterators-vs-generators.html

如有好文章投稿，請點擊 → 這裡了解詳情

本文源自RQ作者的一篇博文，原文是Iterables vs. Iterators vs. Generators，俺寫的這篇文章是按照自己的理解做的參考翻譯，算不上是原文的中譯版本，推薦閱讀原文，謝謝網友指正。

在了解Python的數據結構時，容器(container)、可迭代對象(iterable)、迭代器(iterator)、生成器(generator)、列表/集合/字典推導式(list,set,dict comprehension)眾多概念參雜在一起，難免讓初學者一頭霧水，我將用一篇文章試圖將這些概念以及它們之間的關係捋清楚。

容器(container)

容器是一種把多個元素組織在一起的數據結構，容器中的元素可以逐個地迭代獲取，可以用in, not in關鍵字判斷元素是否包含在容器中。通常這類數據結構把所有的元素存儲在內存中（也有一些特例，並不是所有的元素都放在內存，比如迭代器和生成器對象）在Python中，常見的容器對象有：

• 
  

  list, deque, ….



• 
  

  set, frozensets, ….



• 
  

  dict, defaultdict, OrderedDict, Counter, ….



• 
  

  tuple, namedtuple, …



• 
  

  str

容器比較容易理解，因為你就可以把它看作是一個盒子、一棟房子、一個柜子，裡面可以塞任何東西。從技術角度來說，當它可以用來詢問某個元素是否包含在其中時，那麼這個對象就可以認為是一個容器，比如 list，set，tuples都是容器對象：

>>>

assert

1

in

[

1

,

2

,

3

]

# lists

>>>

assert

4

not

in

[

1

,

2

,

3

]

>>>

assert

1

in

{

1

,

2

,

3

}

# sets

>>>

assert

4

not

in

{

1

,

2

,

3

}

>>>

assert

1

in

(

1

,

2

,

3

)

# tuples

>>>

assert

4

not

in

(

1

,

2

,

3

)

詢問某元素是否在dict中用dict的中key：

>>>

d

=

{

1

:

"foo"

,

2

:

"bar"

,

3

:

"qux"

}

>>>

assert

1

in

d

>>>

assert

"foo"

not

in

d

# "foo" 不是dict中的元素

詢問某substring是否在string中：

>>>

s

=

"foobar"

>>>

assert

"b"

in

s

>>>

assert

"x"

not

in

s

>>>

assert

"foo"

in

s

儘管絕大多數容器都提供了某種方式來獲取其中的每一個元素，但這並不是容器本身提供的能力，而是可迭代對象賦予了容器這種能力，當然並不是所有的容器都是可迭代的，比如：Bloom filter，雖然Bloom filter可以用來檢測某個元素是否包含在容器中，但是並不能從容器中獲取其中的每一個值，因為Bloom filter壓根就沒把元素存儲在容器中，而是通過一個散列函數映射成一個值保存在數組中。

可迭代對象(iterable)

剛才說過，很多容器都是可迭代對象，此外還有更多的對象同樣也是可迭代對象，比如處於打開狀態的files，sockets等等。但凡是可以返回一個迭代器的對象都可稱之為可迭代對象，聽起來可能有點困惑，沒關係，先看一個例子：

>>>

x

=

[

1

,

2

,

3

]

>>>

y

=

iter

(

x

)

>>>

z

=

iter

(

x

)

>>>

next

(

y

)

1

>>>

next

(

y

)

2

>>>

next

(

z

)

1

>>>

type

(

x

)

<

class

"list"

>

>>>

type

(

y

)

<

class

"list_iterator"

>

這裡x是一個可迭代對象，可迭代對象和容器一樣是一種通俗的叫法，並不是指某種具體的數據類型，list是可迭代對象，dict是可迭代對象，set也是可迭代對象。y和z是兩個獨立的迭代器，迭代器內部持有一個狀態，該狀態用於記錄當前迭代所在的位置，以方便下次迭代的時候獲取正確的元素。迭代器有一種具體的迭代器類型，比如list_iterator，set_iterator。可迭代對象實現了__iter__方法，該方法返回一個迭代器對象。

當運行代碼：

x

=

[

1

,

2

,

3

]

for

elem

in

x

:

...

實際執行情況是：

反編譯該段代碼，你可以看到解釋器顯示地調用GET_ITER指令，相當於調用iter(x)，FOR_ITER指令就是調用next()方法，不斷地獲取迭代器中的下一個元素，但是你沒法直接從指令中看出來，因為他被解釋器優化過了。

>>>

import

dis

>>>

x

=

[

1

,

2

,

3

]

>>>

dis

.

dis

(

"for _ in x: pass"

)

1

0

SETUP

_

LOOP

14

(

to

17

)

3

LOAD

_

NAME

0

(

x

)

6

GET_ITER

>>

7

FOR

_

ITER

6

(

to

16

)

10

STORE

_

NAME

1

(

_

)

13

JUMP

_

ABSOLUTE

7

>>

16

POP_BLOCK

>>

17

LOAD

_

CONST

0

(

None

)

20

RETURN_VALUE

迭代器(iterator)

那麼什麼迭代器呢？它是一個帶狀態的對象，他能在你調用next()方法的時候返回容器中的下一個值，任何實現了__iter__和__next__()（python2中實現next()）方法的對象都是迭代器，__iter__返回迭代器自身，__next__返回容器中的下一個值，如果容器中沒有更多元素了，則拋出StopIteration異常，至於它們到底是如何實現的這並不重要。

所以，迭代器就是實現了工廠模式的對象，它在你每次你詢問要下一個值的時候給你返回。有很多關於迭代器的例子，比如itertools函數返回的都是迭代器對象。

生成無限序列：

>>>

from

itertools

import

count

>>>

counter

=

count

(

start

=

13

)

>>>

next

(

counter

)

13

>>>

next

(

counter

)

14

從一個有限序列中生成無限序列：

>>>

from

itertools

import

cycle

>>>

colors

=

cycle

([

"red"

,

"white"

,

"blue"

])

>>>

next

(

colors

)

"red"

>>>

next

(

colors

)

"white"

>>>

next

(

colors

)

"blue"

>>>

next

(

colors

)

"red"

從無限的序列中生成有限序列：

>>>

from

itertools

import

islice

>>>

colors

=

cycle

([

"red"

,

"white"

,

"blue"

])

# infinite

>>>

limited

=

islice

(

colors

,

0

,

4

)

# finite

>>>

for

x

in

limited

:

...

print

(

x

)

red

white

blue

red

為了更直觀地感受迭代器內部的執行過程，我們自定義一個迭代器，以斐波那契數列為例：

class

Fib

:

def

__init__

(

self

)

:

self

.

prev

=

0

self

.

curr

=

1

def

__iter__

(

self

)

:

return

self

def

__next__

(

self

)

:

value

=

self

.

curr

self

.

curr

+=

self

.

prev

self

.

prev

=

value

return

value

>>>

f

=

Fib

()

>>>

list

(

islice

(

f

,

0

,

10

))

[

1

,

1

,

2

,

3

,

5

,

8

,

13

,

21

,

34

,

55

]

Fib既是一個可迭代對象（因為它實現了__iter__方法），又是一個迭代器（因為實現了__next__方法）。實例變數prev和curr用戶維護迭代器內部的狀態。每次調用next()方法的時候做兩件事：

1. 
   

   為下一次調用next()方法修改狀態



2. 
   

   為當前這次調用生成返回結果

迭代器就像一個懶載入的工廠，等到有人需要的時候才給它生成值返回，沒調用的時候就處於休眠狀態等待下一次調用。

生成器(generator)

生成器算得上是Python語言中最吸引人的特性之一，生成器其實是一種特殊的迭代器，不過這種迭代器更加優雅。它不需要再像上面的類一樣寫__iter__()和__next__()方法了，只需要一個yiled關鍵字。 生成器一定是迭代器（反之不成立），因此任何生成器也是以一種懶載入的模式生成值。用生成器來實現斐波那契數列的例子是：

def

fib

()

:

prev

,

curr

=

0

,

1

while

True

:

yield

curr

prev

,

curr

=

curr

,

curr

+

prev

>>>

f

=

fib

()

>>>

list

(

islice

(

f

,

0

,

10

))

[

1

,

1

,

2

,

3

,

5

,

8

,

13

,

21

,

34

,

55

]

fib就是一個普通的python函數，它特殊的地方在於函數體中沒有return關鍵字，函數的返回值是一個生成器對象。當執行f=fib()返回的是一個生成器對象，此時函數體中的代碼並不會執行，只有顯示或隱示地調用next的時候才會真正執行裡面的代碼。

生成器在Python中是一個非常強大的編程結構，可以用更少地中間變數寫流式代碼，此外，相比其它容器對象它更能節省內存和CPU，當然它可以用更少的代碼來實現相似的功能。現在就可以動手重構你的代碼了，但凡看到類似：

def

something

()

:

result

=

[]

for

...

in

...

:

result

.

append

(

x

)

return

result

都可以用生成器函數來替換：

def

iter_something

()

:

for

...

in

...

:

yield

x

生成器表達式(generator expression)

生成器表達式是列表推倒式的生成器版本，看起來像列表推導式，但是它返回的是一個生成器對象而不是列表對象。

>>>

a

=

(

x

*

x

for

x

in

range

(

10

))

>>>

a

<

generator object

<

genexpr

>

at

0x401f08

>

>>>

sum

(

a

)

285

總結

• 
  

  容器是一系列元素的集合，str、list、set、dict、file、sockets對象都可以看作是容器，容器都可以被迭代（用在for，while等語句中），因此他們被稱為可迭代對象。



• 
  

  可迭代對象實現了__iter__方法，該方法返回一個迭代器對象。



• 
  

  迭代器持有一個內部狀態的欄位，用於記錄下次迭代返回值，它實現了__next__和__iter__方法，迭代器不會一次性把所有元素載入到內存，而是需要的時候才生成返回結果。



• 
  

  生成器是一種特殊的迭代器，它的返回值不是通過return而是用yield。

參考鏈接：https://docs.python.org/2/library/stdtypes.html#iterator-types

看完本文有收穫？請轉

發分享給更多人

關注「P

ython開發者」，提升Python技能

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！

本站內容充實豐富，博大精深，小編精選每日熱門資訊，隨時更新，點擊「搶先收到最新資訊」瀏覽吧！

請您繼續閱讀更多來自 Python 的精彩文章: