Python - funções

Uma função é um bloco de código organizado e reutilizável que é usado para realizar uma única ação relacionada. As funções fornecem melhor modularidade para seu aplicativo e um alto grau de reutilização de código.

Como você já sabe, Python oferece muitas funções integradas, como print (), etc., mas você também pode criar suas próprias funções. Essas funções são chamadas de funções definidas pelo usuário.

Definindo uma função

Você pode definir funções para fornecer a funcionalidade necessária. Aqui estão regras simples para definir uma função em Python.

• Os blocos de função começam com a palavra-chave def seguido pelo nome da função e parênteses (()).

• Quaisquer parâmetros de entrada ou argumentos devem ser colocados entre parênteses. Você também pode definir parâmetros dentro desses parênteses.

• A primeira instrução de uma função pode ser uma instrução opcional - a string de documentação da função ou docstring .

• O bloco de código dentro de cada função começa com dois pontos (:) e é indentado.

• A instrução return [expressão] sai de uma função, opcionalmente, passando de volta uma expressão para o chamador. Uma instrução de retorno sem argumentos é o mesmo que return None.

Sintaxe

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

Por padrão, os parâmetros possuem um comportamento posicional e é necessário informá-los na mesma ordem em que foram definidos.

Exemplo

A função a seguir pega uma string como parâmetro de entrada e a imprime na tela padrão.

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

Chamando uma função

Definir uma função apenas lhe dá um nome, especifica os parâmetros que devem ser incluídos na função e estrutura os blocos de código.

Depois que a estrutura básica de uma função é finalizada, você pode executá-la chamando-a de outra função ou diretamente do prompt do Python. A seguir está o exemplo para chamar a função printme () -

#!/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")

Quando o código acima é executado, ele produz o seguinte resultado -

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

Passe por referência vs valor

Todos os parâmetros (argumentos) na linguagem Python são passados ​​por referência. Isso significa que se você alterar a que um parâmetro se refere em uma função, a alteração também refletirá de volta na função de chamada. Por exemplo -

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

Aqui, estamos mantendo a referência do objeto passado e acrescentando valores no mesmo objeto. Então, isso produziria o seguinte resultado -

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

Há mais um exemplo em que o argumento está sendo passado por referência e a referência está sendo substituída dentro da função chamada.

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

O parâmetro mylist é local para a função changeme. Alterar minha lista dentro da função não afeta minha lista . A função não realiza nada e, finalmente, isso produziria o seguinte resultado -

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

Argumentos de função

Você pode chamar uma função usando os seguintes tipos de argumentos formais -

• Argumentos necessários
• Argumentos de palavras-chave
• Argumentos padrão
• Argumentos de comprimento variável

Argumentos necessários

Os argumentos necessários são os argumentos passados ​​para uma função na ordem posicional correta. Aqui, o número de argumentos na chamada da função deve corresponder exatamente à definição da função.

Para chamar a função printme () , você definitivamente precisa passar um argumento, caso contrário, ocorrerá um erro de sintaxe da seguinte maneira -

#!/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()

Quando o código acima é executado, ele produz o seguinte resultado -

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

Argumentos de palavras-chave

Os argumentos de palavra-chave estão relacionados às chamadas de função. Quando você usa argumentos de palavra-chave em uma chamada de função, o chamador identifica os argumentos pelo nome do parâmetro.

Isso permite pular argumentos ou colocá-los fora de ordem porque o interpretador Python é capaz de usar as palavras-chave fornecidas para combinar os valores com os parâmetros. Você também pode fazer chamadas de palavras-chave para a função printme () das seguintes maneiras -

#!/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")

Quando o código acima é executado, ele produz o seguinte resultado -

My string

O exemplo a seguir fornece uma imagem mais clara. Observe que a ordem dos parâmetros não importa.

#!/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" )

Quando o código acima é executado, ele produz o seguinte resultado -

Name:  miki
Age  50

Argumentos padrão

Um argumento padrão é um argumento que assume um valor padrão se um valor não for fornecido na chamada de função para esse argumento. O exemplo a seguir dá uma ideia sobre os argumentos padrão, ele imprime a idade padrão se não for passado -

#!/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" )

Quando o código acima é executado, ele produz o seguinte resultado -

Name:  miki
Age  50
Name:  miki
Age  35

Argumentos de comprimento variável

Você pode precisar processar uma função para mais argumentos do que os especificados ao definir a função. Esses argumentos são chamados de argumentos de comprimento variável e não são nomeados na definição da função, ao contrário dos argumentos obrigatórios e padrão.

A sintaxe para uma função com argumentos variáveis ​​sem palavra-chave é esta -

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

Um asterisco (*) é colocado antes do nome da variável que contém os valores de todos os argumentos de variáveis ​​não-palavra-chave. Essa tupla permanece vazia se nenhum argumento adicional for especificado durante a chamada da função. A seguir está um exemplo simples -

#!/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 )

Quando o código acima é executado, ele produz o seguinte resultado -

Output is:
10
Output is:
70
60
50

As funções anônimas

Essas funções são chamadas de anônimas porque não são declaradas da maneira padrão usando a palavra-chave def . Você pode usar a palavra-chave lambda para criar pequenas funções anônimas.

• As formas lambda podem receber qualquer número de argumentos, mas retornam apenas um valor na forma de uma expressão. Eles não podem conter comandos ou expressões múltiplas.

• Uma função anônima não pode ser uma chamada direta para imprimir porque lambda requer uma expressão

• As funções Lambda têm seu próprio namespace local e não podem acessar variáveis ​​diferentes daquelas em sua lista de parâmetros e aquelas no namespace global.

• Embora pareça que os lambda são uma versão de uma linha de uma função, eles não são equivalentes a instruções embutidas em C ou C ++, cujo objetivo é passar a alocação da pilha de funções durante a invocação por motivos de desempenho.

Sintaxe

A sintaxe das funções lambda contém apenas uma única instrução, que é a seguinte -

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

A seguir está o exemplo para mostrar como funciona a forma lambda da função -

#!/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 )

Quando o código acima é executado, ele produz o seguinte resultado -

Value of total :  30
Value of total :  40

A declaração de retorno

A instrução return [expressão] sai de uma função, opcionalmente, passando de volta uma expressão para o chamador. Uma instrução de retorno sem argumentos é o mesmo que return None.

Todos os exemplos acima não estão retornando nenhum valor. Você pode retornar um valor de uma função da seguinte maneira -

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

Quando o código acima é executado, ele produz o seguinte resultado -

Inside the function :  30
Outside the function :  30

Escopo das Variáveis

Todas as variáveis ​​em um programa podem não estar acessíveis em todos os locais desse programa. Isso depende de onde você declarou uma variável.

O escopo de uma variável determina a parte do programa onde você pode acessar um identificador específico. Existem dois escopos básicos de variáveis ​​em Python -

• Variáveis ​​globais
• Variáveis ​​locais

Variáveis ​​globais vs. locais

Variáveis ​​que são definidas dentro de um corpo de função têm um escopo local e aquelas definidas fora têm um escopo global.

Isso significa que as variáveis ​​locais podem ser acessadas apenas dentro da função na qual são declaradas, enquanto as variáveis ​​globais podem ser acessadas em todo o corpo do programa por todas as funções. Quando você chama uma função, as variáveis ​​declaradas dentro dela são trazidas para o escopo. A seguir está um exemplo simples -

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

Quando o código acima é executado, ele produz o seguinte resultado -

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