Bash und Python: CLI-Argumente mit cowsay

Einleitung: Warum CLI-Argumente?

Stell dir vor, du entwickelst ein Programm, das je nach Eingabe unterschiedlich reagiert – wie ein Chatbot, der auf verschiedene Befehle hört. Genau darum geht es in diesem Lab: Du lernst, wie du mit Python und der Bash-Kommandozeile arbeitest, um ein cowsay-Programm zu schreiben. cowsay ist ein klassisches Unix-Tool aus den 1990ern, das eine sprechende Kuh im Terminal anzeigt. Klingt retro? Ist es auch – aber die Konzepte dahinter sind topaktuell. Ob du später KI-Modelle steuerst oder eigene Tools baust: CLI-Argumente sind der Schlüssel.

Was du lernen wirst

Grundlegende Bash-Befehle: pwd, ls, mkdir, cd
Texteditoren wie nano oder joe (ja, ohne Maus!)
Python-Module und -Klassen schreiben
CLI-Argumente mit sys.argv verarbeiten
Fehlerbehandlung bei unbekannten Eingaben

Schritt 1: Terminal und Verzeichnisse

Melde dich auf den Schulrechnern mit deinem CISE-Account an. Öffne ein Terminal. Mit pwd siehst du dein aktuelles Verzeichnis. Mit ls listest du Dateien auf. Erstelle mit mkdir CowLab einen neuen Ordner und wechsle hinein: cd CowLab. Ab jetzt arbeitest du nur noch in diesem Verzeichnis.

Schritt 2: Texteditor auswählen

Für dieses Lab darfst du keine grafischen Editoren wie IntelliJ verwenden. Empfohlen werden nano (einfach) oder joe. Falls du dich selbst herausfordern willst: vi oder emacs. Mit nano cowsay.py erstellst du die Hauptdatei. Speichern mit Strg+O, beenden mit Strg+X.

Schritt 3: Python-Code – Die Cow-Klasse

Erstelle eine Datei cow.py. Definiere eine Klasse Cow mit privaten Attributen __name und __image. Der Konstruktor __init__(self, name: str) setzt den Namen. Methoden: get_name(self) -> str, get_image(self) -> str, set_image(self, _image: str). Beispiel:

class Cow:
    def __init__(self, name: str):
        self.__name = name
        self.__image = ""

    def get_name(self):
        return self.__name

    def get_image(self):
        return self.__image

    def set_image(self, _image: str):
        self.__image = _image

Schritt 4: Das Hauptmodul cowsay.py

In cowsay.py importierst du sys und die bereitgestellte heiferfactory. Die Funktion get_cows() liefert eine Liste von Cow-Objekten. Dein Programm muss folgende Argumente verarbeiten:

-l: Liste aller Kühe anzeigen
-n COW MESSAGE: Nachricht mit bestimmter Kuh ausgeben
sonst: Nachricht mit Standardkuh (heifer) ausgeben

Beispiel für die Argumentverarbeitung:

import sys
from heiferfactory import get_cows

def main():
    cows = get_cows()
    args = sys.argv[1:]
    if not args:
        print("Usage: python3 cowsay.py [-l] [-n COW] MESSAGE")
        return
    if args[0] == "-l":
        _list_cows(cows)
    elif args[0] == "-n":
        if len(args) < 3:
            print("Usage: -n COW MESSAGE")
            return
        cow_name = args[1]
        message = " ".join(args[2:])
        cow = _find_cow(cow_name, cows)
        if cow is None:
            print(f"Could not find {cow_name} cow!")
        else:
            print(message)
            print(cow.get_image())
    else:
        message = " ".join(args)
        cow = _find_cow("heifer", cows)
        print(message)
        print(cow.get_image())

def _list_cows(cows):
    print("Cows available:", " ".join(c.get_name() for c in cows))

def _find_cow(name, cows):
    for c in cows:
        if c.get_name() == name:
            return c
    return None

if __name__ == "__main__":
    main()

Schritt 5: Testen mit Beispielen

Führe dein Programm im Terminal aus:

python3 cowsay.py "I am a potato!"

Erwartete Ausgabe:

I am a potato!
 ^__^
 (oo)\\\n (__)\
  )/  ||----w |
 ||     ||

Teste auch -l und -n kitteh. Achte auf exakte Übereinstimmung mit den Vorgaben – Zybooks ist streng!

Häufige Fehler vermeiden

Vergiss nicht, #!/usr/bin/env python3 (optional) oder korrekte Python-Version.
Die Ausgabe muss exakt stimmen: Leerzeichen, Zeilenumbrüche, Anführungszeichen.
Wenn eine Kuh nicht existiert, gib die Fehlermeldung genau wie im Beispiel aus.
Nutze sys.argv richtig: Der erste Index ist der Programmname, ab Index 1 kommen die Argumente.

Trend-Beispiel: Von der Kuh zum Chatbot

Warum ist das wichtig? Stell dir vor, du entwickelst einen KI-Assistenten für deine Schule. Der nimmt Befehle entgegen: chat.py -model gpt4 "Erkläre Quantenphysik" – genau das gleiche Prinzip wie bei cowsay! Oder du baust ein Spiel, das je nach --level und --character unterschiedliche Grafiken lädt. CLI-Argumente sind das Fundament für flexible Programme.

Zusammenfassung

Du hast gelernt, wie man mit Bash und Python ein Programm schreibt, das Kommandozeilenargumente verarbeitet. Du kennst jetzt die Basics von sys.argv, Klassen und Methoden. Das cowsay-Lab ist der perfekte Einstieg in die Welt der Unix-Tools und Python-Programmierung. Viel Erfolg bei der Abgabe!