Grundlegende Datei-Eingabe/Ausgabe (File I/O) wiederholen

Einführung

In diesem Lab werden Sie lernen, die grundlegenden Dateieingabe- und -ausgabeoperationen in Python zu überprüfen. Sie werden ein Python-Programm erstellen, um Daten aus einer Datei mit Informationen über eine Aktienportfolios zu lesen und die Gesamtkosten des Portfolios zu berechnen.

Zu den Zielen dieses Labs gehört das Erlernen, wie man Dateien in Python öffnet und liest, Daten aus Dateien zeilenweise verarbeitet, Berechnungen mit den Daten durchführt und die Ergebnisse ausgibt. Die Datei, die Sie erstellen werden, ist pcost.py.

Das Problem verstehen

In diesem Schritt werden wir zunächst verstehen, welches Problem wir lösen müssen, und uns dann die Daten ansehen, mit denen wir arbeiten werden. Dies ist ein wichtiger erster Schritt bei jeder Programmieraufgabe, da es uns hilft, genau zu wissen, was wir erreichen wollen und welche Ressourcen uns zur Verfügung stehen.

In Ihrem Projektverzeichnis befindet sich eine Datei namens portfolio.dat. Diese Datei speichert Informationen über ein Aktienportfolio. Ein Portfolio ist wie eine Sammlung verschiedener Aktien, die ein Investor besitzt. Jede Zeile in dieser Datei repräsentiert einen einzelnen Aktienkauf. Das Format jeder Zeile ist wie folgt:

[Stock Symbol] [Number of Shares] [Price per Share]

Das Aktiensymbol ist ein kurzer Code, der die Aktie eines bestimmten Unternehmens repräsentiert. Die Anzahl der Aktien gibt an, wie viele Einheiten dieser Aktie gekauft wurden, und der Preis pro Aktie ist die Kosten für eine Einheit dieser Aktie.

Schauen wir uns ein Beispiel an. Betrachten Sie die erste Zeile der Datei:

AA 100 32.20

Diese Zeile gibt an, dass 100 Aktien der Aktie mit dem Symbol "AA" gekauft wurden. Jede Aktie kostete 32,20 US-Dollar.

Wenn Sie sehen möchten, was in der Datei portfolio.dat steht, können Sie den folgenden Befehl im Terminal ausführen. Der Befehl cat ist ein nützliches Werkzeug im Terminal, das es Ihnen ermöglicht, den Inhalt einer Datei anzuzeigen.

cat ~/project/portfolio.dat

Nun ist Ihre Aufgabe, ein Python-Programm namens pcost.py zu erstellen. Dieses Programm wird drei Hauptaufgaben ausführen:

1. Zunächst muss es die Datei portfolio.dat öffnen und lesen. Das Öffnen einer Datei in Python ermöglicht es unserem Programm, auf die darin gespeicherten Daten zuzugreifen.
2. Dann muss es die Gesamtkosten aller Aktienkäufe im Portfolio berechnen. Dazu müssen wir für jede Zeile in der Datei die Anzahl der Aktien mit dem Preis pro Aktie multiplizieren. Nachdem wir diese Werte für jede Zeile erhalten haben, summieren wir sie alle auf. Dies gibt uns die Gesamtmenge an Geld, die für alle Aktien im Portfolio ausgegeben wurde.
3. Schließlich sollte das Programm die Gesamtkosten ausgeben. Auf diese Weise können wir das Ergebnis unserer Berechnungen sehen.

Beginnen wir damit, die Datei pcost.py zu erstellen. Sie können den Editor verwenden, um diese Datei zu öffnen und zu bearbeiten. Sie wurde bereits für Sie während des Einrichtungsschritts erstellt. In dieser Datei werden Sie den Python-Code schreiben, um das Problem zu lösen, das wir gerade besprochen haben.

Öffnen und Lesen der Datei

In diesem Schritt werden wir lernen, wie man in Python eine Datei öffnet und liest. Dateieingabe/Ausgabe (I/O) ist ein grundlegendes Konzept in der Programmierung. Es ermöglicht es Ihrem Programm, mit externen Dateien wie Textdateien, CSV-Dateien und mehr zu interagieren. In Python ist eine der häufigsten Methoden, mit Dateien zu arbeiten, die Verwendung der open()-Funktion.

