Comment vérifier si une fonction Python renvoie une valeur spécifique

Introduction

Dans ce labo (laboratoire), vous apprendrez à vérifier si une fonction Python renvoie une valeur spécifique. Le labo se concentre sur la compréhension des retours de fonction à l'aide de l'instruction return et sur la vérification de la sortie.

Vous commencerez par créer un script Python avec une fonction qui calcule la somme de deux nombres et renvoie le résultat. Vous exécuterez ensuite le script et observerez la sortie. Enfin, vous modifiererez le script pour renvoyer différentes valeurs en fonction d'une condition et vérifierez la valeur renvoyée.

Comprendre les retours de fonction

Dans cette étape, vous apprendrez à propos des retours de fonction 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 après avoir terminé son travail. Cela se fait à l'aide de l'instruction return.

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_sum.py dans le répertoire ~/project.
```
~/project/calculate_sum.py
```
Ajoutez le code suivant au fichier calculate_sum.py :
```
def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    """
    sum_result = x + y
    return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)
```
Dans ce code :
- Nous définissons une fonction appelée calculate_sum 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_result.
- L'instruction return sum_result envoie la valeur de sum_result au appelant de la fonction.
- Nous appelons ensuite la fonction avec num1 = 10 et num2 = 5, et stockons la valeur renvoyée dans la variable result.
- Enfin, nous utilisons la fonction print() pour afficher le résultat.
Maintenant, exécutez le script en utilisant la commande suivante dans le terminal :
```
python ~/project/calculate_sum.py
```
Vous devriez voir la sortie suivante :
```
The sum of 10 and 5 is 15
```
Cette sortie confirme que la fonction a correctement calculé la somme et renvoyé la valeur, qui a ensuite été affichée dans la console.

Modifions le script pour renvoyer une valeur différente en fonction d'une condition. Modifiez le fichier calculate_sum.py pour inclure ce qui suit :

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

Ici, nous avons ajouté une instruction conditionnelle (if sum_result > 10:) pour vérifier si la somme est supérieure à 10. Si c'est le cas, la fonction renvoie le double de la somme ; sinon, elle renvoie la somme originale.

Exécutez le script à nouveau :
```
python ~/project/calculate_sum.py
```
Vous devriez maintenant voir la sortie suivante :
```
The sum of 10 and 5 is 30
The sum of 2 and 3 is 5
```
Le premier appel à calculate_sum renvoie 30 car la somme (15) est supérieure à 10, donc elle est doublée. Le deuxième appel renvoie 5 car la somme (5) n'est pas supérieure à 10.

Appeler une fonction et capturer la sortie

Dans cette étape, vous apprendrez à appeler une fonction et à capturer sa sortie en Python. Capturer la sortie d'une fonction vous permet d'utiliser la valeur renvoyée dans d'autres calculs ou opérations au sein de votre script.

Nous continuerons à utiliser le fichier calculate_sum.py de l'étape précédente. Si vous n'avez pas terminé l'étape précédente, veuillez créer le fichier avec le contenu suivant :

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

Maintenant, modifions le script pour capturer la sortie de la fonction calculate_sum et effectuer des opérations supplémentaires avec elle.

Ouvrez le fichier calculate_sum.py dans l'éditeur VS Code.

Modifiez le script comme suit :

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

