Definieren und Importieren von Python-Modulen

Einführung

In diesem Lab lernen Sie etwas über Python-Module (Python modules). Dies sind Dateien, die Python-Code enthalten und die in anderen Programmen importiert und verwendet werden können. Dieser modulare Ansatz fördert die Wiederverwendung von Code und hilft, Programme in logische Komponenten zu organisieren.

Sie werden verstehen, was Python-Module sind und warum sie nützlich sind, erfahren, wie Sie Ihre eigenen Module erstellen können, üben verschiedene Arten der Verwendung der import-Anweisung und ergreifen das Konzept eines Hauptmoduls (main module) sowie den Zeitpunkt, zu dem Code ausgeführt wird. Voraussetzungen sind ein grundlegendes Verständnis der Python-Syntax und -Funktionen sowie Vertrautheit mit dem Erstellen und Ausführen von Python-Skripten. Es wird empfohlen, Ihre Python-Interpreter-Sitzung vor Beginn dieser Übung neu zu starten, um eine saubere Umgebung zu haben.

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 97% ist. Es hat eine positive Bewertungsrate von 100% von den Lernenden erhalten.

Das Verständnis von Python-Modulen

In Python ist ein Modul (module) wie ein Behälter, der Python-Definitionen und -Anweisungen enthält. Es ist im Wesentlichen eine Datei, und der Name dieser Datei ist der Modulname mit der Erweiterung .py am Ende. Stellen Sie sich Module als Werkzeugkästen vor. Sie helfen Ihnen, Ihren Python-Code auf logische Weise zu organisieren, was die Wiederverwendung und Wartung erleichtert. Genauso wie Sie verschiedene Werkzeuge in separaten Kästen aufbewahren würden, um die Organisation zu verbessern, können Sie verwandten Python-Code in verschiedene Module gruppieren.

Schauen wir uns die Dateien an, die für dieses Lab eingerichtet wurden:

Zunächst öffnen wir die Datei stock.py im Editor, um zu sehen, was darin enthalten ist. Dazu verwenden wir die folgenden Befehle. Der Befehl cd wechselt in das Verzeichnis project, in dem sich unsere Datei befindet, und der Befehl cat zeigt den Inhalt der Datei an.

cd ~/project
cat stock.py

Diese Datei stock.py definiert eine Klasse Stock. Eine Klasse ist wie ein Bauplan zum Erstellen von Objekten. In diesem Fall repräsentiert die Klasse Stock eine Aktie. Sie hat Attribute (die wie Eigenschaften sind) für den Namen der Aktie, die Anzahl der Anteile und den Preis. Sie hat auch eine Methode (die wie eine Funktion im Zusammenhang mit der Klasse ist), um die Kosten der Aktie zu berechnen.

Als Nächstes untersuchen wir die Datei pcost.py. Wir verwenden erneut den Befehl cat, um ihren Inhalt anzuzeigen.

cat pcost.py

Diese Datei definiert eine Funktion namens portfolio_cost(). Eine Funktion ist ein Codeblock, der eine bestimmte Aufgabe ausführt. Die Funktion portfolio_cost() liest eine Portfolio-Datei und berechnet die Gesamtkosten aller Aktien in diesem Portfolio.

Jetzt schauen wir uns die Beispiel-Portfolio-Daten an. Wir verwenden den Befehl cat, um den Inhalt der Datei portfolio.dat anzuzeigen.

cat portfolio.dat

Diese Datei enthält Aktiendaten in einem einfachen Format. Jede Zeile enthält das Tickersymbol der Aktie, die Anzahl der Anteile und den Preis pro Anteil.

Die Verwendung der import-Anweisung

Python's import-Anweisung ist ein leistungsstarkes Werkzeug, das es Ihnen ermöglicht, Code aus anderen Modulen in Ihrem aktuellen Programm zu verwenden. Es ist wie das Ausleihen von Werkzeugen aus anderen Werkzeugkästen. Üben wir verschiedene Arten, Code zu importieren:

Zunächst müssen wir den Python-Interpreter starten. Der Python-Interpreter ist ein Programm, das Python-Code ausführt. Wir verwenden den folgenden Befehl, um ihn zu starten.

python3

Jetzt importieren wir das Modul pcost und sehen, was passiert. Wenn wir die import-Anweisung verwenden, sucht Python nach der Datei pcost.py und macht den darin enthaltenen Code für uns verfügbar.

import pcost

Sie sollten die Ausgabe 44671.15 sehen. Dies sind die berechneten Kosten des Portfolios aus der Datei portfolio.dat. Wenn das Modul pcost importiert wird, wird der Code am Ende der Datei pcost.py automatisch ausgeführt.

Versuchen wir, die Funktion portfolio_cost() mit einer anderen Portfolio-Datei aufzurufen. Wir verwenden die Syntax pcost.portfolio_cost(), um die Funktion aus dem Modul pcost aufzurufen.

pcost.portfolio_cost('portfolio2.dat')

Die Ausgabe sollte 19908.75 sein, was die Gesamtkosten der Aktien in der zweiten Portfolio-Datei darstellt.

Jetzt importieren wir eine bestimmte Klasse aus dem Modul stock. Anstatt das gesamte Modul zu importieren, können wir einfach die Klasse Stock mit der from...import-Anweisung importieren.

from stock import Stock

Nachdem wir die Klasse Stock importiert haben, können wir ein Stock-Objekt erstellen. Ein Objekt ist eine Instanz einer Klasse. Wir erstellen ein Stock-Objekt mit dem Namen GOOG, 100 Anteilen und einem Preis von 490.10. Dann geben wir den Namen der Aktie aus und berechnen ihre Kosten mit der Methode cost().

s = Stock('GOOG', 100, 490.10)
print(s.name)
print(s.cost())

Die Ausgabe sollte sein:

GOOG
49010.0

Schließlich können wir, wenn wir mit der Verwendung des Python-Interpreters fertig sind, ihn mit der Funktion exit() beenden.

exit()

Dieses Lab hat zwei verschiedene Arten gezeigt, Python-Code zu importieren:

import module_name - Dies importiert das gesamte Modul und macht alle Funktionen, Klassen und Variablen in diesem Modul verfügbar.
from module_name import specific_item - Dies importiert nur ein bestimmtes Element (wie eine Klasse oder eine Funktion) aus dem Modul, was nützlich sein kann, wenn Sie nur einen Teil der Funktionalität des Moduls benötigen.

Das Verständnis des Hauptmoduls (Main Module) in Python

In Python fungiert ein Skript, wenn es direkt ausgeführt wird, als "Hauptmodul" (main module). Python hat eine spezielle Variable namens __name__. Wenn eine Datei direkt ausgeführt wird, setzt Python den Wert von __name__ auf "__main__". Dies unterscheidet sich von dem Fall, wenn die Datei als Modul importiert wird.

Diese Eigenschaft ist sehr nützlich, da sie es Ihnen ermöglicht, Code zu schreiben, der sich je nachdem unterschiedlich verhält, ob die Datei direkt ausgeführt oder importiert wird. Beispielsweise möchten Sie möglicherweise, dass ein bestimmter Code nur ausgeführt wird, wenn Sie die Datei als Skript ausführen, nicht aber, wenn sie von einem anderen Skript importiert wird.

Das Ändern von pcost.py zur Nutzung des Hauptmodul-Musters

Ändern wir das Programm pcost.py, um dieses Muster zu nutzen.

Zunächst müssen Sie die Datei pcost.py im Editor öffnen. Sie können die folgenden Befehle verwenden, um in das Projektverzeichnis zu navigieren und die Datei zu erstellen, falls sie noch nicht existiert:

cd ~/project
touch pcost.py

Der Befehl cd wechselt das aktuelle Verzeichnis in das project-Verzeichnis in Ihrem Home-Verzeichnis. Der Befehl touch erstellt eine neue Datei namens pcost.py, falls sie noch nicht existiert.

Ändern Sie nun die Datei pcost.py so, dass sie wie folgt aussieht:

## pcost.py

def portfolio_cost(filename):
    total_cost = 0.0

    with open(filename, 'r') as f:
        for line in f:
            fields = line.split()
            try:
                nshares = int(fields[1])
                price = float(fields[2])
                total_cost += nshares * price
            except (ValueError, IndexError):
                print(f"Couldn't parse: {line}")

    return total_cost

## Dieser Code wird nur ausgeführt, wenn die Datei als Skript ausgeführt wird
if __name__ == "__main__":
    total = portfolio_cost('portfolio.dat')
    print(total)

Die Hauptänderung besteht darin, dass wir den Code am Ende in eine if __name__ == "__main__":-Bedingung eingebettet haben. Dies bedeutet, dass der Code in diesem Block nur ausgeführt wird, wenn die Datei direkt als Skript ausgeführt wird, nicht wenn sie als Modul importiert wird.

Speichern Sie die Datei nach diesen Änderungen und verlassen Sie den Editor.

Das Testen des geänderten Moduls

Testen wir nun unser geändertes Modul auf zwei verschiedene Arten, um zu sehen, wie es sich verhält.

Führen Sie zunächst das Programm direkt als Skript mit dem folgenden Befehl aus:

python3 pcost.py

