Python-Funktionen

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