直接跑程式碼，看結果，結果在最後

from queue import Queue
from queue import PriorityQueue
print("Queue類實現了一個基本的先進先出(FIFO)容器，使用put()將元素新增到序列尾端，get()從佇列尾部移除元素。\n")

q = Queue()

for i in range(3):
    q.put(i)

while not q.empty():
    print(q.get())

print("與標準FIFO實現Queue不同的是，LifoQueue使用後進先出序（會關聯一個棧資料結構）。\n")

from queue import LifoQueue

q1 = LifoQueue()

for i in range(3):
    q1.put(i)

while not q1.empty():
    print(q1.get())


print("除了按元素入列順序外，有時需要根據佇列中元素的特性來決定元素的處理順序。例如，老闆的列印任務可能比研發的列印任務優先順序更高。PriorityQueue依據佇列中內容的排序順序(sort order)來決定那個元素將被檢索。")


class Job(object):
    def __init__(self, priority, description):
        self.priority = priority
        self.description = description
        print('New job:', description)
        return

    def __lt__(self, other):
        return self.priority < other.priority

q2 = PriorityQueue()

q2.put(Job(5, 'Mid-level job'))
q2.put(Job(10, 'Low-level job'))
q2.put(Job(1, 'Important job')) #數字越小，優先順序越高

while not q2.empty():
    next_job = q2.get() #可根據優先順序取序列
    print('Processing job', next_job.description)

print(help(Queue))




 

以上程式碼輸出：

Queue類實現了一個基本的先進先出(FIFO)容器，使用put()將元素新增到序列尾端，get()從佇列尾部移除元素。

0 1 2 與標準FIFO實現Queue不同的是，LifoQueue使用後進先出序（會關聯一個棧資料結構）。

2 1 0 除了按元素入列順序外，有時需要根據佇列中元素的特性來決定元素的處理順序。例如，老闆的列印任務可能比研發的列印任務優先順序更高。PriorityQueue依據佇列中內容的排序順序(sort order)來決定那個元素將被檢索。 New job: Mid-level job New job: Low-level job New job: Important job Processing job Important job Processing job Mid-level job Processing job Low-level job

一下是類queue的系統解釋：

Help on class Queue in module queue:

class Queue(builtins.object)  |  Queue(maxsize=0)  |    |  Create a queue object with a given maximum size.  |    |  If maxsize is <= 0, the queue size is infinite.  |    |  Methods defined here:  |    |  __init__(self, maxsize=0)  |      Initialize self.  See help(type(self)) for accurate signature.  |    |  empty(self)  |      Return True if the queue is empty, False otherwise (not reliable!).  |        |      This method is likely to be removed at some point.  Use qsize() == 0  |      as a direct substitute, but be aware that either approach risks a race  |      condition where a queue can grow before the result of empty() or  |      qsize() can be used.  |        |      To create code that needs to wait for all queued tasks to be  |      completed, the preferred technique is to use the join() method.  |    |  full(self)  |      Return True if the queue is full, False otherwise (not reliable!).  |        |      This method is likely to be removed at some point.  Use qsize() >= n  |      as a direct substitute, but be aware that either approach risks a race  |      condition where a queue can shrink before the result of full() or  |      qsize() can be used.  |    |  get(self, block=True, timeout=None)  |      Remove and return an item from the queue.  |        |      If optional args 'block' is true and 'timeout' is None (the default),  |      block if necessary until an item is available. If 'timeout' is  |      a non-negative number, it blocks at most 'timeout' seconds and raises  |      the Empty exception if no item was available within that time.  |      Otherwise ('block' is false), return an item if one is immediately  |      available, else raise the Empty exception ('timeout' is ignored  |      in that case).  |    |  get_nowait(self)  |      Remove and return an item from the queue without blocking.  |        |      Only get an item if one is immediately available. Otherwise  |      raise the Empty exception.  |    |  join(self)  |      Blocks until all items in the Queue have been gotten and processed.  |        |      The count of unfinished tasks goes up whenever an item is added to the  |      queue. The count goes down whenever a consumer thread calls task_done()  |      to indicate the item was retrieved and all work on it is complete.  |        |      When the count of unfinished tasks drops to zero, join() unblocks.  |    |  put(self, item, block=True, timeout=None)  |      Put an item into the queue.  |        |      If optional args 'block' is true and 'timeout' is None (the default),  |      block if necessary until a free slot is available. If 'timeout' is  |      a non-negative number, it blocks at most 'timeout' seconds and raises  |      the Full exception if no free slot was available within that time.  |      Otherwise ('block' is false), put an item on the queue if a free slot  |      is immediately available, else raise the Full exception ('timeout'  |      is ignored in that case).  |    |  put_nowait(self, item)  |      Put an item into the queue without blocking.  |        |      Only enqueue the item if a free slot is immediately available.  |      Otherwise raise the Full exception.  |    |  qsize(self)  |      Return the approximate size of the queue (not reliable!).  |    |  task_done(self)  |      Indicate that a formerly enqueued task is complete.  |        |      Used by Queue consumer threads.  For each get() used to fetch a task,  |      a subsequent call to task_done() tells the queue that the processing  |      on the task is complete.  |        |      If a join() is currently blocking, it will resume when all items  |      have been processed (meaning that a task_done() call was received  |      for every item that had been put() into the queue).  |        |      Raises a ValueError if called more times than there were items  |      placed in the queue.  |    |  ----------------------------------------------------------------------  |  Data descriptors defined here:  |    |  __dict__  |      dictionary for instance variables (if defined)  |    |  __weakref__  |      list of weak references to the object (if defined)

None [Finished in 0.1s]

認識你是我們的緣分，同學，等等，記得關注我。

微信掃一掃 關注該公眾號