Python Queue 入門

Queue 叫隊列，是數(shù)據(jù)結構中的一種，基本上所有成熟的編程語言都內置了對 Queue 的支持。

創(chuàng)新互聯(lián)服務項目包括松溪網站建設、松溪網站制作、松溪網頁制作以及松溪網絡營銷策劃等。多年來，我們專注于互聯(lián)網行業(yè)，利用自身積累的技術優(yōu)勢、行業(yè)經驗、深度合作伙伴關系等，向廣大中小型企業(yè)、政府機構等提供互聯(lián)網行業(yè)的解決方案，松溪網站推廣取得了明顯的社會效益與經濟效益。目前，我們服務的客戶以成都為中心已經輻射到松溪省份的部分城市，未來相信會繼續(xù)擴大服務區(qū)域并繼續(xù)獲得客戶的支持與信任！

Python 中的 Queue 模塊實現(xiàn)了多生產者和多消費者模型，當需要在多線程編程中非常實用。而且該模塊中的 Queue 類實現(xiàn)了鎖原語，不需要再考慮多線程安全問題。

該模塊內置了三種類型的 Queue，分別是 class queue.Queue(maxsize=0) ， class queue.LifoQueue(maxsize=0) 和 class queue.PriorityQueue(maxsize=0) 。它們三個的區(qū)別僅僅是取出時的順序不一致而已。

Queue 是一個 FIFO 隊列，任務按照添加的順序被取出。

LifoQueue 是一個 LIFO 隊列，類似堆棧，后添加的任務先被取出。

PriorityQueue 是一個優(yōu)先級隊列，隊列里面的任務按照優(yōu)先級排序，優(yōu)先級高的先被取出。

如你所見，就是上面所說的三種不同類型的內置隊列，其中 maxsize 是個整數(shù)，用于設置可以放入隊列中的任務數(shù)的上限。當達到這個大小的時候，插入操作將阻塞至隊列中的任務被消費掉。如果 maxsize 小于等于零，則隊列尺寸為無限大。

向隊列中添加任務，直接調用 put() 函數(shù)即可

put() 函數(shù)完整的函數(shù)簽名如下 Queue.put(item, block=True, timeout=None) ，如你所見，該函數(shù)有兩個可選參數(shù)。

默認情況下，在隊列滿時，該函數(shù)會一直阻塞，直到隊列中有空余的位置可以添加任務為止。如果 timeout 是正數(shù)，則最多阻塞 timeout 秒，如果這段時間內還沒有空余的位置出來，則會引發(fā) Full 異常。

當 block 為 false 時，timeout 參數(shù)將失效。同時如果隊列中沒有空余的位置可添加任務則會引發(fā) Full 異常，否則會直接把任務放入隊列并返回，不會阻塞。

另外，還可以通過 Queue.put_nowait(item) 來添加任務，相當于 Queue.put(item, False) ，不再贅述。同樣，在隊列滿時，該操作會引發(fā) Full 異常。

從隊列中獲取任務，直接調用 get() 函數(shù)即可。

與 put() 函數(shù)一樣， get() 函數(shù)也有兩個可選參數(shù)，完整簽名如下 Queue.get(block=True, timeout=None) 。

默認情況下，當隊列空時調用該函數(shù)會一直阻塞，直到隊列中有任務可獲取為止。如果 timeout 是正數(shù)，則最多阻塞 timeout 秒，如果這段時間內還沒有任務可獲取，則會引發(fā) Empty 異常。

當 block 為 false 時，timeout 參數(shù)將失效。同時如果隊列中沒有任務可獲取則會立刻引發(fā) Empty 異常，否則會直接獲取一個任務并返回，不會阻塞。

另外，還可以通過 Queue.get_nowait() 來獲取任務，相當于 Queue.get(False) ，不再贅述。同樣，在隊列為空時，該操作會引發(fā) Empty 異常。

