Python 3 - 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 dá a ela 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á um exemplo para chamar oprintme() função -

#!/usr/bin/python3

# 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("This is first call to the user defined function!")
printme("Again second call to the same function")

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

This is first call to the user defined function!
Again second call to the same function

Passagem por referência x 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/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("Values inside the function before change: ", mylist)
   
   mylist[2]=50
   print ("Values inside the function after change: ", 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. Portanto, isso produziria o seguinte resultado -

Values inside the function before change:  [10, 20, 30]
Values inside the function after change:  [10, 20, 50]
Values outside the function:  [10, 20, 50]

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/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4] # This would assi 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 Requeridos

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

#!/usr/bin/python3

# 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 oprintme() funcionar das seguintes maneiras -

#!/usr/bin/python3

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

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

# 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 é fornecida abaixo -

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/python3

# 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 o defpalavra-chave. Você pode usar olambda palavra-chave 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 lambdas sejam 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 é empilhar a alocação passando uma função, durante a chamada 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

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

#!/usr/bin/python3

# 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 fornecidos abaixo não estão retornando nenhum valor. Você pode retornar um valor de uma função da seguinte maneira -

#!/usr/bin/python3

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

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