Python - Funções

Página anteriorPróxima página
Uma função é um bloco de código organizado e reutilizável que é usado para executar 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, o Python oferece muitas funções internas 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 ou argumentos de entrada devem ser colocados entre esses 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 é recuado.
  
• 
  A instrução return [expressão] sai de uma função, opcionalmente passando de volta uma expressão para o chamador. Uma instrução return sem argumentos é igual a return None.
  

Sintaxe

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

Por padrão, os parâmetros têm um comportamento posicional e você precisa informá-los na mesma ordem em que foram definidos.

Exemplo

A função a seguir recebe 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 estiver finalizada, você poderá 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() −
Demonstração ao vivo

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

Passar 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 o que um parâmetro se refere em uma função, a alteração também será refletida na função de chamada. Por exemplo -
Demonstração ao vivo

#!/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.
Demonstração ao vivo

#!/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 minhalista é local para a função changeme. Alterar minhalista dentro da função não afeta minhalista . 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 palavra-chave
• Argumentos padrão
• Argumentos de comprimento variável

Argumentos necessários

Os argumentos obrigató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, dará um erro de sintaxe da seguinte forma −
Demonstração ao vivo

#!/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 palavra-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 pode usar as palavras-chave fornecidas para corresponder os valores com os parâmetros. Você também pode fazer chamadas de palavras-chave para printme() funcionam das seguintes maneiras -
Demonstração ao vivo

#!/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.
Demonstração ao vivo

#!/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 −
Demonstração ao vivo

#!/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 especificou ao definir a função. Esses argumentos são chamados de comprimento variável argumentos 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 de variáveis ​​que não são palavras-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 ​​que não sejam palavras-chave. Essa tupla permanece vazia se nenhum argumento adicional for especificado durante a chamada da função. A seguir está um exemplo simples -
Demonstração ao vivo

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

O Anônimo Funções

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

• 
  Os formulários 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 várias expressões.
  
• 
  Uma função anônima não pode ser uma chamada direta para imprimir porque lambda requer uma expressão
  
• 
  As funções do Lambda têm seu próprio namespace local e não podem acessar variáveis ​​que não estejam na lista de parâmetros e 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++, cuja finalidade é passar a alocação de pilha de função durante a invocação por motivos de desempenho.
  

Sintaxe

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

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

Segue o exemplo para mostrar como lambda forma de função funciona −
Demonstração ao vivo

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

O retorno Declaração

A instrução return [expressão] sai de uma função, opcionalmente passando de volta uma expressão para o chamador. Uma instrução return sem argumentos é igual a 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 -
Demonstração ao vivo

#!/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 determinado identificador. Existem dois escopos básicos de variáveis ​​em Python -

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

Variáveis ​​globais x locais

As 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 em que 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 -
Demonstração ao vivo

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