Python - Funktionen

Vorherige SeiteNächste Seite

Eine Funktion ist ein Block aus organisiertem, wiederverwendbarem Code, der verwendet wird, um eine einzelne, zusammenhängende Aktion auszuführen. Funktionen bieten eine bessere Modularität für Ihre Anwendung und ein hohes Maß an Wiederverwendung von Code.

Wie Sie bereits wissen, bietet Ihnen Python viele eingebaute Funktionen wie print() usw., aber Sie können auch Ihre eigenen Funktionen erstellen. Diese Funktionen werden als benutzerdefinierte Funktionen. bezeichnet

Definieren einer Funktion

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

• Funktionsbausteine ​​beginnen mit dem Schlüsselwort def gefolgt vom Funktionsnamen und Klammern ( ( ) ).

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

• Die erste Anweisung einer Funktion kann eine optionale Anweisung sein – die Dokumentationszeichenfolge der Funktion oder docstring .

• Der Codeblock innerhalb jeder Funktion beginnt mit einem Doppelpunkt (:) und ist 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 angeben, in der sie definiert wurden.

Beispiel

Die folgende Funktion nimmt einen String als Eingabeparameter und gibt ihn auf dem Standardbildschirm aus.

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

Aufruf einer Funktion

Die Definition einer Funktion gibt ihr nur einen Namen, spezifiziert die Parameter, die in der Funktion enthalten sein sollen, und strukturiert die Codeblöcke.

Sobald die grundlegende Struktur einer Funktion fertiggestellt ist, können Sie sie ausführen, indem Sie sie von einer anderen Funktion oder direkt von der Python-Eingabeaufforderung aufrufen. Es folgt das Beispiel zum Aufrufen der Funktion printme() −

Live-Demo

#!/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, erzeugt er das folgende Ergebnis −

I'm first call to user defined function!
Again second call to the same function

Übergabe als Referenz vs. Wert

Alle Parameter (Argumente) in der Python-Sprache werden als Referenz übergeben. Das heißt, wenn Sie ändern, worauf sich ein Parameter innerhalb einer Funktion bezieht, spiegelt sich die Änderung auch in der aufrufenden Funktion wider. Zum Beispiel −

Live-Demo

#!/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 im selben Objekt an. Das 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 das Argument als Referenz übergeben wird und die Referenz innerhalb der aufgerufenen Funktion überschrieben wird.

Live-Demo

#!/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 die Funktion changeme. Das Ändern von mylist innerhalb der Funktion wirkt sich nicht auf mylist aus . Die Funktion bringt nichts und schließlich würde dies folgendes Ergebnis liefern −

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
• Keyword-Argumente
• Standardargumente
• Argumente variabler Länge

Erforderliche Argumente

Erforderliche Argumente sind die Argumente, die an eine Funktion in korrekter Positionsreihenfolge übergeben werden. Dabei 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, sonst gibt es einen Syntaxfehler wie folgt:−

Live-Demo

#!/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, erzeugt er das folgende Ergebnis −

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

Keyword-Argumente

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

Auf diese Weise können Sie Argumente überspringen oder in der falschen Reihenfolge platzieren, da der Python-Interpreter die bereitgestellten Schlüsselwörter verwenden kann, um die Werte mit Parametern abzugleichen. Sie können printme() auch mit Schlüsselwörtern aufrufen funktionieren wie folgt −

Live-Demo

#!/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, erzeugt er das folgende Ergebnis −

My string

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

Live-Demo

#!/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, erzeugt er das folgende Ergebnis −

Name:  miki
Age  50

Standardargumente

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

Live-Demo

#!/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, erzeugt er das folgende Ergebnis −

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 variable Länge genannt Argumente und werden im Gegensatz zu erforderlichen und Standardargumenten nicht in der Funktionsdefinition benannt.

Die Syntax für eine Funktion mit Variablenargumenten, die keine Schlüsselwörter sind, lautet wie folgt:−

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

Vor dem Variablennamen, der die Werte aller Nicht-Schlüsselwort-Variablenargumente enthält, wird ein Sternchen (*) platziert. Dieses Tupel bleibt leer, wenn beim Funktionsaufruf keine weiteren Argumente angegeben werden. Es folgt ein einfaches Beispiel −

Live-Demo

#!/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, erzeugt er das folgende Ergebnis −

Output is:
10
Output is:
70
60
50

Der Anonyme Funktionen

Diese Funktionen werden anonym genannt, da sie nicht standardmäßig mit def deklariert werden Stichwort. Sie können das Lambda verwenden Schlüsselwort, um kleine anonyme Funktionen zu erstellen.

• Lambda-Formulare können eine beliebige Anzahl von Argumenten annehmen, geben aber nur einen Wert in Form eines Ausdrucks zurück. Sie dürfen keine Befehle oder mehrere Ausdrücke enthalten.

• Eine anonyme Funktion kann kein direkter Aufruf von print sein, da Lambda einen Ausdruck erfordert

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

• Obwohl es scheint, dass Lambdas eine einzeilige Version einer Funktion sind, entsprechen sie nicht den Inline-Anweisungen in C oder C++, deren Zweck es ist, aus Leistungsgründen die Funktionsstapelzuordnung während des Aufrufs zu übergeben.

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 −

Live-Demo

#!/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, erzeugt er das folgende Ergebnis −

Value of total :  30
Value of total :  40

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

Live-Demo

#!/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, erzeugt er das folgende Ergebnis −

Inside the function :  30
Outside the function :  30

Umfang von Variablen

Alle Variablen in einem Programm sind möglicherweise nicht an allen Stellen in diesem Programm zugänglich. Dies hängt davon ab, wo Sie eine Variable deklariert haben.

Der Gültigkeitsbereich einer Variablen bestimmt den Teil des Programms, in dem Sie auf einen bestimmten Bezeichner zugreifen können. Es gibt zwei grundlegende Bereiche von Variablen in Python −

• Globale Variablen
• Lokale Variablen

Globale vs. lokale Variablen

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

Das bedeutet, dass auf lokale Variablen nur innerhalb der Funktion zugegriffen werden kann, in der sie deklariert sind, während auf globale Variablen im gesamten Programmrumpf von allen Funktionen zugegriffen werden kann. Wenn Sie eine Funktion aufrufen, werden die darin deklarierten Variablen in den Geltungsbereich gebracht. Es folgt ein einfaches Beispiel −

Live-Demo

#!/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, erzeugt er das folgende Ergebnis −

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