Website-Suche

Wie man Funktionen in Python 3 definiert

Einführung

Eine Funktion ist ein Block von Anweisungen, der eine Aktion ausführt und, einmal definiert, wiederverwendet werden kann. Funktionen machen den Code modularer, sodass Sie denselben Code immer wieder verwenden können.

Python hat eine Reihe von integrierten Funktionen, mit denen Sie möglicherweise vertraut sind, einschließlich:

  • print(), das ein Objekt im Terminal ausgibt.
  • Der int()-Befehl konvertiert einen String oder einen Zahlendatentyp in einen Ganzzahl-Datentyp.
  • len(), das die Länge eines Objekts zurückgibt

Funktionsnamen enthalten Klammern und können Parameter enthalten.

In diesem Tutorial werden wir besprechen, wie man eigene Funktionen definiert, die man in seinen Programmierprojekten verwenden kann.

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 auf die Installations- und Einrichtungsanleitungen für eine lokale Programmierumgebung oder für eine Programmierumgebung auf Ihrem Server verweisen, die für Ihr Betriebssystem (Ubuntu, CentOS, Debian usw.) geeignet ist.

Eine Funktion definieren

Lass uns damit beginnen, das klassische „Hello, World!“-Programm in eine Funktion umzuwandeln.

Wir werden eine neue Textdatei in unserem bevorzugten Texteditor erstellen und das Programm hello.py nennen. Dann werden wir die Funktion definieren.

Eine Funktion wird definiert, indem das Schlüsselwort def gefolgt von einem Namen Ihrer Wahl verwendet wird, gefolgt von einer Menge von Klammern, die alle Parameter enthalten, die die Funktion annehmen wird (sie können leer sein), und endet mit einem Doppelpunkt.

Info: Um dem Beispielcode in diesem Tutorial zu folgen, öffnen Sie eine Python-interaktive Shell auf Ihrem lokalen System, indem Sie den Befehl python3 ausführen. Dann können Sie die Beispiele kopieren, einfügen oder bearbeiten, indem Sie sie nach der >>> Eingabeaufforderung hinzufügen.

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

def hello():

Dies legt die anfängliche Aussage für die Erstellung einer Funktion fest.

Von hier aus fügen wir eine zweite Zeile mit einem 4-Leerzeichen-Offset hinzu, um die Anweisungen zu geben, was die Funktion tut. In diesem Fall werden wir Hello, World! auf der Konsole ausgeben:

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

Unsere Funktion ist jetzt vollständig definiert, aber wenn wir das Programm an diesem Punkt 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()

Nun, lassen Sie uns das Programm ausführen:

  1. python hello.py

Sie sollten die folgende Ausgabe erhalten:

Hello, World!

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

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

Define function names()
def names():
    # Set up name variable with input
    name = str(input('Enter your name: '))
    # Check whether name has a vowel
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # Iterate over name
    for letter in name:
        print(letter)

Call the function
names()

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

Das Definieren von Funktionen innerhalb eines Programms macht unseren Code modular und wiederverwendbar, sodass wir dieselben Funktionen aufrufen können, ohne sie neu zu schreiben.

Arbeiten mit Parametern

Bisher haben wir Funktionen mit leeren Klammern betrachtet, die keine Argumente annehmen, aber wir können Parameter in den Funktionsdefinitionen innerhalb ihrer Klammern definieren.

Ein Parameter ist eine benannte Entität in einer Funktionsdefinition, die ein Argument angibt, das die Funktion akzeptieren kann.

Lass uns ein kleines Programm erstellen, das die Parameter x, y und z entgegennimmt. Wir werden eine Funktion erstellen, die die Parameter in verschiedenen Konfigurationen zusammenzählt. Die Summen davon werden von der Funktion ausgegeben. 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 Berechnung basierend auf den Werten durch, 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, b gleich 4 und c gleich 5 ist. Lassen Sie uns das Programm ausführen:

  1. python add_numbers.py



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 typischerweise als Variablen innerhalb von Funktionsdefinitionen definiert werden. Sie können Werte zugewiesen bekommen, wenn Sie die Methode ausführen und die Argumente in die Funktion übergeben.