Sie sollten die Ausgabe 44671.15 sehen, genau wie zuvor. Dies liegt daran, dass wenn Sie das Skript direkt ausführen, die Variable __name__ auf "__main__" gesetzt wird, sodass der Code im if __name__ == "__main__":-Block ausgeführt wird.

Starten Sie als Nächstes erneut den Python-Interpreter und importieren Sie das Modul:

python3

import pcost

Diesmal sollten Sie keine Ausgabe sehen. Wenn Sie das Modul importieren, wird die Variable __name__ auf "pcost" (der Modulname) gesetzt, nicht auf "__main__". Daher wird der Code im if __name__ == "__main__":-Block nicht ausgeführt.

Um zu überprüfen, ob die Funktion portfolio_cost weiterhin funktioniert, können Sie sie wie folgt aufrufen:

pcost.portfolio_cost('portfolio.dat')

Die Funktion sollte 44671.15 zurückgeben, was bedeutet, dass sie korrekt funktioniert.

Beenden Sie schließlich den Python-Interpreter mit dem folgenden Befehl:

exit()

Dieses Muster ist sehr nützlich, wenn Sie Python-Dateien erstellen, die sowohl als importierbare Module als auch als eigenständige Skripte verwendet werden können. Der Code im if __name__ == "__main__":-Block wird nur ausgeführt, wenn die Datei direkt ausgeführt wird, nicht wenn sie als Modul importiert wird.

Das Erstellen Ihres eigenen Moduls

Nachdem Sie nun verstehen, wie Sie vorhandene Module nutzen können, ist es an der Zeit, ein neues Modul von Grund auf neu zu erstellen. Ein Modul in Python ist eine Datei, die Python-Definitionen und -Anweisungen enthält. Es ermöglicht Ihnen, Ihren Code in wiederverwendbare und verwaltbare Teile zu organisieren. Indem Sie Ihr eigenes Modul erstellen, können Sie verwandte Funktionen und Variablen zusammenfassen, wodurch Ihr Code modularer und leichter wartbar wird.

Das Erstellen eines Berichtsmoduls

Erstellen wir ein einfaches Modul zur Generierung von Aktienberichten. Dieses Modul wird Funktionen haben, um eine Portfolio-Datei zu lesen und einen formatierten Bericht über die Aktien im Portfolio auszugeben.

Zunächst müssen wir eine neue Datei namens report.py erstellen. Dazu verwenden wir die Befehlszeile. Navigieren Sie in das project-Verzeichnis in Ihrem Home-Verzeichnis und erstellen Sie die Datei mit dem Befehl touch.

cd ~/project
touch report.py

Öffnen Sie nun die Datei report.py in Ihrem bevorzugten Texteditor und fügen Sie den folgenden Code hinzu. Dieser Code definiert zwei Funktionen und einen Hauptblock.

## report.py

def read_portfolio(filename):
    """
    Read a stock portfolio file into a list of dictionaries with
    keys: name, shares, price
    """
    portfolio = []
    with open(filename, 'r') as f:
        for line in f:
            fields = line.split()
            try:
                stock = {
                    'name': fields[0],
                    'shares': int(fields[1]),
                    'price': float(fields[2])
                }
                portfolio.append(stock)
            except (ValueError, IndexError):
                print(f"Couldn't parse: {line}")
    return portfolio

def print_report(portfolio):
    """
    Print a report showing the stock name, shares, price, and total value
    """
    print("Name    Shares    Price    Value")
    print("-" * 40)
    total_value = 0.0
    for stock in portfolio:
        value = stock['shares'] * stock['price']
        total_value += value
        print(f"{stock['name']:6s} {stock['shares']:9d} {stock['price']:9.2f} {value:9.2f}")
    print("-" * 40)
    print(f"Total Value: {total_value:16.2f}")

if __name__ == "__main__":
    portfolio = read_portfolio('portfolio.dat')
    print_report(portfolio)

Die Funktion read_portfolio liest eine Datei mit Aktieninformationen und gibt eine Liste von Dictionaries zurück, wobei jedes Dictionary eine Aktie mit den Schlüsseln name, shares und price repräsentiert. Die Funktion print_report nimmt ein Portfolio (eine Liste von Aktien-Dictionaries) und gibt einen formatierten Bericht aus, der den Aktiennamen, die Anzahl der Anteile, den Preis und den Gesamtwert anzeigt. Der Hauptblock am Ende wird ausgeführt, wenn die Datei direkt ausgeführt wird. Er liest die Portfolio-Datei und gibt den Bericht aus.

Speichern Sie nach dem Hinzufügen des Codes die Datei und verlassen Sie den Editor.

