TOC

So definieren Sie Funktionen in Python 3

Einführung

Eine * Funktion * ist ein Anweisungsblock, der eine Aktion ausführt und nach seiner Definition wiederverwendet werden kann. Durch Funktionen wird der Code modularer, sodass Sie denselben Code immer wieder verwenden können.

Python verfügt über eine Reihe integrierter Funktionen, mit denen Sie möglicherweise vertraut sind, darunter:

  • + print () + druckt ein Objekt auf das Terminal

  • + int () + konvertiert einen String- oder Zahlen-Datentyp in einen Integer-Datentyp

  • + len () + gibt die Länge eines Objekts zurück

Funktionsnamen enthalten Klammern und können Parameter enthalten.

In diesem Lernprogramm wird erläutert, wie Sie Ihre eigenen Funktionen definieren, die Sie in Ihren Codierungsprojekten verwenden können.

Eine Funktion definieren

Beginnen wir damit, das klassische https://www.digitalocean.com/community/tutorials/how-to-write-your-first-python-3-program[ "Hallo, Welt!" - Programm in eine Funktion umzuwandeln.

Wir erstellen eine neue Textdatei in unserem Texteditor Ihrer Wahl und rufen das Programm "+ hello.py +" auf. Dann definieren wir die Funktion.

Eine Funktion wird mit dem Schlüsselwort "+ def +" definiert, gefolgt von einem Namen Ihrer Wahl, gefolgt von einer Reihe von Klammern, die alle Parameter enthalten, die die Funktion annehmen wird (sie können leer sein) und mit einem Doppelpunkt enden.

In diesem Fall definieren wir eine Funktion mit dem Namen "+ hallo () +":

hallo.py

def hello():

Hiermit wird die erste Anweisung zum Erstellen einer Funktion eingerichtet.

Ab hier fügen wir eine zweite Zeile mit einem 4-stelligen Einzug hinzu, um die Anweisungen für die Funktionsweise der Funktion bereitzustellen. In diesem Fall drucken wir "+ Hello, World! +" Auf die Konsole:

hallo.py

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

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

Rufen wir also außerhalb unseres definierten Funktionsblocks die Funktion mit + hello () + auf:

hallo.py

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

hello()

Führen Sie nun das Programm aus:

python hello.py

Sie sollten die folgende Ausgabe erhalten:

OutputHello, World!

Funktionen können komplizierter sein als die oben definierte Funktion + hello () +. Zum Beispiel können wir https://www.digitalocean.com/community/tutorials/how-to-construct-for-loops-inpython-3 [+ for + loops] verwenden, https: //www.digitalocean .com / community / tutorials / Wie schreibe ich bedingte Anweisungen in Python 3-2 und mehr in unserem Funktionsblock.

Die unten definierte Funktion verwendet beispielsweise 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 die Buchstaben in der Zeichenfolge " name +" zu durchlaufen.

names.py

# 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 oben definierte Funktion "+ names () " erstellt eine bedingte Anweisung und eine " for" -Schleife, die zeigt, wie Code in einer Funktionsdefinition organisiert werden kann. Abhängig davon, was wir mit unserem Programm vorhaben und wie wir unseren Code einrichten möchten, möchten wir die bedingte Anweisung und die "+ für" -Schleife möglicherweise als zwei separate Funktionen definieren.

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

Mit Parametern arbeiten

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

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

Erstellen wir ein kleines Programm, das die Parameter "+ x ", " y " und " z +" enthält. Wir erstellen eine Funktion, die die Parameter in verschiedenen Konfigurationen zusammenfügt. Die Summen davon werden von der Funktion gedruckt. Dann rufen wir die Funktion auf und übergeben Nummern an die Funktion.

add_numbers.py

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 Nummer + 1 + in für den Parameter + x +, + 2 + in für den Parameter + y + und + 3 + in für den Parameter + z + übergeben. Diese Werte entsprechen den einzelnen Parametern in der angegebenen Reihenfolge.

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

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