Schlüsselwortargumente

Neben der Aufrufreihenfolge von Parametern können Sie Schlüsselwortargumente in einem Funktionsaufruf verwenden, bei dem der Aufrufer die Argumente anhand des Parameternamens identifiziert.

Wenn Sie Schlüsselwortargumente verwenden, können Sie die Parameter in beliebiger Reihenfolge verwenden, da der Python-Interpreter die angegebenen Schlüsselwörter verwendet, um die Werte den Parametern zuzuordnen.

Lass uns eine Funktion erstellen, die uns Profilinformationen für einen Benutzer zeigt. Wir werden Parameter in Form von Benutzername (vorgesehen als String) und Follower (vorgesehen als Ganzzahl) übergeben.

Define function with parameters
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

Innerhalb der Funktionsdefinitionsanweisung sind username und followers in den Klammern der profile_info()-Funktion enthalten. Der Block der Funktion gibt Informationen über den Benutzer als Strings aus und nutzt die beiden Parameter.

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

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

Call function with parameters assigned as above
profile_info("sammyshark", 945)

Call function with keyword arguments
profile_info(username="AlexAnglerfish", followers=342)

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

Lass uns das Programm ausführen:

  1. python profile.py



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

Die Ausgabe zeigt uns die Benutzernamen und die Anzahl der Follower beider Nutzer.

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))

Change order of parameters
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:

Username: cameron-catfish
Followers: 820

Da die Funktionsdefinition die gleiche Reihenfolge der print()-Anweisungen beibehält, spielt es keine Rolle, in welcher Reihenfolge wir die Schlüsselwortargumente bei dem Funktionsaufruf übergeben.

Standardargumentwerte

Wir können auch Standardwerte für einen oder beide Parameter festlegen. 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 mit nur der zugewiesenen Benutzernamenfunktion ausführen, und die Anzahl der Follower wird automatisch auf 1 gesetzt. Wir können auch weiterhin die Anzahl der Follower ä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:

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

Die Bereitstellung von Standardparametern mit Werten ermöglicht es uns, die Werte für jedes Argument, das bereits einen Standardwert hat, zu überspringen.

Einen Wert zurückgeben

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

Eine Funktion kann mit der return-Anweisung einen Wert produzieren, der die Funktion verlässt und optional einen Ausdruck an den Aufrufer zurückgibt. Wenn Sie eine return-Anweisung ohne Argumente verwenden, gibt die Funktion None zurück.

Bisher haben wir in unseren Funktionen die print()-Anweisung anstelle der return-Anweisung verwendet. Lass uns ein Programm erstellen, das anstatt zu drucken, eine Variable zurückgibt.

In einer neuen Textdatei mit dem Namen square.py erstellen wir ein Programm, das den Parameter x quadriert und die Variable y zurückgibt. Wir rufen die result-Variable auf, die durch den Aufruf der Funktion square() mit 3 als Parameter 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:

  1. python square.py



9

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

Um besser zu verstehen, wie die return-Anweisung funktioniert, können wir die return-Anweisung im Programm auskommentieren:

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

result = square(3)
print(result)

Jetzt lassen Sie uns das Programm erneut ausführen:

  1. python square.py



None

Ohne die return Anweisung hier zu verwenden, kann das Programm keinen Wert zurückgeben, sodass der Wert standardmäßig None ist.

Als weiteres Beispiel könnten wir im obenstehenden add_numbers.py-Programm die print()-Anweisung durch eine return-Anweisung ersetzen.

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 oben beschrieben entgegennimmt. Dann haben wir die sums-Variable gedruckt.

Lass uns das Programm erneut ausführen, jetzt da es die return-Anweisung hat:

  1. python add_numbers.py



(3, 4, 5)

Wir erhalten die gleichen Zahlen 3, 4 und 5 als Ausgabe, die wir zuvor mit der print()-Anweisung in der Funktion erhalten haben. Diesmal wird es als Tuple geliefert, da die Ausdrucksliste der return-Anweisung mindestens ein Komma enthält.