Die open()-Funktion wird in Python verwendet, um eine Datei zu öffnen. Sie nimmt zwei wichtige Argumente entgegen. Das erste Argument ist der Name der Datei, die Sie öffnen möchten. Das zweite Argument ist der Modus, in dem Sie die Datei öffnen möchten. Wenn Sie eine Datei lesen möchten, verwenden Sie den Modus 'r'. Dies teilt Python mit, dass Sie nur den Inhalt der Datei lesen und keine Änderungen daran vornehmen möchten.

Nun fügen wir dem pcost.py-File einige Codezeilen hinzu, um die portfolio.dat-Datei zu öffnen und zu lesen. Öffnen Sie die pcost.py-Datei in Ihrem Code-Editor und fügen Sie den folgenden Code hinzu:

## pcost.py
## Calculate the total cost of a portfolio of stocks

def portfolio_cost(filename):
    """
    Computes the total cost (shares*price) of a portfolio file
    """
    total_cost = 0.0

    ## Open the file
    with open(filename, 'r') as file:
        ## Read all lines in the file
        for line in file:
            print(line)  ## Just for debugging, to see what we're reading

    ## Return the total cost
    return total_cost

## Call the function with the portfolio file
total_cost = portfolio_cost('portfolio.dat')
print(f'Total cost: ${total_cost}')

Lassen Sie uns analysieren, was dieser Code tut:

1. Zunächst definieren wir eine Funktion namens portfolio_cost(). Diese Funktion nimmt einen Dateinamen als Eingabeparameter. Der Zweck dieser Funktion ist es, die Gesamtkosten eines Aktienportfolios basierend auf den Daten in der Datei zu berechnen.
2. Innerhalb der Funktion verwenden wir die open()-Funktion, um die angegebene Datei im Lesemodus zu öffnen. Die with-Anweisung wird hier verwendet, um sicherzustellen, dass die Datei ordnungsgemäß geschlossen wird, nachdem wir sie gelesen haben. Dies ist eine gute Praxis, um Ressourcenlecks zu vermeiden.
3. Anschließend verwenden wir eine for-Schleife, um die Datei zeilenweise zu lesen. Für jede Zeile in der Datei geben wir sie aus. Dies dient nur Debugging-Zwecken, damit wir sehen können, welche Daten wir aus der Datei lesen.
4. Nach dem Lesen der Datei gibt die Funktion die Gesamtkosten zurück. Derzeit ist die Gesamtkosten auf 0,0 gesetzt, da wir die eigentliche Berechnung noch nicht implementiert haben.
5. Außerhalb der Funktion rufen wir die portfolio_cost()-Funktion mit dem Dateinamen 'portfolio.dat' auf. Dies bedeutet, dass wir die Funktion bitten, die Gesamtkosten basierend auf den Daten in der portfolio.dat-Datei zu berechnen.
6. Schließlich geben wir die Gesamtkosten mit einem f-String aus.

Nun lassen wir diesen Code laufen, um zu sehen, was er tut. Sie können die Python-Datei aus dem Terminal mit dem folgenden Befehl ausführen:

python3 ~/project/pcost.py

Wenn Sie diesen Befehl ausführen, sollten Sie jede Zeile der portfolio.dat-Datei im Terminal sehen, gefolgt von den Gesamtkosten, die derzeit auf 0,0 gesetzt sind. Diese Ausgabe hilft Ihnen zu überprüfen, ob die Datei korrekt gelesen wird.

Verarbeitung der Daten

Nachdem wir gelernt haben, wie man eine Datei liest, ist der nächste Schritt, jede Zeile der Datei zu verarbeiten, um die Kosten jedes Aktienkaufs zu berechnen. Dies ist ein wichtiger Teil der Arbeit mit Daten in Python, da es uns ermöglicht, sinnvolle Informationen aus der Datei zu extrahieren.

Jede Zeile in der Datei folgt einem bestimmten Format: [Stock Symbol] [Number of Shares] [Price per Share]. Um die Kosten jedes Aktienkaufs zu berechnen, müssen wir die Anzahl der Aktien und den Preis pro Aktie aus jeder Zeile extrahieren. Dann multiplizieren wir diese beiden Werte miteinander, um die Kosten dieses bestimmten Aktienkaufs zu erhalten. Schließlich addieren wir diese Kosten zu unserem laufenden Gesamtbetrag, um die Gesamtkosten des Portfolios zu ermitteln.

