Revoir la gestion des exceptions dans les fonctions simples

PythonPythonBeginner
Pratiquer maintenant

This tutorial is from open-source community. Access the source code

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, vous apprendrez à examiner la définition de fonctions simples en Python et à explorer la gestion des exceptions. Les fonctions sont un concept clé de la programmation qui vous permet de structurer votre code en segments réutilisables. La gestion des exceptions, quant à elle, est une méthode pour gérer les erreurs et les situations imprévues dans vos programmes.

Les principaux objectifs de ce laboratoire sont de revoir le processus de définition de fonctions simples et d'apprendre à gérer les exceptions en Python. Le fichier qui sera modifié est pcost.py.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/ErrorandExceptionHandlingGroup(["Error and Exception Handling"]) python(("Python")) -.-> python/FileHandlingGroup(["File Handling"]) python/BasicConceptsGroup -.-> python/python_shell("Python Shell") python/FunctionsGroup -.-> python/function_definition("Function Definition") python/ErrorandExceptionHandlingGroup -.-> python/catching_exceptions("Catching Exceptions") python/FileHandlingGroup -.-> python/file_opening_closing("Opening and Closing Files") python/FileHandlingGroup -.-> python/file_reading_writing("Reading and Writing Files") subgraph Lab Skills python/python_shell -.-> lab-132393{{"Revoir la gestion des exceptions dans les fonctions simples"}} python/function_definition -.-> lab-132393{{"Revoir la gestion des exceptions dans les fonctions simples"}} python/catching_exceptions -.-> lab-132393{{"Revoir la gestion des exceptions dans les fonctions simples"}} python/file_opening_closing -.-> lab-132393{{"Revoir la gestion des exceptions dans les fonctions simples"}} python/file_reading_writing -.-> lab-132393{{"Revoir la gestion des exceptions dans les fonctions simples"}} end

Définition d'une fonction

Dans cette étape, nous allons apprendre à créer une fonction. Une fonction en Python est un bloc de code organisé et réutilisable utilisé pour effectuer une seule action liée. Ici, notre fonction lira les données d'un portefeuille depuis un fichier et calculera le coût total. Cela est utile car une fois que nous avons cette fonction, nous pouvons l'utiliser plusieurs fois avec différents fichiers de portefeuille, ce qui nous évite d'écrire le même code à plusieurs reprises.

Comprendre le problème

Dans le laboratoire précédent, vous avez peut - être écrit du code pour lire les données d'un portefeuille et calculer le coût total. Mais ce code était probablement écrit de manière à ne pas être facilement réutilisable. Maintenant, nous allons convertir ce code en une fonction réutilisable.

Les fichiers de données de portefeuille ont un format spécifique. Ils contiennent des informations sous la forme "Symbole Nombre_de_titres Prix". Chaque ligne du fichier représente une action détenue. Par exemple, dans un fichier nommé portfolio.dat, vous pourriez voir des lignes comme celles - ci :

AA 100 32.20
IBM 50 91.10
...

Ici, la première partie (comme "AA" ou "IBM") est le symbole de l'action, qui est un identifiant unique pour l'action. La deuxième partie est le nombre de titres que vous possédez de cette action, et la troisième partie est le prix par titre.

Création de la fonction

Créons un fichier Python appelé pcost.py dans le répertoire /home/labex/project. Ce fichier contiendra notre fonction. Voici le code que nous allons placer dans le fichier pcost.py :

def portfolio_cost(filename):
    """
    Calcule le coût total (nombre_de_titres*prix) d'un fichier de portefeuille

    Args:
        filename: Le nom du fichier de portefeuille

    Returns:
        Le coût total du portefeuille sous forme de nombre à virgule flottante
    """
    total_cost = 0.0

    ## Ouvre le fichier et lit chaque ligne
    with open(filename, 'r') as f:
        for line in f:
            fields = line.split()
            ## Extrait les données (symbole, nombre_de_titres, prix)
            shares = int(fields[1])
            price = float(fields[2])
            ## Ajoute le coût au total en cours
            total_cost += shares * price

    return total_cost

## Appelle la fonction avec le fichier portfolio.dat
if __name__ == '__main__':
    cost = portfolio_cost('/home/labex/project/portfolio.dat')
    print(cost)

