Überprüfung einfacher Funktionen und Ausnahmebehandlung

PythonPythonBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, wie Sie die Definition einfacher Funktionen in Python überprüfen und die Ausnahmebehandlung (Exception Handling) erkunden. Funktionen sind ein wichtiges Programmierkonzept, das es Ihnen ermöglicht, Code in wiederverwendbare Segmente zu strukturieren. Die Ausnahmebehandlung hingegen ist eine Methode zur Behandlung von Fehlern und unvorhergesehenen Umständen in Ihren Programmen.

Die Hauptziele dieses Labs sind es, den Prozess der Definition einfacher Funktionen zu überprüfen und die Ausnahmebehandlung in Python zu lernen. Die Datei, die bearbeitet wird, ist pcost.py.

Dies ist ein Guided Lab, das schrittweise Anweisungen bietet, um Ihnen beim Lernen und Üben zu helfen. Befolgen Sie die Anweisungen sorgfältig, um jeden Schritt abzuschließen und praktische Erfahrungen zu sammeln. Historische Daten zeigen, dass dies ein Labor der Stufe Anfänger mit einer Abschlussquote von 90% ist. Es hat eine positive Bewertungsrate von 97% von den Lernenden erhalten.

Definition einer Funktion

In diesem Schritt lernen wir, wie man eine Funktion erstellt. Eine Funktion in Python ist ein Block organisierter, wiederverwendbarer Code, der für die Ausführung einer einzelnen, zusammenhängenden Aktion verwendet wird. Hier wird unsere Funktion Portfolio-Daten aus einer Datei lesen und die Gesamtkosten berechnen. Dies ist nützlich, denn sobald wir diese Funktion haben, können wir sie mehrmals mit verschiedenen Portfolio-Dateien verwenden, sodass wir nicht ständig denselben Code schreiben müssen.

Das Problem verstehen

Im vorherigen Lab haben Sie möglicherweise Code geschrieben, um Portfolio-Daten zu lesen und die Gesamtkosten zu berechnen. Aber dieser Code war wahrscheinlich so geschrieben, dass er nicht einfach wiederverwendet werden kann. Jetzt werden wir diesen Code in eine wiederverwendbare Funktion umwandeln.

Die Portfolio-Daten-Dateien haben ein bestimmtes Format. Sie enthalten Informationen in der Form "Symbol Anzahl Preis". Jede Zeile in der Datei repräsentiert eine Aktienposition. Beispielsweise könnten Sie in einer Datei namens portfolio.dat Zeilen wie diese sehen:

AA 100 32.20
IBM 50 91.10
...

Hier ist der erste Teil (wie "AA" oder "IBM") das Aktiensymbol, das ein eindeutiger Bezeichner für die Aktie ist. Der zweite Teil ist die Anzahl der Aktien, die Sie von dieser Aktie besitzen, und der dritte Teil ist der Preis pro Aktie.

Die Funktion erstellen

Erstellen wir eine Python-Datei namens pcost.py im Verzeichnis /home/labex/project. Diese Datei wird unsere Funktion enthalten. Hier ist der Code, den wir in die pcost.py-Datei einfügen werden:

def portfolio_cost(filename):
    """
    Berechnet die Gesamtkosten (Anzahl * Preis) einer Portfolio-Datei

    Args:
        filename: Der Name der Portfolio-Datei

    Returns:
        Die Gesamtkosten des Portfolios als Float
    """
    total_cost = 0.0

    ## Öffne die Datei und lies jede Zeile
    with open(filename, 'r') as f:
        for line in f:
            fields = line.split()
            ## Extrahiere die Daten (Symbol, Anzahl, Preis)
            shares = int(fields[1])
            price = float(fields[2])
            ## Füge die Kosten zu unserer laufenden Summe hinzu
            total_cost += shares * price

    return total_cost

## Rufe die Funktion mit der portfolio.dat-Datei auf
if __name__ == '__main__':
    cost = portfolio_cost('/home/labex/project/portfolio.dat')
    print(cost)

In diesem Code definieren wir zunächst eine Funktion namens portfolio_cost, die einen filename als Argument nimmt. Innerhalb der Funktion initialisieren wir eine Variable total_cost mit 0.0. Dann öffnen wir die Datei mit der open-Funktion im Lese-Modus ('r'). Wir verwenden eine for-Schleife, um jede Zeile in der Datei zu durchlaufen. Für jede Zeile teilen wir sie in Felder auf, indem wir die split()-Methode verwenden. Dann extrahieren wir die Anzahl der Aktien und wandeln sie in eine Ganzzahl um, sowie den Preis und wandeln ihn in eine Fließkommazahl um. Wir berechnen die Kosten für diese Aktienposition, indem wir die Anzahl der Aktien mit dem Preis multiplizieren, und fügen sie der total_cost hinzu. Schließlich geben wir die total_cost zurück.

Der Teil if __name__ == '__main__': wird verwendet, um die Funktion aufzurufen, wenn das Skript direkt ausgeführt wird. Wir übergeben den Pfad zur portfolio.dat-Datei an die Funktion und geben das Ergebnis aus.

Die Funktion testen

Jetzt lassen wir das Programm laufen, um zu sehen, ob es funktioniert. Wir müssen in das Verzeichnis navigieren, in dem sich die pcost.py-Datei befindet, und dann das Python-Skript ausführen. Hier sind die Befehle dazu:

cd /home/labex/project
python3 pcost.py

Nachdem Sie diese Befehle ausgeführt haben, sollten Sie die Ausgabe sehen:

44671.15

Diese Ausgabe repräsentiert die Gesamtkosten aller Aktien im Portfolio.

Den Code verstehen

Lassen Sie uns schrittweise analysieren, was unsere Funktion tut:

  1. Sie nimmt einen filename als Eingabeparameter. Dies ermöglicht es uns, die Funktion mit verschiedenen Portfolio-Dateien zu verwenden.
  2. Sie öffnet die Datei und liest sie Zeile für Zeile. Dies geschieht mit der open-Funktion und einer for-Schleife.
  3. Für jede Zeile teilt sie die Zeile in Felder auf, indem sie die split()-Methode verwendet. Diese Methode teilt die Zeile in eine Liste von Strings auf, basierend auf Leerzeichen.
  4. Sie wandelt die Anzahl der Aktien in eine Ganzzahl und den Preis in eine Fließkommazahl um. Dies ist notwendig, da die aus der Datei gelesenen Daten im String-Format vorliegen und wir arithmetische Operationen darauf ausführen müssen.
  5. Sie berechnet die Kosten (Anzahl * Preis) für jede Aktienposition und fügt sie der laufenden Summe hinzu. Dies ergibt uns die Gesamtkosten des Portfolios.
  6. Sie gibt die endgültigen Gesamtkosten zurück. Dies ermöglicht es uns, das Ergebnis bei Bedarf in anderen Teilen unseres Programms zu verwenden.

Diese Funktion ist jetzt wiederverwendbar. Wir können sie mit verschiedenen Portfolio-Dateien aufrufen, um deren Kosten zu berechnen, was unseren Code effizienter und leichter zu warten macht.

✨ Lösung prüfen und üben

Hinzufügen von Fehlerbehandlung

Wenn Sie mit realen Daten arbeiten, ist es sehr üblich, Inkonsistenzen oder Fehler zu finden. Beispielsweise können die Daten fehlende Werte, falsche Formate oder andere Probleme aufweisen. Python bietet Mechanismen zur Ausnahmebehandlung (Exception Handling), um diese Situationen elegant zu bewältigen. Die Ausnahmebehandlung ermöglicht es Ihrem Programm, auch dann weiterlaufen zu können, wenn es auf einen Fehler stößt, anstatt abrupt abzustürzen.

Das Problem verstehen

Schauen wir uns die Datei portfolio3.dat an. Diese Datei enthält einige Daten über ein Portfolio, wie das Aktiensymbol, die Anzahl der Aktien und den Preis pro Aktie. Um den Inhalt dieser Datei anzuzeigen, können wir den folgenden Befehl verwenden:

cat /home/labex/project/portfolio3.dat

Wenn Sie diesen Befehl ausführen, werden Sie feststellen, dass einige Zeilen in der Datei Striche (-) anstelle von Zahlen für die Anzahl der Aktien enthalten. Hier ist ein Beispiel für das, was Sie sehen könnten:

AA 100 32.20
IBM 50 91.10
C - 53.08
...

Wenn wir versuchen, unseren aktuellen Code auf diese Datei anzuwenden, wird er abstürzen. Der Grund dafür ist, dass unser Code erwartet, die Anzahl der Aktien in eine Ganzzahl umzuwandeln, aber er kann einen Strich (-) nicht in eine Ganzzahl umwandeln. Versuchen wir, den Code auszuführen und sehen, was passiert:

python3 -c "import sys; sys.path.append('/home/labex/project'); from pcost import portfolio_cost; print(portfolio_cost('/home/labex/project/portfolio3.dat'))"

Sie werden eine Fehlermeldung wie diese sehen:

ValueError: invalid literal for int() with base 10: '-'

Dieser Fehler tritt auf, weil Python den --Zeichen nicht in eine Ganzzahl umwandeln kann, wenn es versucht, int(fields[1]) auszuführen.

Einführung in die Ausnahmebehandlung

Python's Ausnahmebehandlung verwendet try- und except-Blöcke. Der try-Block enthält den Code, der eine Ausnahme auslösen könnte. Eine Ausnahme ist ein Fehler, der während der Ausführung eines Programms auftritt. Der except-Block enthält den Code, der ausgeführt wird, wenn im try-Block eine Ausnahme auftritt.

Hier ist ein Beispiel dafür, wie try- und except-Blöcke funktionieren:

try:
    ## Code that might raise an exception
    result = risky_operation()
except ExceptionType as e:
    ## Code to handle the exception
    print(f"An error occurred: {e}")

Wenn Python den Code im try-Block ausführt und eine Ausnahme auftritt, springt die Ausführung sofort zum passenden except-Block. Der ExceptionType im except-Block gibt den Typ der Ausnahme an, die wir behandeln möchten. Die Variable e enthält Informationen über die Ausnahme, wie die Fehlermeldung.

Modifizieren der Funktion mit Ausnahmebehandlung

Lassen Sie uns unsere pcost.py-Datei aktualisieren, um Fehler in den Daten zu behandeln. Wir verwenden die try- und except-Blöcke, um Zeilen mit fehlerhaften Daten zu überspringen und eine Warnmeldung anzuzeigen.

def portfolio_cost(filename):
    """
    Computes the total cost (shares*price) of a portfolio file
    Handles lines with bad data by skipping them and showing a warning.

    Args:
        filename: The name of the portfolio file

    Returns:
        The total cost of the portfolio as a float
    """
    total_cost = 0.0

    ## Open the file and read through each line
    with open(filename, 'r') as f:
        for line in f:
            fields = line.split()
            try:
                ## Extract the data (symbol, shares, price)
                shares = int(fields[1])
                price = float(fields[2])
                ## Add the cost to our running total
                total_cost += shares * price
            except ValueError as e:
                ## Print a warning for lines that can't be parsed
                print(f"Couldn't parse: '{line}'")
                print(f"Reason: {e}")

    return total_cost

## Call the function with the portfolio3.dat file
if __name__ == '__main__':
    cost = portfolio_cost('/home/labex/project/portfolio3.dat')
    print(cost)

In diesem aktualisierten Code öffnen wir zunächst die Datei und lesen sie Zeile für Zeile. Für jede Zeile teilen wir sie in Felder auf. Dann versuchen wir, die Anzahl der Aktien in eine Ganzzahl und den Preis in eine Fließkommazahl umzuwandeln. Wenn diese Umwandlung fehlschlägt (d.h., wenn ein ValueError auftritt), geben wir eine Warnmeldung aus und überspringen diese Zeile. Andernfalls berechnen wir die Kosten der Aktien und addieren sie zur Gesamtkosten.

Testen der aktualisierten Funktion

Jetzt lassen wir das aktualisierte Programm mit der problematischen Datei laufen. Zunächst müssen wir in das Projektverzeichnis navigieren und dann das Python-Skript ausführen.

cd /home/labex/project
python3 pcost.py

Sie sollten eine Ausgabe wie diese sehen:

Couldn't parse: 'C - 53.08
'
Reason: invalid literal for int() with base 10: '-'
Couldn't parse: 'DIS - 34.20
'
Reason: invalid literal for int() with base 10: '-'
44671.15

Das Programm macht jetzt Folgendes:

  1. Es versucht, jede Zeile der Datei zu verarbeiten.
  2. Wenn eine Zeile ungültige Daten enthält, fängt es den ValueError ab.
  3. Es gibt eine hilfreiche Meldung über das Problem aus.
  4. Es setzt die Verarbeitung der restlichen Datei fort.
  5. Es gibt die Gesamtkosten basierend auf den gültigen Zeilen zurück.

Dieser Ansatz macht unser Programm viel robuster, wenn es mit unvollkommenen Daten umgeht. Es kann Fehler elegant behandeln und dennoch nützliche Ergebnisse liefern.

✨ Lösung prüfen und üben

Interaktive Experimente

Python bietet einen interaktiven Modus, der es Ihnen ermöglicht, Code sofort auszuführen. Dies ist super nützlich, um Ihren Code zu testen und neue Dinge auszuprobieren. In diesem Schritt lernen wir, wie man eine Funktion direkt aus dem Python-Interpreter aufruft.

Ausführen von Python im interaktiven Modus

Um ein Python-Skript auszuführen und dann in den interaktiven Modus zu gelangen, können Sie die -i-Option verwenden. Diese Option teilt Python mit, nach der Ausführung des Skripts im interaktiven Zustand weiterzulaufen. So geht es:

