Como Verificar se uma Função Retorna um Valor Específico em Python - Tutorial

Introdução

Neste laboratório, você aprenderá como verificar se uma função Python retorna um valor específico. O laboratório se concentra em entender os retornos de funções usando a instrução return e verificando a saída.

Você começará criando um script Python com uma função que calcula a soma de dois números e retorna o resultado. Em seguida, você executará o script e observará a saída. Finalmente, você modificará o script para retornar valores diferentes com base em uma condição e verificará o valor retornado.

Entenda os Retornos de Funções

Nesta etapa, você aprenderá sobre os retornos de funções em Python. Funções são blocos de código reutilizáveis que executam tarefas específicas. Frequentemente, você desejará que uma função lhe retorne um resultado após concluir seu trabalho. Isso é feito usando a instrução return.

Vamos começar criando um script Python simples que define uma função com um valor de retorno.

Abra o editor VS Code no ambiente LabEx.
Crie um novo arquivo chamado calculate_sum.py no diretório ~/project.
```
~/project/calculate_sum.py
```
Adicione o seguinte código ao arquivo calculate_sum.py:
```
def calculate_sum(x, y):
    """
    Esta função calcula a soma de dois números.
    """
    sum_result = x + y
    return sum_result

## Exemplo de uso:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("A soma de", num1, "e", num2, "é", result)
```
Neste código:
- Definimos uma função chamada calculate_sum que recebe dois argumentos, x e y.
- Dentro da função, calculamos a soma de x e y e a armazenamos em uma variável chamada sum_result.
- A instrução return sum_result envia o valor de sum_result de volta para quem chamou a função.
- Em seguida, chamamos a função com num1 = 10 e num2 = 5 e armazenamos o valor retornado na variável result.
- Finalmente, usamos a função print() para exibir o resultado.
Agora, execute o script usando o seguinte comando no terminal:
```
python ~/project/calculate_sum.py
```
Você deve ver a seguinte saída:
```
A soma de 10 e 5 é 15
```
Esta saída confirma que a função calculou corretamente a soma e retornou o valor, que foi então impresso no console.

Vamos modificar o script para retornar um valor diferente com base em uma condição. Edite o arquivo calculate_sum.py para incluir o seguinte:

