Wie man prüft, ob ein Objekt in Python aufrufbar ist

Einführung

In diesem Lab werden Sie untersuchen, wie Sie feststellen können, ob ein Objekt in Python aufrufbar (callable) ist. Sie beginnen damit, zu verstehen, was ein aufrufbares Objekt ausmacht, einschließlich Funktionen, Methoden und Klassen mit der __call__-Methode. Anhand praktischer Beispiele werden Sie lernen, aufrufbare Objekte zu identifizieren und ihr Verhalten beim Aufruf zu beobachten.

Das Lab wird Sie durch das Erstellen einer Python-Datei namens callable_example.py führen und Sie durch Codeausschnitte führen, die aufrufbare Funktionen und Klassen demonstrieren. Sie werden die Ausgabe dieser Beispiele beobachten, um Ihr Verständnis davon zu festigen, wie aufrufbare Objekte in Python funktionieren. Anschließend wird das Lab die callable()-Funktion einführen, um explizit die Aufrufbarkeit eines Objekts zu prüfen.

Skills Graph

Aufrufbare Objekte verstehen

In diesem Schritt werden Sie sich mit aufrufbaren Objekten in Python vertraut machen. Das Verständnis von aufrufbaren Objekten ist entscheidend für die Arbeit mit Funktionen, Klassen und anderen Objekten, die aufgerufen werden können.

In Python ist ein aufrufbares Objekt jedes Objekt, das mit der Funktionsaufruf-Syntax () aufgerufen werden kann. Dazu gehören Funktionen, Methoden, Klassen und Instanzen von Klassen, die die __call__-Methode definieren.

Beginnen wir mit der Untersuchung einer einfachen Funktion:

def my_function():
    return "Hello from my_function!"

print(my_function())

Erstellen Sie mit dem VS Code-Editor eine Datei namens callable_example.py in Ihrem ~/project-Verzeichnis. Kopieren Sie den obigen Code und fügen Sie ihn in die Datei ein.

Führen Sie nun das Skript mit dem folgenden Befehl im Terminal aus:

python callable_example.py

Sie sollten die folgende Ausgabe sehen:

Hello from my_function!

Hier ist my_function ein aufrufbares Objekt, da Sie es mit Klammern () aufrufen können.

Schauen wir uns nun ein weiteres Beispiel mit einer Klasse an:

class MyClass:
    def __init__(self, name):
        self.name = name

    def __call__(self):
        return f"Hello from {self.name}!"

instance = MyClass("MyClass instance")
print(instance())

Fügen Sie diesen Code in Ihre callable_example.py-Datei ein und ersetzen Sie den vorherigen Inhalt.

Führen Sie das Skript erneut aus:

python callable_example.py

Sie sollten die folgende Ausgabe sehen:

Hello from MyClass instance!

In diesem Fall ist MyClass aufrufbar, da es die __call__-Methode definiert. Wenn Sie eine Instanz von MyClass erstellen und sie wie eine Funktion aufrufen (instance()), wird die __call__-Methode ausgeführt.

Aufrufbare Objekte sind grundlegend für die Flexibilität von Python und werden in verschiedenen Programmierparadigmen, einschließlich funktionaler Programmierung und objektorientierter Programmierung, häufig verwendet.

Die callable()-Funktion verwenden

In diesem Schritt werden Sie lernen, wie Sie die callable()-Funktion in Python verwenden, um zu prüfen, ob ein Objekt aufrufbar ist. Die callable()-Funktion ist eine eingebaute Funktion, die True zurückgibt, wenn das ihr übergebene Objekt aufrufbar scheint, und False sonst.

Beginnen wir mit einem einfachen Beispiel, das eine Funktion und eine Variable verwendet:

def my_function():
    return "Hello from my_function!"

x = 10

print(callable(my_function))
print(callable(x))

Fügen Sie diesen Code in Ihre callable_example.py-Datei ein und ersetzen Sie den vorherigen Inhalt.

Führen Sie nun das Skript mit dem folgenden Befehl im Terminal aus:

python callable_example.py

Sie sollten die folgende Ausgabe sehen:

True
False

Hier gibt callable(my_function) True zurück, weil my_function eine Funktion ist und somit aufrufbar. callable(x) gibt False zurück, weil x eine Ganzzahlvariable ist und nicht aufrufbar.

Schauen wir uns nun ein weiteres Beispiel mit einer Klasse an:

class MyClass:
    def __init__(self, name):
        self.name = name

    def __call__(self):
        return f"Hello from {self.name}!"

