Como Definir Funções em Python 3

Introdução

A function is a block of instructions that performs an action and, once defined, can be reused. Functions make code more modular, allowing you to use the same code over and over again.

O Python possui várias funções integradas com as quais você pode estar familiarizado, incluindo:

• print() que imprimirá um objeto no terminal
• int() que converterá um tipo de dados string ou número para um tipo de dados inteiro
• len() que retorna o comprimento de um objeto

Os nomes das funções incluem parênteses e podem incluir parâmetros.

Neste tutorial, vamos aprender como definir suas próprias funções para usar em seus projetos de codificação.

Pré-requisitos

Você deve ter o Python 3 instalado e um ambiente de programação configurado em seu computador ou servidor. Se você não tiver um ambiente de programação configurado, pode consultar os guias de instalação e configuração para um ambiente de programação local ou para um ambiente de programação em seu servidor apropriado para seu sistema operacional (Ubuntu, CentOS, Debian, etc.).

Definindo uma Função

Vamos começar transformando o clássico programa “Olá, Mundo!” em uma função.

Vamos criar um novo arquivo de texto em nosso editor de texto preferido e chamar o programa de hello.py. Em seguida, vamos definir a função.

A function is defined by using the def keyword, followed by a name of your choosing, followed by a set of parentheses which hold any parameters the function will take (they can be empty), and ending with a colon.

Neste caso, vamos definir uma função chamada hello():

def hello():

Isso configura a declaração inicial para criar uma função.

A partir daqui, vamos adicionar uma segunda linha com um recuo de 4 espaços para fornecer as instruções sobre o que a função faz. Neste caso, estaremos imprimindo Olá, Mundo! no console:

def hello():
    print("Hello, World!")

Nossa função está agora totalmente definida, mas se executarmos o programa neste ponto, nada acontecerá, pois não chamamos a função.

Então, fora do nosso bloco de função definido, vamos chamar a função com hello():

def hello():
    print("Hello, World!")

hello()

Agora, vamos executar o programa:

python hello.py

Você deverá receber a seguinte saída:

Output
Hello, World!

As funções podem ser mais complicadas do que a função hello() que definimos acima. Por exemplo, podemos usar loops for, declarações condicionais e mais dentro do bloco da nossa função.

Por exemplo, a função definida abaixo utiliza uma declaração condicional para verificar se a entrada para a variável name contém uma vogal, então utiliza um for loop para iterar sobre as letras na string name.

# Definir função nomes()
def names():
    # Configurar variável name com entrada
    name = str(input('Enter your name: '))
    # Verificar se name tem uma vogal
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # Iterar sobre name
    for letter in name:
        print(letter)

# Chamar a função
names()

A função nombres() que definimos acima configura uma declaração condicional e um for loop, mostrando como o código pode ser organizado dentro da definição de uma função. No entanto, dependendo do que pretendemos com nosso programa e como queremos configurar nosso código, podemos querer definir a declaração condicional e o for loop como duas funções separadas.

Definir funções dentro de um programa torna nosso código modular e reutilizável, para que possamos chamar as mesmas funções sem reescrevê-las.

Trabalhando com Parâmetros

Até agora, vimos funções com parênteses vazios que não recebem argumentos, mas podemos definir parâmetros nas definições de função dentro de seus parênteses.

A parameter is a named entity in a function definition, specifying an argument that the function can accept.

Vamos criar um pequeno programa que recebe parâmetros x, y e z. Vamos criar uma função que some os parâmetros juntos em diferentes configurações. As somas desses serão impressas pela função. Então vamos chamar a função e passar números para a função.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    print(a, b, c)

add_numbers(1, 2, 3)

Passamos o número 1 para o parâmetro x, 2 para o parâmetro y e 3 para o parâmetro z. Esses valores correspondem a cada parâmetro na ordem em que são fornecidos.

O programa está essencialmente fazendo a seguinte matemática com base nos valores que passamos para os parâmetros:

a = 1 + 2
b = 1 + 3
c = 2 + 3

A função também imprime a, b e c, e com base na matemática acima, esperaríamos que a seja igual a 3, b seja 4 e c seja 5. Vamos executar o programa:

python add_numbers.py

Output
3 4 5

Ao passarmos 1, 2 e 3 como parâmetros para a função add_numbers(), recebemos a saída esperada.

Parâmetros são argumentos que geralmente são definidos como variáveis dentro das definições de função. Eles podem receber valores quando você executa o método, passando os argumentos para a função.

Argumentos de Palavra-chave

Além de chamar parâmetros em ordem, você pode usar argumentos de palavra-chave em uma chamada de função, na qual o chamador identifica os argumentos pelo nome do parâmetro.

