Comment vérifier si une fonction retourne None en Python

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si une fonction retourne None en Python. Le laboratoire vous guide dans la compréhension des valeurs de retour des fonctions en créant un simple script Python avec une fonction qui retourne la somme de deux nombres. Vous exécuterez ensuite le script et observerez la sortie.

Le laboratoire se poursuit en modifiant la fonction pour retourner différents types de données, et se concentre finalement sur les scénarios où une fonction peut ne pas retourner explicitement de valeur, ce qui entraîne un retour None. Vous apprendrez à capturer la valeur de retour d'une fonction, puis à vérifier si cette valeur est None en utilisant l'opérateur is.

Apprendre les valeurs de retour des fonctions

Dans cette étape, vous allez apprendre à propos des valeurs de retour des fonctions en Python. Les fonctions sont des blocs de code réutilisables qui effectuent des tâches spécifiques. Souvent, vous voudrez qu'une fonction vous renvoie un résultat une fois qu'elle a terminé son travail. Ce résultat est appelé la valeur de retour.

Commençons par créer un simple script Python qui définit une fonction avec une valeur de retour.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé calculate.py dans le répertoire ~/project.
```
~/project/calculate.py
```
Ajoutez le code suivant à 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)
```
Dans ce code :
- Nous définissons une fonction appelée add qui prend deux arguments, x et y.
- À l'intérieur de la fonction, nous calculons la somme de x et y et la stockons dans une variable appelée sum.
- L'instruction return sum spécifie que la fonction doit retourner la valeur de sum lorsqu'elle est appelée.
- En dehors de la fonction, nous appelons la fonction add avec les arguments 5 et 3, et stockons la valeur retournée dans une variable appelée result.
- Enfin, nous utilisons la fonction print() pour afficher la valeur de result.
Enregistrez le fichier calculate.py.
Ouvrez un terminal dans le WebIDE.
Exécutez le script en utilisant la commande suivante :
```
python calculate.py
```
Vous devriez voir la sortie suivante :
```
8
```
Cette sortie montre que la fonction add a correctement calculé la somme de 5 et 3, et a retourné la valeur 8, qui a ensuite été affichée dans la console.

Maintenant, modifions la fonction pour qu'elle retourne un autre type de valeur, comme une chaîne de caractères.

Ouvrez le fichier calculate.py dans VS Code.
Modifiez le code comme suit :
```
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)
```
Dans ce code :
- Nous définissons une fonction appelée greet qui prend un argument, name.
- À l'intérieur de la fonction, nous créons un message de salutation en concaténant la chaîne "Hello, ", la valeur de l'argument name et la chaîne "!".
- L'instruction return message spécifie que la fonction doit retourner le message de salutation.
- En dehors de la fonction, nous appelons la fonction greet avec l'argument "LabEx User", et stockons la valeur retournée dans une variable appelée greeting.
- Enfin, nous utilisons la fonction print() pour afficher la valeur de greeting.
Enregistrez le fichier calculate.py.
Exécutez le script à nouveau en utilisant la commande suivante :
```
python calculate.py
```
Vous devriez voir la sortie suivante :
```
Hello, LabEx User!
```
Cette sortie montre que la fonction greet a correctement créé un message de salutation et l'a retourné, qui a ensuite été affiché dans la console.

Capturer la valeur de retour

Dans l'étape précédente, vous avez appris à définir des fonctions qui retournent des valeurs. Maintenant, vous allez apprendre à capturer et à utiliser ces valeurs de retour dans vos programmes. Capturer la valeur de retour signifie stocker la valeur retournée par une fonction dans une variable afin de pouvoir l'utiliser plus tard.

Continuons avec le fichier calculate.py que vous avez créé dans l'étape précédente. Nous allons modifier le script pour effectuer plus d'opérations et capturer les valeurs de retour.

Ouvrez le fichier calculate.py dans VS Code.

Modifiez le code comme suit :

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)

Dans ce code :

Nous définissons deux fonctions : add et subtract.
Nous appelons la fonction add avec les arguments num1 et num2, et stockons la valeur retournée dans une variable appelée sum_result.
Nous appelons la fonction subtract avec les arguments num1 et num2, et stockons la valeur retournée dans une variable appelée difference_result.
Nous utilisons la fonction print() pour afficher les valeurs de sum_result et difference_result, accompagnées de textes descriptifs.

Enregistrez le fichier calculate.py.
Exécutez le script en utilisant la commande suivante :
```
python calculate.py
```
Vous devriez voir la sortie suivante :
```
The sum of 10 and 5 is: 15
The difference between 10 and 5 is: 5
```
Cette sortie montre que nous avons réussi à capturer les valeurs de retour des fonctions add et subtract et à les utiliser dans notre programme.

Maintenant, créons un exemple plus complexe où nous utilisons la valeur de retour d'une fonction comme argument pour une autre fonction.

Ouvrez le fichier calculate.py dans VS Code.
Modifiez le code comme suit :
```
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)
```
Dans ce code :
- Nous définissons deux fonctions : add et multiply.
- Nous appelons la fonction add avec les arguments num1 et num2, et stockons la valeur retournée dans une variable appelée sum_result.
- Nous appelons la fonction multiply avec les arguments sum_result et 2. Cela montre comment la valeur de retour de add peut être utilisée comme entrée pour multiply. Nous stockons la valeur retournée dans une variable appelée product_result.
- Nous utilisons la fonction print() pour afficher les valeurs de sum_result et product_result, accompagnées de textes descriptifs.
Enregistrez le fichier calculate.py.
Exécutez le script en utilisant la commande suivante :
```
python calculate.py
```
Vous devriez voir la sortie suivante :
```
The sum of 5 and 3 is: 8
The product of the sum and 2 is: 16
```
Cette sortie montre que nous avons réussi à utiliser la valeur de retour d'une fonction comme argument pour une autre fonction, démontrant la puissance et la flexibilité des valeurs de retour des fonctions.

Vérifier si la valeur de retour est None

Dans certains cas, une fonction peut ne pas toujours retourner une valeur significative. Dans de telles situations, elle peut retourner None. None est une valeur spéciale en Python qui représente l'absence de valeur. Il est important de vérifier si une fonction retourne None avant d'utiliser sa valeur de retour pour éviter les erreurs.

Modifions le fichier calculate.py pour inclure une fonction qui peut retourner None.

Ouvrez le fichier calculate.py dans VS Code.
Modifiez le code comme suit :
```
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)
```
Dans ce code :
- Nous définissons une fonction appelée divide qui prend deux arguments, x et y.
- À l'intérieur de la fonction, nous vérifions si y est égal à 0. Si c'est le cas, nous retournons None pour éviter une erreur de division par zéro.
- Si y n'est pas égal à 0, nous calculons le résultat de x / y et le retournons.
- En dehors de la fonction, nous appelons la fonction divide avec un dénominateur égal à 0.
- Nous vérifions si la valeur retournée est None en utilisant l'opérateur is.
- Si la valeur retournée est None, nous affichons un message d'erreur.
- Sinon, nous affichons le résultat de la division.
- Nous appelons ensuite la fonction divide à nouveau avec un dénominateur valide et affichons le résultat.
Enregistrez le fichier calculate.py.
Exécutez le script en utilisant la commande suivante :
```
python calculate.py
```
Vous devriez voir la sortie suivante :
```
Cannot divide by zero!
The result of 10 / 2 is: 5.0
```
Cette sortie montre que le programme a correctement géré le cas où le dénominateur était égal à 0 et a affiché un message d'erreur approprié. Elle montre également que le programme a correctement calculé et affiché le résultat lorsque le dénominateur n'était pas égal à 0.

Il est important d'utiliser l'opérateur is pour vérifier si une valeur est None car None est un objet singleton en Python. Cela signifie qu'il n'y a qu'une seule instance de None dans tout le programme. L'utilisation de l'opérateur == peut ne pas toujours fonctionner correctement car il compare les valeurs des objets, pas les objets eux-mêmes.

Résumé

Dans ce laboratoire (lab), vous avez appris à propos des valeurs de retour des fonctions en Python. Vous avez créé une fonction appelée add qui prend deux arguments, calcule leur somme et retourne le résultat. Vous avez ensuite appelé la fonction, stocké la valeur retournée dans une variable et l'avez affichée dans la console.

Le laboratoire a démontré comment les fonctions peuvent retourner des valeurs de différents types, comme des entiers (integers). Cela permet aux fonctions d'effectuer des calculs ou des opérations et de fournir les résultats au code appelant pour une utilisation ultérieure.