Lassen Sie uns die portfolio_cost()-Funktion in der pcost.py-Datei ändern, um dies zu erreichen. Hier ist der geänderte Code:

def portfolio_cost(filename):
    """
    Computes the total cost (shares*price) of a portfolio file
    """
    total_cost = 0.0

    ## Open the file
    with open(filename, 'r') as file:
        ## Read all lines in the file
        for line in file:
            ## Strip any leading/trailing whitespace
            line = line.strip()

            ## Skip empty lines
            if not line:
                continue

            ## Split the line into fields
            fields = line.split()

            ## Extract the relevant data
            ## fields[0] is the stock symbol (which we don't need for the calculation)
            shares = int(fields[1])  ## Number of shares (second field)
            price = float(fields[2])  ## Price per share (third field)

            ## Calculate the cost of this stock purchase
            cost = shares * price

            ## Add to the total cost
            total_cost += cost

            ## Print some debug information
            print(f'{fields[0]}: {shares} shares at ${price:.2f} = ${cost:.2f}')

    ## Return the total cost
    return total_cost

Lassen Sie uns schrittweise analysieren, was diese geänderte Funktion tut:

1. Entfernt Leerzeichen: Wir verwenden die strip()-Methode, um alle führenden oder nachfolgenden Leerzeichen von jeder Zeile zu entfernen. Dies stellt sicher, dass wir keine zusätzlichen Leerzeichen versehentlich einbeziehen, wenn wir die Zeile in Felder aufteilen.
2. Überspringt leere Zeilen: Wenn eine Zeile leer ist (d. h., sie enthält nur Leerzeichen), verwenden wir die continue-Anweisung, um sie zu überspringen. Dies hilft uns, Fehler zu vermeiden, wenn wir versuchen, eine leere Zeile zu teilen.
3. Teilt die Zeile in Felder auf: Wir verwenden die split()-Methode, um jede Zeile in eine Liste von Feldern auf der Grundlage von Leerzeichen aufzuteilen. Dies ermöglicht es uns, jeden Teil der Zeile separat zuzugreifen.
4. Extrahiert relevante Daten: Wir extrahieren die Anzahl der Aktien und den Preis pro Aktie aus der Liste der Felder. Die Anzahl der Aktien ist das zweite Feld, und der Preis pro Aktie ist das dritte Feld. Wir konvertieren diese Werte in die entsprechenden Datentypen (int für die Anzahl der Aktien und float für den Preis), damit wir arithmetische Operationen darauf ausführen können.
5. Berechnet die Kosten: Wir multiplizieren die Anzahl der Aktien mit dem Preis pro Aktie, um die Kosten dieses Aktienkaufs zu berechnen.
6. Addiert zum Gesamtbetrag: Wir addieren die Kosten dieses Aktienkaufs zum laufenden Gesamtbetrag.
7. Gibt Debug-Informationen aus: Wir geben einige Informationen über jeden Aktienkauf aus, um zu sehen, was passiert. Dies umfasst das Aktiensymbol, die Anzahl der Aktien, den Preis pro Aktie und die Gesamtkosten des Kaufs.

Nun lassen wir den Code laufen, um zu sehen, ob er funktioniert. Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:

python3 ~/project/pcost.py

Nachdem Sie den Befehl ausgeführt haben, sollten Sie detaillierte Informationen über jeden Aktienkauf sehen, gefolgt von den Gesamtkosten des Portfolios. Diese Ausgabe wird Ihnen helfen, zu überprüfen, ob die Funktion korrekt funktioniert und ob Sie die Gesamtkosten genau berechnet haben.

Abschluss des Programms

Jetzt werden wir unseren Code aufräumen und die endgültige Version des pcost.py-Programms erstellen. Das Aufräumen des Codes bedeutet, alle unnötigen Teile zu entfernen und sicherzustellen, dass die Ausgabe gut aussieht. Dies ist ein wichtiger Schritt in der Programmierung, da es unseren Code professioneller und leichter verständlich macht.

Wir beginnen damit, die Debug-Ausgabebefehle zu entfernen. Diese Befehle werden während der Entwicklung verwendet, um die Werte von Variablen und den Programmablauf zu überprüfen, aber sie sind in der endgültigen Version nicht erforderlich. Dann stellen wir sicher, dass die endgültige Ausgabe schön formatiert ist.

