31.01.2025

Como criar funções no Python 3

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:

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

def hello():

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.

def hello():
print("Hello, Dear, User!")

Chame a função no final do código hello().

def hello():
print("Hello, Dear, User!")

hello()

Vamos executar o código e obter o resultado:

python3 test_hello.py

Tela 1 - O resultado da função escrita

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.

# Creating the names function()
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:

def add(i, j, k):
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:

q = 20 + 25
w = 20 + 30
e = 25 + 30

Vamos executar o programa e obter nosso resultado no formato:

45 50 55

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

#Function with parameters
def info(name, age):
print("Name: " + name)
print("Age: " + str(age))

Em seguida, considere a possibilidade de atribuir valores aos parâmetros.

# Function definition with parameters
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:

Tela 2 - Resultado obtido usando parâmetros e argumentos-chave

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:

# Function definition with parameters
def info(name, age):
print("Name: " + name)
print("Age: " + str(age))

#Calling a Function Using Key Arguments
info(age=40, name="ServerSpaceTeam")

Tela 3 - O resultado da chamada de parâmetros em sentido inverso

Atribuição de argumentos-chave

Copie o arquivo TestInfo.py e altere o nome para TestInfoValue.py

cp TestInfo.py 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:

# Function definition with parameters
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)

Tela 4 - Resultado do código executado usando o valor padrão

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:

def testsquare(i):
j = i ** 3
return j

result = testsquare(5)
print(result)

Depois de executar o código e obter o resultado:

Tela 5 - Retornando uma função com return

Se comentarmos a linha return j, obteremos o resultado:

Tela 6 - Retornando um valor None

Considere o retorno de uma função com return em TestAdd.py:

def add(i, j, k):
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:

Tela 7 - O resultado do retorno da função

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:

def TestMain():
print("Hello, Dear, User!")

def main():
print("This is test text")

TestMain()
main()

Tela 8 - O resultado do código acima

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:

if __name__ == '__main__':

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":

#Declaring a global variable and for entering a name
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:

if __name__ == '__main__':
has_vowel()
print_letters()

Tela 9 - O resultado do código executado

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: