Knowledge Hub

Terminal · Terminal Übungen

Zwei Dokumente

Die Dateien leitfaden-python-cli-projekt.pdf und python-cli-projekt-aufgabe.md (mit PDF-Anhang) — jeweils öffnen oder herunterladen, voller Text darunter.

Vollständige Anleitung

Leitfaden — Mein erstes Python-CLI-Programm · leitfaden-python-cli-projekt.pdf

Alle Abschnitte und Code-Beispiele aus der Quelle — auch als Lektion oder PDF-Anhang (öffnen / herunterladen).

Leitfaden: Mein erstes Python-CLI-Programm

Aufgaben-Manager im Terminal — Schritt für Schritt

Nalan Kara · 30. August 2026

Ziel des Projekts

Ein kleines Terminal-Programm bauen, das ein Menü anzeigt und auf Nutzereingaben reagiert:

=== Aufgaben-Manager ===
1. Aufgabe hinzufügen
2. Aufgabe anzeigen
3. Beenden
4. Aufgaben löschen
Wähle eine Option:

Verwendete Grundlagen: Variablen, Listen, while-Schleife, if/elif, for-Schleife, input(), print(), Listen-Methoden (.append(), .remove()).

1. Projekt-Setup im Terminal

mkdir aufgaben-cli
cd aufgaben-cli
python3 -m venv venv
source venv/bin/activate
touch cli.py

Was diese Befehle tun:

BefehlBedeutung
mkdirlegt einen neuen Ordner an
cdwechselt in den Ordner
python3 -m venv venverstellt eine isolierte Python-Umgebung nur für dieses Projekt
source venv/bin/activateaktiviert diese Umgebung (erkennbar an (venv) vor der Zeile)
touch cli.pyerstellt eine leere Datei

2. Setup in VS Code

  1. Ordner öffnen: Datei → Ordner öffnen → aufgaben-cli auswählen
  2. Terminal öffnen: Menü → Terminal → New Terminal
  3. Interpreter wählen: Cmd/Strg + Shift + P → “Python: Select Interpreter” → den Eintrag mit ./venv/bin/python wählen
  4. Ausführen: im Terminal python cli.py

Wichtig: Der Befehl python muss immer vor dem Dateinamen stehen (python cli.py), sonst meldet das Terminal “command not found” — die Datei ist ja kein eigenständiges Programm, sondern Code, den Python interpretieren muss.

3. Der fertige Code (Zeile für Zeile erklärt)

aufgaben = []

Eine leere Liste wird angelegt — das ist der “Speicher” für alle Aufgaben. Muss vor der Schleife stehen, sonst wäre sie bei jedem Durchlauf wieder leer.

while True:

Startet eine Schleife, deren Bedingung immer wahr ist — sie läuft unendlich, bis irgendwo break aufgerufen wird. Alles darunter Eingerückte gehört zu dieser Schleife.

print("=== Aufgaben-Manager ===")
print("1. Aufgabe hinzufügen")
print("2. Aufgabe anzeigen")
print("3. Beenden")
print("4. Aufgaben löschen")

Das Menü wird bei jedem Schleifendurchlauf neu angezeigt.

auswahl = input("Wähle eine Option: ")

Das Programm hält an und wartet auf eine Tastatureingabe. Der eingegebene Wert wird immer als Text (String) gespeichert — auch Zahlen wie "1", nicht 1.

if auswahl == "1":
    neue_aufgabe = input("Welche Aufgabe? ")
    aufgaben.append(neue_aufgabe)
    print("Hinzugefügt!")

Nur wenn auswahl genau "1" ist: neue Aufgabe abfragen, mit .append() ans Ende der Liste anhängen.

elif auswahl == "2":
    for aufgabe in aufgaben:
        print("-", aufgabe)

elif wird nur geprüft, wenn der if davor nicht zutraf. Die for-Schleife geht jedes Element der Liste einzeln durch und gibt es aus.

elif auswahl == "4":
    aufgabe_löschen = input("Lösche die Aufgabe: ")
    aufgaben.remove(aufgabe_löschen)
    print("Gelöscht!")

