Eine Funktion ist ein organisiertes, wiederverwendbares Codesegment, das zur Implementierung einer einzelnen oder verwandten Funktion verwendet wird.
Funktionen können die Anwendungsmodularität und die Wiederverwendung von Code verbessern. Sie wissen bereits, dass Python viele integrierte Funktionen bietet, beispielsweise print(). Sie können aber auch eigene Funktionen erstellen, die als benutzerdefinierte Funktionen bezeichnet werden.
Funktion definieren
Sie können eine Funktion mit den gewünschten Funktionen definieren. Im Folgenden sind einfache Regeln aufgeführt:
Der Funktionscodeblock beginnt mit dem Schlüsselwort def, gefolgt von Funktionsbezeichnername und Klammern ().
Alle eingehenden Parameter und Argumente müssen in Klammern gesetzt werden. Parameter können in Klammern definiert werden.
Die erste Zeile einer Funktion kann optional einen Dokumentstring verwenden, der zum Speichern von Funktionsbeschreibungen verwendet wird.
Funktionsinhalte beginnen mit einem Doppelpunkt und werden eingerückt.
Return[expression] beendet die Funktion und gibt optional einen Wert an den Aufrufer zurück. Die Rückgabe ohne Ausdruck entspricht der Rückgabe von None.
Syntax
def functionname(parameters):
"Function_docstring"
function_suite
return [expression]
Standardmäßig werden Parameterwerte und Parameternamen in der in der Funktionsdeklaration definierten Reihenfolge abgeglichen.
Beispiel
Das Folgende ist eine einfache Python-Funktion, die eine Zeichenfolge als Eingabeparameter verwendet und sie auf einem Standardanzeigegerät ausgibt.
def printme(string):
"Drucken Sie den eingehenden String auf einem Standardanzeigegerät aus"
print string
Funktionsaufruf
Durch das Definieren einer Funktion wird der Funktion nur ein Name gegeben, die in der Funktion enthaltenen Parameter und die Codeblockstruktur angegeben.
Nachdem die Grundstruktur dieser Funktion fertiggestellt ist, können Sie sie über einen anderen Funktionsaufruf oder direkt über die Python-Eingabeaufforderung ausführen.
Die Funktion printme() wird im folgenden Beispiel aufgerufen:
#!/usr/bin/python
# Funktionsdefinition ist hier
def printme(string):
"Jeden eingehenden String drucken"
print string
# Jetzt können Sie die Funktion printme aufrufen
printme("Ich möchte eine benutzerdefinierte Funktion aufrufen!");
printme("Dieselbe Funktion noch einmal aufrufen") ;
Das obige Beispiel-Ausgabeergebnis:
Ich möchte einen Benutzer anrufen- definierte Funktion!
Gleiche Funktion erneut aufrufen
Parameter als Wert übergeben und Parameter als Referenz übergeben
Alle Parameter ( unabhängige Variablen) sind in Python Es wird als Referenz übergeben. Wenn Sie die Parameter in der Funktion ändern, werden die ursprünglichen Parameter auch in der Funktion geändert, die diese Funktion aufruft. Zum Beispiel:
#!/usr/bin/python
# Beschreibbare Funktionsbeschreibung
def changeme( mylist ):
„Ändern Sie die eingehende Liste“
mylist.append([1,2,3,4])
print „innerhalb der Funktion Wert: ", mylist
# Changeme-Funktion aufrufen
mylist = [10,20,30];
changeme(mylist);
print „Wert außerhalb der Funktion:“, mylist
Das an die Funktion übergebene Objekt und das Objekt zum Hinzufügen neuer Inhalte am Ende sind dasselbe Zitat. Daher lautet das Ausgabeergebnis wie folgt:
Wert innerhalb der Funktion: [10, 20, 30, [1, 2, 3, 4]]
Werte außerhalb der Funktion: [10, 20, 30, [1, 2, 3, 4]]
Parameter
Die folgenden formalen Parametertypen können beim Aufrufen von Funktionen verwendet werden:
Erforderliche Parameter
Benannte Parameter
Standardparameter
Variablenlänge Parameter
Erforderliche Parameter
Erforderliche Parameter müssen in der richtigen Reihenfolge an die Funktion übergeben werden. Die abgerufene Menge muss mit der deklarierten Menge übereinstimmen.
Beim Aufruf der printme()-Funktion müssen Sie einen Parameter übergeben, sonst kommt es zu einem Syntaxfehler:
#!/usr /bin/ python
#Schreibbare Funktionsbeschreibung
def printme(string):
„Jeden eingehenden String drucken“
Zeichenfolge drucken
#Rufen Sie die printme-Funktion auf
printme()
Das obige Beispiel wird ausgegeben das Ergebnis:
Traceback (letzter Aufruf zuletzt):
Datei „test.py“, Zeile 11, in
printme()
TypeError: printme() benötigt genau 1 Argument (0 gegeben)
Benannter Parameter
Benannte Parameter stehen in engem Zusammenhang mit Funktionsaufrufen. Der Aufrufer verwendet die Benennung von Parametern, um den Wert der übergebenen Parameter zu bestimmen. Sie können nicht übergebene Parameter überspringen oder Parameter in der falschen Reihenfolge übergeben, da der Python-Interpreter Parameternamen mit Parameterwerten abgleichen kann. Rufen Sie die Funktion printme() mit benannten Parametern auf:
#!/usr/bin/python
#Writable Funktionsbeschreibung
def printme(string):
„Jeden eingehenden String drucken“
print string
# Rufen Sie das printme auf Funktion
printme(str = "My string")
Das obige Beispiel-Ausgabeergebnis:
Mein String
Das folgende Beispiel zeigt deutlicher, dass die Reihenfolge der benannten Parameter nicht wichtig ist:
#!/usr/bin/python
#Schreibbare Funktionsbeschreibung
def printinfo(name, age):
„Jede eingehende Zeichenfolge drucken“
„Name:“ drucken, Name
„Alter“ drucken, Alter
# Rufen Sie die printinfo-Funktion auf
printinfo( age=50, name="miki" )
Ausgabeergebnis des obigen Beispiels:
Name: miki
Alter 50
Standardparameter
Wenn beim Aufrufen einer Funktion der Wert des Standardparameters nicht übergeben wird, wird er als Standardwert betrachtet. Das folgende Beispiel gibt das Standardalter aus, wenn das Alter nicht übergeben wird:
#!/usr/bin/python
#Schreibbare Funktionsbeschreibung
def printinfo(name, age = 35):
„Jede eingehende Zeichenfolge drucken“
print „Name:“, Name
print „Alter“, Alter
#Printinfo-Funktion aufrufen
printinfo(age=50, name="miki")
printinfo( name="miki" )
Das Ausgabeergebnis des obigen Beispiels:
Name: Miki
Alter 50
Name: Miki
Alter 35
Unbestimmte Länge Parameter
Möglicherweise benötigen Sie eine Funktion, die mehr Parameter verarbeiten kann als ursprünglich deklariert. Diese Parameter werden als Parameter variabler Länge bezeichnet und werden bei der Deklaration nicht benannt. Die grundlegende Syntax lautet wie folgt:
def functionname([formal_args,] *var_args_tuple):
"Function_docstring"
function_suite
return [expression]
Variablennamen mit einem Sternchen (*) speichern alle unbenannten Variablenparameter. Sie können sich auch dafür entscheiden, keine weiteren Parameter zu übergeben. Das folgende Beispiel:
#!/usr/bin/python
# Beschreibbare Funktionsbeschreibung
def printinfo(arg1, *vartuple):
„Alle übergebenen Argumente drucken“
print „Ausgabe: „
print arg1
für var in vartuple:
print var
# Printinfo-Funktion aufrufen
printinfo( 10 )
printinfo( 70, 60 , 50 )
Ausgabeergebnis des obigen Beispiels:
Ausgabe:
10
Ausgabe:
70
60
50
Anonyme Funktion
Verwenden Sie das Schlüsselwort Lambda, um eine kleine anonyme Funktion zu erstellen. Dieser Funktionstyp verdankt seinen Namen der Tatsache, dass der Standardschritt der Deklaration einer Funktion mit def weggelassen wird.
Lambda-Funktion kann eine beliebige Anzahl von Parametern empfangen, aber nur den Wert eines Ausdrucks zurückgeben und keine Befehle oder mehrere Ausdrücke enthalten.
Anonyme Funktionen können print nicht direkt aufrufen, da Lambda einen Ausdruck erfordert.
Die Lambda-Funktion verfügt über einen eigenen Namensraum und kann nicht auf Parameter außerhalb ihrer eigenen Parameterliste oder im globalen Namensraum zugreifen.
Obwohl die Lambda-Funktion scheinbar nur eine Zeile schreiben kann, entspricht sie nicht der Inline-Funktion von C oder C. Der Zweck der letzteren besteht darin, kleine Funktionen aufzurufen, ohne Stapelspeicher zu belegen und somit zu vergrößern Betriebseffizienz.
Grammatik
Die Syntax der Lambda-Funktion enthält nur eine Anweisung wie folgt:
lambda [arg1 [,arg2 ,. ....argn]]:expression
Das folgende Beispiel:
#! /usr/bin/python
#Schreibbare Funktionsbeschreibung
sum = lambda arg1, arg2: arg1 arg2
#Summenfunktion aufrufen
Drucken Sie „Wert der Gesamtsumme:“, Summe( 10, 20)
Drucken Sie „Wert der Gesamtsumme:“, Summe( 20, 20)
Das obige Beispiel-Ausgabeergebnis:
Wert der Gesamtsumme: 30
Wert insgesamt: 40
return-Anweisung
return-Anweisung [Ausdruck] beendet die Funktion und gibt optional einen Ausdruck an den Aufrufer zurück. Eine Return-Anweisung ohne Parameterwerte gibt None zurück. Die vorherigen Beispiele haben nicht gezeigt, wie ein Wert zurückgegeben wird. Das folgende Beispiel zeigt Ihnen, wie es geht:
#!/usr/bin/python
# Beschreibung der beschreibbaren Funktion
def sum(arg1, arg2):
#Gibt die Summe von 2 Parametern zurück."
total = arg1 arg2
print „Innerhalb der Funktion:“, total
return total
# Call sum function
total = sum( 10 , 20 );
print „Outside the function :“, total
Das Ausgabeergebnis des obigen Beispiels:
Innerhalb der Funktion: 30
Außerhalb der Funktion: 30
Variablenbereich
Nicht auf alle Variablen in einem Programm kann überall zugegriffen werden.
Der Gültigkeitsbereich der Variablen bestimmt, auf welchen Teil des Programms Sie zugreifen können . Welcher spezifische Variablenname ist wie folgt:
Globale Variable
Lokale Variable
Variable und lokale Variable
Variablen, die innerhalb einer Funktion definiert sind, haben einen lokalen Gültigkeitsbereich, und Variablen, die außerhalb der Funktion definiert sind, haben einen globalen Gültigkeitsbereich
Auf lokale Variablen kann nur innerhalb der Funktion zugegriffen werden, in der sie deklariert sind, während dies auf globale Variablen möglich ist Auf sie kann innerhalb der Funktion zugegriffen werden, in der sie im gesamten Programm aufgerufen werden. Beim Aufruf einer Funktion werden alle innerhalb der Funktion deklarierten Variablennamen zum Gültigkeitsbereich hinzugefügt:
#! /usr/bin/python
total = 0; # Dies ist eine globale Variable.
# Beschreibbare Funktionsbeschreibung
def sum( arg1, arg2 ):
#Gibt die Summe der 2 Parameter zurück.“
total = arg1 arg2; # total ist hier eine lokale Variable.
drucken „Innerhalb der Funktion local total :“, total
return total;
#Call sum function
sum(10, 20);
print " Außerhalb der Funktion global total : ", total
Das Ausgabeergebnis des obigen Beispiels:
Innerhalb der Funktion lokale Gesamtsumme: 30
Außerhalb der Funktion globale Gesamtsumme: 0
