codestory

Die Anleitung zu Python Function

  1. Python Function
  2. Das Beispiel über Function
  3. Die Funktion mit den erforderlichen Parametern
  4. Die Funktion mit Default parameter
  5. Die Funktion mit dem Variable-Length parameter
  6. Die Anonyme Funktion

1. Python Function

Die Funktion (function) ist ein besonderer Befehlblock. Sie wird einen Namen gestellt, damit die Code des Programm leicht zu lesen ist und in die unterschiedlichen Orten im Programm benutzt wird. Die Funktion ist der wiederverwendbare Befehlblock (reuseable).
Die Syntax
** function syntax **
def functionName( parameters ):
   "Short description of the function"
   codes ...
   return [expression]
  • Eine Funktion beginnt mit einen Schlüsselwort def (Abkürzung von define), danach steht der Name von der Funktion.
  • Zum nächsten ist die Liste vom Parameter in die runde Klammer ( ) und den Doppeltpunkt ( : ), Die Funktion kann 0, 1 oder viele Parameter haben. Die Parameter werden durch Komma getrennt .
  • Die erste Linie von der Funktion-Body ist eine kurze Bezeichungskette über die Funktion (nicht zwingend).
Der Befehl return:
Der Befehl return ist zuständig für die Rückgabe einer Wert (oder eine Ausdruck), oder einfach "nichts". Wenn der Befehl return implementiert wird, wird die Funktion enden. return muss zwingend in dem Funktion body nicht sein
Beispiel
Die Bezeichnung
return 3
Die Funktion gibt einer Wert zurück und endet
return
Die Funktion gibt nichts zurück und endet
Der Parameter
Die Funktion hat 0, 1 oder viele Parameter, die durch Komma getrennt werden. Es gibt 4 Arten von Parameter
  • Compulsory parameter
  • Default parameter
  • Variable-Length Parameter
  • Keyword Parameter

2. Das Beispiel über Function

Zum Beispiel: eine Funktion hat ein Parameter und gibt "nichts" zurück.
functionExample1.py
# Die Definition einer Funktion:
def sayHello(name)  : 
    # Prüfen, ob name leer (empty) oder null ist
    if not name   : 
        print( "Hello every body!" ) 
    # Wenn name nicht leer und nicht null ist.    
    else :          
        print( "Hello " + name)

# Die Aufruf auf der Funktion, die Übertragung des Parameter in die Funktion
sayHello("") 
sayHello("Python");  
sayHello("Java");
Output:
Hello every body!
Hello Python
Hello Java
Danach ist ein Beispiel über eine Funktion mit Parameter und Rückgabe einer Wert
functionExample2.py
# Die Definition einer Funktion 
def getGreeting(name)  :

    # Prüfen, ob name leer oder null (none) ist
    if not name   :
        # Eine Wert zurückgeben.
        # Und die Funktion endet hier
        return "Hello every body!"
    
    # Wenn name nicht leer und nicht null ist, 
    # wird die folgende Code implementiert.
    return "Hello " + name

# Die Aufruf auf die Funktion und die Übertragung des Parameter in die Funktion
greeting = getGreeting("") 
print(greeting)  
greeting = getGreeting("Python") 
print(greeting)
Output:
Hello every body!
Hello Python

3. Die Funktion mit den erforderlichen Parametern

Das folgende Beispiel definiert die Funktion showInfo, die 2 Parameter hat und sie sind obligatorisch. Wenn Sie die Funktion aufrufen, sollen Sie 2 Parameter in der Funktion bringen. wenn nicht, erscheint eine Fehleranmeldung
requiredParameterExample.py
def showInfo(name, gender):
    print ("Name: ", name);
    print ("Gender: ", gender);

# Valid  
showInfo("Tran", "Male")  
# Invalid ==> Error!!
showInfo("Tran")

4. Die Funktion mit Default parameter

Die Funktion können viele Parameter haben, einschließlich die obligatorische Parameter und die Default Parameter.
Die folgende Funktion showInfo hat 3 Parameter (name, gender = "Male", country = "US"):
  • name ist der obligatorische Parameter.
  • gender ist der Default Parameter "Male".
  • country ist der Default Parameter "US".
defaultParameterExample.py
def showInfo(name, gender = "Male", country ="US"):
    print ("Name: ", name)
    print ("Gender: ", gender)
    print ("Country: ", country)

# Valid    
showInfo("Aladdin", "Male", "India")  
print (" ------ ")
# Valid  
showInfo("Tom", "Male")
print (" ------ ")
# Valid  
showInfo("Jerry")
print (" ------ ")
# Valid  
showInfo(name = "Tintin", country ="France")
print (" ------ ")
Output:
Name: Aladdin
Gender: Male
Country: India
 ------
Name: Tom
Gender: Male
Country: US
 ------
Name: Jerry
Gender: Male
Country: US
 ------
Name: Tintin
Gender: Male
Country: France
 ------

5. Die Funktion mit dem Variable-Length parameter

Variable-length Parameter ist ein besonderer Parameter. Bei der Aufruf nach Funktion können Sie 0, 1 oder viele dem Parameter entsprechenden Werten bringen (pass).

Beachten Sie : "Variable-length Parameter" ist immer der letzte Parameter von der Funktion.
Zum Beispiel:
Die Funktion sumValues hat 3 Parameter
  • Der Parameter a, b sind obligatorisch.
  • Der Parameter *others ist "Variable-Length Parameter".
variableLengthParameterExample.py
def sumValues(a, b, *others): 
    retValue = a + b
    
    # Der Parameter 'others' wie einen Array
    for other in others :
        retValue = retValue + other
        
    return retValue
Die Weise von der Aufruf einer Funktion
testVariableLengthParameter.py
from variableLengthParameterExample import sumValues

#  *others = [] übertragen
a = sumValues(10, 20) 
print("sumValues(10, 20) = ", a);

#  *others = [1]  übertragen
a = sumValues(10, 20, 1);  
print("sumValues(10, 20, 1 ) = ", a);

#  *others = [1,2]  übertragen
a = sumValues(10, 20, 1, 2);  
print("sumValues(10, 20, 1 , 2) = ", a);

#  *others = [1,2,3,4,5] übertragen
a = sumValues(10, 20, 1, 2,3,4,5);  
print("sumValues(10, 20, 1, 2, 3, 4, 5) = ", a);
Output:
sumValues(10, 20) = 30
sumValues(10, 20, 1) = 31
sumValues(10, 20, 1, 2) = 33
sumValues(10, 20, 1, 2, 3, 4, 5) = 45

6. Die Anonyme Funktion

Die Funktionen sind anonym wenn sie nach dem normalen Weg durch den Schlüsselwort def nicht definiert werden, sondern benutzen sie den Schlüsselwort von lambda.
  • Die anonymen Funktion kann 0 oder viele Parameter. aber im Funktionskörper gibt es nur einzigen Ausdruck (expression). die Wert des Ausdruck ist die Rückgabewert der Funktion. Aber das Schlüsselwort 'return' wird vor dem Ausdruck nicht benutzt
  • Die Liste der Parameter werden durch Komma getrennt und nicht in die Anführungszeichen ( ) gelegt.
  • Im Körper der anonymen Funktion können Sie in die externen Variable zugreifen, sondern nur ihre Parameter.
  • Die anonymen Funktion ruft auf die Funktion print direkt nicht auf, denn lambda einen Ausdruck fordert
Die Syntax
* syntax *
lambda [arg1 [,arg2,.....argn]]  :  expression
Zum Beispiel
lambdaFunctionExample.py
# Eine Variable erklären: hello = eine anonyme Funktion ohne den Parameter.
hello = lambda  : "Hello"

# Eine Variable: mySum = eine anonyme Funktion mit 2 Parameter
mySum = lambda a, b : a + b 

a= hello() 
print (a) 

a = mySum(10, 20) 
print (a)
Output:
Hello
30

Neueste Artikel

Show More