Fragt den exakten Text der zu löschenden Aufgabe ab. .remove(x) entfernt das erste Element, das genau x entspricht — bei Abweichung (Tippfehler, Groß-/Kleinschreibung) gibt es einen Fehler.

elif auswahl == "3":
    print("Bis bald!")
    break

Abschiedsnachricht, dann break — beendet die while-Schleife sofort. Das Programm läuft danach zu Ende.

4. Der komplette Code am Stück

aufgaben = []

while True:
    print("=== Aufgaben-Manager ===")
    print("1. Aufgabe hinzufügen")
    print("2. Aufgabe anzeigen")
    print("3. Beenden")
    print("4. Aufgaben löschen")

    auswahl = input("Wähle eine Option: ")

    if auswahl == "1":
        neue_aufgabe = input("Welche Aufgabe? ")
        aufgaben.append(neue_aufgabe)
        print("Hinzugefügt!")

    elif auswahl == "2":
        for aufgabe in aufgaben:
            print("-", aufgabe)

    elif auswahl == "4":
        aufgabe_löschen = input("Lösche die Aufgabe: ")
        aufgaben.remove(aufgabe_löschen)
        print("Gelöscht!")

    elif auswahl == "3":
        print("Bis bald!")
        break

5. Typische Stolperfallen (und wie du sie erkennst)

ProblemUrsacheLösung
NameError: name 'aufgaben' is not definedVariable wird benutzt, bevor sie definiert wurdeaufgaben = [] muss vor der ersten Nutzung stehen
IndentationErrorCode, der zur Schleife gehören soll, ist nicht eingerücktBetroffene Zeilen markieren (über die Zeilennummern klicken) und Tab drücken
Markierter Text verschwindet beim EinrückenMit Cmd+A alles markiert, statt ganze ZeilenÜber die Zeilennummern klicken/ziehen, nicht Cmd+A benutzen
elif wird als Fehler markiertZwischen if und elif steht anderer Code (z.B. eine fremde Schleife)if/elif/elif müssen direkt aufeinanderfolgen
command not found: cli.pypython vor dem Dateinamen vergessenImmer python cli.py schreiben, nicht nur cli.py
ValueError: list.remove(x): x not in listEingegebener Text stimmt nicht exakt mit dem Listen-Eintrag übereinMit print(aufgaben) prüfen, was wirklich gespeichert ist

6. Merksätze zum Festhalten

  • pwd → ls → cd: So orientierst du dich im Terminal.
  • while True + break: Das Grundmuster für “läuft, bis der Nutzer aufhören will”.
  • if / elif / elif: Nur EIN Zweig läuft pro Durchlauf — sobald einer zutrifft, werden die anderen übersprungen.
  • .append() fügt hinzu, .remove() entfernt ein bestimmtes Element — Gegenstücke zueinander.
  • Einrückung ist in Python keine Kosmetik, sondern legt fest, was zu welchem Block (Schleife, if) gehört.
  • Bei jedem Fehler zuerst: die letzte Zeile der Fehlermeldung lesen — dort steht meist genau, was falsch ist.

7. Mögliche nächste Schritte

  1. Erweiterung mit bereits Gelerntem: z.B. eine Zählung, wie viele Aufgaben insgesamt erledigt/offen sind.
  2. Daten dauerhaft speichern: Aufgaben in eine Datei (aufgaben.json) schreiben, damit sie nach dem Beenden des Programms nicht verloren gehen (nächster Lernschritt: with open(...), json.load()/json.dump()).
  3. Argumente statt Menü: Das Programm über python cli.py add "Titel" direkt steuern (nächster Lernschritt: Modul argparse).

Vollständige Anleitung

Aufgabe — Dein erstes Python-CLI-Projekt · python-cli-projekt-aufgabe.md

Alle Abschnitte und Code-Beispiele aus der Quelle — auch als Lektion oder PDF-Anhang (öffnen / herunterladen).

Aufgabe: Dein erstes Python-CLI-Projekt

Du baust ein kleines Kommandozeilen-Tool (CLI = Command Line Interface) – ein Programm, das man über das Terminal mit Befehlen und Optionen bedient, z.B. so wie git status oder git commit -m "...".

Ziel-Tool: ein Aufgaben-Manager, den du später so aufrufst:

