Wie man Funktionen in Python 3 definiert

Einführung

A function is a block of instructions that performs an action and, once defined, can be reused. Functions make code more modular, allowing you to use the same code over and over again.

Python verfügt über eine Reihe von integrierten Funktionen, die Ihnen vielleicht bekannt sind, darunter:

• print(), das ein Objekt auf die Konsole druckt
• int(), das einen String oder eine Zahl in einen Integer-Datentyp konvertiert
• len(), das die Länge eines Objekts zurückgibt

Funktionsnamen enthalten Klammern und können Parameter enthalten.

In diesem Tutorial werden wir darüber sprechen, wie Sie Ihre eigenen Funktionen definieren können, um sie in Ihren Codierungsprojekten zu verwenden.

Voraussetzungen

Sie sollten Python 3 installiert und eine Programmierumgebung auf Ihrem Computer oder Server eingerichtet haben. Wenn Sie keine Programmierumgebung eingerichtet haben, können Sie sich an die Installations- und Einrichtungsanleitungen für eine lokale Programmierumgebung oder für eine Programmierumgebung auf Ihrem Server entsprechend Ihrem Betriebssystem (Ubuntu, CentOS, Debian usw.) wenden.

Definition einer Funktion

Beginnen wir damit, das klassische „Hallo, Welt!“ Programm in eine Funktion umzuwandeln.

Wir erstellen eine neue Textdatei in unserem Texteditor der Wahl und nennen das Programm hello.py. Anschließend definieren wir die Funktion.

A function is defined by using the def keyword, followed by a name of your choosing, followed by a set of parentheses which hold any parameters the function will take (they can be empty), and ending with a colon.

In diesem Fall definieren wir eine Funktion namens hello():

def hello():

Dies richtet die erste Anweisung für die Erstellung einer Funktion ein.

Von hier aus fügen wir eine zweite Zeile mit einem 4-Space-Einzug hinzu, um die Anweisungen dafür zu geben, was die Funktion tut. In diesem Fall werden wir Hallo, Welt! in die Konsole drucken:

def hello():
    print("Hello, World!")

Unsere Funktion ist nun vollständig definiert, aber wenn wir das Programm zu diesem Zeitpunkt ausführen, wird nichts passieren, da wir die Funktion nicht aufgerufen haben.

Also, außerhalb unseres definierten Funktionsblocks, rufen wir die Funktion mit hello() auf:

def hello():
    print("Hello, World!")

hello()

Jetzt führen wir das Programm aus:

python hello.py

Sie sollten folgende Ausgabe erhalten:

Output
Hello, World!

Funktionen können komplizierter sein als die oben definierte hello()-Funktion. Zum Beispiel können wir for-Schleifen, bedingte Anweisungen und mehr innerhalb unseres Funktionsblocks verwenden.

Zum Beispiel nutzt die unten definierte Funktion eine bedingte Anweisung, um zu überprüfen, ob die Eingabe für die Variable name einen Vokal enthält, und verwendet dann eine for-Schleife, um über die Buchstaben im name-String zu iterieren.

# Funktion names() definieren
def names():
    # Variable name mit Eingabe einrichten
    name = str(input('Enter your name: '))
    # Überprüfen, ob name einen Vokal enthält
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # Über name iterieren
    for letter in name:
        print(letter)

# Funktion aufrufen
names()

Die oben definierte names()-Funktion richtet eine bedingte Anweisung und eine for-Schleife ein und zeigt, wie Code innerhalb einer Funktionsdefinition organisiert werden kann. Je nachdem, was wir mit unserem Programm beabsichtigen und wie wir unseren Code einrichten möchten, möchten wir die bedingte Anweisung und die for-Schleife jedoch möglicherweise als zwei separate Funktionen definieren.

Die Definition von Funktionen innerhalb eines Programms macht unseren Code modular und wiederverwendbar, sodass wir dieselben Funktionen aufrufen können, ohne sie neu schreiben zu müssen.

Arbeiten mit Parametern

Bisher haben wir uns Funktionen mit leeren Klammern angesehen, die keine Argumente enthalten, aber wir können Parameter in Funktionsdefinitionen innerhalb ihrer Klammern definieren.

A parameter is a named entity in a function definition, specifying an argument that the function can accept.

Lassen Sie uns ein kleines Programm erstellen, das Parameter x, y und z annimmt. Wir werden eine Funktion erstellen, die die Parameter in verschiedenen Konfigurationen zusammenzählt. Die Summen davon werden von der Funktion gedruckt. Dann werden wir die Funktion aufrufen und Zahlen an die Funktion übergeben.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    print(a, b, c)

add_numbers(1, 2, 3)

