aiMOOC

Programmieren für technische Aufgaben – Listen und Datenstrukturen auswählen

QR-Code

Einleitung

Programmieren für technische Aufgaben – Listen und Datenstrukturen auswählen – Lernkurs für die Ausbildung (ca. 60–90 Minuten). Kurzbeschreibung: Sammlungen und passende Zugriffe. Du entscheidest, wie fiktive Werkstattdaten sinnvoll gespeichert, gesucht und abgearbeitet werden.

Lernziele: Du kannst zwischen list, tuple, dict, set und deque wählen, Zugriffe begründen und Deine Lösungen lokal testen.

Sicherer Übungsrahmen: Verwende ausschließlich die erfundenen IDs A-101 bis A-103 und Anlagen M-01/M-02 in einer lokalen, vom Betrieb getrennten Übungsumgebung. Keine Verbindung zu Fremdnetzen oder Produktivanlagen, keine Zugangsdaten oder Kundeninformationen. Die Programme verwenden weder Netzwerk noch Dateien. Externe Videos und iFrames sind nur Lernmedien, keine Code-Testumgebungen; übertrage dort keine betrieblichen Daten.

Ausbildungsfall: Tickets in der Übungswerkstatt

Du unterstützt eine fiktive Technikwerkstatt. Drei Tickets sollen in Eingangsreihenfolge bearbeitet werden; zu jeder Ticket-ID soll der Status abrufbar sein. Außerdem benötigst Du eine Liste der unterschiedlichen betroffenen Anlagen.

Ticket-ID	Anlage	Status	Wartet?
A-101	M-01	offen	ja
A-102	M-02	offen	ja
A-103	M-01	erledigt	nein

Datenfluss als Skizze:

Eingang	Sammlung	Zugriff	Ergebnis
Ticket-Reihenfolge	`list`	Position	A-101 zuerst
Ticket-Stammdaten	`dict`	ID	Status von A-102
Betroffene Anlagen	`set`	Eindeutigkeit	M-01, M-02
Offene Tickets	`deque`	FIFO	A-101 vor A-102

Lerneinheit 1: Liste und Position (8 Minuten)

Eine Liste ist eine veränderbare Folge. In Python beginnt der Index bei 0; mehrfach vorkommende Elemente sind erlaubt.

Visualisierung: Folge mit Positionen 0, 1 und 2.

Index	0	1	2
Ticket	A-101	A-102	A-103

tickets = ["A-101", "A-102", "A-103"]
print(tickets[0])       # A-101
tickets.append("A-104")
print(tickets[-1])      # A-104
assert len(tickets) == 4

Merke: append() ergänzt am Ende; tickets[9] würde hier einen IndexError auslösen.

Vertiefung: Dynamische Arrays können beim Wachsen zeitweise mehr Speicher reservieren.

Videoimpuls: Ab 35:37 behandelt das Tutorial Listen. Stoppe und erkläre, warum tickets[0] das erste Element liefert.

Lerneinheit 2: Tupel und Dictionary (8 Minuten)

Ein Tupel steht für eine feste Folge. Ein Dictionary verknüpft eindeutige Schlüssel mit Werten: Die Ticket-ID ist der Schlüssel, nicht ein Listenindex.

Tupel: feste Lagerangabe	Dictionary: Schlüsselzugriff
`("Regal A", 4)`	`"A-101" → "offen"`

Schaubild: Hashtabelle als Grundidee hinter schnellen Schlüsselzugriffen – keine exakte Darstellung der Python-internen Speicheranordnung.

lagerplatz = ("Regal A", 4)
status = {"A-101": "offen", "A-102": "offen"}
print(lagerplatz[0])                  # Regal A
print(status["A-102"])               # offen
print(status.get("A-999", "fehlt"))  # fehlt

Fehler vermeiden: Für möglicherweise fehlende Schlüssel ist get() mit Standardwert hilfreich; status["A-999"] erzeugt KeyError. Dictionaries bewahren die Einfügereihenfolge, aber Du wählst sie hier wegen des Schlüsselzugriffs.

Videoimpuls: Welche Information würdest Du als Schlüssel verwenden?

Lerneinheit 3: Set für eindeutige Werte (7 Minuten)

Ein Set speichert jeden Wert höchstens einmal. Die Reihenfolge eines Sets ist nicht verlässlich; für eine geordnete Anzeige nutze sorted().

Grafik: Schnittmenge zweier Sets. In der Werkstatt kannst Du damit gemeinsam betroffene Anlagen ermitteln.