python cli.py add "Wäsche waschen"
python cli.py list
python cli.py done 1

Teil 1: Projekt-Setup im Terminal (Schritt für Schritt)

Schritt 1 – Projektordner anlegen

mkdir aufgaben-cli
cd aufgaben-cli

Schritt 2 – Virtuelle Umgebung anlegen & aktivieren

python3 -m venv venv
source venv/bin/activate

Du erkennst die Aktivierung am (venv) vor deiner Terminal-Zeile.

Schritt 3 – Projektdateien anlegen

touch cli.py
touch aufgaben.json
  • cli.py → dein eigentliches Programm
  • aufgaben.json → hier speicherst du die Aufgaben dauerhaft (auch nach Programmende)

In aufgaben.json schreibst du am Anfang manuell eine leere Liste rein:

[]

Schritt 4 – Git initialisieren (optional, aber gute Übung)

git init
echo "venv/" > .gitignore
git add .
git commit -m "Projekt-Setup CLI-Tool"

Schritt 5 – Grundgerüst testen

Schreib testweise in cli.py:

print("CLI läuft!")

Dann im Terminal ausführen:

python cli.py

Wenn "CLI läuft!" erscheint, ist dein Setup korrekt.


Teil 2: Was du für die Aufgabe brauchst

Das eingebaute Modul argparse – damit liest Python die Befehle/Argumente ein, die du im Terminal nach python cli.py eintippst. Kein pip install nötig, ist Teil der Standardbibliothek.

Minimal-Grundgerüst, um zu verstehen wie argparse funktioniert (das ist noch NICHT die Lösung deiner Aufgabe, nur ein Beispiel zum Verstehen des Prinzips):

import argparse

parser = argparse.ArgumentParser(description="Ein Beispiel-CLI")
parser.add_argument("name", help="Dein Name")

args = parser.parse_args()
print(f"Hallo {args.name}!")

Aufruf im Terminal:

python cli.py Nalan
# Ausgabe: Hallo Nalan!

Für mehrere Befehle (add, list, done) brauchst du Subparsers – das Prinzip dahinter:

import argparse

parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest="befehl")

# Unterbefehl "add"
add_parser = subparsers.add_parser("add")
add_parser.add_argument("titel")

args = parser.parse_args()

if args.befehl == "add":
    print(f"Füge hinzu: {args.titel}")

Aufruf:

python cli.py add "Wäsche waschen"
# Ausgabe: Füge hinzu: Wäsche waschen

Das ist bewusst nur ein Mini-Beispiel zum Prinzip verstehen – deine eigentliche Aufgabe ist umfangreicher (siehe unten).


Teil 3: Deine eigentliche Aufgabe

Baue in cli.py einen vollständigen Aufgaben-Manager mit folgenden Anforderungen:

Muss-Anforderungen

  1. python cli.py add "Titel"
    Fügt eine neue Aufgabe hinzu und speichert sie in aufgaben.json.
    Jede Aufgabe soll mindestens haben: id, titel, erledigt (True/False).

  2. python cli.py list
    Zeigt alle gespeicherten Aufgaben an, z.B.:

    [1] Wäsche waschen - offen
    [2] Einkaufen - erledigt
    
  3. python cli.py done 1
    Markiert die Aufgabe mit der ID 1 als erledigt (in der JSON-Datei aktualisieren).

  4. Daten müssen persistent sein — nach Neustart des Programms müssen die Aufgaben noch da sein (deshalb aufgaben.json).

Zusatz-Anforderungen (wenn die Basis läuft)

  1. python cli.py remove 1 — löscht eine Aufgabe anhand der ID.
  2. python cli.py list --nur-offene — zeigt nur nicht-erledigte Aufgaben (optionales Flag).
  3. Fehlerbehandlung: Was passiert, wenn done 99 aufgerufen wird, aber es keine Aufgabe mit ID 99 gibt? Das Programm soll nicht abstürzen, sondern eine verständliche Meldung zeigen.

Teil 4: Wie du es angehst (Struktur-Tipp, ohne fertigen Code)

