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.