meldungen = ["M-01", "M-02", "M-01"]
anlagen = set(meldungen)
print(sorted(anlagen))                 # ['M-01', 'M-02']
pruefung = {"M-01", "M-03"}
print(sorted(anlagen & pruefung))      # ['M-01']

Merke: Eine leere Menge ist set(); {} ist ein leeres Dictionary.

Videoimpuls: Warum verliert ein Set beim Entfernen von Duplikaten die ursprüngliche Meldereihenfolge?

Lerneinheit 4: Warteschlange und Stapel (8 Minuten)

FIFO: Das erste wartende Ticket kommt zuerst dran. Für häufige Entnahmen am Anfang eignet sich collections.deque. LIFO: Bei einem Rückgängig-Stapel wird die zuletzt gespeicherte Aktion zuerst entfernt.

Vorher (links zuerst)	Aktion	Danach
A-101 → A-102	`popleft()`	A-102
A-102	`append("A-104")`	A-102 → A-104

from collections import deque

fifo = deque(["A-101", "A-102"])
print(fifo.popleft())       # A-101
fifo.append("A-104")
print(list(fifo))           # ['A-102', 'A-104']

verlauf = ["Ticket erstellt", "Anlage geprueft"]
print(verlauf.pop())        # Anlage geprueft
assert verlauf == ["Ticket erstellt"]

Begründung: list.pop(0) verschiebt andere Listenelemente und ist für lange FIFO-Schlangen ungünstig; deque.popleft() entnimmt am Anfang effizient. Beide Beispiele arbeiten nur mit Texten im Speicher.

Videoimpuls: Vergleiche FIFO und LIFO; das Video zeigt die Prinzipien anhand von Java, während Du sie hier in Python anwendest.

Lerneinheit 5: Struktur passend auswählen (7 Minuten)

Anforderung	Wahl	Passender Zugriff
Reihenfolge, Index, Duplikate	`list`	`daten[0]`
Unveränderliche Folge	`tuple`	`ort[0]`
ID → Status	`dict`	`status.get(id)`
Verschiedene Anlagen	`set`	`anlage in anlagen`
Nächsten Eingang bearbeiten	`deque`	`popleft()`
Letzten Schritt zurücknehmen	`list` als Stack	`pop()`

Aufwand – typische Python-Operationen: Listenindex ungefähr O(1); Suche in einer Liste O(n); Dictionary-/Set-Nachschlagen im Durchschnitt O(1), im ungünstigen Fall schlechter; deque.popleft() ungefähr O(1). list.append() hat amortisiert O(1). Das sind Größenordnungen, keine Zeitgarantien.

Vergleichsbild: Eine verkettete Liste verwendet Verweise zwischen Knoten. Sie ist nicht identisch mit Pythons eingebauter list.

Entscheidungsregel: Überlege zuerst, wie Du auf Daten zugreifen willst; wähle danach die Sammlung.

Lerneinheit 6: Lokales Werkstatt-Labor (15 Minuten)

Testumgebung A – isolierter Übungsordner: Lege auf einem lokalen, nicht an Betriebsanlagen angeschlossenen Übungsrechner einen frischen Ordner an. Benutze Python 3 und ausschließlich den folgenden selbst geschriebenen Code mit fiktiven Daten. Ein separater Offline-Rechner oder eine vom Betriebsnetz getrennte virtuelle Maschine ist für stärkere Isolation geeignet. python -I startet Python im isolierten Modus, ist aber keine Sicherheits-Sandbox.

Testumgebung B – interaktive Konsole: Speichere den vollständigen Code als werkstatt_lab.py und starte lokal python -I werkstatt_lab.py (bei manchen Installationen python3 -I werkstatt_lab.py). Es werden keine Dateien gelesen/geschrieben und keine Netze angesprochen.

from collections import deque

def demo_daten():
    katalog = {
        "A-101": {"anlage": "M-01", "status": "offen"},
        "A-102": {"anlage": "M-02", "status": "offen"},
        "A-103": {"anlage": "M-01", "status": "erledigt"},
    }
    fifo = deque(["A-101", "A-102"])
    return katalog, fifo

def offene_anlagen(katalog):
    return sorted({d["anlage"] for d in katalog.values()
                   if d["status"] == "offen"})

def naechster(katalog, fifo):
    if not fifo:
        return "leer"
    nummer = fifo.popleft()
    katalog[nummer]["status"] = "in Arbeit"
    return nummer