Dans ce code, nous définissons d'abord une fonction nommée portfolio_cost qui prend un filename comme argument. À l'intérieur de la fonction, nous initialisons une variable total_cost à 0.0. Ensuite, nous ouvrons le fichier à l'aide de la fonction open en mode lecture ('r'). Nous utilisons une boucle for pour parcourir chaque ligne du fichier. Pour chaque ligne, nous la divisons en champs à l'aide de la méthode split(). Nous extrayons ensuite le nombre de titres et le convertissons en entier, et le prix et le convertissons en nombre à virgule flottante. Nous calculons le coût de cette action détenue en multipliant le nombre de titres par le prix et l'ajoutons au total_cost. Enfin, nous retournons le total_cost.

La partie if __name__ == '__main__': est utilisée pour appeler la fonction lorsque le script est exécuté directement. Nous passons le chemin du fichier portfolio.dat à la fonction et affichons le résultat.

Test de la fonction

Maintenant, exécutons le programme pour voir s'il fonctionne. Nous devons nous déplacer dans le répertoire où se trouve le fichier pcost.py, puis exécuter le script Python. Voici les commandes pour cela :

cd /home/labex/project
python3 pcost.py

Après avoir exécuté ces commandes, vous devriez voir la sortie suivante :

44671.15

Cette sortie représente le coût total de toutes les actions du portefeuille.

Comprendre le code

Découpons ce que fait notre fonction étape par étape :

  1. Elle prend un filename comme paramètre d'entrée. Cela nous permet d'utiliser la fonction avec différents fichiers de portefeuille.
  2. Elle ouvre le fichier et le lit ligne par ligne. Cela est fait à l'aide de la fonction open et d'une boucle for.
  3. Pour chaque ligne, elle divise la ligne en champs à l'aide de la méthode split(). Cette méthode divise la ligne en une liste de chaînes de caractères en fonction des espaces.
  4. Elle convertit le nombre de titres en entier et le prix en nombre à virgule flottante. Cela est nécessaire car les données lues depuis le fichier sont au format chaîne de caractères, et nous devons effectuer des opérations arithmétiques sur elles.
  5. Elle calcule le coût (nombre_de_titres * prix) pour chaque action détenue et l'ajoute au total en cours. Cela nous donne le coût total du portefeuille.
  6. Elle retourne le coût total final. Cela nous permet d'utiliser le résultat dans d'autres parties de notre programme si nécessaire.

Cette fonction est maintenant réutilisable. Nous pouvons l'appeler avec différents fichiers de portefeuille pour calculer leurs coûts, ce qui rend notre code plus efficace et plus facile à maintenir.

✨ Vérifier la solution et pratiquer

Ajout de la gestion des erreurs

Lorsque vous travaillez avec des données du monde réel, il est très courant de rencontrer des incohérences ou des erreurs. Par exemple, les données peuvent avoir des valeurs manquantes, des formats incorrects ou d'autres problèmes. Python propose des mécanismes de gestion des exceptions pour gérer ces situations de manière élégante. La gestion des exceptions permet à votre programme de continuer à s'exécuter même lorsqu'il rencontre une erreur, au lieu de planter brutalement.

Comprendre le problème

Regardons le fichier portfolio3.dat. Ce fichier contient des données sur un portefeuille, comme le symbole de l'action, le nombre de titres et le prix par titre. Pour afficher le contenu de ce fichier, nous pouvons utiliser la commande suivante :

cat /home/labex/project/portfolio3.dat

Lorsque vous exécutez cette commande, vous remarquerez que certaines lignes du fichier ont des tirets (-) au lieu de nombres pour le nombre de titres. Voici un exemple de ce que vous pourriez voir :

AA 100 32.20
IBM 50 91.10
C - 53.08
...

Si nous essayons d'exécuter notre code actuel sur ce fichier, il plantera. La raison est que notre code s'attend à convertir le nombre de titres en un entier, mais il ne peut pas convertir un tiret (-) en un entier. Essayons d'exécuter le code et voyons ce qui se passe :

python3 -c "import sys; sys.path.append('/home/labex/project'); from pcost import portfolio_cost; print(portfolio_cost('/home/labex/project/portfolio3.dat'))"

