Wie man prüft, ob eine Funktion in Python bestimmte Argumente akzeptiert

Einführung

In diesem Lab lernen Sie, wie Sie überprüfen können, ob eine Python-Funktion bestimmte Argumente akzeptiert, indem Sie die Funktionssignaturen untersuchen. Das Lab nutzt das Modul inspect, um auf Funktionssignaturen zuzugreifen und diese zu untersuchen. Dadurch erhalten Sie wertvolle Informationen über die erwarteten Argumente und Rückgabewerte einer Funktion.

Das Lab führt Sie durch den Prozess der Erstellung eines Python-Skripts mit einer Beispiel-Funktion. Anschließend verwenden Sie inspect.signature(), um die Signatur der Funktion zu erhalten und auszugeben. Sie lernen auch, wie Sie die Ausgabe interpretieren, um die Parameter und den Rückgabetyp der Funktion zu verstehen. Abschließend wird gezeigt, wie Sie das Übergeben von Argumenten mit try-except-Blöcken testen können.

Skills Graph

Funktionssignaturen kennenlernen

In diesem Schritt lernen Sie die Funktionssignaturen in Python kennen. Funktionssignaturen liefern wertvolle Informationen über die erwarteten Argumente und Rückgabewerte einer Funktion. Das Verständnis von Funktionssignaturen ist entscheidend für das Schreiben von sauberem, wartbarem und fehlerfreiem Code.

Eine Funktionssignatur enthält die folgenden Informationen:

• Funktionsname: Der Name der Funktion.
• Parameter: Die Namen und Typen der Argumente, die die Funktion akzeptiert.
• Rückgabetyp: Der Typ des Werts, den die Funktion zurückgibt (falls vorhanden).

Python bietet mehrere Möglichkeiten, auf Funktionssignaturen zuzugreifen und diese zu untersuchen. Eine der gebräuchlichsten und leistungsstärksten Methoden ist die Verwendung des Moduls inspect. Lassen Sie uns untersuchen, wie man das Modul inspect verwendet, um Funktionssignaturen zu verstehen.

Zunächst erstellen wir ein einfaches Python-Skript namens my_function.py in Ihrem ~/project-Verzeichnis mit dem VS Code-Editor. In diesem Skript wird eine Funktion definiert und anschließend das Modul inspect verwendet, um ihre Signatur zu untersuchen.

## filename: ~/project/my_function.py
import inspect

def add_numbers(x: int, y: int) -> int:
    """This function adds two numbers and returns the result."""
    return x + y

sig = inspect.signature(add_numbers)

print(sig)

In diesem Skript:

• Wir importieren das Modul inspect.
• Wir definieren eine Funktion namens add_numbers, die zwei Ganzzahl-Argumente (x und y) akzeptiert und deren Summe als Ganzzahl zurückgibt.
• Wir verwenden Typ-Hinweise (x: int, y: int, -> int), um die erwarteten Typen der Argumente und des Rückgabewerts anzugeben.
• Wir verwenden inspect.signature(), um die Signatur der Funktion add_numbers zu erhalten und sie in der Variablen sig zu speichern.
• Wir geben die Signatur in der Konsole aus.

Jetzt führen wir das Skript mit dem Befehl python aus:

python ~/project/my_function.py

Sie sollten die folgende Ausgabe sehen:

(x: int, y: int) -> int

Diese Ausgabe repräsentiert die Signatur der Funktion add_numbers. Sie zeigt, dass die Funktion zwei Parameter, x und y, akzeptiert, die beide als Ganzzahlen erwartet werden, und dass die Funktion eine Ganzzahl zurückgibt.

Das Verständnis von Funktionssignaturen hilft Ihnen, Funktionen korrekt zu verwenden und häufige Fehler zu vermeiden. In den nächsten Schritten lernen Sie mehr darüber, wie Sie das Modul inspect nutzen können, um detaillierte Informationen aus Funktionssignaturen zu extrahieren.

Verwendung von inspect.signature()

Im vorherigen Schritt haben Sie gelernt, wie Sie die Signatur einer Funktion mit inspect.signature() erhalten. In diesem Schritt werden Sie näher untersuchen, wie Sie das Signatur-Objekt nutzen können, um detailliertere Informationen über die Parameter der Funktion zu extrahieren.

Die Funktion inspect.signature() gibt ein Signature-Objekt zurück, das mehrere nützliche Attribute und Methoden zum Untersuchen der Parameter der Funktion hat. Lassen Sie uns das Skript my_function.py ändern, um diese Funktionen zu erkunden.

Öffnen Sie die Datei my_function.py in Ihrem ~/project-Verzeichnis mit dem VS Code-Editor und ändern Sie sie wie folgt:

## filename: ~/project/my_function.py
import inspect

def add_numbers(x: int, y: int = 10) -> int:
    """This function adds two numbers and returns the result."""
    return x + y

sig = inspect.signature(add_numbers)

for param in sig.parameters.values():
    print(f"Parameter Name: {param.name}")
    print(f"Parameter Default: {param.default}")
    print(f"Parameter Annotation: {param.annotation}")
    print(f"Parameter Kind: {param.kind}")
    print("-" * 20)

In diesem geänderten Skript:

• Wir haben dem Parameter y einen Standardwert von 10 hinzugefügt (y: int = 10).
• Wir iterieren über das parameters-Attribut des Signature-Objekts, das ein geordnetes Wörterbuch von Parameter-Objekten ist.
• Für jedes Parameter-Objekt geben wir seine Attribute name, default, annotation und kind aus.

