Definir e Usar Funções em Python

Introdução

Neste laboratório, você aprenderá a definir e usar funções em Python. Funções são essenciais para organizar o código e promover a reutilização. Você começará entendendo o conceito de funções e explorando as funções nativas (built-in) do Python, aprendendo a chamá-las com parâmetros e observar sua saída.

Após a exploração das funções nativas, você aprenderá a definir suas próprias funções simples. Finalmente, você praticará a chamada dessas funções definidas pelo usuário para executar os blocos de código que elas contêm, solidificando sua compreensão sobre a criação e o uso de funções em Python.

Compreender e Usar Funções Nativas (Built-in)

Nesta etapa, exploraremos o conceito de funções e aprenderemos a usar as funções nativas (built-in) do Python. Uma função é um bloco de código reutilizável que executa uma ação específica. O Python fornece muitas funções nativas que estão prontas para uso, como print(), len() e sum().

Vamos começar escrevendo um script Python para ver algumas dessas funções em ação.

Primeiro, encontre o arquivo builtin_functions.py no explorador de arquivos do WebIDE à esquerda. Este arquivo foi pré-criado para você no diretório ~/project. Dê um duplo clique no arquivo para abri-lo no editor.

Agora, adicione o seguinte código Python ao arquivo builtin_functions.py. Este código demonstra como chamar várias funções nativas.

## Usando a função print() para exibir a saída
print("Hello, Python Functions!")

## Usando a função len() para obter o comprimento de uma string
message = "Hello World"
print(len(message))

## Usando a função sum() para somar números em uma lista
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)

Após escrever o código, salve o arquivo pressionando Ctrl+S.

Para executar o script, abra o terminal integrado no WebIDE (se ele não estiver aberto, vá ao menu superior e selecione Terminal > New Terminal). Em seguida, execute o seguinte comando:

python ~/project/builtin_functions.py

Você verá a saída de cada chamada print() no terminal.

Hello, Python Functions!
11
15

Esta saída mostra os resultados da chamada das funções nativas: print() exibe texto, len() retorna o número de caracteres em uma string e sum() calcula a soma dos itens em uma lista.

Usar Funções com Parâmetros e Valores de Retorno

As funções frequentemente precisam de dados de entrada para trabalhar. Esses dados são passados para a função como parâmetros (também chamados de argumentos). Após o processamento, uma função pode enviar um resultado de volta, o que é conhecido como valor de retorno (return value).

Vamos expandir nosso script builtin_functions.py para explorar funções que aceitam parâmetros e ver como podemos usar seus valores de retorno.

Abra o arquivo builtin_functions.py novamente no editor do WebIDE. Adicione o seguinte código ao final do arquivo:

## Usando a função max() com múltiplos parâmetros numéricos
largest_number = max(10, 25, 15)
print(largest_number)

## Usando a função round() com dois parâmetros
pi_approx = 3.14159
rounded_pi = round(pi_approx, 2) ## arredonda para 2 casas decimais
print(rounded_pi)

## Usando a função sorted() com um parâmetro de lista
unsorted_list = ['cherry', 'apple', 'banana']
sorted_list = sorted(unsorted_list)
print(sorted_list)

Salve as alterações no arquivo (Ctrl+S).

Agora, execute o script atualizado a partir do terminal:

python ~/project/builtin_functions.py

O terminal exibirá a saída tanto do código original quanto do novo código.

Hello, Python Functions!
11
15
25
3.14
['apple', 'banana', 'cherry']

Vamos revisar a nova saída:

• max(10, 25, 15) recebe três números como parâmetros e retorna o maior deles, 25.
• round(pi_approx, 2) recebe um número e o número de casas decimais como parâmetros. Ele retorna o valor arredondado, 3.14.
• sorted(unsorted_list) recebe uma lista como parâmetro e retorna uma nova lista com os elementos ordenados em ordem crescente.

Em cada caso, armazenamos o valor de retorno da função em uma variável (largest_number, rounded_pi, sorted_list) antes de imprimi-lo. Esta é uma prática comum e útil.