Bau dir das Programm in kleinen, testbaren Schritten auf – nach jedem Schritt im Terminal testen, bevor du weitermachst:

  1. Zuerst: Funktionen aufgaben_laden() und aufgaben_speichern(liste), die die JSON-Datei lesen/schreiben — teste sie isoliert, bevor irgendwas mit argparse passiert.
  2. Dann: argparse-Grundgerüst nur mit dem add-Befehl bauen und testen.
  3. Danach: list-Befehl ergänzen.
  4. Danach: done-Befehl ergänzen.
  5. Erst zum Schluss: Zusatz-Anforderungen.

Fragen, die dir beim Strukturieren helfen:

  • Welche Funktion ist für "Datei lesen/schreiben" zuständig, welche für "Argumente verarbeiten"? (Trenne diese zwei Verantwortlichkeiten!)
  • Woher bekommst du die nächste freie id für eine neue Aufgabe?
  • Wie findest du die Aufgabe mit einer bestimmten id in deiner geladenen Liste wieder?

Wenn du feststeckst

Sag mir, an welchem der 4 Basis-Schritte (add / list / done / speichern) du gerade bist und was genau nicht funktioniert (Fehlermeldung oder unerwartetes Verhalten) — dann gehen wir das gemeinsam Schritt für Schritt durch, ohne dass ich dir gleich den kompletten Code gebe.

Learning Journey

Terminal Übungen

Zwei Dokumente unter Terminal: Leitfaden (Menü-CLI mit fertigem Code) und Aufgabe (argparse + JSON zum Selbstbauen) — jeweils mit PDF-Anhang zum Öffnen oder Herunterladen.

Gesamtfortschritt

0%

