Python - 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 nur 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. Das folgende Beispiel ruft die Funktion printme () auf -

#!/usr/bin/python

# 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("I'm first call to user defined function!")
printme("Again second call to the same function")

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

I'm first call to 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/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   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

Hier behalten wir die Referenz des übergebenen Objekts bei und hängen Werte an dasselbe Objekt an. Dies würde also zu folgendem Ergebnis führen:

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

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

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4]; # This would assig 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 mylist ist 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.

Um die Funktion printme () aufzurufen , müssen Sie auf jeden Fall ein Argument übergeben, da sonst ein Syntaxfehler wie folgt ausgegeben wird:

#!/usr/bin/python

# 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 die Funktion printme () auch auf folgende Weise mit Schlüsselwörtern aufrufen :

#!/usr/bin/python

# 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 gibt ein klareres Bild. Beachten Sie, dass die Reihenfolge der Parameter keine Rolle spielt.

#!/usr/bin/python

# 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/python

# 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 in der Funktionsdefinition im Gegensatz zu erforderlichen und Standardargumenten nicht benannt.

Die Syntax für eine Funktion mit Variablenargumenten ohne Schlüsselwort lautet:

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/python

# 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 Schlüsselwort def deklariert werden. Mit dem Schlüsselwort lambda können Sie kleine anonyme Funktionen erstellen.

• 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 nicht den Inline-Anweisungen in C oder C ++, deren Zweck darin besteht, die Funktionsstapelzuweisung während des Aufrufs aus Leistungsgründen zu übergeben.

Syntax

Die Syntax von Lambda- Funktionen enthält nur eine einzige Anweisung:

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

Das folgende Beispiel zeigt, wie die Lambda- Funktionsform funktioniert:

#!/usr/bin/python

# 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ückkehr Statement

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 obigen Beispiele geben keinen Wert zurück. Sie können einen Wert von einer Funktion wie folgt zurückgeben:

#!/usr/bin/python

# 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/python

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