cd /home/labex/project
python3 -i pcost.py

Lassen Sie uns analysieren, was dieser Befehl macht:

  1. Zunächst wechselt cd /home/labex/project das aktuelle Verzeichnis zu /home/labex/project. Hier befindet sich unser pcost.py-Skript.
  2. Dann führt python3 -i pcost.py das pcost.py-Skript aus. Nach Abschluss der Skriptausführung bleibt Python im interaktiven Modus.
  3. Im interaktiven Modus können Sie direkt Python-Befehle in das Terminal eingeben.

Nachdem Sie den Befehl ausgeführt haben, sehen Sie die Ausgabe des pcost.py-Skripts, gefolgt vom Python-Prompt (>>>). Dieser Prompt zeigt an, dass Sie jetzt Python-Befehle eingeben können.

Interaktives Aufrufen Ihrer Funktion

Sobald Sie sich im interaktiven Modus befinden, können Sie die portfolio_cost()-Funktion mit verschiedenen Dateinamen aufrufen. Dies ermöglicht es Ihnen, zu sehen, wie die Funktion mit verschiedenen Eingaben reagiert. Hier ist ein Beispiel:

>>> portfolio_cost('/home/labex/project/portfolio.dat')
44671.15
>>> portfolio_cost('/home/labex/project/portfolio2.dat')
19908.75
>>> portfolio_cost('/home/labex/project/portfolio3.dat')
Couldn't parse: 'C - 53.08
'
Reason: invalid literal for int() with base 10: '-'
Couldn't parse: 'DIS - 34.20
'
Reason: invalid literal for int() with base 10: '-'
44671.15

Mit diesem interaktiven Ansatz können Sie:

  • Ihre Funktion mit verschiedenen Eingaben testen, um zu sehen, ob sie wie erwartet funktioniert.
  • Die Funktionsweise der Funktion unter verschiedenen Bedingungen experimentell untersuchen.
  • Ihren Code sofort debuggen, indem Sie die unmittelbaren Ergebnisse Ihrer Funktionsaufrufe sehen.

Vorteile des interaktiven Modus

Der interaktive Modus hat mehrere Vorteile:

  1. Sie können verschiedene Szenarien schnell testen, ohne jedes Mal das gesamte Skript ausführen zu müssen.
  2. Sie können Variablen und Ausdrucksresultate sofort untersuchen, was Ihnen hilft, zu verstehen, was in Ihrem Code passiert.
  3. Sie können kleine Code-Stücke testen, ohne ein vollständiges Programm zu erstellen. Dies ist ideal für das Lernen und Ausprobieren neuer Ideen.
  4. Es ist eine ausgezeichnete Möglichkeit, Python zu lernen und zu experimentieren, da Sie sofortige Rückmeldung erhalten.

Verlassen des interaktiven Modus

Wenn Sie mit Ihren Experimenten fertig sind, können Sie den interaktiven Modus auf zwei Arten verlassen:

  • Geben Sie exit() ein und drücken Sie Enter. Dies ist eine einfache Möglichkeit, die interaktive Sitzung zu beenden.
  • Drücken Sie Ctrl+D (unter Unix/Linux). Dies ist eine Tastenkombination, die ebenfalls den interaktiven Modus verlässt.

Im Laufe Ihrer Python-Programmierreise wird die Technik des Definierens von Funktionen und des interaktiven Testens äußerst wertvoll für die Entwicklung und das Debugging sein. Sie ermöglicht es Ihnen, schnell über Ihren Code zu iterieren und Probleme zu finden und zu beheben.

✨ Lösung prüfen und üben

Zusammenfassung

In diesem Lab haben Sie mehrere wichtige Konzepte der Python-Programmierung gelernt. Zunächst haben Sie gelernt, wie Sie Funktionen definieren und nutzen, was Ihren Code wiederverwendbar macht. Zweitens haben Sie die Implementierung der Ausnahmebehandlung (Exception Handling) beherrscht, wodurch die Robustheit Ihrer Programme verbessert wird. Schließlich haben Sie entdeckt, wie Sie Python im interaktiven Modus für Tests und Experimente nutzen können.

Diese Fähigkeiten sind grundlegend für das Schreiben zuverlässiger Python-Programme. Funktionen helfen dabei, Code zu organisieren und wiederzuverwenden, die Ausnahmebehandlung ermöglicht es, unerwartete Situationen elegant zu bewältigen, und der interaktive Modus bietet eine leistungsstarke Umgebung für das Testen und Debugging. Wenn Sie in Ihrem Python-Lernprozess voranschreiten, werden diese Konzepte bei der Entwicklung größerer und komplexerer Anwendungen immer wertvoller sein.