Python中關於循環技術的短文
Python中有很多數據結構可用來存儲數據集合，而當我們想讀取調用這些存儲在數據結構中的數據時，常常使用一些循環遍歷技術。根據我們對調用數據方式的要求以及不同數據結構的特點，我們有許多不同的循環技術，本文將對這些技術進行總結。
基礎
-對於基本的數據結構，像列表、元組，如果我們只是想按順序調用讀取存儲在其中的數據，我們只需用簡單的for循環就可以了。
例子
列表：
代碼：
List = [1,2,3,4]
for i in List:
print(i)
輸出結果:
1
2
3
4
元組：
代碼：
Tuple = ("a","b","c","d")
for i in Tuple:
print(i)
輸出結果:
a
b
c
d
特殊數據結構
-對於集合和字典這兩種數據結構，有特殊的循環技術。
集合
-集合中數據是無序的，如果直接用for循環技術遍歷輸出，則不會按輸入的順序輸出。
例子：
代碼：
Set = {"a","b","f","s"}
for i in Set:
print(i)
輸出：
b
a
s
f
字典
-字典中數據以鍵值對形式存儲，想要循環遍歷輸出key和對應的value值可以使用item()函數。
例子：
代碼：
Dict = {1:"a",2:"b",3:"c"}
for i,j in Dict.items():
print(i,"--",j)
輸出：
1 -- a
2 -- b
3 -- c
特殊遍歷要求
-在實際情況中，我們有時候需要按順序遍歷之外的循環技術。
列表下標和值共同輸出
-當我們在遍歷列表時，如果想要將下標和值一起輸出，可以使用enumerate()函數。
例子：
代碼：
List = [1,2,3,4]
for i,j in enumerate(List):
print(i,"--",j)
輸出：
0 -- 1
1 -- 2
2 -- 3
3 -- 4
同樣適用於元組，集合。
例子：
代碼（元組）：
Tuple = ("a","b","c","d")
for i,j in enumerate(Tuple):
print(i,"--",j)
輸出：
0 -- a
1 -- b
2 -- c
3 -- d
代碼（集合）：
Set = {"a","b","f","s"}
for i,j in enumerate(Set):
print(i,"--",j)
輸出：
0 -- b
1 -- a
2 -- s
3 -- f
-集合輸出依舊是無序的。
多個列表同時遍歷
-當我們想同時遍歷兩個或以上的列表時，我們可以使用zip()函數。下面僅以兩個列表爲例。
例子：
代碼：
List1 = ["a","b","c","d"]
List2 = ["e","f","g","h"]
for i,j in zip(List1,List2):
print(i,"--",j)
輸出：
a -- e
b -- f
c -- g
d -- h
同樣適用於元組，集合。
例子：
代碼（元組）：
Tuple1 = ("a","b","c","d")
Tuple2 = ("e","f","g","h")
for i,j in zip(Tuple1,Tuple2):
print(i,"--",j)
輸出：
a -- e
b -- f
c -- g
d -- h
代碼（集合）：
Set1 = {"a","b","f","s"}
Set2 = {1,2,3,4}
for i,j in zip(Set1,Set2):
print(i,"--",j)
b -- 1
a -- 2
s -- 3
f -- 4
-集合輸出依舊是無序的。
逆序遍歷
-當我們想倒着輸出一個列表時，我們可以使用reversed()函數。
例子：
代碼
List = [1,2,3,4]
for i in reversed(List):
print(i)
輸出：
4
3
2
1
排序後輸出
-當我們循環遍歷一個列表時，想對其中排序後再輸出可以使用sorted()函數
例子：
代碼
List = [4,2,5,1,3]
for i in sorted(List):
print(i)
輸出
1
2
3
4
5
循環技巧
-有時候我們想循環遍歷對一個列表進行操作，我們可以直接新定義一個列表
例子:
代碼
import math
raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
filtered_data = []
for value in raw_data:
if not math.isnan(value):
filtered_data.append(value)
print(filtered_data)
輸出
[56.2, 51.7, 55.3, 52.5, 47.8]
關於python生成器技術的補充
本文簡單對python中生成器的一些應用做出介紹
-可以通過yield實現在單線程的情況下實現併發運算的效果
例子
代碼
import time
def consumer(name):
print("%s 準備學習啦!" %name)
while True:
lesson = yield
print("開始[%s]了,[%s]老師來講課了!" %(lesson,name))
def producer(name):
c = consumer('A')
c2 = consumer('B')
c.__next__()
c2.__next__()
print("同學們開始上課 了!")
for i in range(10):
time.sleep(1)
print("到了兩個同學!")
c.send(i)
c2.send(i)
輸出結果
A 準備學習啦!
B 準備學習啦!
同學們開始上課 了!
到了兩個同學!
開始[0]了,[A]老師來講課了!
開始[0]了,[B]老師來講課了!
到了兩個同學!
開始[1]了,[A]老師來講課了!
開始[1]了,[B]老師來講課了!
到了兩個同學!
開始[2]了,[A]老師來講課了!
開始[2]了,[B]老師來講課了!
到了兩個同學!
開始[3]了,[A]老師來講課了!
開始[3]了,[B]老師來講課了!
到了兩個同學!
開始[4]了,[A]老師來講課了!
開始[4]了,[B]老師來講課了!
到了兩個同學!
開始[5]了,[A]老師來講課了!
開始[5]了,[B]老師來講課了!
到了兩個同學!
開始[6]了,[A]老師來講課了!
開始[6]了,[B]老師來講課了!
到了兩個同學!
解析
-由上面的例子我麼可以發現，python提供了兩種基本的方式
-生成器函數：也是用def定義的，利用關鍵字yield一次性返回一個結果，阻塞，重新開始
-生成器表達式：返回一個對象，這個對象只有在需要的時候才產生結果
-用定義函數來使用生成器
例子：
定義一個可生成斐波那契數列的函數，生成的值存儲到生成器中
代碼
def fib(max):
n,a,b =0,0,1
while n < max:
yield b
a,b =b,a+b
n = n+1
return 'done'
g = fib(6)
while True:
try:
x = next(g)
print('generator: ',x)
except StopIteration as e:
print("生成器返回值：",e.value)
break
輸出結果
generator: 1
generator: 1
generator: 2
generator: 3
generator: 5
generator: 8
生成器返回值： done
解析：
-這段代碼中利用了yield將生成結果存儲到生成器中。然後用next()函數不斷獲取生成器的值，直到全部獲取完。
-在用異常處理捕獲StopIteration異常，獲取函數返回值。
-生成器表達式
-生成器表達式來源於迭代和列表解析的組合，生成器和列表解析類似，但是它使用尖括號而不是方括號
例子
代碼
>>> # 列表解析生成列表
>>> [ x ** 3 for x in range(5)]
[0, 1, 8, 27, 64]
>>>
>>> # 生成器表達式
>>> (x ** 3 for x in range(5))
<generator object <genexpr> at 0x000000000315F678>
>>> # 兩者之間轉換
>>> list(x ** 3 for x in range(5))
[0, 1, 8, 27, 64]
-一個迭代既可以被寫成生成器函數，也可以被協程生成器表達式，均支持自動和手動迭代。而且這些生成器只支持一個active迭代，也就是說生成器的迭代器就是生成器本身。
對yield的幾點總結
（1）通常的for…in…循環中，in後面是一個數組，這個數組就是一個可迭代對象，類似的還有鏈表，字符串，文件。他可以是a = [1,2,3]，也可以是a = [x*x for x in range(3)]。
它的缺點也很明顯，就是所有數據都在內存裏面，如果有海量的數據，將會非常耗內存。
（2）生成器是可以迭代的，但是只可以讀取它一次。因爲用的時候才生成，比如a = (x*x for x in range(3))。!!!注意這裏是小括號而不是方括號。
（3）生成器（generator）能夠迭代的關鍵是他有next()方法，工作原理就是通過重複調用next()方法，直到捕獲一個異常。
（4）帶有yield的函數不再是一個普通的函數，而是一個生成器generator，可用於迭代
（5）yield是一個類似return 的關鍵字，迭代一次遇到yield的時候就返回yield後面或者右面的值。而且下一次迭代的時候，從上一次迭代遇到的yield後面的代碼開始執行
（6）yield就是return返回的一個值，並且記住這個返回的位置。下一次迭代就從這個位置開始。
（7）帶有yield的函數不僅僅是隻用於for循環，而且可用於某個函數的參數，只要這個函數的參數也允許迭代參數。
（8）send()和next()的區別就在於send可傳遞參數給yield表達式，這時候傳遞的參數就會作爲yield表達式的值，而yield的參數是返回給調用者的值，也就是說send可以強行修改上一個yield表達式值。
（9）send()和next()都有返回值，他們的返回值是當前迭代遇到的yield的時候，yield後面表達式的值，其實就是當前迭代yield後面的參數。
（10）第一次調用時候必須先next（）或send（）,否則會報錯，send後之所以爲None是因爲這時候沒有上一個yield，所以也可以認爲next（）等同於send(None)