Queue.qsize() 函數(shù)返回隊列的大小。注意這個大小不是精確的，qsize() 0 不保證后續(xù)的 get() 不被阻塞，同樣 qsize() maxsize 也不保證 put() 不被阻塞。

如果隊列為空，返回 True ，否則返回 False 。如果 empty() 返回 True ，不保證后續(xù)調用的 put() 不被阻塞。類似的，如果 empty() 返回 False ，也不保證后續(xù)調用的 get() 不被阻塞。

如果隊列是滿的返回 True ，否則返回 False 。如果 full() 返回 True 不保證后續(xù)調用的 get() 不被阻塞。類似的，如果 full() 返回 False 也不保證后續(xù)調用的 put() 不被阻塞。

queue.Queue() 是 FIFO 隊列，出隊順序跟入隊順序是一致的。

queue.LifoQueue() 是 LIFO 隊列，出隊順序跟入隊順序是完全相反的，類似于棧。

優(yōu)先級隊列中的任務順序跟放入時的順序是無關的，而是按照任務的大小來排序，最小值先被取出。那任務比較大小的規(guī)則是怎么樣的呢。

注意，因為列表的比較對規(guī)則是按照下標順序來比較的，所以在沒有比較出大小之前 ，隊列中所有列表對應下標位置的元素類型要一致。

好比 [2,1] 和 ["1","b"] 因為第一個位置的元素類型不一樣，所以是沒有辦法比較大小的，所以也就放入不了優(yōu)先級隊列。

然而對于 [2,1] 和 [1,"b"] 來說即使第二個元素的類型不一致也是可以放入優(yōu)先級隊列的，因為只需要比較第一個位置元素的大小就可以比較出結果了，就不需要比較第二個位置元素的大小了。

但是對于 [2,1] 和 1 [2,"b"] 來說，則同樣不可以放入優(yōu)先級隊列，因為需要比較第二個位置的元素才可以比較出結果，然而第二個位置的元素類型是不一致的，無法比較大小。

綜上，也就是說， 直到在比較出結果之前，對應下標位置的元素類型都是需要一致的 。

下面我們自定義一個動物類型，希望按照年齡大小來做優(yōu)先級排序。年齡越小優(yōu)先級越高。

本章節(jié)介紹了隊列以及其常用操作。因為隊列默認實現(xiàn)了鎖原語，因此在多線程編程中就不需要再考慮多線程安全問題了，對于程序員來說相當友好了。

python_隊列

1.隊列是先進先出，列表可以讀取某個指定數(shù)據(jù)

2.隊列如果將儲存的數(shù)據(jù)都讀完就結束，列表可以反復讀取

例如：

二、具體介紹一下queue

在使用queue的時候要先引入queue模塊，創(chuàng)建對象~

其中queue可以創(chuàng)建出三種對象分別是

1.先進先出行Queue（maxsize = ？）

通過上面的例子我們能發(fā)現(xiàn)，put 方法是往隊列放數(shù)據(jù)，但是隊列跟列表不同取完之后數(shù)據(jù)就沒有了，如果取的數(shù)據(jù)大于列表存放的數(shù)據(jù)就會卡住這時候有兩種解決辦法，第一種調用get_nowait（）方法，這時候就會報異常queue.Empty，第二種就是從get自身解決，get(block = False),默認的時候block是True。

2.后進先出LifeQueue()是個縮寫是Last in first out

3.priorityQueue可以理解成vip，看你的心情讓那先出就先出

三、利用queue和多線程寫一個生產者消費者

Python模塊的幾種類型簡介

1、系統(tǒng)內置模塊

os模塊：os模塊包含普遍的操作系統(tǒng)功能

sys模塊：提供了一系列有關Python運行環(huán)境的變量和函數(shù)

random模塊：random模塊用于生成隨機數(shù)

time 模塊: 主要包含各種提供日期、時間功能的類和函數(shù)

datetime模塊：對time模塊的一個高級封裝