Definir uma Função Simples

Embora as funções nativas sejam poderosas, você frequentemente precisará criar suas próprias funções para realizar tarefas personalizadas. Isso é chamado de definir uma função.

Em Python, você define uma função usando a palavra-chave def. A sintaxe básica é:

def function_name(parameters):
    """Docstring: Uma descrição opcional da função."""
    ## Código a ser executado (o corpo da função)
    ## ...
    return value  ## Declaração de retorno opcional

• def: A palavra-chave que inicia uma definição de função.
• function_name: Um nome descritivo para sua função.
• (parameters): Variáveis de entrada para a função. Uma função pode ter zero ou mais parâmetros.
• :: Os dois pontos marcam o fim do cabeçalho da função.
• Indentation (Recuo): As linhas de código dentro da função devem ser recuadas (geralmente com 4 espaços). É assim que o Python agrupa as instruções.

Vamos criar nossa primeira função. No explorador de arquivos do WebIDE, encontre e abra o arquivo my_functions.py.

Adicione o seguinte código ao my_functions.py para definir uma função que imprime uma saudação:

## Define uma função simples chamada 'greet'
def greet():
    """Esta função imprime uma mensagem de saudação simples."""
    print("Hello from a user-defined function!")

Salve o arquivo.

Neste ponto, você definiu com sucesso uma função chamada greet. No entanto, se você executar este script, nada acontecerá. Definir uma função apenas informa ao Python o que a função faz; ela não executa o código dentro dela. Para executar o código da função, você precisa chamá-la, o que abordaremos na próxima etapa.

Chamar uma Função Definida pelo Usuário

Após definir uma função, você precisa chamá-la para executar seu código. Chamar uma função é simples: basta digitar seu nome seguido de parênteses ().

Vamos chamar a função greet que definimos na etapa anterior.

Abra o arquivo my_functions.py no editor do WebIDE. Adicione uma linha de código após a definição da função para chamá-la.

## Define uma função simples chamada 'greet'
def greet():
    """Esta função imprime uma mensagem de saudação simples."""
    print("Hello from a user-defined function!")

## Chama a função greet para executar seu código
print("Calling the function now...")
greet()

Salve o arquivo. É importante que a chamada da função greet() apareça após o bloco def greet():. O Python lê os arquivos de cima para baixo, então você deve definir uma função antes de poder chamá-la.

Agora, execute o script a partir do terminal:

python ~/project/my_functions.py

Você verá a saída impressa no console:

Calling the function now...
Hello from a user-defined function!

A grande vantagem das funções é a reutilização. Você pode chamar a mesma função várias vezes sem reescrever seu código. Vamos chamar greet() novamente. Modifique my_functions.py para que fique assim:

## Define uma função simples chamada 'greet'
def greet():
    """Esta função imprime uma mensagem de saudação simples."""
    print("Hello from a user-defined function!")

## Chama a função greet múltiplas vezes
print("Calling the function...")
greet()
print("Calling it again...")
greet()

Salve o arquivo e execute-o mais uma vez:

python ~/project/my_functions.py

A saída agora mostra que a função foi executada duas vezes:

Calling the function...
Hello from a user-defined function!
Calling it again...
Hello from a user-defined function!

Isso demonstra como as funções ajudam você a escrever um código mais limpo, organizado e reutilizável.

Resumo

Neste laboratório, você aprendeu os fundamentos das funções em Python. Você começou explorando as funções nativas (built-in) do Python, como print(), len() e sum(), e praticou chamá-las em um script. Em seguida, aprofundou-se em como as funções operam, passando parâmetros e utilizando seus valores de retorno com exemplos como max(), round() e sorted().

Finalmente, você aprendeu a sintaxe para definir suas próprias funções personalizadas usando a palavra-chave def e praticou a chamada da sua função definida pelo usuário para executar seu código. Este laboratório forneceu uma base sólida para criar código modular e reutilizável, uma habilidade fundamental para qualquer programador Python.