Como Verificar se uma Função Retorna None em Python - Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se uma função retorna None em Python. O laboratório guia você através da compreensão dos valores de retorno de funções, criando um script Python simples com uma função que retorna a soma de dois números. Em seguida, você executará o script e observará a saída.

O laboratório continua modificando a função para retornar diferentes tipos de dados e, por fim, concentra-se em cenários onde uma função pode não retornar explicitamente um valor, resultando em um retorno None. Você aprenderá como capturar o valor de retorno de uma função e, em seguida, verificar se esse valor é None usando o operador is.

Aprenda Sobre Valores de Retorno de Funções

Nesta etapa, você aprenderá sobre valores de retorno 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. Esse resultado é chamado de valor de retorno.

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.py no diretório ~/project.
```
~/project/calculate.py
```
Adicione o seguinte código a calculate.py:
```
def add(x, y):
    """Esta função soma dois números e retorna o resultado."""
    sum = x + y
    return sum

## Chame a função e imprima o valor retornado
result = add(5, 3)
print(result)
```
Neste código:
- Definimos uma função chamada add 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.
- A instrução return sum especifica que a função deve retornar o valor de sum quando for chamada.
- Fora da função, chamamos a função add com os argumentos 5 e 3 e armazenamos o valor retornado em uma variável chamada result.
- Finalmente, usamos a função print() para exibir o valor de result.
Salve o arquivo calculate.py.
Abra um terminal no WebIDE.
Execute o script usando o seguinte comando:
```
python calculate.py
```
Você deve ver a seguinte saída:
```
8
```
Esta saída mostra que a função add calculou corretamente a soma de 5 e 3 e retornou o valor 8, que foi então impresso no console.

Agora, vamos modificar a função para retornar um tipo diferente de valor, como uma string.

Abra o arquivo calculate.py no VS Code.
Modifique o código para o seguinte:
```
def greet(name):
    """Esta função retorna uma mensagem de saudação."""
    message = "Olá, " + name + "!"
    return message

## Chame a função e imprima o valor retornado
greeting = greet("LabEx User")
print(greeting)
```
Neste código:
- Definimos uma função chamada greet que recebe um argumento, name.
- Dentro da função, criamos uma mensagem de saudação concatenando a string "Olá, ", o valor do argumento name e a string "!".
- A instrução return message especifica que a função deve retornar a mensagem de saudação.
- Fora da função, chamamos a função greet com o argumento "LabEx User" e armazenamos o valor retornado em uma variável chamada greeting.
- Finalmente, usamos a função print() para exibir o valor de greeting.
Salve o arquivo calculate.py.
Execute o script novamente usando o seguinte comando:
```
python calculate.py
```
Você deve ver a seguinte saída:
```
Olá, LabEx User!
```
Esta saída mostra que a função greet criou corretamente uma mensagem de saudação e a retornou, que foi então impressa no console.

Capturar o Valor de Retorno

Na etapa anterior, você aprendeu como definir funções que retornam valores. Agora, você aprenderá como capturar e usar esses valores de retorno em seus programas. Capturar o valor de retorno significa armazenar o valor retornado por uma função em uma variável para que você possa usá-lo mais tarde.

Vamos continuar com o arquivo calculate.py que você criou na etapa anterior. Modificaremos o script para realizar mais operações e capturar os valores de retorno.

Abra o arquivo calculate.py no VS Code.

Modifique o código para o seguinte:

def add(x, y):
    """Esta função soma dois números e retorna o resultado."""
    sum = x + y
    return sum

def subtract(x, y):
    """Esta função subtrai dois números e retorna o resultado."""
    difference = x - y
    return difference

## Chame as funções e capture os valores de retorno
num1 = 10
num2 = 5

sum_result = add(num1, num2)
print("A soma de", num1, "e", num2, "é:", sum_result)

difference_result = subtract(num1, num2)
print("A diferença entre", num1, "e", num2, "é:", difference_result)

Neste código:

Definimos duas funções: add e subtract.
Chamamos a função add com os argumentos num1 e num2 e armazenamos o valor retornado em uma variável chamada sum_result.
Chamamos a função subtract com os argumentos num1 e num2 e armazenamos o valor retornado em uma variável chamada difference_result.
Usamos a função print() para exibir os valores de sum_result e difference_result, juntamente com texto descritivo.

Salve o arquivo calculate.py.
Execute o script usando o seguinte comando:
```
python calculate.py
```
Você deve ver a seguinte saída:
```
A soma de 10 e 5 é: 15
A diferença entre 10 e 5 é: 5
```
Esta saída mostra que capturamos com sucesso os valores de retorno das funções add e subtract e os usamos em nosso programa.

