Python queue get

A queue, useful for coordinating producer and consumer coroutines.

If maxsize is less than or equal to zero, the queue size is infinite. If it is an integer greater than , then will block when the queue reaches maxsize, until an item is removed by .

Unlike the standard library , you can reliably know this Queue’s size with , since your single-threaded asyncio application won’t be interrupted between calling and doing an operation on the Queue.

This class is not thread safe.

()¶

Return if the queue is empty, otherwise.

()¶

Return if there are items in the queue.

Note

If the Queue was initialized with (the default), then is never .

coroutine ()¶

Remove and return an item from the queue. If queue is empty, wait until an item is available.

This method is a coroutine.

()¶

Remove and return an item from the queue.

Return an item if one is immediately available, else raise .

coroutine ()¶

Block 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 to indicate that the item was retrieved and all work on it is complete. When the count of unfinished tasks drops to zero, unblocks.

This method is a coroutine.

coroutine (item)¶

Put an item into the queue. If the queue is full, wait until a free slot is available before adding item.

This method is a coroutine.

(item)¶

Put an item into the queue without blocking.

If no free slot is immediately available, raise .

()¶

Number of items in the queue.

()¶

Indicate that a formerly enqueued task is complete.

Used by queue consumers. For each used to fetch a task, a subsequent call to tells the queue that the processing on the task is complete.

If a is currently blocking, it will resume when all items have been processed (meaning that a call was received for every item that had been into the queue).

Raises if called more times than there were items placed in the queue.

¶

Number of items allowed in the queue.

Example 1

Example 2

Example 3

Example 4

Example 5

Example 6

Example 7

Example 8

Example 9

Example 10

Example 11

Example 12

Example 13

Example 14

Example 15

Example 16

Example 17

Example 18

Example 19

Example 20

Example 21

Example 22

Example 23

Example 24

Example 25

Source code:Lib/queue.py

The module implements multi-producer, multi-consumer queues. It is especially useful in threaded programming when information must be exchanged safely between multiple threads. The class in this module implements all the required locking semantics. It depends on the availability of thread support in Python; see the module.

The module implements three types of queue, which differ only in the order in which the entries are retrieved. In a FIFO queue, the first tasks added are the first retrieved. In a LIFO queue, the most recently added entry is the first retrieved (operating like a stack). With a priority queue, the entries are kept sorted (using the module) and the lowest valued entry is retrieved first.

Internally, the module uses locks to temporarily block competing threads; however, it is not designed to handle reentrancy within a thread.

The module defines the following classes and exceptions:

class (maxsize=0)¶

Constructor for a FIFO queue. maxsize is an integer that sets the upperbound limit on the number of items that can be placed in the queue. Insertion will block once this size has been reached, until queue items are consumed. If maxsize is less than or equal to zero, the queue size is infinite.

class (maxsize=0)¶

Constructor for a LIFO queue. maxsize is an integer that sets the upperbound limit on the number of items that can be placed in the queue. Insertion will block once this size has been reached, until queue items are consumed. If maxsize is less than or equal to zero, the queue size is infinite.

class (maxsize=0)¶

Constructor for a priority queue. maxsize is an integer that sets the upperbound limit on the number of items that can be placed in the queue. Insertion will block once this size has been reached, until queue items are consumed. If maxsize is less than or equal to zero, the queue size is infinite.

The lowest valued entries are retrieved first (the lowest valued entry is the one returned by ). A typical pattern for entries is a tuple in the form: .

exception ¶

Exception raised when non-blocking (or ) is called on a object which is empty.

exception ¶

Exception raised when non-blocking (or ) is called on a object which is full.

What is Python Queue?

A queue is a container that holds data. The data that is entered first will be removed first, and hence a queue is also called “First in First Out” (FIFO). The queue has two ends front and rear. The items are entered from the rear and removed from the front side.

In this Python tutorial, you will learn:

How does Python Queue Work?

The queue can be easily compared with the real-world example the line of people waiting in a queue at the ticket counter, the person standing first will get the ticket first, followed by the next person and so on. The same logic goes for the queue data structure too.

Here is a diagrammatic representation of queue:

The Rear represents the point where the items are inserted inside the queue. In this example, 7 is value for that.

The Front represents the point where the items from the queue will be removed. If you remove an item from the queue, the first element you will get is 1, as shown in the figure.

Item 1 was the first one to be inserted in the queue, and while removing it is the first one to come out. Hence the queue is called FIRST IN FIRST OUT (FIFO)