Wir haben die Zahl 1 für den Parameter x, 2 für den Parameter y und 3 für den Parameter z übergeben. Diese Werte entsprechen jedem Parameter in der Reihenfolge, in der sie gegeben sind.

Das Programm führt im Wesentlichen die folgende Mathematik basierend auf den Werten aus, die wir an die Parameter übergeben haben:

a = 1 + 2
b = 1 + 3
c = 2 + 3

Die Funktion druckt auch a, b und c, und basierend auf der obigen Mathematik würden wir erwarten, dass a gleich 3 ist, b 4 und c 5 ist. Lassen Sie uns das Programm ausführen:

python add_numbers.py

Output
3 4 5

Wenn wir 1, 2 und 3 als Parameter an die Funktion add_numbers() übergeben, erhalten wir die erwartete Ausgabe.

Parameter sind Argumente, die normalerweise als Variablen innerhalb von Funktionsdefinitionen definiert werden. Ihnen können Werte zugewiesen werden, wenn Sie die Methode ausführen, indem Sie die Argumente an die Funktion übergeben.

Stichwortargumente

Zusätzlich zum Aufrufen von Parametern in der Reihenfolge können Sie bei einem Funktionsaufruf Schlüsselwortargumente verwenden, bei dem der Aufrufer die Argumente mit dem Parameternamen identifiziert.

Beim Verwenden von Schlüsselwortargumenten können Sie Parameter in beliebiger Reihenfolge verwenden, da der Python-Interpreter die bereitgestellten Schlüsselwörter verwendet, um die Werte den Parametern zuzuordnen.

Erstellen wir eine Funktion, die uns Profilinformationen für einen Benutzer anzeigt. Wir werden Parameter in Form von Benutzername (als Zeichenfolge gedacht) und Followern (als Ganzzahl gedacht) übergeben.

# Funktion mit Parametern definieren
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

In der Funktionsdefinitionsanweisung sind Benutzername und Followern in den Klammern der Funktion profile_info() enthalten. Der Block der Funktion gibt Informationen über den Benutzer als Zeichenfolgen aus und verwendet die beiden Parameter.

Jetzt können wir die Funktion aufrufen und Parameter zuweisen:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Funktion mit oben zugewiesenen Parametern aufrufen
profile_info("sammyshark", 945)

# Funktion mit Schlüsselwortargumenten aufrufen
profile_info(username="AlexAnglerfish", followers=342)

Im ersten Funktionsaufruf haben wir die Informationen mit einem Benutzernamen von sammyshark und einer Anzahl von Followern von 945 ausgefüllt, im zweiten Funktionsaufruf haben wir Schlüsselwortargumente verwendet, um Werte den Argumentvariablen zuzuweisen.

Lassen Sie uns das Programm ausführen:

python profile.py

Output
Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

Die Ausgabe zeigt uns die Benutzernamen und die Anzahl der Follower für beide Benutzer.

Dies ermöglicht es uns auch, die Reihenfolge der Parameter zu ändern, wie in diesem Beispiel des gleichen Programms mit einem anderen Aufruf:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Ändern der Reihenfolge der Parameter
profile_info(followers=820, username="cameron-catfish")

Wenn wir das Programm erneut mit dem Befehl python profile.py ausführen, erhalten wir die folgende Ausgabe:

Output
Username: cameron-catfish
Followers: 820

Weil die Funktionsdefinition die gleiche Reihenfolge der print()-Anweisungen beibehält, ist es egal, in welcher Reihenfolge wir sie in den Funktionsaufruf übergeben, wenn wir Schlüsselwortargumente verwenden.

Standardargumentwerte

Wir können auch Standardwerte für einen oder beide Parameter angeben. Lassen Sie uns einen Standardwert für den followers-Parameter mit einem Wert von 1 erstellen:

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

Jetzt können wir die Funktion nur mit der zugewiesenen Benutzerfunktion ausführen, und die Anzahl der Follower wird automatisch auf 1 festgelegt. Wir können die Anzahl der Follower auch weiterhin ändern, wenn wir möchten.

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)

Wenn wir das Programm mit dem Befehl python profile.py ausführen, erhalten wir die folgende Ausgabe:

Output
Username: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

Das Bereitstellen von Standardparametern mit Werten ermöglicht es uns, das Definieren von Werten für jeden Argument zu überspringen, das bereits einen Standardwert hat.

Rückgabe eines Wertes

Sie können einen Parameterwert in eine Funktion übergeben, und eine Funktion kann auch einen Wert produzieren.

A function can produce a value with the return statement, which will exit a function and optionally pass an expression back to the caller. If you use a return statement with no arguments, the function will return None.