Vous verrez un message d'erreur comme celui - ci :

ValueError: invalid literal for int() with base 10: '-'

Cette erreur se produit car Python ne peut pas convertir le caractère - en un entier lorsqu'il essaie d'exécuter int(fields[1]).

Introduction à la gestion des exceptions

La gestion des exceptions en Python utilise les blocs try et except. Le bloc try contient le code qui peut lever une exception. Une exception est une erreur qui se produit pendant l'exécution d'un programme. Le bloc except contient le code qui sera exécuté si une exception se produit dans le bloc try.

Voici un exemple de fonctionnement des blocs try et except :

try:
    ## Code that might raise an exception
    result = risky_operation()
except ExceptionType as e:
    ## Code to handle the exception
    print(f"An error occurred: {e}")

Lorsque Python exécute le code dans le bloc try, si une exception se produit, l'exécution saute immédiatement au bloc except correspondant. Le ExceptionType dans le bloc except spécifie le type d'exception que nous voulons gérer. La variable e contient des informations sur l'exception, comme le message d'erreur.

Modification de la fonction avec gestion des exceptions

Mettons à jour notre fichier pcost.py pour gérer les erreurs dans les données. Nous utiliserons les blocs try et except pour sauter les lignes avec des données incorrectes et afficher un message d'avertissement.

def portfolio_cost(filename):
    """
    Calcule le coût total (nombre_de_titres*prix) d'un fichier de portefeuille
    Gère les lignes avec des données incorrectes en les sautant et en affichant un avertissement.

    Args:
        filename: Le nom du fichier de portefeuille

    Returns:
        Le coût total du portefeuille sous forme de nombre à virgule flottante
    """
    total_cost = 0.0

    ## Ouvre le fichier et lit chaque ligne
    with open(filename, 'r') as f:
        for line in f:
            fields = line.split()
            try:
                ## Extrait les données (symbole, nombre_de_titres, prix)
                shares = int(fields[1])
                price = float(fields[2])
                ## Ajoute le coût au total en cours
                total_cost += shares * price
            except ValueError as e:
                ## Affiche un avertissement pour les lignes qui ne peuvent pas être analysées
                print(f"Couldn't parse: '{line}'")
                print(f"Reason: {e}")

    return total_cost

## Appelle la fonction avec le fichier portfolio3.dat
if __name__ == '__main__':
    cost = portfolio_cost('/home/labex/project/portfolio3.dat')
    print(cost)

Dans ce code mis à jour, nous ouvrons d'abord le fichier et le lisons ligne par ligne. Pour chaque ligne, nous la divisons en champs. Ensuite, nous essayons de convertir le nombre de titres en un entier et le prix en un nombre à virgule flottante. Si cette conversion échoue (c'est - à - dire qu'une ValueError se produit), nous affichons un message d'avertissement et sautons cette ligne. Sinon, nous calculons le coût des titres et l'ajoutons au coût total.

Test de la fonction mise à jour

Maintenant, exécutons le programme mis à jour avec le fichier problématique. Tout d'abord, nous devons nous déplacer dans le répertoire du projet, puis nous pouvons exécuter le script Python.

cd /home/labex/project
python3 pcost.py

Vous devriez voir une sortie comme celle - ci :

Couldn't parse: 'C - 53.08
'
Reason: invalid literal for int() with base 10: '-'
Couldn't parse: 'DIS - 34.20
'
Reason: invalid literal for int() with base 10: '-'
44671.15

Le programme fait maintenant ce qui suit :

  1. Il tente de traiter chaque ligne du fichier.
  2. Si une ligne contient des données invalides, il capture la ValueError.
  3. Il affiche un message utile sur le problème.
  4. Il continue de traiter le reste du fichier.
  5. Il retourne le coût total basé sur les lignes valides.

Cette approche rend notre programme beaucoup plus robuste lorsqu'il s'agit de traiter des données imparfaites. Il peut gérer les erreurs de manière élégante et fournir toujours des résultats utiles.

✨ Vérifier la solution et pratiquer

Expérimentation interactive