def selbsttest():
    katalog, fifo = demo_daten()
    assert offene_anlagen(katalog) == ["M-01", "M-02"]
    assert naechster(katalog, fifo) == "A-101"
    assert list(fifo) == ["A-102"]
    assert katalog["A-101"]["status"] == "in Arbeit"
    assert offene_anlagen(katalog) == ["M-02"]
    assert naechster(katalog, fifo) == "A-102"
    assert naechster(katalog, fifo) == "leer"

if __name__ == "__main__":
    selbsttest()
    print("Selbsttest bestanden")
    katalog, fifo = demo_daten()
    while True:
        wahl = input("a=Anlagen, n=naechster, q=Ende: ").strip().lower()
        if wahl == "a":
            print(offene_anlagen(katalog))
        elif wahl == "n":
            print("Entnommen:", naechster(katalog, fifo))
        elif wahl == "q":
            break
        else:
            print("Nur a, n oder q verwenden.")

Erwartete Bedienung: a zeigt ['M-01', 'M-02']; nach n wird A-101 entnommen; das nächste a zeigt ['M-02']. Bei leerer Queue erscheint leer. Mit q beendest Du den Test.

Gestufte Hilfen zum Labor:

Hilfe 1 – Hinweis: Suche für „nächster Eingang“ nach einem Zugriff am linken Ende.
Hilfe 2 – Denkweg: Die Reihenfolge steht in fifo; Ticketdaten stehen im katalog unter der ID.
Hilfe 3 – Codeanker: nummer = fifo.popleft() und danach katalog[nummer]["status"] = "in Arbeit".

Begründetes Testfeedback: „Selbsttest bestanden“ heißt, dass die geprüften Fälle passen, nicht dass alle denkbaren Fälle abgedeckt sind. Ein fehlgeschlagenes assert weist auf eine verletzte erwartete Eigenschaft hin. Verändere jeweils nur eine Zeile und prüfe erneut.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Welche Struktur bewahrt die Reihenfolge und erlaubt den Zugriff mit einem Index? (Liste) (!Set) (!Dictionary) (!Hashfunktion)

Feedback: Der Listenindex benennt eine Position; Sets haben keine verlässliche Positionsreihenfolge.

Welcher Index bezeichnet das erste Listenelement in Python? (Null) (!Eins) (!Minus zwei) (!Letzter)

Feedback: Python beginnt die Zählung von Positionen bei null.

Welche Struktur eignet sich für den Status zu einer Ticket-ID? (Dictionary) (!Set) (!Stack) (!Tupel ohne Schlüssel)

Feedback: Ein Dictionary verbindet eindeutige Schlüssel direkt mit Werten.

Welche Struktur entfernt doppelte Anlagennamen? (Set) (!Liste) (!Tuple) (!Warteschlange)

Feedback: Jedes Set-Element ist höchstens einmal vorhanden.

Welche Python-Funktion erzeugt eine leere Menge? (set) (!Leeres Klammernpaar) (!Leere eckige Klammern) (!Leere geschweifte Klammern)

Feedback: Die Funktion set erzeugt eine leere Menge; leere geschweifte Klammern stehen für ein Dictionary.

Welches Prinzip bearbeitet zuerst eingegangene Tickets zuerst? (FIFO) (!LIFO) (!Zufall) (!Sortierung nach Namen)

Feedback: First In First Out erhält die Eingangsreihenfolge.

Mit welcher Methode entnimmst Du links aus einer deque? (popleft) (!append) (!sort) (!get)

Feedback: popleft entfernt das älteste Element am linken Ende.

Was ist bei einem Tupel mit unveränderlichen Elementen nicht erlaubt? (Ein Element direkt ersetzen) (!Ein Element lesen) (!Die Länge ermitteln) (!Das Tupel ausgeben)

Feedback: Tupel unterstützen keinen direkten Austausch eines Elements.

Welche Methode liefert bei einem fehlenden Dictionary-Schlüssel einen Standardwert? (get) (!append) (!popleft) (!index)

Feedback: get kann einen Ersatzwert liefern, statt einen KeyError auszulösen.

Warum ist eine deque für häufiges FIFO-Entnehmen meist geeigneter als eine Liste? (Entnahme links ist effizient) (!Eine deque sortiert automatisch) (!Eine deque löscht Duplikate) (!Eine deque speichert nur Zahlen)

Feedback: Das Entfernen am Listenanfang verschiebt Elemente; deque ist für beide Enden optimiert.

Memory

Liste	Positionszugriff
Tupel	Feste Folge
Dictionary	Schlüsselsuche
Set	Eindeutige Werte
Deque	Zweiseitige Entnahme
FIFO	Ältester Eintrag zuerst
LIFO	Neuester Eintrag zuerst
Get-Methode	Standardwert bei Fehlschlag