In a queue, the items are removed in order and cannot be removed from in between. You just cannot remove the item 5 randomly from the queue, to do that you will have to remove all the items before 5. The items in queue will be removed in the order they are inserted.

Types of Queue in Python

There are mainly two types of queue in Python:

• First in First out Queue: For this, the element that goes first will be the first to come out.

  To work with FIFO, you have to call Queue() class from queue module.

• Last in First out Queue: Over here, the element that is entered last will be the first to come out.

  To work with LIFO, you have to call LifoQueue() class from the queue module.

Python queue Installation

It is very easy to work with queue in python. Here are the steps to follow to make use of queue in your code.

Step 1) You just have to import the queue module, as shown below:

The module is available by default with python, and you don’t need any additional installation to start working with the queue. There are 2 types of queue FIFO (first in first out) and LIFO (last in first out).

Step 2) To work with FIFO queue , call the Queue class using the queue module imported as shown below:

Step 3) To work with LIFO queue call the LifoQueue() class as shown below:

Methods available inside Queue and LifoQueue class

Following are the important methods available inside Queue and LifoQueue class:

• put(item): This will put the item inside the queue.
• get(): This will return you an item from the queue.
• empty(): It will return true if the queue is empty and false if items are present.
• qsize(): returns the size of the queue.
• full(): returns true if the queue is full, otherwise false.

First In First Out Queue Example

In the case of first in first out, the element that goes first will be the first to come out.

Add and item in a queue

Let us work on an example to add an item in a queue. To start working with the queue, first import the module queue, as shown in the example below.

To add an item , you can make use of put() method as shown in the example:

By default, the size of the queue is infinite and you can add any number of items to it. In case you want to define the size of the queue the same can be done as follows

Output:

Now the size of the queue is 5, and it will not take more than 5 items, and the method q1.full() will return true. Adding any more items will not execute the code any further.

Remove an item from the queue

To remove an item from the queue, you can use the method called get(). This method allows items from the queue when called.

The following example shows how to remove an item from the queue.

Output:

Last In First Out queue Example

In the case of last in the first out queue, the element that is entered last will be the first to come out.

To work with LIFO, i.e., last in the first out queue, we need to import the queue module and make use of the LifoQueue() method.

Add and item in a queue

Here we will understand how to add an item to the LIFO queue.

You have to use the put() method on LifoQueue, as shown in the above example.

Remove an item from the queue

To remove an item from the LIFOqueue you can make use of get() method .

Output:

Add more than 1 item in a Queue

In the above examples, we have seen how to add a single item and remove the item for FIFO and LIFOqueue. Now we will see how to add more than one item and also remove it.

Add and item in a FIFOqueue

Remove an item from the FIFOqueue

Output:

Add and item in a LIFOqueue

Remove an item from the LIFOqueue

Output:

Sorting Queue

Following example shows the queue sorting.The algorithm used for sorting is bubble sort.

Output:

Reversing Queue

To reverse the queue, you can make use of another queue and recursion.

The following example shows how to get the queue reversed.

Example:

Output:

Summary:

• A queue is a container that holds data. There are two types of Queue, FIFO, and LIFO.
• For a FIFO (First in First out Queue), the element that goes first will be the first to come out.
• For a LIFO (Last in First out Queue), the element that is entered last will be the first to come out.
• An item in a queue is added using the put(item) method.
• To remove an item, get() method is used.

# Example Python program that uses put() method

# to add elements to a queue.Queue instance

import queue

import threading

import os

import sys

import random

import time

try:

    # Function for writer thread

    def writer(sq):

        while(True):

            data = random.randint(0, 9999);

            time.sleep(1);

            sq.put(data);

            print("writer:added %d"%data);

    # Function for reader thread

    def reader(sq):

        while(True):

            data = sq.get();

            time.sleep(1);

            print("reader:removed %d"%data);

    # Create a synchronized queue instance

    sharedQueue = queue.Queue();

    # Create reader and writer threads

    threads     = [None, None];

    threads[0]  = threading.Thread(target=reader, args=(sharedQueue,));

    threads[1]  = threading.Thread(target=writer, args=(sharedQueue,));

    # Start the reader and writer threads

    for thread in threads:

        thread.start();

    # Wait for the reader and writer threads to exit

    for thread in threads:

        thread.join();

except KeyboardInterrupt:   

    print('Keyboard interrupt received from user');

    try:

        sys.exit(0);

    except:

        os._exit(0);

Like stack, queue is a linear data structure that stores items in First In First Out (FIFO) manner. With a queue the least recently added item is removed first. A good example of queue is any queue of consumers for a resource where the consumer that came first is served first.
 

