寫這篇文章，是對于平常開發(fā)不是以Python為主冤吨，以便能快速復習Python基礎知識而記錄，以下文章都是基于python 3+

1 列表

1.1 定義

序列是Python 中最基本的數(shù)據(jù)結構
序列中的每個值都有對應的位置值饶套，稱之為索引漩蟆，第一個索引是 0，第二個索引是 1妓蛮，依此類推怠李。
Python 有 6 個序列的內置類型，但最常見的是列表和元組
列表都可以進行的操作包括索引蛤克，切片捺癞，加，乘构挤，檢查成員髓介。
此外，Python 已經(jīng)內置確定序列的長度以及確定最大和最小的元素的方法筋现。
列表是最常用的 Python 數(shù)據(jù)類型唐础，它可以作為一個方括號內的逗號分隔值出現(xiàn)箱歧。列表的數(shù)據(jù)項 不需要具有相同的類型

創(chuàng)建一個列表，只要把逗號分隔的不同的數(shù)據(jù)項使用方括號括起來即可一膨。如下所示：

list1 = ['Google', 'Test', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1.2 訪問列表中的值

列表索引從 0開始呀邢，第二個索引是 1，依此類推豹绪。
通過索引列表可以進行截取价淌、組合等操作。

#!/usr/bin/python3
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

結果：
red
green
blue

索引也可以從尾部開始瞒津，最后一個元素的索引為-1输钩，往前一位為 -2，以此類推

image.png

#!/usr/bin/python3

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

結果：
black
white
yellow

使用下標索引來訪問列表中的值仲智，同樣也可以使用方括號 [] 的形式截取字符买乃，如下所示：

image.png

#!/usr/bin/python3
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])

結果：
[10, 20, 30, 40]

使用負數(shù)索引值截取：

#!/usr/bin/python3 
list = ['Google', 'Test', "Zhihu", "Taobao", "Wiki"]
 # 讀取第二位
print ("list[1]: ", list[1])
# 從第二位開始（包含）截取到倒數(shù)第二位（不包含）
print ("list[1:-2]: ", list[1:-2])

結果：

list[1]:  Test
list[1:-2]:  ['Test', 'Zhihu']

1.3 更新列表

可以對列表的數(shù)據(jù)項進行修改或更新钓辆，也可以使用 append()方法來添加列表項剪验，如下所示：

#!/usr/bin/python3
 
list = ['Google', 'Test', 1997, 2000]
 
print ("第三個元素為 : ", list[2])
list[2] = 2001
print ("更新后的第三個元素為 : ", list[2])
 