Drag and Drop

Ordne die richtigen Begriffe zu.	Einsatz im Werkstattfall
Liste	Eingangsfolge mit Index
Dictionary	Ticketstatus per ID
Set	Einmalige Anlagenbezeichnungen
Tupel	Fester Lagerplatz
Deque	Warteschlange mit Entnahme links
Stapel	Rückgängig-Folge mit letzter Aktion zuerst

Kreuzworträtsel

Liste	Welche veränderbare Python-Folge erlaubt Positionszugriffe?
Tupel	Welche unveränderliche Folge kennt Python?
Dictionary	Welche Struktur ordnet einem Schlüssel einen Wert zu?
Menge	Welche Sammlung enthält keine Duplikate?
Warteschlange	Wie heißt die Datenstruktur nach dem FIFO-Prinzip?
Stapel	Welche Datenstruktur nutzt das LIFO-Prinzip?

LearningApps

Nur als freiwillige externe Übungssuche; keine betrieblichen Daten eingeben. Die lokalen Python-Tests oben sind die maßgebliche isolierte Testumgebung.

Lückentext

Eine geordnete und veränderbare Python-Folge heißt

und lässt doppelte Werte zu.

Der erste gültige Index einer nicht leeren Liste ist

und nicht eins.

Eine unveränderliche Folge heißt

und kann feste Angaben bündeln.

Eine Zuordnung von Ticket-ID zu Status speicherst Du als

mit eindeutigen Schlüsseln.

Für einen möglicherweise fehlenden Schlüssel nutzt Du die Methode

mit einem Standardwert.

Eine Sammlung ohne doppelte Elemente ist ein

mit nicht verlässlicher Ausgabe-Reihenfolge.

Mit der Funktion

zeigst Du Set-Werte sortiert an.

Das Prinzip „zuerst hinein, zuerst hinaus“ wird als

bezeichnet.

Für effiziente Entnahme am linken Ende nutzt Du eine

aus collections.

Die Methode

entnimmt das erste Element einer solchen Warteschlange.

Ein Rückgängig-Stapel folgt dem Prinzip

, bei dem die letzte Aktion zuerst entfernt wird.

Mit

vergleichst Du im lokalen Selbsttest eine Bedingung mit Deiner Erwartung.

Offene Aufgaben

Bearbeite die zwölf Aufgaben in einem lokalen Übungsordner mit den erfundenen Ticketdaten. Feedback gibt Dir jeweils ein überprüfbares Begründungskriterium.

Leicht – Basis

Liste zeichnen: Zeichne A-101, A-102, A-103 mit den Indizes. Feedback: Der erste Index muss 0 sein, weil Python nullbasiert zählt.
Code lesen: Sage die Ausgabe von ["M-01", "M-02"][1] vorher und prüfe sie lokal. Feedback: M-02 ist richtig, weil Index 1 das zweite Element bezeichnet.
Feste Angaben: Lege einen Lagerplatz als Tupel aus Regalname und Fachnummer an. Feedback: Ein Tupel passt, wenn die Position als Datensatz nicht elementweise geändert werden soll.
Duplikate finden: Baue aus M-01, M-02, M-01 ein Set und gib es sortiert aus. Feedback: Zwei Anlagen sind richtig, da ein Set keine Wiederholungen enthält.

Standard – Anwendung

Ticket-Nachschlagewerk: Ergänze A-104 mit dem fiktiven Status „offen“ in einem Dictionary. Feedback: Der Schlüssel A-104 muss eindeutig sein; er erlaubt direkten Zugriff auf genau dieses Ticket.
FIFO prüfen: Füge A-104 rechts in die deque ein und entnimm zwei Tickets links. Feedback: A-101, dann A-102 ist richtig, weil Eingangsreihenfolge gilt.
Randfall testen: Prüfe, dass naechster() bei leerer Queue „leer“ liefert. Feedback: Der Test verhindert einen unkontrollierten Entnahmefehler.
Kombinierte Sammlung: Erstelle eine Liste von zwei Dictionaries für Ticketdetails und erläutere einen Nachteil der Suche nach ID. Feedback: Bei linearer Suche müssen im ungünstigen Fall alle Einträge geprüft werden.

Schwer – Transfer