Hier ist die endgültige Version des pcost.py-Codes:

## pcost.py
## Calculate the total cost of a portfolio of stocks

def portfolio_cost(filename):
    """
    Computes the total cost (shares*price) of a portfolio file
    """
    total_cost = 0.0

    try:
        ## Open the file
        with open(filename, 'r') as file:
            ## Read all lines in the file
            for line in file:
                ## Strip any leading/trailing whitespace
                line = line.strip()

                ## Skip empty lines
                if not line:
                    continue

                ## Split the line into fields
                fields = line.split()

                ## Extract the relevant data
                ## fields[0] is the stock symbol (which we don't need for the calculation)
                shares = int(fields[1])  ## Number of shares (second field)
                price = float(fields[2])  ## Price per share (third field)

                ## Calculate the cost of this stock purchase and add to the total
                total_cost += shares * price

    except FileNotFoundError:
        print(f"Error: Could not find file '{filename}'")
        return 0.0
    except Exception as e:
        print(f"Error processing file: {e}")
        return 0.0

    ## Return the total cost
    return total_cost

## Main block to run when the script is executed directly
if __name__ == '__main__':
    ## Call the function with the portfolio file
    total_cost = portfolio_cost('portfolio.dat')
    print(f'Total cost: ${total_cost:.2f}')

Diese endgültige Version des Codes hat mehrere Verbesserungen:

1. Fehlerbehandlung: Wir haben Code hinzugefügt, um zwei Arten von Fehlern abzufangen. Der FileNotFoundError wird ausgelöst, wenn die angegebene Datei nicht existiert. Wenn dies geschieht, gibt das Programm eine Fehlermeldung aus und gibt 0,0 zurück. Der Exception-Block fängt alle anderen Fehler ab, die beim Verarbeiten der Datei auftreten können. Dies macht unser Programm robuster und weniger anfällig für unerwartete Abstürze.
2. Korrekte Formatierung: Die Gesamtkosten werden mit dem :.2f-Format-Spezifizierer in der f-String auf zwei Dezimalstellen formatiert. Dies macht die Ausgabe professioneller und leichter lesbar.
3. __name__ == '__main__'-Prüfung: Dies ist ein gängiges Python-Idiom. Es stellt sicher, dass der Code innerhalb des if-Blocks nur ausgeführt wird, wenn das Skript direkt ausgeführt wird. Wenn das Skript als Modul in ein anderes Skript importiert wird, wird dieser Code nicht ausgeführt. Dies gibt uns mehr Kontrolle darüber, wie unser Skript verhält.

Jetzt lassen wir den endgültigen Code laufen. Öffnen Sie Ihr Terminal und geben Sie den folgenden Befehl ein:

python3 ~/project/pcost.py

Wenn Sie diesen Befehl ausführen, liest das Programm die portfolio.dat-Datei, berechnet die Gesamtkosten des Portfolios und gibt das Ergebnis aus. Sie sollten die Gesamtkosten des Portfolios sehen, die $44671,15 betragen sollten.

Herzlichen Glückwunsch! Sie haben erfolgreich ein Python-Programm erstellt, das Daten aus einer Datei liest, verarbeitet und ein Ergebnis berechnet. Dies ist ein großartiges Erreichen und zeigt, dass Sie auf dem Weg sind, ein versierter Python-Programmierer zu werden.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man grundlegende Datei-Eingabe/Ausgabe-Operationen (File I/O) in Python durchführt. Sie können Dateien mit der open()-Funktion und einem Kontext-Manager öffnen und lesen, Daten zeilenweise verarbeiten, Textdaten analysieren, Berechnungen durchführen, Fehler behandeln und ein komplettes Python-Programm mit Funktionen und einem Hauptblock strukturieren.

Diese Fähigkeiten sind für viele Python-Programme grundlegend und nützlich in verschiedenen Anwendungen, wie beispielsweise Datenanalyse und Konfigurationsverwaltung. Sie können das Programm weiter verbessern, indem Sie Befehlszeilenargumente hinzufügen, verschiedene Dateiformate verarbeiten, die Fehlerprüfung verbessern und detailliertere Berichte erstellen.