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 de escolha e chamá-lo 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 uma indentação 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 agora está totalmente definida, mas se executarmos o programa neste momento, nada acontecerá, pois não chamamos a função.

Então, fora do 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ê deve 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 laços 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 e, em seguida, usa 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 nomes() que definimos acima configura uma declaração condicional e um for loop, mostrando como o código pode ser organizado dentro de uma definição de função. No entanto, dependendo do que pretendemos com nosso programa e de 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, analisamos 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 receba parâmetros x, y e z. Vamos criar uma função que some os parâmetros juntos em diferentes configurações. As somas destes serão impressas pela função. Então vamos chamar a função e passar números para ela.

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 dados.

O programa essencialmente está 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 normalmente são definidos como variáveis dentro de 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 os 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 corresponder os valores aos parâmetros.

Vamos criar uma função que nos mostrará informações de perfil para um usuário. Passaremos parâmetros para ela na forma de nome_de_usuário (pretendido como uma string) e seguidores (pretendido como 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 de função, nome_de_usuário e seguidores estão contidos entre parênteses da função info_perfil(). O bloco da função imprime informações sobre o usuário como strings, fazendo uso dos 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 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))

# Alterar a 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 de 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 de Argumento Padrão

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 com apenas a função de nome de usuário atribuída, e o número de seguidores será automaticamente padrão para 1. Também podemos ainda mudar 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, usamos a instrução print() em vez da instrução return em nossas funções. Vamos criar um programa que, em vez de imprimir, retornará uma variável.

Em um novo arquivo de texto chamado square.py, vamos criar um programa que eleva ao quadrado o parâmetro x e retorna a variável y. Emitimos uma chamada para imprimir a variável result, que é formada ao executar a função square() com 3 passado para ela.

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

result = square(3)
print(result)

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 seria esperado ao solicitar ao Python que encontre o quadrado de 3.

Para entender melhor como a instrução return funciona, podemos comentar a instrução return no programa:

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

result = square(3)
print(result)

Agora, vamos executar o programa novamente:

python square.py

Output
None

Sem usar a instrução 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 trocar 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. Em seguida, 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 ou não retornando um valor.

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

loop_five()

O uso da instrução return dentro do for loop termina a função, então a linha que está fora do loop não será executada. Se, em vez disso, tivéssemos usado um instrução break, apenas o loop teria sido encerrado 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 executar. 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. Também pode tornar nossos programas mais fáceis de ler para programadores não-Python.

Começaremos adicionando uma função main() ao programa hello.py acima. Manteremos nossa função hello() e depois 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()

Finalmente, 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 depois 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 várias 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ê quiser 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, o seu __name__ é definido como igual a '__main__'.

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

if __name__ == '__main__':
    # Código para ser executado 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 nesta instrução será executado ao executar. Se você estiver usando seu arquivo de programa como um módulo, o código que não está nesta instrução também será executado ao importá-lo enquanto executa o 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 original names() para que as instruções estejam em duas funções discretas.

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

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

# Declarar 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 do nome
def print_letters():
    for letter in name:
        print(letter)

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

# Declarar 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 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()

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

# Declarar variável global 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 de 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 instrução if __name__ == '__main__': pode organizar seu código de forma lógica, tornando-o mais legível e modular.

Conclusão

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

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