Operations associated with queue are: 
 

• Enqueue: Adds an item to the queue. If the queue is full, then it is said to be an Overflow condition – Time Complexity : O(1)
• Dequeue: Removes an item from the queue. The items are popped in the same order in which they are pushed. If the queue is empty, then it is said to be an Underflow condition – Time Complexity : O(1)
• Front: Get the front item from queue – Time Complexity : O(1)
• Rear: Get the last item from queue – Time Complexity : O(1)

Implementation

There are various ways to implement a queue in Python. This article covers the implementation of queue using data structures and modules from Python library.
Queue in Python can be implemented by the following ways:
 

• list
• collections.deque
• queue.Queue

Implementation using list

List is a Python’s built-in data structure that can be used as a queue. Instead of enqueue() and dequeue(), append() and pop() function is used. However, lists are quite slow for this purpose because inserting or deleting an element at the beginning requires shifting all of the other elements by one, requiring O(n) time.
 

Output: 
 

Implementation using collections.deque

Queue in Python can be implemented using deque class from the collections module. Deque is preferred over list in the cases where we need quicker append and pop operations from both the ends of container, as deque provides an O(1) time complexity for append and pop operations as compared to list which provides O(n) time complexity. Instead of enqueue and deque, append() and popleft() functions are used.
 

Output: 
 

Implementation using queue.Queue

Queue is built-in module of Python which is used to implement a queue. queue.Queue(maxsize) initializes a variable to a maximum size of maxsize. A maxsize of zero ‘0’ means a infinite queue. This Queue follows FIFO rule. 
There are various functions available in this module: 
 

• maxsize – Number of items allowed in the queue.
• empty() – Return True if the queue is empty, False otherwise.
• full() – Return True if there are maxsize items in the queue. If the queue was initialized with maxsize=0 (the default), then full() never returns True.
• get() – Remove and return an item from the queue. If queue is empty, wait until an item is available.
• get_nowait() – Return an item if one is immediately available, else raise QueueEmpty.
• put(item) – Put an item into the queue. If the queue is full, wait until a free slot is available before adding the item.
• put_nowait(item) – Put an item into the queue without blocking. If no free slot is immediately available, raise QueueFull.
• qsize() – Return the number of items in the queue.

Output: 
 

Source code:Lib/queue.py

The module implements multi-producer, multi-consumer queues. It is especially useful in threaded programming when information must be exchanged safely between multiple threads. The class in this module implements all the required locking semantics.

The module implements three types of queue, which differ only in the order in which the entries are retrieved. In a FIFO queue, the first tasks added are the first retrieved. In a LIFO queue, the most recently added entry is the first retrieved (operating like a stack). With a priority queue, the entries are kept sorted (using the module) and the lowest valued entry is retrieved first.

Internally, those three types of queues use locks to temporarily block competing threads; however, they are not designed to handle reentrancy within a thread.

In addition, the module implements a “simple” FIFO queue type, , whose specific implementation provides additional guarantees in exchange for the smaller functionality.

The module defines the following classes and exceptions:

class (maxsize=0)¶

Constructor for a FIFO queue. maxsize is an integer that sets the upperbound limit on the number of items that can be placed in the queue. Insertion will block once this size has been reached, until queue items are consumed. If maxsize is less than or equal to zero, the queue size is infinite.

class (maxsize=0)¶

Constructor for a LIFO queue. maxsize is an integer that sets the upperbound limit on the number of items that can be placed in the queue. Insertion will block once this size has been reached, until queue items are consumed. If maxsize is less than or equal to zero, the queue size is infinite.

class (maxsize=0)¶

Constructor for a priority queue. maxsize is an integer that sets the upperbound limit on the number of items that can be placed in the queue. Insertion will block once this size has been reached, until queue items are consumed. If maxsize is less than or equal to zero, the queue size is infinite.

The lowest valued entries are retrieved first (the lowest valued entry is the one returned by ). A typical pattern for entries is a tuple in the form: .

If the data elements are not comparable, the data can be wrapped in a class that ignores the data item and only compares the priority number:

fromdataclassesimportdataclass,[email protected](order=True)classPrioritizedItem:priority:intitem:Any=field(compare=False)

class ¶

Constructor for an unbounded FIFO queue. Simple queues lack advanced functionality such as task tracking.

exception ¶

Exception raised when non-blocking (or ) is called on a object which is empty.

exception ¶

Exception raised when non-blocking (or ) is called on a object which is full.