So rufen Sie eine Funktion in Python auf: Der ultimative Leitfaden

Funktionen sind ein wesentliches Konzept in der Programmierung, mit dem Sie Codeblöcke verwalten und wiederverwenden können. Zu wissen, wie man eine Funktion in Python aufruft, ist eine Schlüsselkompetenz, die es zu erlernen gilt.

In diesem Tutorial lernen Sie die Grundlagen des Aufrufs von Funktionen kennen und erhalten einige Tipps zum Schreiben von effizientem, leichter verständlichem Code.

Durch die Beherrschung der Funktionen können Sie nicht nur vielseitigeren Code erstellen, sondern auch Ihren Programmierprozess rationalisieren und Ihre Gesamteffizienz als Entwickler verbessern.

Funktionen unterliegen den gleichen Grundprinzipien. Sobald Sie Funktionen in Python beherrschen, können Sie Ihr Verständnis von Funktionen im Vergleich zu anderen Programmiersprachen wie Java, R, JavaScript, PHP usw. erweitern.

Inhaltsverzeichnis

• Was ist eine Funktion?
• Definieren einer Funktion in Python
  • Funktionssyntax
  • Parameter und Argumente
    • Das Kwargs-Argument
• Aufrufen einer Funktion
  • Grundlegender Funktionsaufruf
  • Positionsargumente
  • Schlüsselwortargumente
• Rückgabewerte
  • Einzelner Rückgabewert
  • Mehrere Rückgabewerte
• Übergeben von Python-Funktionen als Argumente
• Verschachtelte Funktionen
• Lambda-Funktionen
• Rekursion
• Häufige Fehler und Fehlerbehebung
• Abschluss

Was ist eine Funktion?

Mit einer Funktion in Python können Sie wiederverwendbare Codeteile erstellen, die im gesamten Programm aufgerufen werden können, wodurch Ihr Code vereinfacht und die Lesbarkeit verbessert wird. Es führt eine bestimmte Aufgabe oder einen bestimmten Aufgabensatz aus und kann innerhalb eines Programms mehrmals aufgerufen werden. 

Definieren einer Funktion in Python

In Python gibt es zwei Hauptkategorien von Funktionen:

• Benutzerdefinierte Funktionen: Funktionen, die ein Programmierer definiert, um Wiederholungen von Code zu vermeiden
• Integrierte Funktionen : Funktionen, die von jemand anderem definiert werden und nach der Installation der erforderlichen Pakete in Ihrem Code verwendet werden können

Dieser Abschnitt des Python-Tutorials konzentriert sich auf benutzerdefinierte Funktionen. Du wirst lernen:

• So definieren Sie eine Funktion in Python
• Die Funktionssyntax
• Verwendung von Parametern und Argumenten

Funktionssyntax

Mit dem def Schlüsselwort, gefolgt vom Funktionsnamen und Klammern, können Sie eine Funktion in Python definieren. Der Funktionskörper ist eingerückt und enthält den Code, der beim Aufruf der Funktion ausgeführt werden soll. Nachfolgend finden Sie ein Beispiel für eine Grundfunktion in Python:

def Greet(): print("Hallo Welt!") Greet()

Das def Schlüsselwort definiert eine neue Funktion mit dem Namengreet. Die dritte Codezeile ruft die Funktion auf, die den Code innerhalb der Funktion ausführt.

Die printZeile im obigen Code ist ebenfalls eine Funktion. Wenn Sie jedoch in einer Python 2-Umgebung arbeiten, wird es als Anweisung definiert. Später, in Python 3, wurde es von einer Anweisung in eine Funktion geändert.

Parameter und Argumente

Parameter sind die Platzhalter in der Funktionsdefinition, während Argumente die Werte sind, die beim Aufruf der Funktion übergeben werden.

Um Parameter anzugeben, fügen Sie diese in die Klammern der Funktionsdefinition ein, getrennt durch Kommas, wenn mehrere Parameter vorhanden sind. Wenn Sie eine Funktion aufrufen, stellen Sie die als Argumente bezeichneten Eingabewerte bereit. Das folgende Beispiel zeigt die Definition einer Funktion, die zwei Parameter annimmt:

def add_numbers(a, b): a+b zurückgeben

Die return Anweisung im Funktionskörper gibt die Addition der beiden übergebenen Argumente zurück. Man kann es sich wie einen Taschenrechner vorstellen, bei dem man Werte eingibt und im Gegenzug das gewünschte Ergebnis erhält.