list1 = ['Google', 'Test', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

結果：
第三個元素為 :  1997
更新后的第三個元素為 :  2001
更新后的列表 :  ['Google', 'Test', 'Taobao', 'Baidu']

1.4 刪除列表元素

可以使用 del 語句來刪除列表的的元素，如下實例：

#!/usr/bin/python3
 
list = ['Google', 'Test', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("刪除第三個元素 : ", list)

結果：
原始列表 :  ['Google', 'Test', 1997, 2000]
刪除第三個元素 :  ['Google', 'Test', 2000]

1.5 Python列表腳本操作符

列表對+ 和 * 的操作符與字符串相似前联。+ 號用于組合列表功戚，* 號用于重復列表

1.6 Python列表截取與拼接

Python的列表截取與字符串操作類型，如下所示：

L=['Google', 'Test', 'Taobao']

操作：

>>>L=['Google', 'Test', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Test'
>>> L[1:]
['Test', 'Taobao']
>>>

列表還支持拼接操作：
>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

1.7 嵌套列表

使用嵌套列表即在列表里創(chuàng)建其它列表似嗤，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

1.8 列表比較

列表比較需要引入 operator 模塊的 eq 方法

# 導入 operator 模塊
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))

結果
operator.eq(a,b):  False
operator.eq(c,b):  True

2 元組

2.1 定義

Python 的元組與列表類似啸臀，不同之處在于 元組的元素不能修改
注意：元組使用小括號( )，列表使用方括號[ ]
元組創(chuàng)建很簡單烁落，只需要在括號中添加元素乘粒，并使用逗號隔開即可

>>> tup1 = ('Google', 'Test', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括號也可以
>>> type(tup3)
<class 'tuple'>

2.2 創(chuàng)建空元組

創(chuàng)建空元組

tup1 = ()

元組中只包含一個元素時，需要在元素后面添加逗號 ,伤塌，否則括號會被當作運算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗號灯萍，類型為整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗號，類型為元組
<class 'tuple'>

元組與字符串類似每聪，下標索引從 0 開始旦棉，可以進行截取，組合等药薯。

image.png

2.3 訪問元組

元組可以使用下標索引來訪問元組中的值绑洛，如下實例:

#!/usr/bin/python3

tup1 = ('Google', 'Test', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

結果：
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

2.4 修改元組

元組中的元素值是不允許修改的，但我們可以對元組進行連接組合童本，如下實例:

#!/usr/bin/python3
 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元組元素操作是非法的真屯。
# tup1[0] = 100
 
# 創(chuàng)建一個新的元組
tup3 = tup1 + tup2
print (tup3)

結果：
(12, 34.56, 'abc', 'xyz')

2.5 刪除元組

元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組巾陕，如下實例:

#!/usr/bin/python3
tup = ('Google', 'Test', 1997, 2000)
 
print (tup)
del tup
print ("刪除后的元組 tup : ")
print (tup)

以上實例元組被刪除后讨跟，輸出變量會有異常信息纪他，輸出如下所示：

刪除后的元組 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

2.6 元組運算符

與字符串一樣，元組之間可以使用 + 號和 * 號進行運算晾匠。這就意味著他們可以組合和復制茶袒，運算后會生成一個新的元組。

3 字典

3.1 定義

字典是另一種可變容器模型凉馆，且可存儲任意類型對象薪寓。
字典的每個鍵值 key=>value 對用冒號 : 分割，每個對之間用逗號(,)分割澜共，整個字典包括在花括號 {}中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

注意：dict 作為 Python 的關鍵字和內置函數(shù)向叉，變量名不建議命名為 dict

鍵必須是唯一的，但值則不必嗦董。
值可以取任何數(shù)據(jù)類型母谎，但鍵必須是不可變的，如字符串京革，數(shù)字奇唤。

3.2 創(chuàng)建空字典

使用大括號 { } 創(chuàng)建空字典：

# 使用大括號 {} 來創(chuàng)建空字典
emptyDict = {}
# 打印字典
print(emptyDict)
# 查看字典的數(shù)量
print("Length:", len(emptyDict))
# 查看類型
print(type(emptyDict))

結果：
{}
Length: 0
<class 'dict'>

使用內建函數(shù) dict()創(chuàng)建字典：

emptyDict = dict()
# 打印字典
print(emptyDict)
# 查看字典的數(shù)量
print("Length:",len(emptyDict))
# 查看類型
print(type(emptyDict))

結果：
{}
Length: 0
<class 'dict'>

3.3 訪問字典里的值

把相應的鍵放入到方括號中，如下實例:

#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

結果：
tinydict['Name']:  Test
tinydict['Age']:  7

如果用字典里沒有的鍵訪問數(shù)據(jù)匹摇，會輸出錯誤如下：

#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
 print ("tinydict['Alice']: ", tinydict['Alice'])

結果：
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'

3.4 修改字典

向字典添加新內容的方法是增加新的鍵/值對咬扇，修改或刪除已有鍵/值對如下實例:

#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鳥教程"  # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

結果：
tinydict['Age']:  8
tinydict['School']:  菜鳥教程

3.5 刪除字典元素

能刪單一的元素也能清空字典，清空只需一項操作廊勃。
顯式刪除一個字典用del命令懈贺，如下實例：

#!/usr/bin/python3 
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'} 
del tinydict['Name'] # 刪除鍵 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 刪除字典
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

但這會引發(fā)一個異常，因為用執(zhí)行 del 操作后字典不再存在：
Traceback (most recent call last):
  File "/test-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined

3.6 字典鍵的特性

字典值可以是任何的 python 對象坡垫，既可以是標準的對象圈纺，也可以是用戶定義的缕贡，但鍵不行

• 不允許同一個鍵出現(xiàn)兩次笼蛛。創(chuàng)建時如果同一個鍵被賦值兩次倘核，后一個值會被記住
• 鍵必須不可變片拍，所以可以用數(shù)字恨统，字符串或元組充當疯淫，而用列表就不行

#!/usr/bin/python3 
tinydict = {'Name': 'Test', 'Age': 7, 'Name': '小菜鳥'} 
print ("tinydict['Name']: ", tinydict['Name'])

結果：
tinydict['Name']:  小菜鳥

#!/usr/bin/python3
 
tinydict = {['Name']: 'Test', 'Age': 7}
 
print ("tinydict['Name']: ", tinydict['Name'])
以上實例輸出結果：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    tinydict = {['Name']: 'Test', 'Age': 7}
TypeError: unhashable type: 'list'

3.7 字典內置函數(shù)&方法

Python字典包含了以下內置函數(shù)：

• len(dict)：計算字典元素個數(shù)歉糜，即鍵的總數(shù)宪卿。
• str(dict)：輸出字典的诵，可以打印的字符串表示。
• type(variable)：返回輸入的變量類型佑钾，如果變量是字典就返回字典類型

3.8 字典優(yōu)勢

為什么dict查找速度這么快西疤？因為dict的實現(xiàn)原理和查字典是一樣的。假設字典包含了1萬個漢字休溶，我們要查某一個字代赁，一個辦法是把字典從第一頁往后翻扰她，直到找到我們想要的字為止，這種方法就是在list中查找元素的方法芭碍，list越大徒役，查找越慢。第二種方法是先在字典的索引表里（比如部首表）查這個字對應的頁碼窖壕，然后直接翻到該頁忧勿，找到這個字，無論找哪個字瞻讽，這種查找速度都非吃快，不會隨著字典大小的增加而變慢速勇。

dict就是第二種實現(xiàn)方式晌砾，給定一個名字，比如'Michael'烦磁，dict在內部就可以直接計算出Michael對應的存放成績的“頁碼”养匈，也就是95這個數(shù)字存放的內存地址，直接取出來个初，所以速度非彻院快。這種key-value存儲方式院溺，在放進去的時候楣嘁，必須根據(jù)key算出value的存放位置，這樣珍逸，取的時候才能根據(jù)key直接拿到value逐虚。

和list比較，dict有以下幾個特點：

• 查找和插入的速度極快谆膳，不會隨著key的增加而增加叭爱； 需要占用大量的內存，內存浪費多漱病。 而list相反：
• 查找和插入的時間隨著元素的增加而增加买雾； 占用空間小，浪費內存很少杨帽。 所以漓穿，dict是用空間來換取時間的一種方法。
• dict可以用在需要高速查找的很多地方注盈，在Python代碼中幾乎無處不在晃危，正確使用dict非常重要，需要牢記的第一條就是dict的key必須是不可變對象老客。
• 這是因為dict根據(jù)key來計算value的存儲位置僚饭，如果每次計算相同的key得出的結果不同震叮，那dict內部就完全混亂了。這個通過key計算位置的算法稱為哈希算法（Hash）鳍鸵。

4 集合

4.1 定義

集合（set）是一個無序的不重復元素序列苇瓣。
可以使用 set()函數(shù)創(chuàng)建集合，注意：創(chuàng)建一個空集合必須用 set() 而不是{ }权纤，因為{ }是用來創(chuàng)建一個空字典钓简。

創(chuàng)建格式：

parame = {value01,value02,...}
或者
set(value)

集合大致操作如下:

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 這里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判斷元素是否在集合內
True
>>> 'crabgrass' in basket
False

>>> # 下面展示兩個集合間的運算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同時包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

遍歷元素：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

4.2 操作集合

4.2.1 添加元素

語法格式如下：

s.add( x )

將元素 x 添加到集合 s 中，如果元素已存在汹想，則不進行任何操作外邓。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Test'}

還有一個方法，也可以添加元素古掏，且參數(shù)可以是列表损话，元組，字典等槽唾，語法格式如下：

s.update( x )

x 可以有多個丧枪，用逗號分開。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Test'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Test'}
>>>

4.2.2 移除元素

語法格式如下：

s.remove( x )

將元素 x 從集合 s 中移除庞萍，如果元素不存在拧烦，則會發(fā)生錯誤。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Test'}
>>> thisset.remove("Facebook")   # 不存在會發(fā)生錯誤
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

此外還有一個方法也是移除集合中的元素钝计，且 如果元素不存在恋博，不會發(fā)生錯誤
格式如下所示：

s.discard( x )

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不會發(fā)生錯誤
>>> print(thisset)
{'Taobao', 'Google', 'Test'}

我們也可以設置隨機刪除集合中的一個元素，語法格式如下：

s.pop() 

thisset = set(("Google", "Test", "Taobao", "Facebook"))
x = thisset.pop()

print(x)
結果：

$ python3 test.py 
Test

多次執(zhí)行測試結果都不一樣私恬。
set 集合的 pop 方法會對集合進行無序的排列债沮，然后將這個無序排列集合的左面第一個元素進行刪除。

4.2.3 計算集合元素個數(shù)

語法格式如下：

len(s)

計算集合 s 元素個數(shù)本鸣。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> len(thisset)
3

4.2.4 清空集合

語法格式如下：

s.clear()

清空集合 s

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

4.2.5 判斷元素是否在集合中存在

語法格式如下：

x in s

判斷元素 x 是否在集合 s 中疫衩，存在返回 True，不存在返回 False荣德。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> "Test" in thisset
True
>>> "Facebook" in thisset
False
>>>

5 推導式

Python 推導式是一種獨特的數(shù)據(jù)處理方式闷煤，可以從一個數(shù)據(jù)序列構建另一個新的數(shù)據(jù)序列的結構體

Python支持各種數(shù)據(jù)結構的推導式：

• 列表(list)推導式
• 字典(dict)推導式
• 集合(set)推導式
• 元組(tuple)推導式

5.1 列表推導式

列表推導式格式為：

[表達式 for 變量 in 列表] 
[out_exp_res for out_exp in input_list]

或者

[表達式 for 變量 in 列表 if 條件]
[out_exp_res for out_exp in input_list if condition]

各個元素說明：

• out_exp_res：列表生成元素表達式，可以是有返回值的函數(shù)涮瞻。
• for out_exp in input_list：迭代 input_list 將 out_exp 傳入到 out_exp_res 表達式中曹傀。
• if condition：條件語句，可以過濾列表中不符合條件的值饲宛。

過濾掉長度小于或等于3的字符串列表，并將剩下的轉換成大寫字母：

>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']

計算 30 以內可以被 3 整除的整數(shù)：

>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

5.2 字典推導式

字典推導基本格式：

{ key_expr: value_expr for value in collection }

或

{ key_expr: value_expr for value in collection if condition }

使用字符串及其長度創(chuàng)建字典：

listdemo = ['Google','Test', 'Taobao']
# 將列表中各字符串值為鍵嗜价，各字符串的長度為值艇抠，組成鍵值對
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Test': 4, 'Taobao': 6}

提供三個數(shù)字幕庐，以三個數(shù)字為鍵，三個數(shù)字的平方為值來創(chuàng)建字典：

>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

5.3 集合推導式

集合推導式基本格式：

{ expression for item in Sequence }

或

{ expression for item in Sequence if conditional }

計算數(shù)字 1,2,3 的平方數(shù)：

>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}

判斷不是 abc 的字母并輸出：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

5.4 元組推導式(生成器表達式)

元組推導式可以利用 range 區(qū)間家淤、元組异剥、列表、字典和集合等數(shù)據(jù)類型絮重，快速生成一個滿足指定需求的元組冤寿。

元組推導式基本格式：

(expression for item in Sequence )

或

(expression for item in Sequence if conditional )

元組推導式和列表推導式的用法也完全相同，只是元組推導式是用() 圓括號將各部分括起來青伤，而列表推導式用的是中括號 []督怜，另外元組推導式返回的結果是一個生成器對象。

例如狠角，我們可以使用下面的代碼生成一個包含數(shù)字 1~9 的元組：

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器對象

>>> tuple(a)       # 使用 tuple() 函數(shù)号杠，可以直接將生成器對象轉換成元組
(1, 2, 3, 4, 5, 6, 7, 8, 9)

6 迭代器與生成器

6.1 迭代器定義

迭代是Python最強大的功能之一，是訪問集合元素的一種方式丰歌，特點：

• 迭代器是一個可以記住遍歷的位置的對象姨蟋。
• 迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束立帖。
• 迭代器只能往前不會后退眼溶。
• 迭代器有兩個基本的方法：iter() 和 next()

字符串，列表或元組對象都可用于創(chuàng)建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list)    # 創(chuàng)建迭代器對象
>>> print (next(it))   # 輸出迭代器的下一個元素
1
>>> print (next(it))
2
>>>