Bisher haben wir die print()-Anweisung anstelle der return-Anweisung in unseren Funktionen verwendet. Lassen Sie uns ein Programm erstellen, das anstelle des Druckens eine Variable zurückgibt.

In einer neuen Textdatei namens square.py erstellen wir ein Programm, das den Parameter x quadriert und die Variable y zurückgibt. Wir rufen die Variable result auf, die durch Ausführen der Funktion square() mit 3 als Argument gebildet wird.

def square(x):
    y = x ** 2
    return y

result = square(3)
print(result)

Wir können das Programm ausführen und die Ausgabe erhalten:

python square.py

Output
9

Die Ganzzahl 9 wird als Ausgabe zurückgegeben, was wir erwarten würden, wenn wir Python bitten, das Quadrat von 3 zu finden.

Um das Funktionsprinzip der return-Anweisung weiter zu verstehen, können wir die return-Anweisung im Programm auskommentieren:

def square(x):
    y = x ** 2
    # return y

result = square(3)
print(result)

Jetzt führen wir das Programm erneut aus:

python square.py

Output
None

Ohne die Verwendung der return-Anweisung kann das Programm hier keinen Wert zurückgeben, daher wird der Wert auf None zurückgesetzt.

Als weiteres Beispiel könnten wir im obigen Programm add_numbers.py die print()-Anweisung gegen eine return-Anweisung austauschen.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

sums = add_numbers(1, 2, 3)
print(sums)

Außerhalb der Funktion setzen wir die Variable sums gleich dem Ergebnis der Funktion, die 1, 2 und 3 wie zuvor entgegennimmt. Dann rufen wir einen Druck der Variablen sums auf.

Lassen Sie uns das Programm erneut ausführen, jetzt da es die return-Anweisung enthält:

python add_numbers.py

Output
(3, 4, 5)

Wir erhalten die gleichen Zahlen 3, 4 und 5 als Ausgabe, die wir zuvor durch Verwendung der print()-Anweisung in der Funktion erhalten haben. Diesmal wird es als Tupel geliefert, weil die return-Anweisung eine Ausdrucksliste mit mindestens einem Komma hat.

Funktionen beenden sich sofort, wenn sie auf eine return-Anweisung treffen, unabhängig davon, ob sie einen Wert zurückgeben.

def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # Funktion bei x == 5 beenden
            return
    print("This line will not execute.")

loop_five()

Die Verwendung der return-Anweisung innerhalb der for-Schleife beendet die Funktion, sodass die Zeile außerhalb der Schleife nicht ausgeführt wird. Wenn wir stattdessen eine break-Anweisung verwendet hätten, würde nur die Schleife zu diesem Zeitpunkt verlassen, und die letzte print()-Zeile würde ausgeführt.

Die return-Anweisung beendet eine Funktion und kann einen Wert zurückgeben, wenn sie mit einem Parameter ausgeführt wird.

Verwendung von main() als Funktion

Auch wenn Sie in Python die Funktion am Ende Ihres Programms aufrufen können und sie ausgeführt wird (wie wir es in den obigen Beispielen getan haben), benötigen viele Programmiersprachen (wie C++ und Java) eine main-Funktion, um ausgeführt zu werden. Das Hinzufügen einer main()-Funktion, obwohl nicht erforderlich, kann unsere Python-Programme auf logische Weise strukturieren, indem es die wichtigsten Komponenten des Programms in einer Funktion zusammenführt. Dies kann es auch für Nicht-Python-Programmierer einfacher machen, unsere Programme zu lesen.

Wir beginnen damit, eine main()-Funktion zum obigen hello.py-Programm hinzuzufügen. Wir behalten unsere hello()-Funktion bei und definieren dann eine main()-Funktion:

def hello():
    print("Hello, World!")

def main():

Innerhalb der main()-Funktion fügen wir eine print()-Anweisung ein, um uns mitzuteilen, dass wir uns in der main()-Funktion befinden. Außerdem rufen wir die hello()-Funktion innerhalb der main()-Funktion auf:

def hello():
    print("Hello, World!")


def main():
    print("This is the main function")
    hello()

Zuletzt rufen wir am Ende des Programms die main()-Funktion auf:

def hello():
    print("Hello, World!")

def main():
    print("This is the main function.")
    hello()

main()

Zu diesem Zeitpunkt können wir unser Programm ausführen:

python hello.py

Wir erhalten die folgende Ausgabe:

Output
This is the main function.
Hello, World!

Weil wir die hello()-Funktion innerhalb von main() aufgerufen haben und dann nur main() aufgerufen haben, wurde der Text Hallo, Welt! nur einmal gedruckt, nach dem String, der uns sagte, dass wir uns in der Hauptfunktion befinden.

