Introdução
Uma função em Python é um bloco de instruções que recebe entrada, executa instruções e retorna informações de entrada. Os blocos de código definidos como uma função podem ser reutilizados.
O Python tem funções incorporadas:
- print() - exibe informações;
- int() - converte uma cadeia de caracteres ou um tipo de dados numérico em um tipo de dados inteiro;
- len() - retorna o comprimento do valor;
Neste tutorial, veremos como criar novas funções para uso em nosso projeto.
Preparação antes do trabalho
É necessário preparar o sistema para o trabalho, instalar o Python 3 mais recente e implantar o ambiente virtual.
Definição de função
Vamos considerar o código usual, como o de exibição de informações. Vamos criar um arquivo test_hello.py e adicionar uma função em nosso ambiente virtual. Uma função é definida usando a palavra-chave def():
Se você estiver usando o editor de texto Vim, depois de criar a função, o Vim redirecionará para a segunda linha usando tabulação automática.
Vamos adicionar o seguinte trecho de código para gerar informações no console.
print("Hello, Dear, User!")
Chame a função no final do código hello().
print("Hello, Dear, User!")
hello()
Vamos executar o código e obter o resultado:
As funções têm diferentes graus de complexidade, sendo que a mais simples foi discutida acima.
Considere a função abaixo, que usará instruções condicionais if-else para iterar sobre vogais em strings.
def names():
# Name input variable
name = str(input('Enter your name: '))
# Checking for vowels
if set('aeiou').intersection(name.lower()):
print('Your name has vowels!')
else:
print('Your name does not contain vowels')
# Iterate by name
for letter in name:
print(letter)
# Function call
names()
Portanto, criamos a função names() e usamos instruções condicionais if-else e uma instrução for nela.
Trabalhando com parâmetros
Até este ponto, consideramos as funções sem o uso de parâmetros; em seguida, definiremos a função e seus parâmetros.
Os parâmetros são objetos em nossa função que apontam para um argumento que a função pode receber.
Considere um código com três parâmetros i, j e k e crie uma função para somar todos eles em diferentes configurações. Em seguida, suas somas serão impressas na função add(). Chame a função para obter o resultado.
Vamos escrever o seguinte trecho de código em um novo arquivo TestAdd.py:
q = i + j
w = i + k
e = j + k
print(q, w, e)
add(20, 25, 30)
Passamos os dados para os parâmetros, ou seja, 20 - para o parâmetro i, 25 - para o parâmetro j, 30 - para o parâmetro k. O programa executa as seguintes operações matemáticas:
w = 20 + 30
e = 25 + 30
Vamos executar o programa e obter nosso resultado no formato:
Quando passamos 20, 25 e 30 como parâmetros para a função add(), obtivemos o resultado esperado.
Principais argumentos
Os parâmetros podem ser chamados não apenas em ordem, mas também usando argumentos-chave no momento em que a função chamada identifica os argumentos pelo nome do parâmetro.
Vamos criar um arquivo chamado TestInfo. Vamos definir a função info() e atribuir parâmetros. Vamos adicionar uma instrução print() para exibir informações. No final do código, chamamos a função info usando os parâmetros e seus valores definidos dentro da chamada da função info().
def info(name, age):
print("Name: " + name)
print("Age: " + str(age))
Em seguida, considere a possibilidade de atribuir valores aos parâmetros.
def info(name, age):
print("Name: " + name)
print("Age: " + str(age))
#Calling a function with parameters above
info("ServerSpace", 25)
#Calling a Function Using Key Arguments
info(name="Team", age=35)
Vamos executar o código e obter o resultado:
No código a seguir, considere a especificação do parâmetro age no início da chamada da função info(). Depois de definir a função, chamamos a instrução print() para imprimir informações sobre o nome e a idade.
No final do código, chamamos a função info, especificando primeiro a idade e depois o nome. Mas antes disso, obtemos o resultado sobre o nome e depois sobre a idade dentro da função info(). O motivo é que a ordem em que a instrução print() é chamada não foi alterada:
def info(name, age):
print("Name: " + name)
print("Age: " + str(age))
#Calling a Function Using Key Arguments
info(age=40, name="ServerSpaceTeam")
Atribuição de argumentos-chave
Copie o arquivo TestInfo.py e altere o nome para TestInfoValue.py
Por padrão, o parâmetro age recebe o valor "1". Se você chamar a função info sem especificar o valor do parâmetro age, obteremos o resultado Age = 1. Considere as opções para chamar a função info com o valor do parâmetro age e usar o argumento key:
def info(name, age=1):
print("Name: " + name)
print("Age: " + str(age))
#Calling a Function with a Key Argument and Without a Key Argument
info(name="ServerSpace")
info(name="Team", age=15)
Consideramos dois tipos de chamada da função info(). No primeiro caso, especificamos um valor para o parâmetro name e não especificamos um valor para o parâmetro age e, ao exibir as informações, o parâmetro age recebeu um valor padrão de "1". No segundo caso, foram especificados valores para ambos os parâmetros, mas o valor padrão do parâmetro age não foi exibido.
Retorno de valores
Os dados dos parâmetros podem ser passados para uma função. O valor de um parâmetro pode ser retornado usando a instrução return.
Ao usar return sem um argumento, obtemos um resultado com o valor None.
Vamos criar um arquivo TestSquare.py e definir a função testsquare com o parâmetro i. Vamos adicionar uma variável j na qual elevamos o parâmetro i à terceira potência. Usamos return para retornar o valor obtido como resultado da operação dentro da variável j. Usando a variável result, atribuímos o valor 5 ao parâmetro i na função testsquare. No final do código, usamos a instrução print() para imprimir as informações do resultado. Isso retornará o valor da operação 5 ** 3. O uso de "**" no Python denota exponenciação:
j = i ** 3
return j
result = testsquare(5)
print(result)
Depois de executar o código e obter o resultado:
Se comentarmos a linha return j, obteremos o resultado:
Considere o retorno de uma função com return em TestAdd.py:
q = i + j
w = i + k
e = j + k
return q, w, e
result = add(20,25,30)
print(result)
Vamos executar o código e obter o resultado:
Obtemos o valor (45, 50, 55) como uma tupla, pois quando a função de retorno foi chamada, as variáveis foram especificadas separadas por vírgulas.
Usando main() como uma função
A função main() coloca os componentes do programa em uma única função, enquanto a função main() não precisa ser chamada no programa.
Considere o uso de main() em um programa normal, vamos criar um arquivo TestMain.py. Vamos definir a função TestMain e adicionar uma instrução print() para imprimir texto. Vamos definir uma função main() e adicionar uma instrução print(). Na parte inferior do código, adicione TestMain() e main() para chamar funções e exibir texto. Vamos escrever o código, executá-lo e obter o resultado:
print("Hello, Dear, User!")
def main():
print("This is test text")
TestMain()
main()
No Python, você pode usar a seguinte construção '__main__', que executará o código de nível superior.
Toda a estrutura é semelhante a esta:
Considere um programa que usa a construção "__main__". A lógica do programa é que o código analisa o valor inserido na variável name e faz a correspondência com as vogais. Se o nome contiver vogais, o resultado será retornado
"Seu nome tem vogais":
name = str(input('Your name: '))
# Function to check vowels
def vowel():
if set('aeiou').intersection(name.lower()):
print('Your name has vowels!')
else:
print('Your name has no vowels!')
# Iteration of letters in a name
def print_letters():
for letter in name:
print(letter)
# Main function definition
def main():
has_vowel()
print_letters()
# Executing the main function
if __name__ == '__main__':
main()
Você também pode especificar duas funções has_vowel() e print_letters() no final; o resultado será o mesmo:
has_vowel()
print_letters()
Conclusões
Como resultado, podemos dizer que as funções são objetos que recebem argumentos e retornam um valor.
Para obter mais informações sobre como escrever um módulo em Python, sugerimos que você consulte nosso guia.
Aqui, examinamos possibilidades como:
- definição de funções;
- trabalhar com parâmetros de função;
- argumentos-chave;
- retorno de valores com retorno;
- usando main() como uma função;