## Capture the output and perform an additional operation
final_result = result + 20
print("The final result after adding 20 is:", final_result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

## Capture the output and perform an additional operation
final_result2 = result2 * 2
print("The final result after multiplying by 2 is:", final_result2)

Dans ce script modifié :

Nous appelons la fonction calculate_sum avec num1 et num2, et stockons la valeur renvoyée dans la variable result.
Nous ajoutons ensuite 20 au result et le stockons dans final_result.
Enfin, nous affichons la valeur de final_result.
Nous appelons également la fonction calculate_sum avec num3 et num4, et stockons la valeur renvoyée dans la variable result2.
Nous multiplions ensuite result2 par 2 et le stockons dans final_result2.
Enfin, nous affichons la valeur de final_result2.

Exécutez le script en utilisant la commande suivante :
```
python ~/project/calculate_sum.py
```
Vous devriez voir la sortie suivante :
```
The sum of 10 and 5 is 30
The final result after adding 20 is: 50
The sum of 2 and 3 is 5
The final result after multiplying by 2 is: 10
```
Cette sortie démontre que vous pouvez appeler avec succès une fonction, capturer la valeur qu'elle renvoie et utiliser cette valeur dans des opérations ultérieures au sein de votre script.

Comparer la sortie avec la valeur attendue

Dans cette étape, vous apprendrez à comparer la sortie d'une fonction avec une valeur attendue. Cela est une partie cruciale des tests et de la vérification que vos fonctions fonctionnent correctement. En comparant la sortie réelle avec la sortie attendue, vous pouvez identifier et corriger les erreurs dans votre code.

Nous continuerons à utiliser le fichier calculate_sum.py des étapes précédentes. Si vous n'avez pas terminé les étapes précédentes, veuillez créer le fichier avec le contenu suivant :

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

## Capture the output and perform an additional operation
final_result = result + 20
print("The final result after adding 20 is:", final_result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

## Capture the output and perform an additional operation
final_result2 = result2 * 2
print("The final result after multiplying by 2 is:", final_result2)

Maintenant, ajoutons une fonction pour comparer la sortie avec une valeur attendue et afficher un message indiquant si le test a réussi ou échoué.

Ouvrez le fichier calculate_sum.py dans l'éditeur VS Code.

Modifiez le script comme suit :

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

def compare_output(actual_output, expected_output):
    """
    This function compares the actual output with the expected output.
    """
    if actual_output == expected_output:
        print("Test passed!")
    else:
        print("Test failed. Expected:", expected_output, "Actual:", actual_output)

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

## Capture the output and perform an additional operation
final_result = result + 20
print("The final result after adding 20 is:", final_result)

## Compare the output with the expected value
expected_final_result = 50
compare_output(final_result, expected_final_result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

## Capture the output and perform an additional operation
final_result2 = result2 * 2
print("The final result after multiplying by 2 is:", final_result2)

## Compare the output with the expected value
expected_final_result2 = 10
compare_output(final_result2, expected_final_result2)

Dans ce script modifié :

Nous définissons une fonction appelée compare_output qui prend deux arguments : actual_output et expected_output.
À l'intérieur de la fonction, nous comparons actual_output avec expected_output.
Si elles sont égales, nous affichons "Test passed!".
Si elles ne sont pas égales, nous affichons "Test failed." ainsi que les valeurs attendue et réelle.
Nous appelons ensuite la fonction compare_output avec final_result et expected_final_result pour comparer la sortie du premier calcul avec la valeur attendue de 50.
Nous appelons également la fonction compare_output avec final_result2 et expected_final_result2 pour comparer la sortie du deuxième calcul avec la valeur attendue de 10.

Exécutez le script en utilisant la commande suivante :
```
python ~/project/calculate_sum.py
```
Vous devriez voir la sortie suivante :
```
The sum of 10 and 5 is 30
The final result after adding 20 is: 50
Test passed!
The sum of 2 and 3 is 5
The final result after multiplying by 2 is: 10
Test passed!
```
Cette sortie démontre que vous pouvez comparer avec succès la sortie d'une fonction avec une valeur attendue et déterminer si le test a réussi ou échoué.

Résumé

Dans ce laboratoire (lab), la première étape consiste à comprendre les retours de fonction en Python. Elle implique la création d'un script calculate_sum.py qui définit une fonction, calculate_sum(x, y), qui calcule la somme de deux nombres d'entrée et renvoie le résultat à l'aide de l'instruction return. Le script appelle ensuite cette fonction avec des valeurs d'exemple et affiche la somme renvoyée dans la console, démontrant ainsi comment une fonction peut renvoyer une valeur qui peut être capturée et utilisée ailleurs dans le code.

Le script initial est ensuite modifié pour renvoyer différentes valeurs en fonction d'une condition, illustrant ainsi davantage la flexibilité des retours de fonction. Cette étape renforce le concept des fonctions comme des blocs de code réutilisables qui peuvent fournir des sorties spécifiques en fonction de leurs entrées et de leur logique interne.