Nächster Schritt: Leitfaden: Mein erstes Python-CLI-Programm

  1. 01

    Leitfaden: Mein erstes Python-CLI-Programm

    Aufgaben-Manager im Terminal — Menü mit while True, if/elif und Listen; Schritt für Schritt inkl. fertigem Code und PDF-Anhang.

    • Projektordner, venv und cli.py im Terminal anlegen
    • Den Menü-basierten Aufgaben-Manager Zeile für Zeile verstehen
    • Typische Stolperfallen und Merksätze anwenden
    while Trueif/elifListeninput/printvenv

    Der fertige Code (Zeile für Zeile)

    Lesson · Leitfaden · 15 min

    Von `aufgaben = []` über `while True`, Menü-prints, input und if/elif-Zweige bis `break`.

    • `aufgaben = []` vor der Schleife — sonst wäre die Liste bei jedem Durchlauf leer
    • `while True:` läuft, bis irgendwo `break` aufgerufen wird
    • `auswahl = input(...)` speichert immer Text — auch `"1"`, nicht `1`
    • Option `"1"`: `.append()`, Option `"2"`: for-Schleife, Option `"4"`: `.remove()`, Option `"3"`: break

    Liste anlegen · python

    aufgaben = []

    Endlosschleife · python

    while True:

    Menü ausgeben · python

    print("=== Aufgaben-Manager ===")
    print("1. Aufgabe hinzufügen")
    print("2. Aufgabe anzeigen")
    print("3. Beenden")
    print("4. Aufgaben löschen")

    Eingabe · python

    auswahl = input("Wähle eine Option: ")

    Zweig "1" hinzufügen · python

    if auswahl == "1":
        neue_aufgabe = input("Welche Aufgabe? ")
        aufgaben.append(neue_aufgabe)
        print("Hinzugefügt!")

    Zweig "2" anzeigen · python

    elif auswahl == "2":
        for aufgabe in aufgaben:
            print("-", aufgabe)

    Zweig "4" löschen · python

    elif auswahl == "4":
        aufgabe_löschen = input("Lösche die Aufgabe: ")
        aufgaben.remove(aufgabe_löschen)
        print("Gelöscht!")

    Zweig "3" beenden · python

    elif auswahl == "3":
        print("Bis bald!")
        break

    Der komplette Code am Stück

    Lesson · Leitfaden · 5 min

    Der vollständige Aufgaben-Manager aus dem Leitfaden — zum Abtippen und Vergleichen.

    • Alles in einer `while True`-Schleife
    • Vier Optionen über if/elif
    • Liste nur im Speicher — nach Programmende weg (nächster Schritt: Datei/JSON)

    4. Der komplette Code am Stück · python

    aufgaben = []
    
    while True:
        print("=== Aufgaben-Manager ===")
        print("1. Aufgabe hinzufügen")
        print("2. Aufgabe anzeigen")
        print("3. Beenden")
        print("4. Aufgaben löschen")
    
        auswahl = input("Wähle eine Option: ")
    
        if auswahl == "1":
            neue_aufgabe = input("Welche Aufgabe? ")
            aufgaben.append(neue_aufgabe)
            print("Hinzugefügt!")
    
        elif auswahl == "2":
            for aufgabe in aufgaben:
                print("-", aufgabe)
    
        elif auswahl == "4":
            aufgabe_löschen = input("Lösche die Aufgabe: ")
            aufgaben.remove(aufgabe_löschen)
            print("Gelöscht!")
    
        elif auswahl == "3":
            print("Bis bald!")
            break
  2. 02

    Aufgabe: Dein erstes Python-CLI-Projekt

    Selbst bauen: CLI mit argparse (add / list / done), Persistenz in aufgaben.json — ohne fertige Gesamtlösung, inkl. PDF-Anhang.

    • Projekt mit venv, cli.py, aufgaben.json und optional Git aufsetzen
    • argparse und Subparsers als Prinzip verstehen
    • Muss- und Zusatz-Anforderungen schrittweise umsetzen
    argparseSubparsersJSONadd/list/donePersistenz

    Projekt-Setup im Terminal (Schritt für Schritt)

    Lesson · Aufgabe · 10 min

    Ordner, venv, cli.py + aufgaben.json (`[]`), optional Git, Grundgerüst `print("CLI läuft!")` testen.

    • `mkdir aufgaben-cli` und `cd aufgaben-cli`
    • `python3 -m venv venv` und `source venv/bin/activate` — `(venv)` in der Prompt
    • `touch cli.py` und `touch aufgaben.json` mit Inhalt `[]`
    • Optional: `git init`, `venv/` ins `.gitignore`, erster Commit
    • `python cli.py` soll „CLI läuft!“ zeigen

    Schritt 1–2 Ordner & venv · bash

    mkdir aufgaben-cli
    cd aufgaben-cli
    python3 -m venv venv
    source venv/bin/activate

    Schritt 3 Dateien · bash

    touch cli.py
    touch aufgaben.json

    aufgaben.json Startinhalt · json

    []

    Schritt 4 Git (optional) · bash

    git init
    echo "venv/" > .gitignore
    git add .
    git commit -m "Projekt-Setup CLI-Tool"

    Schritt 5 Grundgerüst · python

    print("CLI läuft!")

    Ausführen · bash

    python cli.py

    Was du für die Aufgabe brauchst

    Lesson · Aufgabe · 10 min

    Eingebautes Modul `argparse` — Minimalbeispiel und Subparsers für add/list/done (noch nicht die Lösung).

    • `argparse` ist Standardbibliothek — kein pip install nötig
    • Minimal: `ArgumentParser`, `add_argument`, `parse_args()`
    • Mehrere Befehle: `add_subparsers(dest="befehl")` + `add_parser("add")`
    • Mini-Beispiele bewusst nur zum Prinzip — eigentliche Aufgabe ist umfangreicher

    Minimal-Grundgerüst argparse · python

    import argparse
    
    parser = argparse.ArgumentParser(description="Ein Beispiel-CLI")
    parser.add_argument("name", help="Dein Name")
    
    args = parser.parse_args()
    print(f"Hallo {args.name}!")

    Aufruf Minimalbeispiel · bash

    python cli.py Nalan
    # Ausgabe: Hallo Nalan!

    Subparsers-Prinzip · python

    import argparse
    
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(dest="befehl")
    
    # Unterbefehl "add"
    add_parser = subparsers.add_parser("add")
    add_parser.add_argument("titel")
    
    args = parser.parse_args()
    
    if args.befehl == "add":
        print(f"Füge hinzu: {args.titel}")

    Aufruf Subparser · bash

    python cli.py add "Wäsche waschen"
    # Ausgabe: Füge hinzu: Wäsche waschen