Python Queue Stack einfach erklärt: FIFO & LIFO mit Beispielen

Stell dir vor, du bekommst in deinem ersten Job die Aufgabe, ein kleines Ticketsystem zu bauen. Anfragen sollen in der Reihenfolge bearbeitet werden, in der sie eingehen - wer zuerst fragt, bekommt zuerst eine Antwort. Zwei Schränke weiter soll eine Undo-Funktion genau das Gegenteil tun: die letzte Aktion zuerst zurücknehmen.

Für beide Probleme liefert dir Python mit Queue und Stack zwei Datenstrukturen, die jede Algorithmen-Vorlesung und fast jede IHK-Prüfung im Fach Anwendungsentwicklung abfragt. Der wichtigte Unterschied in einem Satz: Queue = FIFO, Stack = LIFO. Was das genau bedeutet und wie du beide in Python umsetzt, zeige ich dir jetzt.

Was ist eine Queue in Python? (FIFO)

Eine Queue (deutsch: Warteschlange) ist eine Datenstruktur nach dem FIFO-Prinzip: First In, First Out. Das Element, das als erstes hinzugefügt wird, kommt auch als erstes wieder heraus.

Du kennst das Prinzip von der Supermarktkasse: Wer sich zuerst anstellt, wird zuerst abgefertigt. Neue Kunden reihen sich hinten ein, bedient wird vorne. Genau so arbeitet eine Queue - Elemente werden am Ende (Enqueue) angefügt und am Anfang (Dequeue) entnommen.

In Python implementierst du eine Queue am besten mit `deque` aus dem Modul `collections`:

from collections import deque

tickets = deque()

# Neue Tickets kommen hinten an
tickets.append("Drucker geht nicht")
tickets.append("Passwort zuruecksetzen")
tickets.append("Monitor flackert")

# Das erste Ticket wird zuerst bearbeitet (FIFO)
while tickets:
    naechstes_ticket = tickets.popleft()
    print(f"Bearbeite: {naechstes_ticket}")

# Ausgabe:
# Bearbeite: Drucker geht nicht
# Bearbeite: Passwort zuruecksetzen
# Bearbeite: Monitor flackert

Warum `deque` und nicht eine normale Liste? Weil `deque.popleft()` in konstanter Zeit läuft (O(1)), während `list.pop(0)` alle restlichen Elemente verschieben muss (O(n)). Die Details dazu stehen in der offiziellen Python-Dokumentation zu collections.deque.

Merke: Eine Queue arbeitet nach FIFO - zuerst hinein, zuerst heraus. In Python nutzt du dafür `collections.deque` mit `append()` und `popleft()`.

Was ist ein Stack in Python? (LIFO)

Ein Stack (deutsch: Stapel) ist eine Datenstruktur nach dem LIFO-Prinzip: Last In, First Out. Das zuletzt hinzugefügte Element wird als erstes wieder entfernt.

Bild dir einen Stapel von Tellern in der Kantine: Du legst neue Teller oben drauf und nimmst auch nur oben wieder welche weg. Den Teller ganz unten erreichst du erst, wenn alle darüber liegenden weg sind. Genau deshalb heißt der Stack auch Stapelspeicher - und genau so funktioniert der Zurück-Button deines Browsers oder Strg+Z in jedem Texteditor.

In Python brauchst du für einen Stack keine spezielle Klasse. Eine normale Liste reicht völlig:

verlauf = []

# Seiten besuchen: neue Eintraege landen oben auf dem Stapel
verlauf.append("google.com")
verlauf.append("docs.python.org")
verlauf.append("study-it.education")

# Zurueck-Navigation: die letzte Seite kommt zuerst (LIFO)
letzte_seite = verlauf.pop()
print(f"Zurueck zu: {letzte_seite}")  # study-it.education

`append()` legt oben drauf, `pop()` nimmt oben herunter. Beide Operationen laufen am Listenende in O(1) - schneller geht es kaum. Mehr dazu findest du im Python-Tutorial zu Datenstrukturen.

Merke: Ein Stack arbeitet nach LIFO - zuletzt hinein, zuerst heraus. In Python reicht dafür eine Liste mit `append()` und `pop()`.

Python Queue Stack im Vergleich: Die Unterschiede im Überblick

Wenn du dich generell noch tiefer in Pythons Datentypen einarbeiten willst, wirf einen Blick in unseren Überblick zu Python Collections: list, dict, set und tuple.

Praxisbeispiel: Druckerverwaltung mit Queue und Stack

Hier kombinierst du beide Strukturen in einem kompletten Beispiel: Druckaufträge landen in einer Queue (FIFO), abgeschlossene Drucke in einem Stack (LIFO) - so lässt sich ein Druck rückgängig machen und der Auftrag wandert zurück an den Anfang der Warteschlange.

from collections import deque


class DruckerVerwaltung:
    def __init__(self):
        self.warteschlange = deque()  # Queue: wartende Auftraege
        self.verlauf = []  # Stack: gedruckte Auftraege

    def auftrag_hinzufuegen(self, dokument):
        self.warteschlange.append(dokument)
        print(f"Angereiht: {dokument}")

    def naechsten_drucken(self):
        if not self.warteschlange:
            print("Keine Auftraege in der Warteschlange")
            return
        dokument = self.warteschlange.popleft()  # FIFO: vorne entnehmen
        self.verlauf.append(dokument)
        print(f"Drucke: {dokument}")

    def druck_rueckgaengig(self):
        if not self.verlauf:
            print("Nichts zum Rueckgaengigmachen")
            return
        dokument = self.verlauf.pop()  # LIFO: letzten Druck holen
        self.warteschlange.appendleft(dokument)  # wieder vorne einreihen
        print(f"Rueckgaengig: {dokument} erneut in der Warteschlange")


