Cómo comprobar si una función devuelve None en Python

Introducción

En este laboratorio, aprenderás cómo verificar si una función devuelve None en Python. El laboratorio te guía a través de la comprensión de los valores de retorno de las funciones creando un sencillo script de Python con una función que devuelve la suma de dos números. Luego, ejecutarás el script y observarás la salida.

El laboratorio continúa modificando la función para devolver diferentes tipos de datos y, finalmente, se centra en escenarios en los que una función puede no devolver explícitamente un valor, lo que resulta en un retorno de None. Aprenderás cómo capturar el valor de retorno de una función y luego verificar si ese valor es None utilizando el operador is.

Aprende sobre los valores de retorno de las funciones

En este paso, aprenderás sobre los valores de retorno de las funciones en Python. Las funciones son bloques de código reutilizables que realizan tareas específicas. A menudo, querrás que una función te devuelva un resultado después de terminar su trabajo. Este resultado se llama valor de retorno.

Comencemos creando un sencillo script de Python que defina una función con un valor de retorno.

Abre el editor de VS Code en el entorno de LabEx.
Crea un nuevo archivo llamado calculate.py en el directorio ~/project.
```
~/project/calculate.py
```
Agrega el siguiente código a calculate.py:
```
def add(x, y):
    """This function adds two numbers and returns the result."""
    sum = x + y
    return sum

## Call the function and print the returned value
result = add(5, 3)
print(result)
```
En este código:
- Definimos una función llamada add que toma dos argumentos, x e y.
- Dentro de la función, calculamos la suma de x e y y la almacenamos en una variable llamada sum.
- La declaración return sum especifica que la función debe devolver el valor de sum cuando se la llama.
- Fuera de la función, llamamos a la función add con los argumentos 5 y 3, y almacenamos el valor devuelto en una variable llamada result.
- Finalmente, usamos la función print() para mostrar el valor de result.
Guarda el archivo calculate.py.
Abre una terminal en el WebIDE.
Ejecuta el script usando el siguiente comando:
```
python calculate.py
```
Deberías ver la siguiente salida:
```
8
```
Esta salida muestra que la función add calculó correctamente la suma de 5 y 3, y devolvió el valor 8, que luego se imprimió en la consola.

Ahora, modifiquemos la función para que devuelva un tipo de valor diferente, como una cadena (string).

Abre el archivo calculate.py en VS Code.
Modifica el código para que sea el siguiente:
```
def greet(name):
    """This function returns a greeting message."""
    message = "Hello, " + name + "!"
    return message

## Call the function and print the returned value
greeting = greet("LabEx User")
print(greeting)
```
En este código:
- Definimos una función llamada greet que toma un argumento, name.
- Dentro de la función, creamos un mensaje de saludo concatenando la cadena "Hello, ", el valor del argumento name y la cadena "!".
- La declaración return message especifica que la función debe devolver el mensaje de saludo.
- Fuera de la función, llamamos a la función greet con el argumento "LabEx User", y almacenamos el valor devuelto en una variable llamada greeting.
- Finalmente, usamos la función print() para mostrar el valor de greeting.
Guarda el archivo calculate.py.
Ejecuta el script nuevamente usando el siguiente comando:
```
python calculate.py
```
Deberías ver la siguiente salida:
```
Hello, LabEx User!
```
Esta salida muestra que la función greet creó correctamente un mensaje de saludo y lo devolvió, que luego se imprimió en la consola.

Captura el valor de retorno

En el paso anterior, aprendiste cómo definir funciones que devuelven valores. Ahora, aprenderás cómo capturar y utilizar esos valores de retorno en tus programas. Capturar el valor de retorno significa almacenar el valor devuelto por una función en una variable para poder utilizarlo más tarde.

Continuemos con el archivo calculate.py que creaste en el paso anterior. Modificaremos el script para realizar más operaciones y capturar los valores de retorno.

Abre el archivo calculate.py en VS Code.

Modifica el código para que sea el siguiente:

def add(x, y):
    """This function adds two numbers and returns the result."""
    sum = x + y
    return sum

def subtract(x, y):
    """This function subtracts two numbers and returns the result."""
    difference = x - y
    return difference

## Call the functions and capture the return values
num1 = 10
num2 = 5

sum_result = add(num1, num2)
print("The sum of", num1, "and", num2, "is:", sum_result)

difference_result = subtract(num1, num2)
print("The difference between", num1, "and", num2, "is:", difference_result)

En este código:

Definimos dos funciones: add y subtract.
Llamamos a la función add con los argumentos num1 y num2, y almacenamos el valor devuelto en una variable llamada sum_result.
Llamamos a la función subtract con los argumentos num1 y num2, y almacenamos el valor devuelto en una variable llamada difference_result.
Usamos la función print() para mostrar los valores de sum_result y difference_result, junto con texto descriptivo.