Skalierung: Vergleiche für viele Tickets list.pop(0) mit deque.popleft() anhand der erwarteten Laufzeit. Feedback: deque ist für häufige Entnahmen links günstiger; einzelne Messungen beweisen keine allgemeine Laufzeitklasse.
Modellwechsel: Ein Betrieb fordert eindeutige IDs und zugleich eine zeitliche Folge: Entwirf eine Kombination aus Dictionary und deque. Feedback: Dictionary sichert die Schlüsselzuordnung, deque die Bearbeitungsreihenfolge; erläutere das Synchronisieren beider Strukturen.
Fehlerszenario: Entwirf lokale Tests für eine versehentlich doppelt eingereihte Ticket-ID. Feedback: Ein zusätzlicher Prüf-Set kann Doppeleinreihungen verhindern, ohne die FIFO-Reihenfolge zu verlieren.
Neue Anforderung: Plane eine simulierte Prioritätsbearbeitung und begründe, warum reine FIFO-Verarbeitung nicht mehr genügt. Feedback: Priorität verändert die Auswahlregel; eine geeignete Prioritätsstruktur wäre z. B. eine Heap-Lösung mit eindeutigem Tie-Breaker.

Lernkontrolle

Anforderungen abwägen: Entscheide zwischen Liste und Dictionary für 10.000 fiktive Tickets mit häufiger ID-Suche. Begründe Zugriff und Pflege.
Fehler analysieren: Erkläre, was mit der Reihenfolge geschieht, wenn Du eine Eingangsfolge in ein Set umwandelst, und entwickle eine Alternative zur Duplikatvermeidung.
Transfer planen: Entwirf ein Modell mit Ticketdaten, Eingangsqueue und eindeutigen Anlagennamen. Beschreibe die Schnittstellen zwischen den Sammlungen.
Randfälle prüfen: Formuliere mindestens drei lokale Tests für leere Queue, unbekannte Ticket-ID und doppelte Meldung. Begründe die erwarteten Ergebnisse.
Entscheidung verteidigen: Begründe, warum ein Stack für „Rückgängig“, aber eine FIFO-Queue für reguläre Eingänge passt, und nenne eine Ausnahme von dieser Auswahl.
Sicherheit übertragen: Beschreibe, wie Du eine neue Datenstruktur ausschließlich mit fiktiven Daten auf einem vom Betriebsnetz getrennten Rechner erprobst.

Lernnachweis

Für einen überprüfbaren Lernnachweis dokumentierst Du:

Ein beschriftetes Datenmodell mit Liste, Dictionary, Set und deque und ihrem jeweiligen Zugriff.
Den lokal ausführbaren Quellcode und die verwendeten fiktiven Eingabedaten.
Ein Protokoll der Selbsttests einschließlich Leerfall und unbekannter ID.
Eine begründete Auswahl der Datenstrukturen nach Reihenfolge, Eindeutigkeit, Schlüsseln und Aufwand.
Eine nachvollziehbare Verbesserung nach mindestens einem eigenen Fehlversuch.
Die Erklärung, dass keine fremden Netze, Produktivsysteme oder realen personenbezogenen Daten beteiligt waren.

OERs zum Thema

Fachlich überprüfte Grundlagen:

Python-Dokumentation: Datenstrukturen – offizielle Referenz zu Listen, Tupeln, Mengen und Dictionaries.
Python-Dokumentation: collections.deque – offizielle Beschreibung von deque und der effizienten Entnahme an beiden Enden.
HubbS: Listen in Python – Lehrvideo, als CC BY 4.0 ausgewiesen.
HubbS: Mengen im Pythonkurs – Lehrvideo, als CC BY 4.0 ausgewiesen.

Geprüfte Wikimedia-Commons-Bildquellen und Rechte (bei Nachnutzung Lizenzseite beachten):

Array1.svg – Jarkko Piiroinen, gemeinfrei.
Dynamic array.svg – Dcoetzee, CC0.
Dsa hash table.svg – Amit6, gemeinfrei.
Venn A intersect B.svg – Cepheus, gemeinfrei.
Data queue.svg – Pluke, gemeinfrei.
Data stack.svg – Boivie, gemeinfrei.
LinkedListHsrw.svg – Dirk Hünniger, CC BY-SA 4.0 mit Namensnennung und Lizenzhinweis.

Medienhinweis: Die verlinkten YouTube-Videos sind eingebettete Drittinhalte, nicht automatisch frei zur Weiterverbreitung lizenziert. Einbettung und Herunterladen sind rechtlich unterschiedlich. Nutze für eigenen OER-Video-Remix lieber ausdrücklich frei lizenzierte Quellen; veröffentliche keine Betriebsdaten.

Wikipedia als ergänzender Überblick: