Python 3 - Funktionen

Eine Funktion ist ein Block aus organisiertem, wiederverwendbarem Code, mit dem eine einzelne verwandte Aktion ausgeführt wird. Funktionen bieten eine bessere Modularität für Ihre Anwendung und einen hohen Grad an Wiederverwendung von Code.

Wie Sie bereits wissen, bietet Python viele integrierte Funktionen wie print () usw. Sie können jedoch auch eigene Funktionen erstellen. Diese Funktionen werden als benutzerdefinierte Funktionen bezeichnet.

Funktion definieren

Sie können Funktionen definieren, um die erforderliche Funktionalität bereitzustellen. Hier sind einfache Regeln zum Definieren einer Funktion in Python.

• Funktionsblöcke beginnen mit dem Schlüsselwort def gefolgt von Funktionsname und Klammern (()).

• Alle Eingabeparameter oder Argumente sollten in diese Klammern gesetzt werden. Sie können auch Parameter in diesen Klammern definieren.

• Die erste Anweisung einer Funktion kann eine optionale Anweisung sein - die Dokumentationszeichenfolge der Funktion oder der Dokumentzeichenfolge .

• Der Codeblock in jeder Funktion beginnt mit einem Doppelpunkt (:) und wird eingerückt.

• Die Anweisung return [Ausdruck] beendet eine Funktion und gibt optional einen Ausdruck an den Aufrufer zurück. Eine return-Anweisung ohne Argumente ist dasselbe wie return None.

Syntax

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

Standardmäßig haben Parameter ein Positionsverhalten, und Sie müssen sie in derselben Reihenfolge informieren, in der sie definiert wurden.

Beispiel

Die folgende Funktion verwendet eine Zeichenfolge als Eingabeparameter und druckt sie auf dem Standardbildschirm aus.

def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

Eine Funktion aufrufen

Das Definieren einer Funktion gibt ihr einen Namen, gibt die Parameter an, die in die Funktion aufgenommen werden sollen, und strukturiert die Codeblöcke.

Sobald die Grundstruktur einer Funktion fertiggestellt ist, können Sie sie ausführen, indem Sie sie von einer anderen Funktion oder direkt von der Python-Eingabeaufforderung aus aufrufen. Es folgt ein Beispiel zum Aufrufen derprintme() Funktion -

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme("This is first call to the user defined function!")
printme("Again second call to the same function")

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

This is first call to the user defined function!
Again second call to the same function

Als Referenz gegen Wert übergeben

