當我們需要處理一個大量的數據集合時，一次性將其全部讀入記憶體並處理可能會導致記憶體溢出。此時，我們可以採用迭代器`Iterator`和生成器`Generator`的方法，逐個地處理數據，從而避免記憶體溢出的問題。迭代器是一個可以逐個訪問元素的對象，它實現了`python`的迭代協議，即實現了`__iter... ...
當我們需要處理一個大量的數據集合時，一次性將其全部讀入記憶體並處理可能會導致記憶體溢出。此時，我們可以採用迭代器Iterator和生成器Generator的方法，逐個地處理數據，從而避免記憶體溢出的問題。
迭代器是一個可以逐個訪問元素的對象，它實現了python的迭代協議，即實現了__iter__()和__next__()方法。通過調用__next__()方法，我們可以逐個訪問迭代器中的元素，直到所有元素都被訪問完畢，此時再次調用__next__()方法會引發StopIteration異常。
生成器是一種特殊的迭代器，它的實現方式更為簡潔，即通過yield語句來實現。生成器函數使用yield語句返回值，當生成器函數被調用時，它會返回一個生成器對象，通過調用__next__()方法來逐個訪問生成器中的元素，直到所有元素都被訪問完畢，此時再次調用__next__()方法會引發StopIteration異常。
使用迭代器和生成器可以有效地避免記憶體溢出問題，並且代碼實現也更為簡潔、高效。在python中，很多內置函數和語言特性都支持迭代器和生成器的使用，例如for迴圈、列表推導式、生成器表達式等。
3.1 使用迭代器
迭代器可以通過內置函數iter()進行創建，同時可以使用next()函數獲取下一個元素，如果迭代器沒有更多的元素，則拋出StopIteration異常在for迴圈中，迭代器可以自動實現例如for x in my_iterable:語句就可以遍歷my_iterable對象的所有元素。此外python中還有一種特殊的迭代器，稱為生成器(generator)，生成器是一種用簡單的方法實現迭代器的方式，使用了yield語句，生成器在執行過程中可以暫停並繼續執行，而函數則是一旦開始執行就會一直執行到返回。
創建基本迭代器: 首先聲明列表,然後使用__iter__將其轉為迭代器,並通過__next__遍歷迭代對象.
>>> list = [1,2,3,4,5,6,7,8,9,10]
>>>
>>> item = list.__iter__()
>>> type(item)
<class 'list_iterator'>
>>>
>>> item.__next__()
1
>>> next(item)
2
迭代器遍歷日誌文件: 使用迭代器可以實現對文本文件或日誌的遍歷,該方式可以遍歷大型文件而不會出現卡死現象.
# 手動訪問迭代器中的元素,可以使用next()函數
>>> with open("passwd.log") as fp:
... try:
... while True:
... print(next(fp))
... except StopIteration:
... print("none")
# 通過指定返回結束值來判斷迭代結束
>>> with open("passwd.log") as fp:
... while True:
... line = next(fp,None)
... if line is None:
... break
... print(line)
迴圈遍歷迭代元素: 由於迭代器遍歷結束會報錯,所以要使用try語句拋出一個StopIteration結束異常.
>>> listvar = ["呂洞賓", "張果老", "藍採和", "特乖離", "和香菇", "漢鐘離", "王文"]
>>> item = listvar.__iter__()
>>>
>>> while True:
... try:
... temp = next(item)
... print(temp)
... except StopIteration:
... break
迭代器與數組之間互轉: 通過使用enumerate方法,並將列表轉為迭代器對象,然後將對象轉為制定格式.
>>> listvar = ["呂洞賓", "張果老", "藍採和", "特乖離", "和香菇", "漢鐘離", "王文"]
>>>
>>> iter = enumerate(listvar) # 轉換為迭代器
>>> dict = tuple(iter) # 轉換為元組
>>> dict
((0, '呂洞賓'), (1, '張果老'), (2, '藍採和'), (3, '特乖離'), (4, '和香菇'), (5, '漢鐘離'), (6, '王文'))
>>>
>>> dict = list(iter)
>>> dict
[(0, '呂洞賓'), (1, '張果老'), (2, '藍採和'), (3, '特乖離'), (4, '和香菇'), (5, '漢鐘離'), (6, '王文')]
3.2 使用生成器
生成器是一種可以動態生成數據的迭代器,不同於列表等容器類型一次性把所有數據生成並存儲在記憶體中,生成器可以在需要時動態生成數據,這樣可以節省記憶體空間和提高程式效率.使用生成器可以通過for迴圈遍歷序列、列表等容器類型,而不需要提前知道其中所有元素.生成器可以使用yield關鍵字返回值,每次調用yield會暫停生成器並記錄當前狀態,下一次調用時可以從上一次暫停的地方繼續執行,而生成器的狀態則保留在生成器對象內部.除了使用next()函數調用生成器外,還可以使用send()函數向生成器中發送數據,併在生成器內部使用yield表達式接收發送的數據.
當我們調用一個生成器函數時,其實返回的是一個迭代器對象
只要表達式中使用了yield函數,通常將此類函數稱為生成器(generator)
運行生成器時,每次遇到yield函數,則會自動保存並暫停執行,直到使用next()方法時,才會繼續迭代
跟普通函數不同,生成器是一個返回迭代器的函數,只能用於迭代操作,更簡單點理解生成器就是一個迭代器
在學習生成器之前,需要一些前置知識,先來研究一下列表解析,列表解析是python迭代機制的一種應用,它常用於實現創建新的列表,因此要放置於[]中,列表解析非常靈活,可以用戶快速創建一組相應規則的列表元素,且支持迭代操作.
列表生成式基本語法: 通過列表生成式,我們可以完成數據的生成與過濾等操作.
>>> ret = [item for item in range(30) if item >0]
>>> print(ret)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
>>>
>>> ret = [item for item in range(30) if item >3]
>>> print(ret)
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
>>>
>>> ret = [item for item in range(30) if item%2!=0]
>>> ret
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29]
列表式求階乘: 通過列表解析式,來實現列表的迭代求階乘,並且只列印大於2(if x>=2)的數據.
>>> var = [1,2,3,4,5]
>>> retn = [ item ** 2 for item in var ]
>>> retn
[1, 4, 9, 16, 25]
>>>
>>> retn = [ item ** 2 for item in var if item >= 2 ]
>>> retn
[4, 9, 16, 25]
>>>
>>> retn = [ (item**2)/2 for item in range(1,10) ]
>>> retn
[0.5, 2.0, 4.5, 8.0, 12.5, 18.0, 24.5, 32.0, 40.5]
數據轉換: 通過使用列表生成式,實現將一個字元串轉換成一個合格的列表.
>>> String = "a,b,c,d,e,f,g,h"
>>> List = [item for item in String.split(",")]
>>> List
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
數據合併: 通過列表解析式,實現迭代將兩個列表按照規律合併.
>>> temp1=["x","y","z"]
>>> temp2=[1,2,3]
>>> temp3=[ (i,j) for i in temp1 for j in temp2 ]
>>> temp3
[('x', 1), ('x', 2), ('x', 3), ('y', 1), ('y', 2), ('y', 3), ('z', 1), ('z', 2), ('z', 3)]
文件過濾: 通過使用列表解析,實現文本的過濾操作.
>>> import os
>>> file_list=os.listdir("/var/log")
>>> file_log=[ i for i in file_list if i.endswith(".log") ]
>>> print(file_log)
['boot.log', 'yum.log', 'ecs_network_optimization.log', 'ntp.log']
>>> file_log=[ i for i in os.listdir("/var/log") if i.endswith(".log") ]
>>> print(file_log)
['boot.log', 'yum.log', 'ecs_network_optimization.log', 'ntp.log']
接下來我們就來研究一下生成器吧,生成器類似於返回值為數組的一個函數,這個函數可以接受參數,可以被調用,但不同於一般的函數會一次性返回包括了所有數值的數組,生成器一次只能產生一個值,這樣消耗的記憶體數量將大大減小,而且允許調用函數可以很快的處理前幾個返回值,因此生成器看起來像是一個函數,但是表現得卻像是迭代器.
我們先來看以下兩種情況的對比,第一種方法很簡單,只有把一個列表生成式的[]中括弧改為()小括弧,就創建了一個生成器.
>>> lis = [x*x for x in range(10)]
>>> print(lis)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> generator = (x*x for x in range(10))
>>> print(generator)
<generator object <genexpr> at 0x0000022E5C788A98>
如上例子,第一個lis通過列表生成式,創建了一個列表,而第二個generator則列印出一個記憶體地址,如果我們想獲取到第二個變數中的數據,則需要迭代操作,如下所示:
>>> generator = (x*x for x in range(10))
>>> print(next(generator))
0
>>> print(next(generator))
1
>>> print(next(generator))
4
>>> print(next(generator))
9
以上可以看到,generator保存的是演算法,每次調用next(generaotr),就計算出他的下一個元素的值,直到計算出最後一個元素,使用for迴圈可以簡便的遍歷出迭代器中的數據,因為generator也是可迭代對象.
>>> generator = (x*x for x in range(10))
>>>
>>> for i in generator:
print(i,end="")
0149162536496481
生成器表達式並不真正創建數字列表,而是返回一個生成器對象,此對象在每次計算出一個條目後,把這個條目"產生"(yield)出來,生成器表達式使用了"惰性計算"或稱作"延遲求值"的機制序列過長,並且每次只需要獲取一個元素時,應當考慮使用生成器表達式而不是列表解析.
>>> import sys
>>>
>>> yie=( i**2 for i in range(1,10) )
>>> next(yie)
1
>>> next(yie)
4
>>> next(yie)
9
>>> for j in ( i**2 for i in range(1,10)):print(j/2)
3.3 隊列的使用
隊列是一個多線程編程中常用的數據結構,它提供了一種可靠的方式來安全地傳遞數據和控制線程間的訪問. 在多線程環境下,如果沒有同步機制,多個線程同時訪問共用資源,可能會導致數據混亂或者程式崩潰.而Queue隊列就是一種線程安全的數據結構,它提供了多個線程訪問和操作的介面,可以保證多個線程之間的數據安全性和順序性. 通過Queue隊列,一個線程可以將數據放入隊列,而另一個線程則可以從隊列中取出數據進行處理,實現了線程之間的通信和協調.
先進先出隊列: 先來介紹簡單的隊列例子,以及隊列的常用方法的使用,此隊列是先進先出模式.
import queue
q = queue.Queue(5) #預設maxsize=0無限接收,最大支持的個數
print(q.empty()) #查看隊列是否為空,如果為空則返回True
q.put(1) #PUT方法是,向隊列中添加數據
q.put(2) #第二個PUT,第二次向隊列中添加數據
q.put(3,block=False,timeout=2) #是否阻塞:預設是阻塞block=True,timeout=超時時間
print(q.full()) #查看隊列是否已經放滿
print(q.qsize()) #隊列中有多少個元素
print(q.maxsize) #隊列最大支持的個數
print(q.get(block=False,timeout=2)) #GET取數據
print(q.get())
q.task_done() #join配合task_done,隊列中有任務就會阻塞進程,當隊列中的任務執行完畢之後,不在阻塞
print(q.get())
q.task_done()
q.join() #隊列中還有元素的話,程式就不會結束程式,只有元素被取完配合task_done執行,程式才會結束
import queue
def show(q,i):
if q.empty() or q.qsize() >= 1:
q.put(i) #存隊列
elif q.full():
print('queue not size')
que = queue.Queue(5) #允許5個隊列的隊列對象
for i in range(5):
show(que,i)
print('queue is number:',que.qsize()) #隊列元素個數
for j in range(5):
print(que.get()) #取隊列
print('......end')
後進先出隊列: 這個隊列則是,後進先出,也就是最後放入的數據最先彈出,類似於堆棧.
>>> import queue
>>>
>>> q = queue.LifoQueue()
>>>
>>> q.put("wang")
>>> q.put("rui")
>>> q.put("ni")
>>> q.put("hao")
>>>
>>> print(q.get())
hao
>>> print(q.get())
ni
>>> print(q.get())
rui
>>> print(q.get())
wang
>>> print(q.get())
優先順序隊列: 此類隊列,可以指定優先順序順序,預設從高到低排列,以此根據優先順序彈出數據.
>>> import queue
>>>
>>> q = queue.PriorityQueue()
>>>
>>> q.put((1,"python1"))
>>> q.put((-1,"python2"))
>>> q.put((10,"python3"))
>>> q.put((4,"python4"))
>>> q.put((98,"python5"))
>>>
>>> print(q.get())
(-1, 'python2')
>>> print(q.get())
(1, 'python1')
>>> print(q.get())
(4, 'python4')
>>> print(q.get())
(10, 'python3')
>>> print(q.get())
(98, 'python5')
雙向的隊列: 雙向隊列,也就是說可以分別從兩邊彈出數據,沒有任何限制.
>>> import queue
>>>
>>> q = queue.deque()
>>>
>>> q.append(1)
>>> q.append(2)
>>> q.append(3)
>>> q.append(4)
>>> q.append(5)
>>>
>>> q.appendleft(6)
>>>
>>> print(q.pop())
5
>>> print(q.pop())
4
>>> print(q.popleft())
6
>>> print(q.popleft())
1
>>> print(q.popleft())
2
生產者消費者模型: 生產者消費者模型,是各種開發場景中最常用的開發模式,以下是模擬的模型.
import queue,time
import threading
q = queue.Queue()
def productor(arg):
while True:
q.put(str(arg))
print("%s 號視窗有票...."%str(arg))
time.sleep(1)
def consumer(arg):
while True:
print("第 %s 人取 %s 號視窗票"%(str(arg),q.get()))
time.sleep(1)
for i in range(10): #負責生產票數
t = threading.Thread(target=productor,args=(i,))
t.start()
for j in range(5): #負責取票,兩個用戶取票
t = threading.Thread(target=consumer,args=(j,))
t1 = threading.Thread(target=consumer,args=(j,))
t.start()
t1.start()
本文作者： 王瑞
本文鏈接： https://www.lyshark.com/post/1c1ebaa1.html
版權聲明： 本博客所有文章除特別聲明外，均採用 BY-NC-SA 許可協議。轉載請註明出處！
文章出處：https://www.cnblogs.com/LyShark/p/17624639.html
本博客所有文章除特別聲明外，均採用 BY-NC-SA 許可協議。轉載請註明出處！