def calculate_sum(x, y):
    """
    Esta função calcula a soma de dois números.
    Se a soma for maior que 10, ela retorna o dobro da soma.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Exemplo de uso:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("A soma de", num1, "e", num2, "é", result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("A soma de", num3, "e", num4, "é", result2)

Aqui, adicionamos uma instrução condicional (if sum_result > 10:) para verificar se a soma é maior que 10. Se for, a função retorna o dobro da soma; caso contrário, ela retorna a soma original.

Execute o script novamente:
```
python ~/project/calculate_sum.py
```
Você deve ver agora a seguinte saída:
```
A soma de 10 e 5 é 30
A soma de 2 e 3 é 5
```
A primeira chamada para calculate_sum retorna 30 porque a soma (15) é maior que 10, então ela é dobrada. A segunda chamada retorna 5 porque a soma (5) não é maior que 10.

Chamar a Função e Capturar a Saída

Nesta etapa, você aprenderá como chamar uma função e capturar sua saída em Python. Capturar a saída de uma função permite que você use o valor retornado em cálculos ou operações adicionais dentro do seu script.

Continuaremos usando o arquivo calculate_sum.py da etapa anterior. Se você não concluiu a etapa anterior, crie o arquivo com o seguinte conteúdo:

def calculate_sum(x, y):
    """
    Esta função calcula a soma de dois números.
    Se a soma for maior que 10, ela retorna o dobro da soma.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Exemplo de uso:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("A soma de", num1, "e", num2, "é", result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("A soma de", num3, "e", num4, "é", result2)

Agora, vamos modificar o script para capturar a saída da função calculate_sum e realizar operações adicionais com ela.

Abra o arquivo calculate_sum.py no editor VS Code.

Modifique o script da seguinte forma:

def calculate_sum(x, y):
    """
    Esta função calcula a soma de dois números.
    Se a soma for maior que 10, ela retorna o dobro da soma.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Exemplo de uso:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("A soma de", num1, "e", num2, "é", result)

## Captura a saída e realiza uma operação adicional
final_result = result + 20
print("O resultado final após adicionar 20 é:", final_result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("A soma de", num3, "e", num4, "é", result2)

## Captura a saída e realiza uma operação adicional
final_result2 = result2 * 2
print("O resultado final após multiplicar por 2 é:", final_result2)

Neste script modificado:

Chamamos a função calculate_sum com num1 e num2 e armazenamos o valor retornado na variável result.
Em seguida, adicionamos 20 ao result e o armazenamos em final_result.
Finalmente, imprimimos o valor de final_result.
Também chamamos a função calculate_sum com num3 e num4 e armazenamos o valor retornado na variável result2.
Em seguida, multiplicamos result2 por 2 e o armazenamos em final_result2.
Finalmente, imprimimos o valor de final_result2.

Execute o script usando o seguinte comando:
```
python ~/project/calculate_sum.py
```
Você deve ver a seguinte saída:
```
A soma de 10 e 5 é 30
O resultado final após adicionar 20 é: 50
A soma de 2 e 3 é 5
O resultado final após multiplicar por 2 é: 10
```
Esta saída demonstra que você pode chamar com sucesso uma função, capturar seu valor retornado e usar esse valor em operações subsequentes dentro do seu script.

Comparar a Saída com o Valor Esperado

Nesta etapa, você aprenderá como comparar a saída de uma função com um valor esperado. Esta é uma parte crucial dos testes e garante que suas funções estejam funcionando corretamente. Ao comparar a saída real com a saída esperada, você pode identificar e corrigir quaisquer erros em seu código.

Continuaremos usando o arquivo calculate_sum.py das etapas anteriores. Se você não concluiu as etapas anteriores, crie o arquivo com o seguinte conteúdo:

def calculate_sum(x, y):
    """
    Esta função calcula a soma de dois números.
    Se a soma for maior que 10, ela retorna o dobro da soma.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Exemplo de uso:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("A soma de", num1, "e", num2, "é", result)

## Captura a saída e realiza uma operação adicional
final_result = result + 20
print("O resultado final após adicionar 20 é:", final_result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("A soma de", num3, "e", num4, "é", result2)

## Captura a saída e realiza uma operação adicional
final_result2 = result2 * 2
print("O resultado final após multiplicar por 2 é:", final_result2)

Agora, vamos adicionar uma função para comparar a saída com um valor esperado e imprimir uma mensagem indicando se o teste passou ou falhou.

Abra o arquivo calculate_sum.py no editor VS Code.

Modifique o script da seguinte forma:

def calculate_sum(x, y):
    """
    Esta função calcula a soma de dois números.
    Se a soma for maior que 10, ela retorna o dobro da soma.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

def compare_output(actual_output, expected_output):
    """
    Esta função compara a saída real com a saída esperada.
    """
    if actual_output == expected_output:
        print("Teste passou!")
    else:
        print("Teste falhou. Esperado:", expected_output, "Real:", actual_output)

## Exemplo de uso:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("A soma de", num1, "e", num2, "é", result)

## Captura a saída e realiza uma operação adicional
final_result = result + 20
print("O resultado final após adicionar 20 é:", final_result)

## Compara a saída com o valor esperado
expected_final_result = 50
compare_output(final_result, expected_final_result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("A soma de", num3, "e", num4, "é", result2)

## Captura a saída e realiza uma operação adicional
final_result2 = result2 * 2
print("O resultado final após multiplicar por 2 é:", final_result2)

## Compara a saída com o valor esperado
expected_final_result2 = 10
compare_output(final_result2, expected_final_result2)

Neste script modificado:

Definimos uma função chamada compare_output que recebe dois argumentos: actual_output e expected_output.
Dentro da função, comparamos o actual_output com o expected_output.
Se eles forem iguais, imprimimos "Teste passou!".
Se eles não forem iguais, imprimimos "Teste falhou." junto com os valores esperados e reais.
Em seguida, chamamos a função compare_output com final_result e expected_final_result para comparar a saída do primeiro cálculo com o valor esperado de 50.
Também chamamos a função compare_output com final_result2 e expected_final_result2 para comparar a saída do segundo cálculo com o valor esperado de 10.

Execute o script usando o seguinte comando:
```
python ~/project/calculate_sum.py
```
Você deve ver a seguinte saída:
```
A soma de 10 e 5 é 30
O resultado final após adicionar 20 é: 50
Teste passou!
A soma de 2 e 3 é 5
O resultado final após multiplicar por 2 é: 10
Teste passou!
```
Esta saída demonstra que você pode comparar com sucesso a saída de uma função com um valor esperado e determinar se o teste passou ou falhou.

Resumo

Neste laboratório, a primeira etapa se concentra em entender os retornos de funções em Python. Ela envolve a criação de um script calculate_sum.py que define uma função, calculate_sum(x, y), que calcula a soma de dois números de entrada e retorna o resultado usando a instrução return. O script então chama essa função com valores de exemplo e imprime a soma retornada no console, demonstrando como uma função pode retornar um valor que pode ser capturado e usado em outro lugar no código.

O script inicial é então modificado para retornar valores diferentes com base em uma condição, ilustrando ainda mais a flexibilidade dos retornos de funções. Esta etapa reforça o conceito de funções como blocos de código reutilizáveis que podem fornecer saídas específicas com base em suas entradas e lógica interna.