shutil模塊：是一種高層次的文件操作工具

logging模塊：將日志打印到了標準輸出中

re模塊：可以直接調用來實現(xiàn)正則匹配

pymysql模塊：連接數(shù)據(jù)庫,并實現(xiàn)簡單的增刪改查

threading模塊：提供了更強大的多線程管理方案

queue模塊：實現(xiàn)了多生產者,多消費者的隊列

json模塊：用于字符串和數(shù)據(jù)類型間進行轉換json

2、開源(三方)模塊

Requests：最富盛名的http庫。每個Python程序員都應該有它。

Scrapy：從事爬蟲相關的工作，這個庫也是必不可少的。

NumPy：為Python提供了很多高級的數(shù)學方法。

matplotlib：一個繪制數(shù)據(jù)圖的庫。對于數(shù)據(jù)分析師非常有用。

Pygame：開發(fā)2D游戲的時候可以用上 。

Scapy：用Python寫的數(shù)據(jù)包探測和分析庫。

Django：開源Web開發(fā)框架，它鼓勵快速開發(fā),并遵循MVC設計，開發(fā)周期短。

Py2exe：將python腳本轉換為windows上可以獨立運行的可執(zhí)行程序。

BeautifulSoup：基于Python的HTML/XML解析器，簡單易用。

PyGtk：基于Python的GUI程序開發(fā)GTK+庫。

3、自定義模塊

自定義模塊是自己寫的模塊，對某段邏輯或某些函數(shù)進行封裝后供其他函數(shù)調用。

注意：自定義模塊的命名一定不能和系統(tǒng)內置的模塊重名了，否則將不能再導入系統(tǒng)的內置模塊了。

例如：自定義了一個sys.py模塊后，再想使用系統(tǒng)的sys模塊是不能使用的。

多線程和隊列

1、python提供兩種方式使用多線程：一個是基于函數(shù)：_thread模塊或者threading模塊。一個是基于類：theading.Thread

使用多線程函數(shù)包裝線程對象：_thread

_thead.start_new_thead(func,*args,**kwargs)

args,**kwargs是被包裝函數(shù)的入參，必須傳入元祖或字典

使用多線程函數(shù)包裝線程對象：threading

threading._start_new_thread(func,*args,**kwargs)：開啟線程，帶元祖或字典

threading.currentThread()：返回當前線程變量

threading.enumerate()：正在運行的線程列表，不含未啟動和已結束線程

threading.activeCount()：返回正在運行的線程數(shù)量

threading.settrace(func)：為所有threading模塊啟動的線程設置追蹤函數(shù)，在調用run方法之前，func會被傳給追蹤函數(shù)

threading.setprofile(func)：為所有threading模塊啟動的線程設置性能測試函數(shù)，也是在run方法調用前就傳遞給性能測試函數(shù)

使用多線程類包裝線程對象：threading.Thread

Thread類提供以下方法：

run()：表示線程活動的方法，線程需要控制些什么活動都在這里面定義。當線程對象一但被創(chuàng)建，其活動一定會因調用線程的 start() 方法開始。這會在獨立的控制線程調用 run() 方法。

start()：開啟線程活動

join()：等待線程中止，阻塞當前線程直到被調用join方法的線程中止。線程A調用線程B的join方法，那線程A將會被阻塞至線程B中止。

isAlive()：返回線程是否還活動

getName()：獲取線程名字

setName()：設置線程名字

Lock對象：實例化線程鎖，包含acquire方法獲取鎖 和 release 方法釋放鎖，在最開始創(chuàng)建鎖的時候，鎖為未鎖定狀態(tài)，調用acquire方法后鎖置為鎖定狀態(tài)，此時其他線程再調用acquire方法就將會被阻塞至其他線程調用release方法釋放鎖，如果釋放一個并未被鎖定的鎖將會拋出異常。支持上下文管理協(xié)議，直接with lock 無需調用鎖定，釋放方法

