Python Queue: FIFO & LIFO begrijpen met praktische voorbeelden

Wat is een Queue in Python?

Een queue is een datastructuur die items in lineaire volgorde opslaat. Items worden achteraan toegevoegd en vooraan verwijderd, volgens het First-In, First-Out (FIFO) principe. De queue blootstelt twee logische uiteinden: front en rear – enqueue achteraan, dequeue vooraan.

In deze tutorial leer je:

• Hoe Python's queue module werkt.
• Typen queues beschikbaar in Python.
• Hoe de module te installeren en importeren.
• Belangrijkste methoden op Queue en LifoQueue objecten.
• Hands-on voorbeelden voor FIFO en LIFO queues.
• Batch-operaties, sorteren en queues omkeren.

Hoe werkt de Queue Module?

Het gedrag is analoog aan een fysieke rij: de eerste persoon in de rij wordt als eerste bediend. In de queue-datastructuur wordt het element dat eerst ge-enequeued wordt, ook eerst ge-dequeued.

Het rear punt is waar nieuwe items worden ingevoegd (bijv. waarde 7). Het front punt is waar items de queue verlaten; het verwijderen van het eerste item levert waarde 1 op.

Omdat de queue lineair is, kun je willekeurige elementen in het midden niet verwijderen; je moet alle voorgaande elementen eerst dequeueen.

Typen Queues in Python

Python's queue module biedt twee primaire queue-klassen:

• FIFO Queue – gebruik Queue(). Het oudste item is altijd het eerste dat verwijderd wordt.
• LIFO Queue – gebruik LifoQueue(). Het meest recent toegevoegde item wordt eerst geretourneerd.

Aan de slag: De module importeren

Python levert de queue module standaard; geen externe installatie vereist.

import queue

Instantieer een FIFO queue:

q1 = queue.Queue()

Instantieer een LIFO queue:

q1 = queue.LifoQueue()

Belangrijkste methoden

Zowel Queue als LifoQueue blootstellen dezelfde kern-API:

• put(item) – enqueue een item.
• get() – dequeue en retourneer het volgende item.
• empty() – retourneert True als de queue leeg is.
• full() – retourneert True als de queue de maximumgrootte bereikt heeft.
• qsize() – retourneert het huidige aantal items.

FIFO Queue Voorbeeld

Enkele item enqueuen

import queue
q1 = queue.Queue()
q1.put(10)  # voeg 10 toe aan de queue

Meerdere items enqueuen met grootte-limiet

q1 = queue.Queue(maxsize=5)  # maximum 5 items
for i in range(1, 6):
    q1.put(i)
print(q1.full())  # → True

Output:

True

Een item dequeuen

item = q1.get()
print('Gedequeued item:', item)

Output:

Gedequeued item: 10

LIFO Queue Voorbeeld

Enkele item enqueuen

q1 = queue.LifoQueue()
q1.put(10)

Een item dequeuen

item = q1.get()
print('Gedequeued van LIFO:', item)

Output:

Gedequeued van LIFO: 10

Batch-operaties

FIFO – 20 getallen enqueuen

q1 = queue.Queue()
for i in range(20):
    q1.put(i)

FIFO – Alles dequeuen

while not q1.empty():
    print('Waarde:', q1.get())

Output:

Waarde: 0
Waarde: 1
...
Waarde: 19

LIFO – 20 getallen enqueuen

q1 = queue.LifoQueue()
for i in range(20):
    q1.put(i)

LIFO – Alles dequeuen

while not q1.empty():
    print('Waarde:', q1.get())

Output:

Waarde: 19
Waarde: 18
...
Waarde: 0

Een Queue sorteren (Bubble Sort)

q1 = queue.Queue()
for item in [11, 5, 4, 21, 3, 10]:
    q1.put(item)
n = q1.qsize()
for i in range(n):
    x = q1.get()
    for j in range(n-1):
        y = q1.get()
        if x > y:
            q1.put(y)
        else:
            q1.put(x)
        x = y
    q1.put(x)
while not q1.empty():
    print(q1.queue[0], end=' ')
    q1.get()

Output:

3 4 5 10 11 21

Een Queue omkeren met recursie

def reverse_queue(src, dest):
    item = src.get()
    if not src.empty():
        reverse_queue(src, dest)
    dest.put(item)
    return dest
q1 = queue.Queue()
for item in [11, 5, 4, 21, 3, 10]:
    q1.put(item)
q2 = queue.Queue()
reverse_queue(q1, q2)
while not q2.empty():
    print(q2.queue[0], end=' ')
    q2.get()

Output:

10 3 21 4 5 11

Korte samenvatting

• Python's queue.Queue implementeert FIFO; queue.LifoQueue implementeert LIFO.
• Gebruik put() om te enqueuen en get() om te dequeuen.
• Beide klassen blootstellen empty(), full(), en qsize() voor state-inspectie.
• Je kunt een maximumgrootte instellen op een FIFO queue; poging tot put() daarboven blokkeert tot ruimte vrijkomt.
• Sorteren en omkeren is mogelijk met standaard algoritmes, hoewel de ingebouwde deque uit collections vaak meer flexibiliteit biedt.