Jetzt führen Sie das Skript mit dem Befehl python aus:

python ~/project/my_function.py

Sie sollten die folgende Ausgabe sehen:

Parameter Name: x
Parameter Default: <class 'inspect._empty'>
Parameter Annotation: <class 'int'>
Parameter Kind: POSITIONAL_OR_KEYWORD
--------------------
Parameter Name: y
Parameter Default: 10
Parameter Annotation: <class 'int'>
Parameter Kind: POSITIONAL_OR_KEYWORD
--------------------

Lassen Sie uns die Ausgabe analysieren:

• Parameter Name: Der Name des Parameters (x und y).
• Parameter Default: Der Standardwert des Parameters. Wenn ein Parameter keinen Standardwert hat, ist dies inspect._empty.
• Parameter Annotation: Die Typ-Annotation des Parameters (z.B. <class 'int'>).
• Parameter Kind: Die Art des Parameters, die POSITIONAL_OR_KEYWORD, VAR_POSITIONAL, VAR_KEYWORD, KEYWORD_ONLY oder POSITIONAL_ONLY sein kann. In diesem Fall sind sowohl x als auch y POSITIONAL_OR_KEYWORD, was bedeutet, dass sie als Positions- oder Schlüsselwort-Argumente übergeben werden können.

Durch die Verwendung von inspect.signature() können Sie ein tieferes Verständnis der Parameter einer Funktion und ihrer Eigenschaften erlangen. Diese Informationen sind wertvoll für das Schreiben von Code, der korrekt mit Funktionen interagiert, und für die effektive Dokumentation Ihres Codes.

Testen der Argumentübergabe mit try-except

In diesem Schritt lernen Sie, wie Sie try-except-Blöcke verwenden können, um potenzielle Fehler beim Übergeben von Argumenten an eine Funktion zu behandeln. Dies ist besonders wichtig, wenn Sie mit Benutzereingaben oder externen Daten arbeiten, bei denen der Datentyp oder das Format möglicherweise nicht dem entspricht, was die Funktion erwartet.

Lassen Sie uns das Skript my_function.py ändern, um die Fehlerbehandlung mit try-except einzubeziehen. Wir werden versuchen, die Funktion add_numbers mit ungültigen Argumenten aufzurufen und die resultierende TypeError-Ausnahme abzufangen.

Öffnen Sie die Datei my_function.py in Ihrem ~/project-Verzeichnis mit dem VS Code-Editor und ändern Sie sie wie folgt:

## filename: ~/project/my_function.py
import inspect

def add_numbers(x: int, y: int = 10) -> int:
    """This function adds two numbers and returns the result."""
    return x + y

try:
    result = add_numbers("hello", 5)
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

try:
    result = add_numbers(5, "world")
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

try:
    result = add_numbers(5, 5)
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

In diesem geänderten Skript:

• Wir umschließen die Aufrufe von add_numbers in try-except-Blöcken.
• Wir versuchen, add_numbers mit einer Zeichenkette als erstes Argument und einer Ganzzahl als zweites Argument aufzurufen.
• Wir versuchen, add_numbers mit einer Ganzzahl als erstes Argument und einer Zeichenkette als zweites Argument aufzurufen.
• Wir versuchen, add_numbers mit zwei Ganzzahlen als Argumente aufzurufen.
• Wenn ein TypeError auftritt (was passiert, wenn wir eine Zeichenkette anstelle einer Ganzzahl übergeben), fangen wir die Ausnahme ab und geben eine Fehlermeldung aus.
• Wenn kein TypeError auftritt, geben wir das Ergebnis des Funktionsaufrufs aus.

Jetzt führen Sie das Skript mit dem Befehl python aus:

python ~/project/my_function.py

Sie sollten die folgende Ausgabe sehen:

Error: unsupported operand type(s) for +: 'str' and 'int'
Error: unsupported operand type(s) for +: 'int' and 'str'
Result: 10

Diese Ausgabe zeigt, wie try-except-Blöcke verwendet werden können, um Fehler, die beim Übergeben von ungültigen Argumenten an eine Funktion auftreten, elegant zu behandeln. Die ersten beiden Aufrufe von add_numbers führen zu TypeError-Ausnahmen, die von den except-Blöcken abgefangen und behandelt werden. Der dritte Aufruf von add_numbers mit zwei Ganzzahlen wird erfolgreich ausgeführt, und das Ergebnis wird ausgegeben.

Die Verwendung von try-except-Blöcken ist eine bewährte Methode für das Schreiben von robustem und zuverlässigem Code. Sie ermöglicht es Ihnen, potenzielle Fehler vorherzusehen und sie so zu behandeln, dass Ihr Programm nicht abstürzt.

Zusammenfassung

In diesem Lab lernen Sie über Funktionssignaturen in Python und wie sie Informationen über die erwarteten Argumente und Rückgabewerte einer Funktion liefern. Das Verständnis von Funktionssignaturen ist entscheidend für das Schreiben von sauberem und wartbarem Code.

Das Lab zeigt, wie Sie das inspect-Modul, insbesondere die Funktion inspect.signature(), verwenden können, um die Signatur einer Python-Funktion abzurufen und zu untersuchen. Sie erstellen eine einfache Funktion mit Typ-Hints und verwenden dann inspect.signature(), um die Signatur der Funktion in der Konsole auszugeben, wodurch die erwarteten Argumenttypen und der Rückgabetyp angezeigt werden.