Die Funktion gibt auch "+ a ", " b " und " c " aus. Basierend auf den obigen Berechnungen würden wir erwarten, dass " a " gleich " 3 " und " b +" ist + 4 + und + c + sind + 5 + `. Führen wir das Programm aus:

python add_numbers.py
Output3 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 in Funktionsdefinitionen definiert sind. Ihnen können Werte zugewiesen werden, wenn Sie die Methode ausführen und die Argumente an die Funktion übergeben.

Schlüsselwortargumente

Zusätzlich zum Aufrufen von Parametern in der angegebenen Reihenfolge können Sie in einem Funktionsaufruf * Schlüsselwortargumente * verwenden, bei denen der Aufrufer die Argumente anhand des Parameternamens identifiziert.

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

Erstellen wir eine Funktion, die uns Profilinformationen für einen Benutzer anzeigt. Wir übergeben ihm Parameter in Form von "+ Benutzername " (als Zeichenfolge vorgesehen) und " Follower +" (als Ganzzahl vorgesehen).

profile.py

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

In der Funktionsdefinitionsanweisung stehen "+ Benutzername " und " Follower " in den Klammern der Funktion " profile_info () +". Der Block der Funktion druckt Informationen über den Benutzer als Zeichenfolgen aus und verwendet dabei die beiden Parameter.

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

profile.py

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

# Call function with parameters assigned as above


# Call function with keyword arguments

Im ersten Funktionsaufruf haben wir die Informationen mit dem Benutzernamen "+ sammyshark " und den Followern " 945 +" ausgefüllt. Im zweiten Funktionsaufruf haben wir Schlüsselwortargumente verwendet und den Argumentvariablen Werte zugewiesen.

Führen wir das Programm aus:

python profile.py
OutputUsername: 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 uns auch, die Reihenfolge der Parameter zu ändern, wie in diesem Beispiel des gleichen Programms mit einem anderen Aufruf:

profile.py

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

# Change order of parameters

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

OutputUsername: cameron-catfish
Followers: 820

Da die Funktionsdefinition die gleiche Reihenfolge von "+ print () +" - Anweisungen beibehält, spielt es bei Verwendung von Schlüsselwortargumenten keine Rolle, in welcher Reihenfolge sie an den Funktionsaufruf übergeben werden.

Standardargumentwerte

Wir können auch Standardwerte für einen oder beide Parameter bereitstellen. Erstellen wir einen Standardwert für den Parameter "+ followers " mit dem Wert " 1 +":

profile.py

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

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

profile.py

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:

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

Wenn Sie Standardparameter mit Werten versehen, können Sie die Definition von Werten für jedes Argument überspringen, für das bereits ein Standardwert festgelegt wurde.

Wert zurückgeben

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

Eine Funktion kann mit der Anweisung "+ return " einen Wert erzeugen, der eine Funktion beendet 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 Anweisung + print () + anstelle der Anweisung + return + verwendet. Erstellen wir ein Programm, das anstelle des Druckens 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 geben einen Aufruf aus, um die Variable ` result ` zu drucken, die durch Ausführen der Funktion ` square () ` mit der Übergabe von ` 3 +` gebildet wird.

square.py

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

result = square(3)
print(result)

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

python square.py
Output9

Die Ganzzahl "+ 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 Sie die "+ return" -Anweisung im Programm auskommentieren:

square.py

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

result = square(3)
print(result)

Führen Sie das Programm jetzt erneut aus:

python square.py
OutputNone

Ohne die Verwendung der Anweisung "+ return " kann das Programm keinen Wert zurückgeben, sodass der Standardwert " None +" ist.

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

add_numbers.py

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 "+ Summen " gleich dem Ergebnis der Funktion, die " 1 ", " 2 " und " 3 " wie oben verwendet. Dann haben wir einen Ausdruck der Variablen ` sums +` aufgerufen.

Führen wir das Programm jetzt erneut aus, da es die Anweisung "+ return +" enthält:

python add_numbers.py
Output(3, 4, 5)

Wir erhalten die gleichen Zahlen "+ 3 ", " 4 " und " 5 " als Ausgabe, die wir zuvor mit der Anweisung " print () " in der Funktion erhalten haben. Dieses Mal wird es als https://www.digitalocean.com/community/tutorials/understanding-tuples-in-python-3[tuple] ausgeliefert, da die Anweisung " return +" https://docs.python.org/ 3.6 / reference / expressions.html # grammar-token-expression_list [Ausdrucksliste] enthält mindestens ein Komma.

Funktionen werden sofort beendet, wenn sie eine "+ return +" - Anweisung drücken, unabhängig davon, ob sie einen Wert zurückgeben oder nicht.

return_loop.py

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

Wenn Sie die Anweisung "+ return" in der Schleife "+ for" verwenden, wird die Funktion beendet, sodass die Zeile außerhalb der Schleife nicht ausgeführt wird. Wenn wir stattdessen https://www.digitalocean.com/community/tutorials/how-to-use-break-continue-and-pass-statements-wenn-working-with-loops-in-python- verwendet hätten 3 # break-Anweisung [+ break + Anweisung], nur die Schleife wäre zu diesem Zeitpunkt beendet worden, und die letzte Zeile + print () + würde ausgeführt.

Die Anweisung "+ return" beendet eine Funktion und gibt möglicherweise einen Wert zurück, wenn sie mit einem Parameter ausgegeben wird.

Verwenden von + main () + als Funktion

Obwohl Sie in Python die Funktion am unteren Rand 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 Einfügen einer " main () +" - Funktion, obwohl nicht erforderlich, kann unsere Python-Programme auf eine logische Weise strukturieren, die die wichtigsten Komponenten des Programms in einer Funktion zusammenfasst. Es kann auch das Lesen unserer Programme für Nicht-Python-Programmierer erleichtern.

Wir beginnen mit dem Hinzufügen einer "+ main () " - Funktion zum " hello.py " - Programm. Wir behalten unsere " hello () " - Funktion bei und definieren dann eine " main () +" - Funktion:

hallo.py

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

Fügen Sie in die Funktion "+ main () " die Anweisung " print () " ein, um uns mitzuteilen, dass wir uns in der Funktion " main () " befinden. Rufen wir zusätzlich die Funktion ` hello () ` in der Funktion ` main () +` auf:

hallo.py

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


def main():

Schließlich rufen wir am Ende des Programms die Funktion "+ main () +" auf:

hallo.py

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

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

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

python hello.py

Wir erhalten folgende Ausgabe:

OutputThis is the main function.
Hello, World!

Da wir die "+ hello () " - Funktion innerhalb von " main () " aufgerufen haben und dann nur " main () " aufgerufen haben, wird der " Hello, World! +" - Text nur einmal gedruckt, nach dem Zeichenfolge, die uns mitteilte, dass wir in der Hauptfunktion waren.

Als Nächstes werden wir mit mehreren Funktionen arbeiten. Es lohnt sich daher, den Variablenbereich von https://www.digitalocean.com/community/tutorials/how-to-use-variables-in-python-3#global zu überprüfen -und-lokale-Variablen [globale und lokale Variablen]. Wenn Sie eine Variable innerhalb eines Funktionsblocks definieren, können Sie diese Variable nur innerhalb dieser Funktion verwenden. Wenn Sie Variablen funktionsübergreifend verwenden möchten, ist es möglicherweise besser, eine globale Variable zu deklarieren.

In Python ist "" __ main __ "" der Name des Bereichs, in dem Code der obersten Ebene ausgeführt wird. Wenn ein Programm über die Standardeingabe, ein Skript oder eine interaktive Eingabeaufforderung ausgeführt wird, wird sein "" - Name "" gleich "+" gesetzt.

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

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

Auf diese Weise können Programmdateien verwendet werden:

  • als Hauptprogramm und führen Sie aus, was der Anweisung "+ if +" folgt

  • als Modul und nicht ausführen, was der Anweisung "+ if +" folgt.

Jeglicher 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 nicht in dieser Anweisung enthalten ist, auch beim Import ausgeführt, während die sekundäre Datei ausgeführt wird.

Erweitern wir unser Programm "+ names.py " oben und erstellen eine neue Datei mit dem Namen " more_names.py ". In diesem Programm deklarieren wir eine globale Variable und ändern unsere ursprüngliche Funktion " names () +" so, dass sich die Anweisungen in zwei diskreten Funktionen befinden.

Die erste Funktion, "+ has_vowel () ", prüft, ob der " name +" - String einen Vokal enthält.

Die zweite Funktion + print_letters () + druckt jeden Buchstaben der Zeichenkette + name +.

more_names.py

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

Definieren wir mit dieser Einstellung die Funktion "+ main () ", die einen Aufruf sowohl der Funktionen " has_vowel () " als auch " print_letters () +" enthält.

more_names.py

# 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

Zum Schluss fügen wir die + if name == 'main ': + -Konstruktion am Ende der Datei hinzu. Da wir für unsere Zwecke alle Funktionen, die wir ausführen möchten, in die Funktion "+ main () " eingegeben haben, rufen wir die Funktion " main () " nach dieser " if +" - Anweisung auf.

more_names.py

# 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





# Execute main() function

Wir können jetzt das Programm ausführen:

python more_names.py

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

Wenn Sie keine "+ main () +" - Funktion deklarieren möchten, können Sie das Programm auch folgendermaßen beenden:

more_names.py

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

Durch die Verwendung von + main () + als Funktion und der Anweisung + if name == 'main ': + kann der Code logisch organisiert und lesbarer und modularer gestaltet werden.

Fazit

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

Weitere Informationen zur Modularisierung Ihres Codes finden Sie in unserem Handbuch unter How To Write Modules in Python 3.

Related