迭代器對象可以使用常規(guī)for語句進行遍歷：

#!/usr/bin/python3
list=[1,2,3,4]
it = iter(list)    # 創(chuàng)建迭代器對象
for x in it:
    print (x, end=" ")

結果：
1 2 3 4

也可以使用 next()函數(shù)：

#!/usr/bin/python3 
import sys         # 引入 sys 模塊
 
list=[1,2,3,4]
it = iter(list)    # 創(chuàng)建迭代器對象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

結果如下：
1
2
3
4

6.2 創(chuàng)建一個迭代器

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

類都有一個構造函數(shù)晓勇，Python 的構造函數(shù)為__init__(), 它會在對象初始化的時候執(zhí)行

• __iter__()方法返回一個特殊的迭代器對象堂飞， 這個迭代器對象實現(xiàn)了 __next__() 方法并通過 StopIteration 異常標識迭代的完成。
• __next__() 方法（Python 2 里是 next()）會返回下一個迭代器對象宵蕉。

創(chuàng)建一個返回數(shù)字的迭代器酝静，初始值為 1，逐步遞增 1：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

結果：
1
2
3
4
5

6.3 StopIteration

StopIteration異常用于標識迭代的完成羡玛，防止出現(xiàn)無限循環(huán)的情況别智，在 __next__()方法中我們可以設置在完成指定循環(huán)次數(shù)后觸發(fā) StopIteration 異常來結束迭代。

例如在 20 次迭代后停止執(zhí)行：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

6.4 生成器

在 Python 中稼稿，使用了 yield函數(shù)被稱為生成器(generator)
跟普通函數(shù)不同的是薄榛，生成器是一個返回迭代器的函數(shù)，只能用于迭代操作让歼，更簡單點理解生成器就是一個迭代器
在調用生成器運行的過程中敞恋，每次遇到 yield 時函數(shù)會暫停并保存當前所有的運行信息，返回 yield 的值, 并在下一次執(zhí)行 next() 方法時從當前位置繼續(xù)運行

調用一個生成器函數(shù)谋右，返回的是一個迭代器對象硬猫。

#!/usr/bin/python3
import sys
def fibonacci(n): # 生成器函數(shù) - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一個迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

結果：
0 1 1 2 3 5 8 13 21 34 55