Das Testen Ihres Moduls

Testen wir unser neues Modul, um sicherzustellen, dass es wie erwartet funktioniert.

Zunächst führen wir das Skript direkt von der Befehlszeile aus. Dies führt den Hauptblock in der Datei report.py aus.

python3 report.py

Sie sollten einen formatierten Bericht sehen, der die Aktien im Portfolio und ihre Werte anzeigt. Dieser Bericht enthält den Aktiennamen, die Anzahl der Anteile, den Preis und den Gesamtwert, sowie den Gesamtwert des gesamten Portfolios.

Name    Shares    Price    Value
----------------------------------------
AA         100     32.20   3220.00
IBM         50     91.10   4555.00
CAT        150     83.44  12516.00
MSFT       200     51.23  10246.00
GE          95     40.37   3835.15
MSFT        50     65.10   3255.00
IBM        100     70.44   7044.00
----------------------------------------
Total Value:         44671.15

Als Nächstes verwenden wir das Modul aus dem Python-Interpreter. Starten Sie den Python-Interpreter, indem Sie den Befehl python3 im Terminal ausführen.

python3

Sobald der Interpreter läuft, können wir das report-Modul importieren und seine Funktionen nutzen.

import report
portfolio = report.read_portfolio('portfolio.dat')
len(portfolio)  ## Should return 7, the number of stocks
portfolio[0]    ## First stock in the portfolio

Die Anweisung import report macht die in der Datei report.py definierten Funktionen und Variablen in der aktuellen Python-Sitzung verfügbar. Wir verwenden dann die Funktion read_portfolio, um die Portfolio-Datei zu lesen und das Ergebnis in der Variable portfolio zu speichern. Die Anweisung len(portfolio) gibt die Anzahl der Aktien im Portfolio zurück, und portfolio[0] gibt die erste Aktie im Portfolio zurück.

Sie sollten die folgende Ausgabe sehen:

7
{'name': 'AA', 'shares': 100, 'price': 32.2}

Jetzt verwenden wir das importierte Modul, um die Gesamtkosten des Portfolios selbst zu berechnen. Wir gehen die Aktien im Portfolio durch und summieren den Gesamtwert jeder Aktie auf.

total = 0.0
for stock in portfolio:
    total += stock['shares'] * stock['price']
print(total)

Die Ausgabe sollte 44671.15 sein, was dem Gesamtwert entspricht, der von der Funktion print_report ausgegeben wird.

Schließlich erstellen wir einen benutzerdefinierten Bericht für einen bestimmten Aktientyp. Wir filtern das Portfolio, um nur die IBM-Aktien einzuschließen, und verwenden dann die Funktion print_report, um einen Bericht für diese Aktien auszugeben.

ibm_stocks = [stock for stock in portfolio if stock['name'] == 'IBM']
report.print_report(ibm_stocks)

Dies sollte einen Bericht ausgeben, der nur die IBM-Aktien und ihre Werte zeigt.

Name    Shares    Price    Value
----------------------------------------
IBM         50     91.10   4555.00
IBM        100     70.44   7044.00
----------------------------------------
Total Value:         11599.00

Wenn Sie mit dem Testen fertig sind, beenden Sie den Python-Interpreter, indem Sie den Befehl exit() ausführen.

exit()

Sie haben nun erfolgreich Ihr eigenes Python-Modul erstellt und verwendet, das sowohl Funktionen als auch einen Hauptblock kombiniert, der nur ausgeführt wird, wenn die Datei direkt ausgeführt wird. Dieser modulare Ansatz beim Programmieren ermöglicht es Ihnen, Code wiederzuverwenden und Ihre Projekte besser zu organisieren und zu warten.

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Konzepte von Python-Modulen gelernt und erfahren, wie Sie sie zur Codeorganisation nutzen können. Module sind Python-Dateien mit wiederverwendbarem Code, und die import-Anweisung ermöglicht es Ihnen, Code aus anderen Modulen in Ihrem Programm zu nutzen. Das Muster if __name__ == "__main__" ermöglicht es Dateien, sowohl als importierbare Module als auch als eigenständige Skripte zu fungieren.

Diese Konzepte sind von entscheidender Bedeutung für das Schreiben von wartbarem Python-Code, insbesondere bei der Entwicklung größerer Anwendungen. Wenn Sie weiterhin Python lernen, denken Sie daran, dass Module helfen, verwandten Code zu gruppieren, das Importieren spezifischer Elemente den Namensraum sauber hält und das Hauptmodul-Muster eine bewährte Methode ist. Die Anwendung dieser Techniken wird Ihren Code organisierter, wartbarer und wiederverwendbarer machen.