🏆Abschlussprojekt: Projekt: Das interaktive Menü mit Funktionen neu aufbauen

In Kapitel 7 hast du ein interaktives Menü als eine lange Schleife gebaut. Es war ein funktionierendes Programm, und sein wachsender Schleifenkörper machte das nächste Entwurfsproblem sichtbar.

Jetzt baust du dasselbe Verhalten mit Funktionen neu auf.

Das ist Refactoring: die Struktur von funktionierendem Code verändern und dabei sein Verhalten beibehalten.

Vergleiche die beiden Formen

Im ursprünglichen Menü stand jedes Detail innerhalb seiner Zweige:

if command == "add":
    new_item = input("What should I add? ").strip()
    items.append(new_item)
    print(f"Added: {new_item}")
elif command == "list":
    if len(items) == 0:
        print("The list is empty.")
    else:
        number = 1
        for item in items:
            print(f"{number}. {item}")
            number += 1
elif command == "count":
    print(f"Items stored: {len(items)}")

Die umstrukturierte Schleife übergibt diese Aktionen an Funktionen:

if command == "add":
    add_item(items)
elif command == "list":
    show_items(items)
elif command == "count":
    show_count(items)

Das gesamte Programm ist nicht unbedingt kürzer. Es ist leichter, sich darin zurechtzufinden:

• run_menu erklärt den gesamten Dialog.

• add_item erklärt das Hinzufügen.

• show_items erklärt das Auflisten.

• show_count erklärt das Zählen.

Jede Funktion lässt sich einzeln lesen und prüfen.

Die vier Funktionen

add_item(items)

Frage genau Folgendes ab:

What should I add? 

Bereinige die Antwort mit .strip(), hänge sie an items an und gib Folgendes aus:

Added: read a book

Die an die Funktion übergebene Liste ist dieselbe Liste, die das Menü verwendet. Das Anhängen verändert diese Liste, deshalb sehen spätere Befehle den neuen Eintrag.

show_items(items)

Wenn die Liste leer ist, gib Folgendes aus:

The list is empty.

Gib andernfalls jeden Eintrag in einer nummerierten Zeile aus, beginnend bei 1.

show_count(items)

Gib Folgendes aus:

Items stored: 2

Verwende dabei die tatsächliche Länge der Liste.

run_menu(items)

Diese Funktion ist für die Schleife zuständig. Sie fragt genau Folgendes ab:

Command (add, list, count, quit): 

Bereinige den Befehl mit .strip().lower().

Rufe für add, list und count die passende Funktion auf. Gib bei quit den Text Goodbye. aus und verlasse die Schleife. Gib bei allem anderen I do not know that command. aus und mache weiter.

Das Programm auf der obersten Ebene

Nach den Definitionen:

1. wähle einen nicht leeren menu_title;

2. erstelle eine leere Liste namens items;

3. gib den Titel aus;

4. rufe run_menu(items) auf;

5. gib Final count: gefolgt von der endgültigen Länge aus.

Diese fünf Zeilen beschreiben den Ablauf des Programms, ohne jede Menüaktion zu erklären.

In Teilen bauen und testen

Schreibe nicht das gesamte Projekt, bevor du es ausführst.

1. Schreibe show_count und rufe die Funktion dann vorübergehend mit einer Liste aus zwei Werten auf.

2. Schreibe show_items und teste sowohl eine leere Liste als auch eine Liste mit zwei Werten.

3. Schreibe add_item, rufe die Funktion einmal auf und untersuche danach die Liste.

4. Schreibe run_menu zunächst nur mit dem quit-Zweig.

5. Füge einen Befehlszweig nach dem anderen hinzu. Jeder Zweig soll die Arbeit an seine Funktion übergeben.

6. Entferne die vorübergehenden Aufrufe und führe dann das vollständige Programm auf der obersten Ebene aus.

Arbeite diese Reihenfolge durch:

1. list bei leerer Liste;

2. mit add einen ersten Eintrag hinzufügen;

3. ADD in Großbuchstaben eingeben und einen zweiten Eintrag mit umgebenden Leerzeichen hinzufügen;

4. count;

5. einen unbekannten Befehl;

6. list;

7. quit.

Das Verhalten soll deinem Projekt aus Kapitel 7 entsprechen. Der Unterschied liegt darin, was der Code vermittelt.

Lies das Ergebnis auf zwei Ebenen

Lies zuerst nur die Zeilen auf der obersten Programmebene und run_menu. Kannst du den Plan des gesamten Programms verstehen?

Öffne dann show_items. Kannst du das Auflisten verstehen, ohne die Logik für Eingaben und das Hinzufügen zu lesen?

Diese Trennung ist das Ergebnis dieses Kapitels. Mit Funktionen kannst du nicht nur vermeiden, Code zu kopieren. Du kannst damit festlegen, an welche Stelle welches Wissen gehört.

Wenn dein Tarif Guided enthält, kannst du Monty fragen:

Lies meine Funktionsnamen und sage mir, ob jede Funktion eine klare Aufgabe hat. Zeige mir eine Grenze, die ich überdenken sollte, aber schreibe das Projekt nicht um.

Du weißt jetzt, wie du eine funktionierende Folge von Anweisungen in benannte, prüfbare Vorgänge verwandelst. Kapitel 9 gibt diesen Funktionen umfangreichere Informationen, indem es Dictionaries einführt und Sammlungstypen vergleicht.