drucker = DruckerVerwaltung()
drucker.auftrag_hinzufuegen("Bericht.pdf")
drucker.auftrag_hinzufuegen("Foto.png")
drucker.naechsten_drucken()  # Drucke: Bericht.pdf
drucker.druck_rueckgaengig()  # Rueckgaengig: Bericht.pdf erneut ...
drucker.naechsten_drucken()  # Drucke: Bericht.pdf (jetzt wieder erster)

Sieh dir an, wie natürlich beide Prinzipien hier zusammenspielen: Die Queue garantiert faire Reihenfolge, der Stack merkt sich die Chronologie der Aktionen. Genau solche Kombinationen wirst du später in echten Anwendungen ständig antreffen.

Diese 3 Fehler machen Anfänger häufig

Die meisten Queue-und-Stack-Bugs entstehen durch die falsche Methode oder das falsche Werkzeug. Diese drei Fehler solltest du dir merken - und vermeiden.

Fehler 1: `list.pop(0)` für eine Queue

Falsch:

schlange = ["a", "b", "c"]
erstes = schlange.pop(0)  # langsam: verschiebt alle Elemente

Richtig:

from collections import deque

schlange = deque(["a", "b", "c"])
erstes = schlange.popleft()  # schnell: O(1)

Bei 10 Elementen merkt niemand den Unterschied. Bei einer Million Elementen in einer Engpass-Schleife bremst `pop(0)` dein Programm spürbar aus. Warum? Weil Python bei `pop(0)` alle nachfolgenden Elemente um eine Position nach vorne verschieben muss.

Fehler 2: `pop()` auf einen leeren Stack

stack = []
stack.pop()  # IndexError: pop from empty list

Prüfe vorher, ob der Stack leer ist - entweder mit `if not stack:` oder innerhalb einer `while`-Schleife, die automatisch bei leerem Stack endet. Wer das Absichern systematisch lernen will, dem hilft unser Artikel zu Python Exception Handling mit try und except.

Fehler 3: `pop()` und `popleft()` verwechseln

`pop()` entnimmt das letzte Element (LIFO), `popleft()` das erste (FIFO). Vertauschst du beide bei einer `deque`, funktioniert dein Programm trotzdem - es macht nur das Gegenteil von dem, was du willst. Das ist tückisch, weil kein Fehler geworfen wird. Prüfe im Zweifel mit einem kleinen Test wie oben im Drucker-Beispiel, ob wirklich das erwartete Element herauskommt.

Übungstipp: Bau eine Undo-Funktion für einen Texteditor

Nimm dir 20 Minuten und schreibe ein Mini-Programm: Ein Text wird Wort für Wort aufgebaut, jede Eingabe landet auf einem Stack. Ein Befehl wie `"undo"` ruft `pop()` auf und entfernt das letzte Wort. Erweiterung für Fortgeschrittene: ein zweiter Stack (Redo), der rückgängig gemachte Wörter sammelt.

Diese Übung trainiert genau die Denkweise, die in Klausuren zu Algorithmen und Datenstrukturen verlangt wird - und der Code bleibt klein genug, um ihn handschriftlich zu üben.

FAQ: Häufige Fragen zu Queue und Stack in Python

Was ist der Unterschied zwischen Queue und Stack?

Eine Queue arbeitet nach FIFO (First In, First Out) - das erste Element kommt zuerst heraus. Ein Stack arbeitet nach LIFO (Last In, First Out) - das letzte Element kommt zuerst heraus.

Soll ich für einen Stack eine Liste oder ein deque verwenden?

Für einen Stack reicht eine normale Liste völlig aus, da `append()` und `pop()` am Listenende beide O(1) sind. Ein `deque` bietet hier keinen nennenswerten Vorteil.

Wann brauche ich `queue.Queue` statt `collections.deque`?

`queue.Queue` ist threadsicher und blockiert automatisch, wenn die Queue leer ist. Das brauchst du nur bei nebenläufiger Programmierung mit mehreren Threads - Details dazu in unserem Artikel zum Python Multithreading GIL. Für Single-Threaded-Code ist `deque` die schnellere und einfachere Wahl.

Was bedeuten FIFO und LIFO?

FIFO heißt "First In, First Out" - wer zuerst kommt, wird zuerst bedient. LIFO heißt "Last In, First Out" - das Zuletztgefügte wird zuerst entnommen.

Ist eine Python-Liste eine Queue?

Nein. Eine Liste kann eine Queue nachbilden, ist dafür aber nicht gebaut: `pop(0)` ist mit O(n) zu langsam. Für Queues nutzt du `collections.deque`.

Fazit

Queue und Stack sind die beiden fundamentalen linearen Datenstrukturen - und jetzt kennst du beide: FIFO für faire Reihenfolge mit `deque.append()` und `deque.popleft()`, LIFO für Chronologie und Undo mit `list.append()` und `list.pop()`. Mehr brauchst du für Prüfung, Studium und Arbeitsalltag ehrlicherweise nicht. Die Struktur hinter den Strukturen - also welche Implementierung Python intern für Listen verwendet - beleuchten wir separat in Listen in Python: Welche Implementation wann?.

Wenn du bei Datenstrukturen, Prüfungsvorbereitung oder deinen ersten eigenen Projekten Unterstützung brauchst: Wir von study-it.education unterstützen Azubis, Studenten und Berufseinsteiger mit individueller IT-Nachhilfe - auch zu genau solchen Themen wie Queue und Stack. Schau vorbei und meld dich bei uns.