Guarda el archivo calculate.py.
Ejecuta el script usando el siguiente comando:
```
python calculate.py
```
Deberías ver la siguiente salida:
```
The sum of 10 and 5 is: 15
The difference between 10 and 5 is: 5
```
Esta salida muestra que capturamos con éxito los valores de retorno de las funciones add y subtract y los utilizamos en nuestro programa.

Ahora, creemos un ejemplo más complejo donde usamos el valor de retorno de una función como argumento para otra función.

Abre el archivo calculate.py en VS Code.

Modifica el código para que sea el siguiente:

def add(x, y):
    """This function adds two numbers and returns the result."""
    sum = x + y
    return sum

def multiply(x, y):
    """This function multiplies two numbers and returns the result."""
    product = x * y
    return product

## Call the functions and capture the return values
num1 = 5
num2 = 3

sum_result = add(num1, num2)
product_result = multiply(sum_result, 2)  ## Use the return value of add as an argument to multiply

print("The sum of", num1, "and", num2, "is:", sum_result)
print("The product of the sum and 2 is:", product_result)

En este código:

Definimos dos funciones: add y multiply.
Llamamos a la función add con los argumentos num1 y num2, y almacenamos el valor devuelto en una variable llamada sum_result.
Llamamos a la función multiply con los argumentos sum_result y 2. Esto demuestra cómo el valor de retorno de add se puede utilizar como entrada para multiply. Almacenamos el valor devuelto en una variable llamada product_result.
Usamos la función print() para mostrar los valores de sum_result y product_result, junto con texto descriptivo.

Guarda el archivo calculate.py.
Ejecuta el script usando el siguiente comando:
```
python calculate.py
```
Deberías ver la siguiente salida:
```
The sum of 5 and 3 is: 8
The product of the sum and 2 is: 16
```
Esta salida muestra que utilizamos con éxito el valor de retorno de una función como argumento para otra función, demostrando el poder y la flexibilidad de los valores de retorno de las funciones.

Comprueba si el valor de retorno es None

En algunos casos, una función puede no devolver siempre un valor significativo. En tales situaciones, puede devolver None. None es un valor especial en Python que representa la ausencia de un valor. Es importante comprobar si una función devuelve None antes de utilizar su valor de retorno para evitar errores.

Modifiquemos el archivo calculate.py para incluir una función que pueda devolver None.

Abre el archivo calculate.py en VS Code.

Modifica el código para que sea el siguiente:

def divide(x, y):
    """This function divides x by y and returns the result.
    If y is 0, it returns None to avoid division by zero errors.
    """
    if y == 0:
        return None
    else:
        return x / y

## Call the function and check if the return value is None
numerator = 10
denominator = 0

result = divide(numerator, denominator)

if result is None:
    print("Cannot divide by zero!")
else:
    print("The result of", numerator, "/", denominator, "is:", result)

denominator = 2
result = divide(numerator, denominator)

if result is None:
    print("Cannot divide by zero!")
else:
    print("The result of", numerator, "/", denominator, "is:", result)

En este código:

Definimos una función llamada divide que toma dos argumentos, x e y.
Dentro de la función, comprobamos si y es igual a 0. Si lo es, devolvemos None para evitar un error de división por cero.
Si y no es 0, calculamos el resultado de x / y y lo devolvemos.
Fuera de la función, llamamos a la función divide con un denominador de 0.
Comprobamos si el valor devuelto es None utilizando el operador is.
Si el valor devuelto es None, imprimimos un mensaje de error.
De lo contrario, imprimimos el resultado de la división.
Luego llamamos a la función divide nuevamente con un denominador válido e imprimimos el resultado.

Guarda el archivo calculate.py.
Ejecuta el script usando el siguiente comando:
```
python calculate.py
```
Deberías ver la siguiente salida:
```
Cannot divide by zero!
The result of 10 / 2 is: 5.0
```
Esta salida muestra que el programa manejó correctamente el caso en el que el denominador era 0 e imprimió un mensaje de error adecuado. También muestra que el programa calculó e imprimió correctamente el resultado cuando el denominador no era 0.

Es importante utilizar el operador is para comprobar si un valor es None porque None es un objeto singleton en Python. Esto significa que solo hay una instancia de None en todo el programa. Utilizar el operador == puede no funcionar correctamente porque compara los valores de los objetos, no los objetos en sí.

Resumen

En este laboratorio, aprendiste sobre los valores de retorno de las funciones en Python. Creaste una función llamada add que toma dos argumentos, calcula su suma y devuelve el resultado. Luego llamaste a la función, almacenaste el valor devuelto en una variable e imprimiste ese valor en la consola.

El laboratorio demostró cómo las funciones pueden devolver valores de diferentes tipos, como enteros. Esto permite que las funciones realicen cálculos u operaciones y proporcionen los resultados al código que las llama para su posterior uso.