LU01.A09 - Vom Skript zur Funktion

Das Skript in ausgangslage.py funktioniert – solange man es genau in dieser Reihenfolge aufruft. Es zeigt gleich mehrere typische Schwächen prozeduralen Codes: globalen Zustand, Berechnung und Ausgabe im selben Atemzug, und Prozeduren, die None zurückgeben.

ausgangslage.py

"""
Die urspruengliche Fassung des Lagerskripts - NUR ZUM NACHLESEN.
 
Diese Datei wird nicht bewertet und muss nicht veraendert werden.
Sie zeigt, womit Sie starten: globale Variablen, Berechnung und Ausgabe
vermischt, und drei Prozeduren, die None zurueckgeben.
"""
 
lager = []
gesamtwert = 0
 
 
def artikel_hinzufuegen(name, menge, preis):
    """Haengt einen Artikel an die globale Liste und aktualisiert die globale Summe."""
    global gesamtwert
    lager.append({'name': name, 'menge': menge, 'preis': preis})
    gesamtwert += menge * preis
 
 
def zeige_gesamtwert():
    """Druckt den globalen Gesamtwert."""
    print(f'Gesamtwert: {gesamtwert:.2f} CHF')
 
 
def zeige_teuersten():
    """Druckt den Namen des teuersten Artikels."""
    teuerster = None
    for artikel in lager:
        if teuerster is None or artikel['preis'] > teuerster['preis']:
            teuerster = artikel
    name = teuerster['name']
    print(f'Teuerster Artikel: {name}')
 
 
if __name__ == '__main__':
    artikel_hinzufuegen('Maus', 10, 24.90)
    artikel_hinzufuegen('Tastatur', 4, 79.50)
    artikel_hinzufuegen('Monitor', 2, 249.00)
    zeige_gesamtwert()
    zeige_teuersten()

Die Namen und Signaturen in main.py sind fix – die Tests rufen genau diese auf.

main.py

"""
LU01.A09 - Vom Skript zur Funktion
 
Bauen Sie das prozedurale Lagerskript in echte Funktionen um:
keine globalen Variablen, kein print in den berechnenden Funktionen,
jede Funktion gibt einen Wert zurueck, und die uebergebene Liste wird
nicht veraendert.
 
Die urspruengliche Fassung finden Sie in ausgangslage.py.
"""
 
 
def artikel_hinzufuegen(lager, name, menge, preis):
    """
    Gibt ein NEUES Lager zurueck, das zusaetzlich den angegebenen Artikel enthaelt.
    Das uebergebene Lager darf dabei nicht veraendert werden.
 
    :param lager: Liste von Artikeln (dict mit name, menge, preis)
    :param name: Name des neuen Artikels
    :param menge: Stueckzahl des neuen Artikels
    :param preis: Stueckpreis des neuen Artikels
    :return: neue Liste mit allen bisherigen Artikeln plus dem neuen
    """
    # TODO Neue Liste erzeugen statt append verwenden
 
 
def gesamtwert(lager):
    """
    Berechnet den Gesamtwert aller Artikel im Lager (Menge mal Preis).
 
    :param lager: Liste von Artikeln
    :return: Gesamtwert als Zahl, bei leerem Lager 0
    """
    # TODO Summe berechnen und zurueckgeben
 
 
def teuerster_artikel(lager):
    """
    Sucht den Artikel mit dem hoechsten Stueckpreis.
 
    :param lager: Liste von Artikeln
    :return: der teuerste Artikel, bei leerem Lager None
    """
    # TODO Teuersten Artikel suchen und zurueckgeben
 
 
def formatiere_gesamtwert(lager):
    """
    Erzeugt den Ausgabetext zum Gesamtwert - und gibt ihn zurueck,
    statt ihn zu drucken.
 
    Format: 'Gesamtwert: 1065.00 CHF' (zwei Nachkommastellen)
 
    :param lager: Liste von Artikeln
    :return: Ausgabetext als String
    """
    # TODO Text zusammensetzen und zurueckgeben
 
 
def main():
    """Baut ein Lager auf und gibt die Auswertung aus."""
    lager = []
    lager = artikel_hinzufuegen(lager, 'Maus', 10, 24.90)
    lager = artikel_hinzufuegen(lager, 'Tastatur', 4, 79.50)
    lager = artikel_hinzufuegen(lager, 'Monitor', 2, 249.00)
 
    name = teuerster_artikel(lager)['name']
    print(formatiere_gesamtwert(lager))
    print(f'Teuerster Artikel: {name}')
 
 
if __name__ == '__main__':
    main()

1. Analyse: Halten Sie schriftlich fest, welche der drei def-Blöcke in ausgangslage.py Prozeduren sind und woran Sie das erkennen.
2. Umbau: Implementieren Sie in main.py die vier vorgegebenen Funktionen so, dass gilt:
   • Keine globalen Variablen – alle benötigten Daten kommen als Parameter herein.
   • Kein print innerhalb der berechnenden Funktionen. Ausgegeben wird ausschliesslich in main().
   • Jede Funktion gibt einen Wert zurück.
   • artikel_hinzufuegen verändert die übergebene Liste nicht, sondern gibt eine neue Liste zurück.

Gesamtwert: 1065.00 CHF
Teuerster Artikel: Monitor

1. Warum kann man den Ausdruck gesamtwert(lager) im Kopf jederzeit durch seine Zahl ersetzen, den Aufruf artikel_hinzufuegen('Maus', 10, 24.90) aus der Ausgangslage aber nicht? Wie heisst diese Eigenschaft?
2. Was gibt zeige_gesamtwert() zurück? Probieren Sie ergebnis = zeige_gesamtwert() und geben Sie ergebnis aus.
3. Welche Ihrer neuen Funktionen liessen sich mit einem automatischen Test prüfen, welche der alten Prozeduren nicht? Begründen Sie.

1. Akzeptiere das Classroom-Assignment
2. Klone dein persönliches Repository in die Entwicklungsumgebung
3. Lies ausgangslage.py und beantworte Teil 1 (Analyse)
4. Implementiere die vier Funktionen in main.py
5. Lokal prüfen mit pytest und python _run_pylint.py
6. Pushen – die Bewertung läuft automatisch

Die Abgabe des Codes erfolgt als Push in das persönliche GitHub-Repository. Die drei Kontrollfragen geben Sie zusätzlich in Moodle ab.

© Kevin Maurizi