Rlock對象：重入鎖，相比lock增加了線程和遞歸的概念。比如：線程目標函數(shù)F，在獲得鎖之后執(zhí)行函數(shù)G，但函數(shù)G也需要先獲得鎖，此時同一線程，F(xiàn)獲得鎖，G等待，F(xiàn)等待G執(zhí)行，就造成了死鎖，此時使用rlock可避免。一旦線程獲得了重入鎖，同一個線程再次獲取它將不阻塞；但線程必須在每次獲取它時釋放一次。

daemon屬性：設置該線程是否是守護線程，默認為none，需要在調用start方法之前設置好

事件對象：一個線程發(fā)出事件信號 ，其他線程收到信號后作出對應活動。實例化事件對象后，初始事件標志為flase。調用其wait方法將阻塞當前所屬線程，至事件標志為true時。調用set方法可將事件標志置為true，被阻塞的線程將被執(zhí)行。調用clear方法可將事件標志置為flase

注意點：

1、繼承threading.Thread類，初始化時要記得繼承父類的__init__方法

2、run()方法只能有一個入參，故盡量把啟動線程時的參數(shù)入參到初始化的時候

3、鎖要設定全局的，一個子線程獲得一個鎖沒有意義

以下實例：有一個列表，線程A從尾到頭遍歷元素，線程B從頭到尾將元素值重置為1，設置線程鎖之前線程A遍歷到頭部的數(shù)據(jù)已經被修改，設置線程鎖之后不會再有數(shù)據(jù)不一致的情況

import threading,time

class tt(threading.Thread):

def __init__(self,name,func,ll):

? ? threading.Thread.__init__(self) #繼承父級的初始化方法

? ? self.name=name

? ? self.func=func? #run方法只能帶一個入參，故把方法入參到初始化的時候

? ? self.ll=ll

def run(self):

? ? print(self.name)

? ? threadlock.acquire() #獲得鎖

? ? self.func(self.ll)

? ? threadlock.release() #釋放鎖

def readd(x):

a=len(x)

while a0:

? ? print(x[a-1])

? ? a-=1

def sett(x):

for i in range(len(x)):

? ? x[i]=1

print(x)

if __name__=="__main__":

l = [0,0,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]

threadlock=threading.Lock() #實例化全局鎖

th1=tt("read",readd,l)

th2=tt("set",sett,l)

th1.start()

th2.start()

th_list=[]?

th_list.append(th1)

th_list.append(th2)

for li in th_list:

? ? li.join()? ? ? ? #主線程被阻塞，直到兩個子線程處理結束

print("主線程結束")

2、隊列

queue模塊包含queue.Queue(maxsize=0)先入先出隊列，queue.LifoQueue()先入后出隊列，和queue.PriorityQueue()優(yōu)先級可設置的隊列

Queue 模塊中的常用方法:

Queue.qsize() 返回隊列的大小，獲取的數(shù)據(jù)不可靠，因為一直有線程在操作隊列，數(shù)據(jù)一直變化

Queue.empty() 如果隊列為空，返回True,反之False

Queue.full() 如果隊列滿了，返回True,反之False

Queue.full 與 maxsize 大小對應

Queue.put(block=true,timeout=none) 將item數(shù)據(jù)寫入隊列，block=True，設置線程是否阻塞，設置阻塞當隊列數(shù)據(jù)滿了之后就會阻塞，一直到隊列數(shù)據(jù)不滿時繼續(xù)添加，如果設置不阻塞，當隊列滿了就會一直到timeout到后報錯

Queue.get([block[, timeout]]) 取出隊列數(shù)據(jù)，block=True，設置線程是否阻塞。設置阻塞，將會等待直到隊列不為空有數(shù)據(jù)可取出，設置不阻塞直到超過timeout等待時間后報錯

Queue.task_done() 在完成一項工作之后，Queue.task_done()函數(shù)向任務已經完成的隊列發(fā)送一個信號