Ao usar argumentos de palavra-chave, você pode usar parâmetros fora de ordem porque o interpretador Python usará as palavras-chave fornecidas para associar os valores aos parâmetros.

Vamos criar uma função que nos mostrará informações do perfil de um usuário. Passaremos parâmetros para ela na forma de username (destinado a ser uma string) e followers (destinado a ser um inteiro).

# Definir função com parâmetros
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

Dentro da declaração de definição da função, username e followers estão contidos entre parênteses da função profile_info(). O bloco da função imprime informações sobre o usuário como strings, utilizando os dois parâmetros.

Agora, podemos chamar a função e atribuir parâmetros a ela:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Chamar função com parâmetros atribuídos como acima
profile_info("sammyshark", 945)

# Chamar função com argumentos de palavra-chave
profile_info(username="AlexAnglerfish", followers=342)

Na primeira chamada de função, preenchemos as informações com um nome de usuário de sammyshark e seguidores sendo 945, na segunda chamada de função usamos argumentos de palavra-chave, atribuindo valores às variáveis de argumento.

Vamos executar o programa:

python profile.py

Output
Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

A saída nos mostra os nomes de usuário e números de seguidores para ambos os usuários.

Isso também nos permite modificar a ordem dos parâmetros, como neste exemplo do mesmo programa com uma chamada diferente:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Mudar ordem dos parâmetros
profile_info(followers=820, username="cameron-catfish")

Quando executamos o programa novamente com o comando python profile.py, receberemos a seguinte saída:

Output
Username: cameron-catfish
Followers: 820

Porque a definição da função mantém a mesma ordem das declarações de print(), se usarmos argumentos de palavra-chave, não importa em que ordem os passamos para a chamada da função.

Valores Padrão dos Argumentos

Também podemos fornecer valores padrão para um ou ambos os parâmetros. Vamos criar um valor padrão para o parâmetro followers com um valor de 1:

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

Agora, podemos executar a função apenas com a função de nome de usuário atribuída, e o número de seguidores será automaticamente padrão para 1. Também ainda podemos alterar o número de seguidores se quisermos.

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)

Quando executamos o programa com o comando python profile.py, receberemos a seguinte saída:

Output
Username: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

Fornecer parâmetros padrão com valores pode nos permitir pular a definição de valores para cada argumento que já possui um padrão.

Retornando um Valor

Você pode passar um valor de parâmetro para uma função, e uma função também pode produzir um valor.

A function can produce a value with the return statement, which will exit a function and optionally pass an expression back to the caller. If you use a return statement with no arguments, the function will return None.

Até agora, nós utilizamos o comando print() em vez do comando return em nossas funções. Vamos criar um programa que, em vez de imprimir, irá retornar uma variável.

Em um novo arquivo de texto chamado square.py, vamos criar um programa que calcula o quadrado do parâmetro x e retorna a variável y. Nós emitimos uma chamada para imprimir a variável resultado, que é formada executando a função square() com o valor 3 passado para ela.

def square(x):
    y = x ** 2
    return y

result = square(3)
print(result)

Nós podemos executar o programa e receber a saída:

python square.py

Output
9

O número inteiro 9 é retornado como saída, o que é o que esperaríamos ao solicitar ao Python para encontrar o quadrado de 3.

Para entender melhor como o comando return funciona, podemos comentar o comando return no programa:

def square(x):
    y = x ** 2
    # retornar y

result = square(3)
print(result)

Agora, vamos executar o programa novamente:

python square.py

Output
None

Sem usar o comando return aqui, o programa não pode retornar um valor, então o valor padrão é None.

Como outro exemplo, no programa add_numbers.py acima, poderíamos substituir a instrução print() por uma instrução return.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

sums = add_numbers(1, 2, 3)
print(sums)

Fora da função, definimos a variável somas igual ao resultado da função recebendo 1, 2 e 3 como fizemos anteriormente. Então chamamos um print da variável somas.

Vamos executar o programa novamente agora que ele tem a instrução return:

python add_numbers.py

Output
(3, 4, 5)

Recebemos os mesmos números 3, 4 e 5 como saída que recebemos anteriormente usando a instrução print() na função. Desta vez é entregue como uma tupla porque a lista de expressões da instrução return tem pelo menos uma vírgula.

As funções saem imediatamente quando encontram uma instrução return, independentemente de estarem retornando um valor.

def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # Pare a função em x == 5
            return
    print("This line will not execute.")

loop_five()

Usar a instrução return dentro do for loop encerra a função, então a linha que está fora do loop não será executada. Se, em vez disso, tivéssemos usado uma instrução break, apenas o loop teria sido interrompido naquele momento, e a última linha print() seria executada.

O comando return sai de uma função e pode retornar um valor quando emitido com um parâmetro.