Nachdem wir die Funktion definiert haben, können wir sie mit Argumenten unserer Wahl aufrufen.

add_numbers(3, 5)

Das Kwargs-Argument

kwargs ist die Abkürzung für „Schlüsselwortargumente“ in Python. Sie können damit die Flexibilität einer Funktion erweitern, indem Sie dem Aufrufer erlauben, beim Aufruf der Funktion eine beliebige Anzahl von Schlüsselwortargumenten anzugeben. Die Schlüsselwortargumente werden als Wörterbuch an die Funktion übergeben.

In einer Funktionsdefinition können Sie die **Syntax mit einem doppelten Sternchen vor dem Parameternamen verwenden, um Schlüsselwortargumente zu akzeptieren.

def my_function(**kwargs): für Schlüssel, Wert in kwargs.items(): print(f"{key} = {value}") my_function(a=1, b=2, c=3)

In diesem Beispiel kwargs handelt es sich um ein Wörterbuch, das die an die Funktion übergebenen Schlüsselwortargumente enthält. Die Ausgabe ist im Bild unten dargestellt:

Aufrufen einer Funktion

Beim Aufrufen einer Funktion wird der Code im Funktionskörper ausgeführt. In Python gibt es vier Arten von Funktionsaufrufen:

• Grundlegender Funktionsaufruf
• Aufruf mit Positionsargumenten
• Aufruf mit Schlüsselwortargumenten

Grundlegender Funktionsaufruf

Ein einfacher Funktionsaufruf ruft die Funktion auf, ohne Argumente an die Funktion zu übergeben. Nachdem Sie eine Funktion definiert haben, können Sie sie aufrufen, indem Sie ihren Namen gefolgt von Klammern verwenden.

Wenn die Funktion keine Argumente akzeptiert, sind die Klammern leer. Der folgende Code ist ein Beispiel für eine Grundfunktion.

def Welcome_message(): print("Willkommen bei LuckyTemplates!") Welcome_message()

Wenn Sie den obigen Code ausführen, erhalten Sie die folgende Ausgabe:

Positionsargumente

Positionsargumente sind der häufigste Argumenttyp und werden in derselben Reihenfolge an die Funktion übergeben, in der sie angegeben werden. Das Folgende ist ein Beispiel für einen Funktionsaufruf mit Positionsargumenten:

def Welcome_message(Name): print(f"Willkommen bei LuckyTemplates, {Name}!") Welcome_Message("John")

Im obigen Beispiel welcome_message()benötigt die Funktion ein Argument, name. Wenn Sie diese Funktion mit dem Argument aufrufen John, wird die Nachricht neben dem Namen gedruckt.

Der obige Code liefert die folgende Ausgabe:

Schlüsselwortargumente

Eine andere Möglichkeit, Argumente an eine Funktion zu übergeben, ist die Verwendung von Schlüsselwortargumenten. Mit Schlüsselwortargumenten können Sie den Namen des Parameters zusammen mit seinem Wert angeben, wodurch der Code besser lesbar wird und die Wahrscheinlichkeit verringert wird, dass Argumente in der falschen Reihenfolge übergeben werden. 

Das folgende Beispiel verwendet Schlüsselwortargumente, um die welcome_messageFunktion aufzurufen:

def Welcome_message(name, message='Willkommen bei LuckyTemplates!'): print(message, name) Welcome_message(name='Alice', message='Guten Morgen')

In diesem Beispiel haben wir eine Funktion definiert welcome_message(), die zwei Parameter hat, nameund message. Der Nachrichtenparameter hat das Standardargument Welcome to LuckyTemplates!Beim Aufruf der Funktion verwenden wir Schlüsselwortargumente, um den Wert zu übergeben John, was zur Ausgabe führtWelcome to LuckyTemplates! John.

Rückgabewerte

Wenn Sie mit Funktionen arbeiten, möchten Sie häufig das Ergebnis von Operationen innerhalb des Funktionskörpers zurückgeben. Rückgabewerte ermöglichen es einer Funktion, ein Ergebnis an den Aufrufer zurückzusenden. Wenn Sie verstehen, wie Sie mit einzelnen und mehreren Rückgabewerten arbeiten, können Sie die Funktionalität Ihrer Python-Programme verbessern.

Einzelner Rückgabewert

Eine einzelne Rückgabewertfunktion gibt einen Wert aus den Operationen in einer Funktion zurück.

Nachfolgend finden Sie ein Beispiel für eine einzelne Rückgabewertfunktion:

def get_greeting(name): return „Hallo, „ + Name + „!“ Greeting = get_greeting("Alice") print(greeting)

Im obigen Beispiel get_greetingübernimmt die Funktion einen Namen, während ihr Funktionsargument ihn kompiliert und eine personalisierte Begrüßung zurückgibt. Der Rückgabewert wird dann in der Variablen Greeting gespeichert und auf der Konsole ausgegeben.

Mehrere Rückgabewerte

Manchmal müssen Sie von einer Funktion in Python mehr als einen Wert zurückgeben. Um dies zu erreichen, können Sie ein Tupel oder eine Liste verwenden, um die Rückgabewerte zu umschließen.

Im Folgenden finden Sie ein Beispiel für eine Funktion mit mehreren Rückgabewerten in der Programmiersprache Python.

def get_name_and_age(): return ("John", 30) name, age = get_name_and_age() print(name) print(age)

In diesem Beispiel get_name_and_agehandelt es sich um eine Funktion, die ein Tupel mit zwei Werten zurückgibt: a name und an age.

Sie können auch eine Werteliste von einer Funktion in Python zurückgeben . Die folgende Funktion zeigt einen Listenrückgabewert einer Funktion.

def berechne_areas(höhe, breite): return [Höhe * Breite, (Höhe * Breite) / 2] Fläche, dreieck_area = berechne_areas(10, 5) print(area) print(triangle_area)

In diesem Fall nimmt die Funktion calculate_areaszwei Argumente an, height, und width, und gibt eine Liste zurück, die die Fläche eines Rechtecks ​​und die Fläche eines Dreiecks enthält.

Übergeben von Python-Funktionen als Argumente

Mit Python können Sie Funktionen als Argumente an andere Funktionen übergeben. Wenn eine Funktion eine andere Funktion als Argument akzeptiert, wird sie als Funktion höherer Ordnung bezeichnet.

Der folgende Code ist ein Beispiel für die Übergabe einer Funktion an eine andere Funktion in Python:

def Quadrat(x): Rückgabe x * x def Doppelt(x): Rückgabe x * 2 def apply_func(func, x): Rückgabe func(x) Ergebnis = apply_func(Quadrat, 5)

Verschachtelte Funktionen

Verschachtelte Funktionen sind Funktionen, die innerhalb einer anderen Funktion definiert sind und auch als innere Funktionen bezeichnet werden. Diese können beim Erstellen von Abschlüssen und modularem Code nützlich sein. 

Um eine verschachtelte Funktion zu erstellen, definieren Sie einfach eine Funktion innerhalb einer anderen Funktion:

def äußere_Funktion(x, y): def innere_Funktion(z): Rückgabe x + y + z Ergebnis = innere_Funktion(3) Rückgabeergebnis # Rufen Sie die äußere Funktion auf print(outer_function(1, 2))

Im obigen Beispiel ist die inner_function innerhalb der external_function definiert. Die innere Funktion hat Zugriff auf die Variablen der äußeren Funktion und kann so Operationen an ihnen ausführen.

Lambda-Funktionen

Lambda-Funktionen, auch anonyme Funktionen genannt, sind eine Möglichkeit, kleine, einmalig verwendbare Funktionen in Python zu erstellen. In Data-Science-Projekten arbeiten Sie häufig mit Lambda-Funktionen, um effiziente Datenstrukturen und Pipelines zu erstellen.

Um eine Lambda-Funktion zu erstellen, können Sie das Schlüsselwort lambda gefolgt von einer Liste von Argumenten, einem Doppelpunkt und dann einem Ausdruck verwenden. Der Ausdruck ist das, was die Lambda-Funktion zurückgibt, sobald sie aufgerufen wird. Das Folgende ist ein Beispiel einer Lambda-Funktion in Python:

add = lambda a, b: a + b result = add(3, 4) print(result) # Ausgabe: 7

Im obigen Beispiel haben wir eine Lambda-Funktion erstellt, die zwei Argumente ( a und b) akzeptiert und deren Summe zurückgibt. Wir haben diese Lambda-Funktion einer Variablen namens zugewiesen add.

Lambda kann in den folgenden Szenarien nützlich sein:

• Als Argumente für Funktionen höherer Ordnung wie map(), filter() und sorted().
• Als Schlüsselfunktionen beim Sortieren von Listen oder Wörterbüchern.

Das folgende Beispiel zeigt die Verwendung der Funktion filter() höherer Ordnung mit Lambda:

zahlen = [1, 2, 3, 4, 5, 6, 7, 8, 9] even_numbers = list(filter(lambda x: x % 2 == 0, zahlen)) print(even_numbers) # Ausgabe: [2, 4, 6, 8]