Python propose un mode interactif qui vous permet d'exécuter du code immédiatement. Cela est très utile pour tester votre code et essayer de nouvelles choses. Dans cette étape, nous allons apprendre à appeler une fonction directement depuis l'interpréteur Python.

Exécution de Python en mode interactif

Pour exécuter un script Python puis entrer en mode interactif, vous pouvez utiliser le flag -i. Ce flag indique à Python de rester en mode interactif après avoir exécuté le script. Voici comment faire :

cd /home/labex/project
python3 -i pcost.py

Découpons ce que fait cette commande :

  1. Tout d'abord, cd /home/labex/project change le répertoire courant pour /home/labex/project. C'est là que se trouve notre script pcost.py.
  2. Ensuite, python3 -i pcost.py exécute le script pcost.py. Une fois le script terminé, Python reste en mode interactif.
  3. En mode interactif, vous pouvez taper des commandes Python directement dans le terminal.

Après avoir exécuté la commande, vous verrez la sortie du script pcost.py, suivie de l'invite Python (>>>). Cette invite indique que vous pouvez maintenant entrer des commandes Python.

Appel de votre fonction de manière interactive

Une fois que vous êtes en mode interactif, vous pouvez appeler la fonction portfolio_cost() avec différents noms de fichiers. Cela vous permet de voir comment la fonction se comporte avec diverses entrées. Voici un exemple :

>>> portfolio_cost('/home/labex/project/portfolio.dat')
44671.15
>>> portfolio_cost('/home/labex/project/portfolio2.dat')
19908.75
>>> portfolio_cost('/home/labex/project/portfolio3.dat')
Couldn't parse: 'C - 53.08
'
Reason: invalid literal for int() with base 10: '-'
Couldn't parse: 'DIS - 34.20
'
Reason: invalid literal for int() with base 10: '-'
44671.15

En utilisant cette approche interactive, vous pouvez :

  • Tester votre fonction avec différentes entrées pour voir si elle fonctionne comme prévu.
  • Expérimenter le comportement de la fonction dans diverses conditions.
  • Déboguer votre code en direct en voyant les résultats immédiats de vos appels de fonction.

Avantages du mode interactif

Le mode interactif présente plusieurs avantages :

  1. Vous pouvez tester rapidement différents scénarios sans avoir à exécuter tout le script à chaque fois.
  2. Vous pouvez inspecter immédiatement les variables et les résultats des expressions, ce qui vous aide à comprendre ce qui se passe dans votre code.
  3. Vous pouvez tester de petits morceaux de code sans créer un programme complet. C'est idéal pour apprendre et tester de nouvelles idées.
  4. C'est une excellente façon d'apprendre et d'expérimenter avec Python car vous obtenez des retours immédiats.

Sortie du mode interactif

Lorsque vous avez terminé vos expériences, vous pouvez quitter le mode interactif de deux manières :

  • Tapez exit() puis appuyez sur Entrée. C'est un moyen simple de terminer la session interactive.
  • Appuyez sur Ctrl+D (sur Unix/Linux). C'est un raccourci qui permet également de quitter le mode interactif.

Tout au long de votre parcours de programmation en Python, la technique de définition de fonctions et de test interactif sera extrêmement précieuse pour le développement et le débogage. Elle vous permet d'itérer rapidement sur votre code et de trouver et de corriger les problèmes.

✨ Vérifier la solution et pratiquer

Résumé

Dans ce laboratoire (lab), vous avez appris plusieurs concepts clés de la programmation Python. Tout d'abord, vous avez appris à définir et à utiliser des fonctions, ce qui rend votre code réutilisable. Ensuite, vous avez maîtrisé la mise en œuvre de la gestion des exceptions, améliorant ainsi la robustesse de vos programmes. Enfin, vous avez découvert comment utiliser Python en mode interactif pour les tests et les expérimentations.

Ces compétences sont fondamentales pour écrire des programmes Python fiables. Les fonctions aident à organiser et à réutiliser le code, la gestion des exceptions permet de gérer de manière élégante les situations inattendues, et le mode interactif offre un environnement puissant pour les tests et le débogage. Au fur et à mesure de votre progression dans l'apprentissage du Python, ces concepts s'avéreront de plus en plus précieux pour le développement d'applications plus grandes et plus complexes.