instance = MyClass("MyClass instance")

print(callable(MyClass))
print(callable(instance))

Fügen Sie diesen Code in Ihre callable_example.py-Datei ein und ersetzen Sie den vorherigen Inhalt.

Führen Sie das Skript erneut aus:

python callable_example.py

Sie sollten die folgende Ausgabe sehen:

True
True

In diesem Fall gibt callable(MyClass) True zurück, weil MyClass eine Klasse ist und somit aufrufbar (Sie können Instanzen von ihr erstellen). callable(instance) gibt ebenfalls True zurück, weil instance eine Instanz von MyClass ist und MyClass die __call__-Methode definiert, wodurch seine Instanzen aufrufbar werden.

Die callable()-Funktion ist nützlich, um zu prüfen, ob ein Objekt aufgerufen werden kann, bevor Sie es versuchen, was helfen kann, Fehler in Ihrem Code zu vermeiden.

Testen mit try-except für Aufrufe

In diesem Schritt werden Sie lernen, wie Sie try-except-Blöcke verwenden, um potenzielle Fehler beim Aufrufen von Objekten in Python zu behandeln. Dies ist besonders nützlich, wenn Sie nicht sicher sind, ob ein Objekt aufrufbar ist oder ob sein Aufruf eine Ausnahme auslösen könnte.

Beginnen wir mit einem Beispiel, in dem wir versuchen, ein Objekt aufzurufen, das möglicherweise nicht aufrufbar ist:

def my_function():
    return "Hello from my_function!"

x = 10

objects_to_test = [my_function, x]

for obj in objects_to_test:
    try:
        result = obj()
        print(f"Object is callable, result: {result}")
    except TypeError as e:
        print(f"Object is not callable: {e}")

Fügen Sie diesen Code in Ihre callable_example.py-Datei ein und ersetzen Sie den vorherigen Inhalt.

Führen Sie nun das Skript mit dem folgenden Befehl im Terminal aus:

python callable_example.py

Sie sollten die folgende Ausgabe sehen:

Object is callable, result: Hello from my_function!
Object is not callable: 'int' object is not callable

In diesem Beispiel iterieren wir durch eine Liste von Objekten und versuchen, jedes Objekt aufzurufen. Der try-Block versucht, das Objekt aufzurufen. Wenn das Objekt aufrufbar ist und der Aufruf erfolgreich ist, wird das Ergebnis ausgegeben. Wenn das Objekt nicht aufrufbar ist, wird ein TypeError ausgelöst, und der except-Block fängt die Ausnahme ab und gibt eine entsprechende Nachricht aus.

Betrachten wir nun einen Fall, in dem das Objekt aufrufbar ist, aber sein Aufruf eine andere Art von Ausnahme auslösen könnte:

def my_function(a, b):
    return a / b

try:
    result = my_function(10, 0)
    print(f"Result: {result}")
except ZeroDivisionError as e:
    print(f"Error: {e}")
except TypeError as e:
    print(f"Error: {e}")

Fügen Sie diesen Code in Ihre callable_example.py-Datei ein und ersetzen Sie den vorherigen Inhalt.

Führen Sie das Skript erneut aus:

python callable_example.py

Sie sollten die folgende Ausgabe sehen:

Error: division by zero

In diesem Fall ist my_function aufrufbar, aber der Aufruf mit b = 0 löst einen ZeroDivisionError aus. Der try-except-Block fängt diese spezifische Ausnahme ab und behandelt sie gracefully.

Die Verwendung von try-except-Blöcken ermöglicht es Ihnen, robusteres und zuverlässigeres Code zu schreiben, indem Sie potenzielle Fehler, die beim Aufrufen von Objekten auftreten können, antizipieren und behandeln.

Zusammenfassung

In diesem Lab haben Sie sich mit aufrufbaren Objekten in Python vertraut gemacht. Aufrufbare Objekte sind solche, die mit der Funktionsaufruf-Syntax () aufgerufen werden können. Dazu gehören Funktionen, Methoden, Klassen und Instanzen von Klassen, die die __call__-Methode definieren. Sie haben Beispiele sowohl für eine einfache Funktion als auch für eine Klasse mit der __call__-Methode untersucht und gesehen, wie diese aufgerufen und ausgeführt werden können.

Sie haben auch gelernt, wie Sie die callable()-Funktion verwenden können, um zu prüfen, ob ein Objekt aufrufbar ist.