Alle Parameter (Argumente) in der Python-Sprache werden als Referenz übergeben. Wenn Sie also ändern, worauf sich ein Parameter innerhalb einer Funktion bezieht, wird die Änderung auch in der aufrufenden Funktion wiedergegeben. Zum Beispiel -

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("Values inside the function before change: ", mylist)
   
   mylist[2]=50
   print ("Values inside the function after change: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

Hier behalten wir die Referenz des übergebenen Objekts bei und hängen Werte an dasselbe Objekt an. Daher würde dies das folgende Ergebnis erzeugen -

Values inside the function before change:  [10, 20, 30]
Values inside the function after change:  [10, 20, 50]
Values outside the function:  [10, 20, 50]

Es gibt noch ein weiteres Beispiel, bei dem Argumente als Referenz übergeben und die Referenz innerhalb der aufgerufenen Funktion überschrieben wird.

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4] # This would assi new reference in mylist
   print ("Values inside the function: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

Der Parameter mylistist lokal für das Funktionsänderungsprogramm. Das Ändern der Mylist innerhalb der Funktion wirkt sich nicht auf die Mylist aus. Die Funktion erreicht nichts und würde schließlich das folgende Ergebnis erzeugen -

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

Funktionsargumente

Sie können eine Funktion aufrufen, indem Sie die folgenden Arten von formalen Argumenten verwenden:

• Erforderliche Argumente
• Schlüsselwortargumente
• Standardargumente
• Argumente variabler Länge

Erforderliche Argumente

Erforderliche Argumente sind die Argumente, die in der richtigen Positionsreihenfolge an eine Funktion übergeben werden. Hier sollte die Anzahl der Argumente im Funktionsaufruf genau mit der Funktionsdefinition übereinstimmen.

Funktion aufrufen printme()müssen Sie auf jeden Fall ein Argument übergeben, da sonst ein Syntaxfehler wie folgt angezeigt wird:

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme()

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

Schlüsselwortargumente

Schlüsselwortargumente beziehen sich auf die Funktionsaufrufe. Wenn Sie in einem Funktionsaufruf Schlüsselwortargumente verwenden, identifiziert der Aufrufer die Argumente anhand des Parameternamens.

Auf diese Weise können Sie Argumente überspringen oder nicht in der richtigen Reihenfolge platzieren, da der Python-Interpreter die angegebenen Schlüsselwörter verwenden kann, um die Werte mit Parametern abzugleichen. Sie können auch Keyword-Aufrufe an dieprintme() Funktion auf folgende Weise -

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme( str = "My string")

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

My string

Das folgende Beispiel zeigt ein klareres Bild. Beachten Sie, dass die Reihenfolge der Parameter keine Rolle spielt.

#!/usr/bin/python3

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print ("Name: ", name)
   print ("Age ", age)
   return

# Now you can call printinfo function
printinfo( age = 50, name = "miki" )

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Name:  miki
Age  50

Standardargumente

Ein Standardargument ist ein Argument, das einen Standardwert annimmt, wenn im Funktionsaufruf für dieses Argument kein Wert angegeben wird. Das folgende Beispiel gibt eine Vorstellung von Standardargumenten. Es gibt das Standardalter aus, wenn es nicht übergeben wird.

#!/usr/bin/python3

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print ("Name: ", name)
   print ("Age ", age)
   return

# Now you can call printinfo function
printinfo( age = 50, name = "miki" )
printinfo( name = "miki" )

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Name:  miki
Age  50
Name:  miki
Age  35

Argumente variabler Länge

Möglicherweise müssen Sie eine Funktion für mehr Argumente verarbeiten, als Sie beim Definieren der Funktion angegeben haben. Diese Argumente werden als Argumente variabler Länge bezeichnet und im Gegensatz zu erforderlichen und Standardargumenten in der Funktionsdefinition nicht benannt.

Die Syntax für eine Funktion mit Variablenargumenten ohne Schlüsselwort ist unten angegeben -

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

Vor dem Variablennamen steht ein Sternchen (*), der die Werte aller Nicht-Schlüsselwort-Variablenargumente enthält. Dieses Tupel bleibt leer, wenn während des Funktionsaufrufs keine zusätzlichen Argumente angegeben werden. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python3

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print ("Output is: ")
   print (arg1)
   
   for var in vartuple:
      print (var)
   return

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Output is:
10
Output is:
70
60
50

Die anonymen Funktionen

Diese Funktionen werden anonym genannt, da sie nicht standardmäßig mit dem deklariert werden defStichwort. Du kannst den ... benutzenlambda Schlüsselwort zum Erstellen kleiner anonymer Funktionen.

• Lambda-Formulare können beliebig viele Argumente annehmen, geben jedoch nur einen Wert in Form eines Ausdrucks zurück. Sie können keine Befehle oder mehrere Ausdrücke enthalten.

• Eine anonyme Funktion kann kein direkter Aufruf zum Drucken sein, da Lambda einen Ausdruck erfordert.

• Lambda-Funktionen haben einen eigenen lokalen Namespace und können nicht auf andere Variablen als die in ihrer Parameterliste und die im globalen Namespace zugreifen.

• Obwohl es den Anschein hat, dass Lambdas eine einzeilige Version einer Funktion sind, entsprechen sie aus Leistungsgründen nicht den Inline-Anweisungen in C oder C ++, deren Zweck darin besteht, die Zuweisung durch Übergabe der Funktion während des Aufrufs zu stapeln.

Syntax

Die Syntax von lambda Funktionen enthält nur eine einzige Anweisung, die wie folgt lautet:

lambda [arg1 [,arg2,.....argn]]:expression

Das folgende Beispiel zeigt, wie lambda Form der Funktion funktioniert -

#!/usr/bin/python3

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2

# Now you can call sum as a function
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Value of total :  30
Value of total :  40

Die Rückgabeerklärung

Die Anweisung return [Ausdruck] beendet eine Funktion und gibt optional einen Ausdruck an den Aufrufer zurück. Eine return-Anweisung ohne Argumente ist dasselbe wie return None.

Alle unten angegebenen Beispiele geben keinen Wert zurück. Sie können einen Wert von einer Funktion wie folgt zurückgeben:

#!/usr/bin/python3

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print ("Inside the function : ", total)
   return total

# Now you can call sum function
total = sum( 10, 20 )
print ("Outside the function : ", total )

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Inside the function :  30
Outside the function :  30

Umfang der Variablen

Auf alle Variablen in einem Programm kann möglicherweise nicht an allen Stellen in diesem Programm zugegriffen werden. Dies hängt davon ab, wo Sie eine Variable deklariert haben.

Der Umfang einer Variablen bestimmt den Teil des Programms, in dem Sie auf eine bestimmte Kennung zugreifen können. In Python gibt es zwei grundlegende Bereiche von Variablen:

• Globale Variablen
• Lokale Variablen

Globale vs. lokale Variablen

Variablen, die innerhalb eines Funktionskörpers definiert sind, haben einen lokalen Bereich, und solche, die außerhalb definiert sind, haben einen globalen Bereich.

Dies bedeutet, dass auf lokale Variablen nur innerhalb der Funktion zugegriffen werden kann, in der sie deklariert sind, während auf globale Variablen von allen Funktionen im gesamten Programmkörper zugegriffen werden kann. Wenn Sie eine Funktion aufrufen, werden die darin deklarierten Variablen in den Gültigkeitsbereich gebracht. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python3

total = 0   # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print ("Inside the function local total : ", total)
   return total

# Now you can call sum function
sum( 10, 20 )
print ("Outside the function global total : ", total )

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Inside the function local total :  30
Outside the function global total :  0