Usando main() como uma Função

Embora em Python você possa chamar a função no final do seu programa e ela será executada (como fizemos nos exemplos acima), muitas linguagens de programação (como C++ e Java) exigem uma função main para ser executada. Incluir uma função main(), embora não seja obrigatório, pode estruturar nossos programas Python de uma maneira lógica que coloca os componentes mais importantes do programa em uma função. Isso também pode tornar nossos programas mais fáceis de serem lidos por programadores não-Python.

Começaremos adicionando uma função main() ao programa hello.py acima. Manteremos nossa função hello(), e então definiremos uma função main():

def hello():
    print("Hello, World!")

def main():

Dentro da função main(), vamos incluir um comando print() para nos informar que estamos na função main(). Além disso, vamos chamar a função hello() dentro da função main():

def hello():
    print("Hello, World!")


def main():
    print("This is the main function")
    hello()

Por fim, no final do programa, chamaremos a função main():

def hello():
    print("Hello, World!")

def main():
    print("This is the main function.")
    hello()

main()

Neste ponto, podemos executar nosso programa:

python hello.py

Receberemos a seguinte saída:

Output
This is the main function.
Hello, World!

Porque chamamos a função hello() dentro de main() e então só chamamos main() para executar, o texto Hello, World! foi impresso apenas uma vez, depois da string que nos informou que estávamos na função principal.

Em seguida, vamos trabalhar com múltiplas funções, então vale a pena revisar o escopo de variáveis globais e locais. Se você definir uma variável dentro de um bloco de função, só poderá usar essa variável dentro dessa função. Se você deseja usar variáveis entre funções, pode ser melhor declarar uma variável global.

No Python, '__main__' é o nome do escopo onde o código de nível superior será executado. Quando um programa é executado a partir da entrada padrão, de um script, ou de um prompt interativo, seu __name__ é definido como '__main__'.

Por causa disso, há uma convenção de usar a seguinte construção:

if __name__ == '__main__':
    # Código para executar quando este é o programa principal aqui

Isso permite que arquivos de programa sejam usados tanto:

• como o programa principal e executem o que segue a instrução if
• como um módulo e não executem o que segue a instrução if.

Qualquer código que não esteja contido dentro desta declaração será executado ao ser executado. Se você estiver usando seu arquivo de programa como um módulo, o código que não está nesta declaração também será executado ao importá-lo durante a execução do arquivo secundário.

Vamos expandir nosso programa names.py acima e criar um novo arquivo chamado more_names.py. Neste programa, vamos declarar uma variável global e modificar nossa função names() original para que as instruções estejam em duas funções discretas.

A primeira função, has_vowel(), irá verificar se a string name contém uma vogal.

A segunda função print_letters() irá imprimir cada letra da string name.

# Declarar a variável global name para uso em todas as funções
name = str(input('Enter your name: '))


# Definir função para verificar se o nome contém uma vogal
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterar sobre as letras na string name
def print_letters():
    for letter in name:
        print(letter)

Com isso configurado, vamos definir a função main() que irá conter uma chamada para ambas as funções has_vowel() e print_letters().

# Declarar a variável global name para uso em todas as funções
name = str(input('Enter your name: '))


# Definir função para verificar se o nome contém uma vogal
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterar sobre as letras na string name
def print_letters():
    for letter in name:
        print(letter)


# Definir método principal que chama outras funções
def main():
    has_vowel()
    print_letters()

Finalmente, adicionaremos a construção if __name__ == '__main__': na parte inferior do arquivo. Para nossos propósitos, uma vez que colocamos todas as funções que gostaríamos de fazer na função main(), chamaremos a função main() após esta declaração if.

# Declarar variável global de nome para uso em todas as funções
name = str(input('Enter your name: '))


# Definir função para verificar se o nome contém uma vogal
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterar sobre letras na string do nome
def print_letters():
    for letter in name:
        print(letter)


# Definir método principal que chama outras funções
def main():
    has_vowel()
    print_letters()


# Executar função main()
if __name__ == '__main__':
    main()

Agora podemos executar o programa:

python more_names.py

O programa mostrará a mesma saída que o programa names.py, mas aqui o código está mais organizado e pode ser usado de forma modular sem modificação.

Se você não quisesse declarar uma função main(), alternativamente poderia ter encerrado o programa assim:

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

Usar main() como uma função e a declaração if __name__ == '__main__': pode organizar seu código de forma lógica, tornando-o mais legível e modular.

Conclusão

Funções são blocos de código de instruções que executam ações dentro de um programa, ajudando a tornar nosso código reutilizável e modular.

Para saber mais sobre como tornar seu código mais modular, você pode ler nosso guia sobre Como Escrever Módulos em Python 3.