As funções em Python são os blocos de código definidos que executam uma tarefa específica. Nesta seção, discutiremos a diferença em invocar funções com e sem parênteses.

• Quando chamamos uma função com parênteses , a função é executada e retorna o resultado ao que pode ser chamado .
• Em outro caso, quando chamamos uma função sem parênteses , uma referência de função é enviada ao chamável em vez de executar a própria função.

Vamos discutir três conceitos importantes:

• Invocando funções
• Funções de retorno
• Passando funções

Invocando funções -

A função abaixo executa uma tarefa simples, concatenação de strings. Aqui, invocaremos a função `concatenate_string` com e sem parênteses e veremos a diferença.

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) 

Resultado

Chamada de função com parênteses:
Ola George
Chamada de função sem parênteses:
<função concatenate_string em 0x7f0bb991df28>

Para o primeiro caso, quando chamamos concatenate_string('Hello, ', 'George'), a função executa e retorna a string concatenada.
E, para o segundo caso, quando chamamos concatenate_stringie sem parênteses, uma referência é passada para o chamável em vez de executar a própria função. Aqui, o chamável pode decidir o que fazer com a referência.

Funções de retorno -

A partir da discussão acima, você pode entender que, quando a função é chamada com parênteses, o código é executado e retorna o resultado. E, quando ele é chamado sem parênteses, uma referência de função é retornada ao chamável.
Então, o que acontece quando uma função é codificada junto com uma instrução de retorno com parênteses e sem parênteses. Vamos ver um exemplo.

Com parênteses

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() 

Resultado

Ola George

A partir do exemplo acima, está claro que merge_stringé uma função dentro da função concatenate_stringe a função principal ( concatenate_string) retorna a subfunção ( merge_string) para o chamador.

 return merge_string(string1, string2) 

Aqui merge_stringé chamado com parênteses, portanto, ele executa e fornece o resultado concatenate_stringde onde o resultado é passado func.

Sem parênteses

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() 

Resultado:

<function concatenate_string..merge_string em 0x7f1e54ebc158>
Ola George

Como o merge_stringé usado sem parênteses, o concatenate_stringpassa a referência da função para o chamável em funcvez de executar o merge_string.

return merge_string

Portanto, podemos concluir que, quando codificamos a subfunção com parênteses em uma instrução de retorno, a função principal executa a subfunção e passa o resultado para o que pode ser chamado. 
E, quando codificamos a subfunção sem parênteses em uma instrução de retorno, a função principal passa a referência da subfunção ao chamável em vez de executá-la. Aqui, o chamável decide o que fazer com a referência.

Passando funções -

Você pode passar uma função como um argumento criando a referência, chamando a função sem parênteses e fornecê-la como um argumento. Vamos dar uma olhada no código.

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))   

Resultado:

Ola George

Nesse caso, a referência de concatenate_stringé passada para o function_callcomo um argumento.

function_call(concatenate_string)

Dentro de function_call, ele executa o concatenate_stringusando a referência e retorna o resultado para o chamável.