In diesem Beispiel haben wir eine Lambda-Funktion verwendet, um die Filterkriterien für die Funktion filter() zu definieren. Die Lambda-Funktion prüft, ob eine Zahl gerade ist, und die Funktion filter() gibt eine neue Liste zurück, die nur die geraden Zahlen enthält.

Um ein Beispiel dafür zu sehen, wie Funktionen in verschiedenen Data-Science-Szenarien nützlich sein können, sehen Sie sich das folgende Video an:

Rekursion

Rekursion ist eine Technik in der Programmierung, bei der sich eine Funktion selbst aufruft. Dies kann eine nützliche Möglichkeit sein, komplexe Probleme zu lösen, indem man sie in kleinere, identische Teilprobleme zerlegt.

Beim Erstellen einer rekursiven Funktion müssen Sie zwei Dinge beachten: den Basisfall und den rekursiven Fall. 

• Der Basisfall ist die Bedingung, die die Rekursion stoppt
• Im rekursiven Fall ruft sich die Funktion selbst auf. Der rekursive Fall fungiert als Iterator für die Funktion

Das folgende Beispiel demonstriert rekursive Funktionen in Python:

def Fakultät(n): wenn n == 1: Rückgabe 1 Rückgabe n * Fakultät(n - 1) Fakultät(5)

In diesem Beispiel ist der Basisfall when n == 1und die Funktion gibt zurück 1. Der rekursive Fall tritt auf, wenn n ungleich 1 ist und die Funktion sich selbst mit aufruft n - 1.

Häufige Fehler und Fehlerbehebung

Wenn Sie ein Programmieranfänger sind, werden Sie bei der Implementierung von Funktionen wie rekursiven und Lambda-Funktionen häufig auf Fehler stoßen. In den folgenden Abschnitten werden einige häufige Fehler und Tipps zur Fehlerbehebung aufgeführt, damit Sie diese effizient beheben können.

1. TypeError: fehlt ein erforderliches Argument : Dieser Fehler tritt auf, wenn Sie nicht die richtige Anzahl von Argumenten angeben, die die Funktion erwartet.

def my_function(fname, lname): print(fname, lname) # Korrekter Aufruf von my_function("John", "Doe") # Löst einen Fehler aus my_function("John")

Um diesen Fehler zu beheben, stellen Sie sicher, dass Sie die richtige Anzahl von Argumenten an Ihre Funktion übergeben.

2. TypeError: nicht unterstützter Operandentyp . Dieser Fehler kann auftreten, wenn Sie versuchen, einen Operator mit inkompatiblen Typen zu verwenden.

def add_number(a, b): return a + b # Korrektes Aufrufergebnis = add_number(5, 3) print(result) # Wird aufgrund falscher Argumente einen Fehler auslösen result = add_number("5", 3) print(result)

Um diesen Fehler zu beheben, überprüfen Sie, ob Ihre Funktionen die richtigen Datentypen verarbeiten, und erwägen Sie gegebenenfalls die Verwendung einer Typumwandlung

3. NameError: Name 'Funktionsname' ist nicht definiert : Dieser Fehler deutet darauf hin, dass die Funktion vor dem Aufruf nicht definiert wurde. 

# Richtige Reihenfolge def meet(): print("Hallo, da!")greet() # Falsche Reihenfolge goodbye() def goodbye(): print("Goodbye!")

Um diesen Fehler zu beheben, stellen Sie sicher, dass Ihre Funktion ordnungsgemäß definiert ist und dass Sie sie nach ihrer Definition aufrufen.

Abschluss

Um es noch einmal zusammenzufassen und Ihnen zu helfen, Ihr Verständnis zu festigen, fassen die folgenden Punkte die wichtigsten Aspekte des Aufrufs von Funktionen in Python zusammen:

• Um eine Funktion aufzurufen, verwenden Sie den Funktionsnamen gefolgt von Klammern (z. B. function_name()).
• Wenn die Funktion Argumente akzeptiert, schließen Sie diese in Klammern ein (z. B. function_name(arg1, arg2)).
• Sie können Ihre eigenen Funktionen mit dem Schlüsselwort def erstellen und dabei den Umfang der Funktion und alle erforderlichen Argumente definieren.
• Wenn Sie eine Funktion aufrufen, die einen Wert zurückgibt, können Sie das Ergebnis zur späteren Verwendung einer Variablen zuweisen (z. B. result = function_name(args)).