Funktionen verlassen sofort, wenn sie eine return-Anweisung erreichen, unabhängig davon, ob sie einen Wert zurückgeben oder nicht.

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

loop_five()

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

Die return-Anweisung verlässt eine Funktion und kann einen Wert zurückgeben, wenn sie mit einem Parameter ausgegeben wird.

Verwendung von main() als Funktion

Obwohl man in Python die Funktion am Ende des Programms aufrufen kann und sie ausgeführt wird (wie wir es in den obigen Beispielen getan haben), erfordern viele Programmiersprachen (wie C++ und Java) eine main-Funktion, um ausgeführt zu werden. Die Einbeziehung einer main()-Funktion, obwohl nicht erforderlich, kann unsere Python-Programme auf eine logische Weise strukturieren, die die wichtigsten Komponenten des Programms in eine Funktion zusammenführt. Es kann auch unsere Programme für nicht-Python-Programmierer einfacher lesbar machen.

Wir werden beginnen, indem wir eine main() Funktion zum obigen hello.py Programm hinzufügen. Wir werden unsere hello() Funktion beibehalten und dann eine main() Funktion definieren:

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

def main():

Innerhalb der main()-Funktion fügen wir eine print()-Anweisung hinzu, 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()

Schließlich werden wir am Ende des Programms die main()-Funktion aufrufen:

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

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

main()

An diesem Punkt können wir unser Programm ausführen:

  1. python hello.py

Wir werden die folgende Ausgabe erhalten:

This is the main function.
Hello, World!

Weil wir die hello()-Funktion innerhalb von main() aufgerufen haben und dann nur main() aufgerufen haben, um auszuführen, wurde der Text Hello, World! 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 ist es sinnvoll, den Variablenbereich 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, kann es besser sein, eine globale Variable zu deklarieren.

In Python ist '__main__' der Name des Namensraums, in dem der Code auf der obersten Ebene 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.

Aus diesem Grund gibt es eine Konvention, folgende Konstruktion zu verwenden:

if __name__ == '__main__':
    # Code to run when this is the main program here

Dies ermöglicht es, Programmdateien entweder zu verwenden:

  • als das Hauptprogramm und führe aus, was nach der if-Anweisung kommt
  • als ein Modul und nicht den Code ausführen, der nach der if-Anweisung folgt.

Jeder Code, der nicht in dieser Anweisung enthalten ist, 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 Import in die sekundäre Datei ausgeführt.

Lassen Sie uns unser obiges names.py Programm erweitern und eine neue Datei mit dem Namen 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 getrennten Funktionen enthalten sind.

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

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

Declare global variable name for use in all functions
name = str(input('Enter your name: '))


Define function to check if name contains a vowel
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


Iterate over letters in name string
def print_letters():
    for letter in name:
        print(letter)

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

Declare global variable name for use in all functions
name = str(input('Enter your name: '))


Define function to check if name contains a vowel
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


Iterate over letters in name string
def print_letters():
    for letter in name:
        print(letter)


Define main method that calls other functions
def main():
    has_vowel()
    print_letters()

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

Declare global variable name for use in all functions
name = str(input('Enter your name: '))


Define function to check if name contains a vowel
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


Iterate over letters in name string
def print_letters():
    for letter in name:
        print(letter)


Define main method that calls other functions
def main():
    has_vowel()
    print_letters()


Execute main() function
if __name__ == '__main__':
    main()

Wir können das Programm jetzt ausführen:

  1. python more_names.py

Das Programm wird die gleiche Ausgabe wie das names.py Programm zeigen, aber hier ist der Code besser organisiert und kann auf modulare Weise ohne Modifikation verwendet werden.

Wenn Sie keine main() Funktion deklarieren wollten, hätten Sie das Programm alternativ so beenden können:

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

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

Schlussfolgerung

Funktionen sind Codeteile von Anweisungen, die Aktionen innerhalb eines Programms 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 über das Schreiben von Modulen in Python 3 lesen.