Funktionen in Python sind die definierten Codeblöcke, die eine bestimmte Aufgabe ausführen. In diesem Abschnitt werden wir den Unterschied beim Aufrufen von Funktionen mit und ohne Klammern erläutern.

• Wenn wir eine Funktion mit Klammern aufrufen , wird die Funktion ausgeführt und gibt das Ergebnis an den aufrufbaren zurück.
• In einem anderen Fall, wenn wir eine Funktion ohne Klammern aufrufen , wird eine Funktionsreferenz an den aufrufbaren gesendet, anstatt die Funktion selbst auszuführen.

Lassen Sie uns 3 wichtige Konzepte diskutieren:

• Funktionen aufrufen
• Rückgabefunktionen
• Funktionen übergeben

Funktionen aufrufen -

Die folgende Funktion führt eine einfache Aufgabe aus, die Verkettung von Zeichenfolgen. Hier rufen wir die Funktion `concatenate_string` mit und ohne Klammern auf und sehen den Unterschied.

def concatenate_string(*args): 
    string1 = args[0] 
    string2 = args[1] 
  
    return string1 + string2 
  
obj = concatenate_string('Hello, ', 'George') 
print('Function call with Parentheses: ') 
print(obj) 
  
obj = concatenate_string 
print('Function call without Parentheses: ') 
print(obj) 

Ausgabe

Funktionsaufruf mit Klammern:
Hallo George
Funktionsaufruf ohne Klammern:
<function concatenate_string at 0x7f0bb991df28>

Im ersten Fall concatenate_string('Hello, ', 'George')führt die Funktion beim Aufruf die verkettete Zeichenfolge aus und gibt sie zurück.
Und für den zweiten Fall, wenn wir concatenate_stringdh ohne Klammern aufrufen , wird eine Referenz an den aufrufbaren übergeben, anstatt die Funktion selbst auszuführen. Hier kann der Anrufer entscheiden, was mit der Referenz geschehen soll.

Rückgabefunktionen -

Aus der obigen Diskussion können Sie ersehen, dass beim Aufrufen der Funktion in Klammern der Code ausgeführt wird und das Ergebnis zurückgibt. Und wenn es ohne Klammern aufgerufen wird, wird eine Funktionsreferenz an den aufrufbaren zurückgegeben.
Was passiert also, wenn eine Funktion zusammen mit einer return-Anweisung mit Klammern und ohne Klammern codiert wird? Lassen Sie uns ein Beispiel durchgehen.

Mit Klammern

def concatenate_string(*args): 
  
    string1 = args[0] 
    string2 = args[1] 
      
    def merge_string(string1, string2): 
        return string1 + string2 
      
    return merge_string(string1, string2) 
  
def func(): 
    conc_obj = concatenate_string('Hello, ', 'George') 
    print(conc_obj) 
  
func() 

Ausgabe

Hallo George

Aus dem obigen Beispiel geht hervor, dass merge_stringes sich um eine Funktion innerhalb der Funktion handelt concatenate_stringund die Hauptfunktion ( concatenate_string) die Unterfunktion ( merge_string) an den Aufrufer zurückgibt .

 return merge_string(string1, string2) 

Hier merge_stringwird mit Klammern aufgerufen, daher wird es ausgeführt und liefert das Ergebnis an die Stelle, concatenate_stringan die das Ergebnis übergeben wird func.

Ohne Klammern

def concatenate_string(): 
      
    def merge_string(string1, string2): 
        return string1 + string2 
      
    return merge_string 
  
def func(): 
      
    
    conc_obj = concatenate_string() 
    print(conc_obj)  
  
    
    print(conc_obj('Hello, ', 'George'))   
  
func() 

Ausgabe:

<function concatenate_string..merge_string at 0x7f1e54ebc158>
Hallo George

Da das merge_stringohne Klammern verwendet wird, concatenate_stringübergibt das die Funktionsreferenz an das aufrufbare, funcanstatt das auszuführen merge_string.

return merge_string

Wir können daher den Schluss ziehen, dass die Hauptfunktion die Unterfunktion ausführt und das Ergebnis an den aufrufbaren Code weitergibt, wenn wir die Unterfunktion in einer return-Anweisung mit Klammern codieren. 
Und wenn wir eine Unterfunktion ohne Klammern in einer return-Anweisung codieren, übergibt die Hauptfunktion die Unterfunktionsreferenz an den aufrufbaren, anstatt sie auszuführen. Hier entscheidet der Callable, was mit der Referenz geschehen soll.

Funktionen übergeben -

Sie können eine Funktion als Argument übergeben, indem Sie die Referenz erstellen, die Funktion ohne Klammern aufrufen und als Argument angeben. Schauen wir uns den Code an.

def concatenate_string(*args): 
    string1 = args[0] 
    string2 = args[1] 
  
    def merge_string(string1, string2): 
        return string1 + string2  
     
    
    return merge_string(string1, string2) 
  
def function_call(function): 
    string1 = 'Hello, '
    string2 = 'George'
    return function(string1, string2) 
  
print(function_call(concatenate_string))   

Ausgabe:

Hallo George

In diesem Fall wird die Referenz concatenate_stringübergeben wird , um das function_callals Argument.

function_call(concatenate_string)

Innerhalb von function_call führt es die concatenate_stringVerwendung der Referenz aus und gibt das Ergebnis an den aufrufbaren zurück.