Als nächstes werden wir mit mehreren Funktionen arbeiten, daher lohnt es sich, den Variablengeltungsbereich von globalen und lokalen Variablen zu überprüfen. Wenn Sie eine Variable innerhalb eines Funktionsblocks definieren, können Sie diese Variable nur innerhalb dieser Funktion verwenden. Wenn Sie Variablen über Funktionen hinweg verwenden möchten, ist es möglicherweise besser, eine globale Variable zu deklarieren.

In Python ist '__main__' der Name des Bereichs, in dem der Top-Level-Code ausgeführt wird. Wenn ein Programm von der Standardeingabe, einem Skript oder von einem interaktiven Prompt ausgeführt wird, wird sein __name__ auf '__main__' gesetzt.

Aufgrund dessen gibt es eine Konvention, die folgende Konstruktion zu verwenden:

if __name__ == '__main__':
    # Code, der ausgeführt wird, wenn dies das Hauptprogramm ist, steht hier

Dies ermöglicht es Programmdateien entweder:

• als Hauptprogramm verwendet zu werden und das auszuführen, was dem if-Statement folgt
• als Modul verwendet zu werden und nicht das auszuführen, was dem if-Statement folgt.

Jeder Code, der sich nicht in dieser Anweisung befindet, wird beim Ausführen ausgeführt. Wenn Sie Ihre Programmdatei als Modul verwenden, wird der Code, der sich nicht in dieser Anweisung befindet, auch beim Importieren während des Ausführens der sekundären Datei ausgeführt.

Lassen Sie uns unser obenstehendes names.py Programm erweitern und eine neue Datei namens more_names.py erstellen. In diesem Programm werden wir eine globale Variable deklarieren und unsere ursprüngliche names() Funktion so ändern, dass die Anweisungen in zwei separaten Funktionen vorliegen.

Die erste Funktion, has_vowel(), wird überprüfen, ob der name-String ein Vokal enthält.

Die zweite Funktion print_letters() wird jeden Buchstaben des name-Strings ausgeben.

# Deklarieren Sie die globale Variable name für die Verwendung in allen Funktionen
name = str(input('Enter your name: '))


# Definition der Funktion zur Überprüfung, ob der Name einen Vokal enthält
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterieren über Buchstaben im Namen-String
def print_letters():
    for letter in name:
        print(letter)

Mit diesem Setup definieren wir die main() Funktion, die einen Aufruf sowohl an die has_vowel() als auch an die print_letters() Funktionen enthalten wird.

# Deklarieren Sie die globale Variable name für die Verwendung in allen Funktionen
name = str(input('Enter your name: '))


# Definition der Funktion zur Überprüfung, ob der Name einen Vokal enthält
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterieren über Buchstaben im Namen-String
def print_letters():
    for letter in name:
        print(letter)


# Definieren der Hauptmethode, die andere Funktionen aufruft
def main():
    has_vowel()
    print_letters()

Schließlich fügen wir die Konstruktion if __name__ == '__main__': am Ende der Datei hinzu. Für unsere Zwecke werden wir, da wir alle Funktionen, die wir ausführen möchten, in der Funktion main() platziert haben, nach dieser if-Anweisung die Funktion main() aufrufen.

# Globale Variable "name" für die Verwendung in allen Funktionen deklarieren
name = str(input('Enter your name: '))


# Funktion definieren, um zu überprüfen, ob der Name einen Vokal enthält
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Über Buchstaben im Namensstring iterieren
def print_letters():
    for letter in name:
        print(letter)


# Hauptmethode definieren, die andere Funktionen aufruft
def main():
    has_vowel()
    print_letters()


# Hauptfunktion ausführen
if __name__ == '__main__':
    main()

Wir können das Programm jetzt ausführen:

python more_names.py

Das Programm zeigt die gleiche Ausgabe wie das Programm names.py, aber hier ist der Code organisierter und kann ohne Änderung modular verwendet werden.

Wenn Sie keine main()-Funktion deklarieren möchten, könnten Sie das Programm alternativ wie folgt beenden:

...
if __name__ == '__main__':
    has_vowel()
    print_letters()

Die Verwendung von main() als Funktion und der Anweisung if __name__ == '__main__': kann Ihren Code auf eine logische Weise organisieren, was ihn lesbarer und modularer macht.

Schlussfolgerung

Funktionen sind Codeblöcke von Anweisungen, die innerhalb eines Programms Aktionen ausführen und dazu beitragen, unseren Code wiederverwendbar und modular zu gestalten.

Um mehr darüber zu erfahren, wie Sie Ihren Code modularer gestalten können, können Sie unseren Leitfaden zu So schreiben Sie Module in Python 3 lesen.