Queue.join() 實際上意味著等到隊列為空，再執(zhí)行別的操作。會在隊列有未完成時阻塞，等待隊列無未完成的任務，取出數(shù)據(jù)get()之后還需要配置task_done使用才能讓等待隊列數(shù)-1

import queue,time

import threading

q=queue.Queue(maxsize=5)

def sett():

a=0

while a20:

? ? q.put(a,True)

? ? print("%d被put"%a)

? ? a+=1

def gett():

time.sleep(1)

while not q.empty(): #只要隊列沒空，一直取數(shù)據(jù)

? ? print("%d被取出"%q.get(True))

? ? q.task_done() #取出一次數(shù)據(jù)，將未完成任務-1，不然使用join方法線程會一直阻塞

if __name__=="__main__":

th1=threading._start_new_thread(sett,()) #不帶參數(shù)也要傳入空元祖不然會報錯

th2=threading._start_new_thread(gett,())

time.sleep(1) #延時主線程1S，等待put線程已經put部分數(shù)據(jù)到隊列

q.join()#阻塞主線程，直到未完成任務為0

python中棧和隊列在功能上的區(qū)別

“?！?/p>

和

“隊列”

是數(shù)據(jù)結構，與具體的語言無關。

1.隊列先進先出，棧先進后出。

2.

對插入和刪除操作的"限定"。

棧是限定只能在表的一端進行插入和刪除操作的線性表。

隊列是限定只能在表的一端進行插入和在另一端進行刪除操作的線性表。

從"數(shù)據(jù)結構"的角度看，它們都是線性結構，即數(shù)據(jù)元素之間的關系相同。但它們是完全不同的數(shù)據(jù)類型。除了它們各自的基本操作集不同外，主要區(qū)別是對插入和刪除操作的"限定"。

棧和隊列是在程序設計中被廣泛使用的兩種線性數(shù)據(jù)結構，它們的特點在于基本操作的特殊性，棧必須按"后進先出"的規(guī)則進行操作，而隊列必須按"先進先出"

的規(guī)則進行操作。和線性表相比，它們的插入和刪除操作受更多的約束和限定，故又稱為限定性的線性表結構。

3.遍歷數(shù)據(jù)速度不同。棧只能從頭部取數(shù)據(jù)

也就最先放入的需要遍歷整個棧最后才能取出來，而且在遍歷數(shù)據(jù)的時候還得為數(shù)據(jù)開辟臨時空間，保持數(shù)據(jù)在遍歷前的一致性隊列怎不同，他基于地址指針進行遍歷，而且可以從頭或尾部開始遍歷，但不能同時遍歷，無需開辟臨時空間，因為在遍歷的過程中不影像數(shù)據(jù)結構，速度要快的多

棧（stack）是限定只能在表的一端進行插入和刪除操作的線性表。

隊列（queue）是限定只能在表的一端進行插入和在另一端進行刪除操作的線性表。

從"數(shù)據(jù)結構"的角度看，它們都是線性結構，即數(shù)據(jù)元素之間的關系相同。但它們是完全不同的數(shù)據(jù)類型。除了它們各自的基本操作集不同外，主要區(qū)別是對插入和刪除操作的"限定"。

棧和隊列是在程序設計中被廣泛使用的兩種線性數(shù)據(jù)結構，它們的特點在于基本操作的特殊性，棧必須按"后進先出"的規(guī)則進行操作，而隊列必須按"先進先出"的規(guī)則進行操作。和線性表相比，它們的插入和刪除操作受更多的約束和限定，故又稱為限定性的線性表結構。

名稱欄目：python隊列模塊函數(shù) python隊列數(shù)據(jù)結構
網站網址：http://jinyejixie.com/article32/dochgpc.html

成都網站建設公司_創(chuàng)新互聯(lián)，為您提供App設計、建站公司、網站設計公司、自適應網站、、微信公眾號

廣告

聲明：本網站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)