Agora, vamos criar um exemplo mais complexo onde usamos o valor de retorno de uma função como um argumento para outra função.

Abra o arquivo calculate.py no VS Code.

Modifique o código para o seguinte:

def add(x, y):
    """Esta função soma dois números e retorna o resultado."""
    sum = x + y
    return sum

def multiply(x, y):
    """Esta função multiplica dois números e retorna o resultado."""
    product = x * y
    return product

## Chame as funções e capture os valores de retorno
num1 = 5
num2 = 3

sum_result = add(num1, num2)
product_result = multiply(sum_result, 2)  ## Use o valor de retorno de add como um argumento para multiply

print("A soma de", num1, "e", num2, "é:", sum_result)
print("O produto da soma e 2 é:", product_result)

Neste código:

Definimos duas funções: add e multiply.
Chamamos a função add com os argumentos num1 e num2 e armazenamos o valor retornado em uma variável chamada sum_result.
Chamamos a função multiply com os argumentos sum_result e 2. Isso demonstra como o valor de retorno de add pode ser usado como entrada para multiply. Armazenamos o valor retornado em uma variável chamada product_result.
Usamos a função print() para exibir os valores de sum_result e product_result, juntamente com texto descritivo.

Salve o arquivo calculate.py.
Execute o script usando o seguinte comando:
```
python calculate.py
```
Você deve ver a seguinte saída:
```
A soma de 5 e 3 é: 8
O produto da soma e 2 é: 16
```
Esta saída mostra que usamos com sucesso o valor de retorno de uma função como um argumento para outra função, demonstrando o poder e a flexibilidade dos valores de retorno de funções.

Verificar se o Valor de Retorno é None

Em alguns casos, uma função pode nem sempre retornar um valor significativo. Em tais situações, ela pode retornar None. None é um valor especial em Python que representa a ausência de um valor. É importante verificar se uma função retorna None antes de usar seu valor de retorno para evitar erros.

Vamos modificar o arquivo calculate.py para incluir uma função que pode retornar None.

Abra o arquivo calculate.py no VS Code.

Modifique o código para o seguinte:

def divide(x, y):
    """Esta função divide x por y e retorna o resultado.
    Se y for 0, ela retorna None para evitar erros de divisão por zero.
    """
    if y == 0:
        return None
    else:
        return x / y

## Chame a função e verifique se o valor de retorno é None
numerator = 10
denominator = 0

result = divide(numerator, denominator)

if result is None:
    print("Não é possível dividir por zero!")
else:
    print("O resultado de", numerator, "/", denominator, "é:", result)

denominator = 2
result = divide(numerator, denominator)

if result is None:
    print("Não é possível dividir por zero!")
else:
    print("O resultado de", numerator, "/", denominator, "é:", result)

Neste código:

Definimos uma função chamada divide que recebe dois argumentos, x e y.
Dentro da função, verificamos se y é igual a 0. Se for, retornamos None para evitar um erro de divisão por zero.
Se y não for 0, calculamos o resultado de x / y e o retornamos.
Fora da função, chamamos a função divide com um denominador de 0.
Verificamos se o valor retornado é None usando o operador is.
Se o valor retornado for None, imprimimos uma mensagem de erro.
Caso contrário, imprimimos o resultado da divisão.
Em seguida, chamamos a função divide novamente com um denominador válido e imprimimos o resultado.

Salve o arquivo calculate.py.
Execute o script usando o seguinte comando:
```
python calculate.py
```
Você deve ver a seguinte saída:
```
Não é possível dividir por zero!
O resultado de 10 / 2 é: 5.0
```
Esta saída mostra que o programa tratou corretamente o caso em que o denominador era 0 e imprimiu uma mensagem de erro apropriada. Também mostra que o programa calculou e imprimiu corretamente o resultado quando o denominador não era 0.

É importante usar o operador is para verificar se um valor é None porque None é um objeto singleton em Python. Isso significa que existe apenas uma instância de None em todo o programa. Usar o operador == pode nem sempre funcionar corretamente porque ele compara os valores dos objetos, não os próprios objetos.

Resumo

Neste laboratório, você aprendeu sobre valores de retorno de funções em Python. Você criou uma função chamada add que recebe dois argumentos, calcula sua soma e retorna o resultado. Em seguida, você chamou a função, armazenou o valor retornado em uma variável e o imprimiu no console.

O laboratório demonstrou como as funções podem retornar valores de diferentes tipos, como inteiros. Isso permite que as funções realizem cálculos ou operações e forneçam os resultados de volta ao código de chamada para uso posterior.