Révision des opérations d'entrée/sortie de base sur les fichiers

Introduction

Dans ce labo, vous apprendrez à revoir les opérations de base d'entrée et de sortie de fichiers en Python. Vous allez créer un programme Python pour lire les données d'un fichier contenant des informations sur un portefeuille d'actions et calculer le coût total du portefeuille.

Les objectifs de ce labo incluent l'apprentissage de la manière d'ouvrir et de lire des fichiers en Python, de traiter les données des fichiers ligne par ligne, d'effectuer des calculs sur les données et de sortir les résultats. Le fichier que vous allez créer est pcost.py.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau débutant avec un taux de réussite de 89%. Il a reçu un taux d'avis positifs de 98% de la part des apprenants.

Comprendre le problème

Dans cette étape, nous allons d'abord comprendre le problème que nous devons résoudre, puis examiner les données avec lesquelles nous allons travailler. C'est une première étape importante dans toute tâche de programmation car elle nous aide à savoir exactement ce que nous visons et quelles ressources nous avons à notre disposition.

Dans votre répertoire de projet, il y a un fichier nommé portfolio.dat. Ce fichier stocke des informations sur un portefeuille d'actions. Un portefeuille est comme une collection de différentes actions que possède un investisseur. Chaque ligne de ce fichier représente un achat d'action unique. Le format de chaque ligne est le suivant :

[Symbole de l'action] [Nombre d'actions] [Prix par action]

Le symbole de l'action est un code court qui représente les actions d'une entreprise particulière. Le nombre d'actions nous indique combien d'unités de cette action ont été achetées, et le prix par action est le coût d'une unité de cette action.

Regardons un exemple. Considérons la première ligne du fichier :

AA 100 32.20

Cette ligne indique que 100 actions de l'action avec le symbole "AA" ont été achetées. Chaque action a coûté 32,20 $.

Si vous voulez voir ce qui se trouve à l'intérieur du fichier portfolio.dat, vous pouvez exécuter la commande suivante dans le terminal. La commande cat est un outil utile dans le terminal qui vous permet de visualiser le contenu d'un fichier.

cat ~/project/portfolio.dat

Maintenant, votre tâche est de créer un programme Python nommé pcost.py. Ce programme effectuera trois tâches principales :

Tout d'abord, il doit ouvrir et lire le fichier portfolio.dat. Ouvrir un fichier en Python permet à notre programme d'accéder aux données stockées à l'intérieur.
Ensuite, il doit calculer le coût total de tous les achats d'actions dans le portefeuille. Pour ce faire, pour chaque ligne du fichier, nous devons multiplier le nombre d'actions par le prix par action. Après avoir obtenu ces valeurs pour chaque ligne, nous les additionnons toutes. Cela nous donne le montant total d'argent dépensé pour toutes les actions du portefeuille.
Enfin, le programme doit afficher le coût total. De cette façon, nous pouvons voir le résultat de nos calculs.

Commençons par créer le fichier pcost.py. Vous pouvez utiliser l'éditeur pour ouvrir et modifier ce fichier. Il a déjà été créé pour vous lors de l'étape de configuration. Ce fichier sera l'endroit où vous écrirez le code Python pour résoudre le problème que nous venons de discuter.

Ouvrir et lire un fichier

Dans cette étape, nous allons apprendre à ouvrir et lire un fichier en Python. L'entrée/sortie de fichiers (E/S) est un concept fondamental en programmation. Elle permet à votre programme d'interagir avec des fichiers externes, comme des fichiers texte, des fichiers CSV, etc. En Python, l'une des méthodes les plus courantes pour travailler avec des fichiers consiste à utiliser la fonction open().

La fonction open() est utilisée pour ouvrir un fichier en Python. Elle prend deux arguments importants. Le premier argument est le nom du fichier que vous souhaitez ouvrir. Le deuxième argument est le mode dans lequel vous souhaitez ouvrir le fichier. Lorsque vous souhaitez lire un fichier, vous utilisez le mode 'r'. Cela indique à Python que vous ne souhaitez que lire le contenu du fichier sans apporter de modifications.

Maintenant, ajoutons un peu de code au fichier pcost.py pour ouvrir et lire le fichier portfolio.dat. Ouvrez le fichier pcost.py dans votre éditeur de code et ajoutez le code suivant :

## pcost.py
## Calculate the total cost of a portfolio of stocks

def portfolio_cost(filename):
    """
    Computes the total cost (shares*price) of a portfolio file
    """
    total_cost = 0.0

    ## Open the file
    with open(filename, 'r') as file:
        ## Read all lines in the file
        for line in file:
            print(line)  ## Just for debugging, to see what we're reading

    ## Return the total cost
    return total_cost

## Call the function with the portfolio file
total_cost = portfolio_cost('portfolio.dat')
print(f'Total cost: ${total_cost}')

Analysons ce que ce code fait :

Tout d'abord, nous définissons une fonction nommée portfolio_cost(). Cette fonction prend un nom de fichier en tant que paramètre d'entrée. Le but de cette fonction est de calculer le coût total d'un portefeuille d'actions en fonction des données du fichier.
À l'intérieur de la fonction, nous utilisons la fonction open() pour ouvrir le fichier spécifié en mode lecture. L'instruction with est utilisée ici pour garantir que le fichier est correctement fermé une fois que nous avons terminé de le lire. C'est une bonne pratique pour éviter les fuites de ressources.
Nous utilisons ensuite une boucle for pour lire le fichier ligne par ligne. Pour chaque ligne du fichier, nous l'affichons. Cela ne sert qu'à des fins de débogage, afin que nous puissions voir quelles données nous lisons à partir du fichier.
Après avoir lu le fichier, la fonction retourne le coût total. Actuellement, le coût total est fixé à 0,0 car nous n'avons pas encore implémenté le calcul réel.
En dehors de la fonction, nous appelons la fonction portfolio_cost() avec le nom de fichier 'portfolio.dat'. Cela signifie que nous demandons à la fonction de calculer le coût total en fonction des données du fichier portfolio.dat.
Enfin, nous affichons le coût total à l'aide d'une chaîne formatée (f-string).

Maintenant, exécutons ce code pour voir ce qu'il fait. Vous pouvez exécuter le fichier Python depuis le terminal en utilisant la commande suivante :

python3 ~/project/pcost.py

Lorsque vous exécutez cette commande, vous devriez voir chaque ligne du fichier portfolio.dat affichée sur le terminal, suivie du coût total, qui est actuellement fixé à 0,0. Cette sortie vous permet de vérifier que le fichier est correctement lu.

Traitement des données

Maintenant que nous avons appris à lire un fichier, l'étape suivante consiste à traiter chaque ligne du fichier pour calculer le coût de chaque achat d'actions. C'est une partie importante du travail avec des données en Python, car cela nous permet d'extraire des informations significatives du fichier.

Chaque ligne du fichier suit un format spécifique : [Symbole de l'action] [Nombre d'actions] [Prix par action]. Pour calculer le coût de chaque achat d'actions, nous devons extraire le nombre d'actions et le prix par action de chaque ligne. Ensuite, nous multiplions ces deux valeurs ensemble pour obtenir le coût de cet achat d'actions particulier. Enfin, nous ajoutons ce coût à notre total en cours pour trouver le coût global du portefeuille.

Modifions la fonction portfolio_cost() dans le fichier pcost.py pour y parvenir. Voici le code modifié :

def portfolio_cost(filename):
    """
    Computes the total cost (shares*price) of a portfolio file
    """
    total_cost = 0.0

    ## Open the file
    with open(filename, 'r') as file:
        ## Read all lines in the file
        for line in file:
            ## Strip any leading/trailing whitespace
            line = line.strip()

            ## Skip empty lines
            if not line:
                continue

            ## Split the line into fields
            fields = line.split()

            ## Extract the relevant data
            ## fields[0] is the stock symbol (which we don't need for the calculation)
            shares = int(fields[1])  ## Number of shares (second field)
            price = float(fields[2])  ## Price per share (third field)

            ## Calculate the cost of this stock purchase
            cost = shares * price

            ## Add to the total cost
            total_cost += cost

            ## Print some debug information
            print(f'{fields[0]}: {shares} shares at ${price:.2f} = ${cost:.2f}')

    ## Return the total cost
    return total_cost

Analysons étape par étape ce que fait cette fonction modifiée :

Supprime les espaces blancs : Nous utilisons la méthode strip() pour supprimer tout espace blanc en début ou en fin de chaque ligne. Cela garantit que nous n'incluons pas accidentellement des espaces supplémentaires lorsque nous divisons la ligne en champs.
Saute les lignes vides : Si une ligne est vide (c'est-à-dire qu'elle ne contient que des espaces blancs), nous utilisons l'instruction continue pour la sauter. Cela nous aide à éviter les erreurs lors de la tentative de division d'une ligne vide.
Divise la ligne en champs : Nous utilisons la méthode split() pour diviser chaque ligne en une liste de champs en fonction des espaces blancs. Cela nous permet d'accéder à chaque partie de la ligne séparément.
Extrait les données pertinentes : Nous extrayons le nombre d'actions et le prix par action de la liste de champs. Le nombre d'actions est le deuxième champ, et le prix par action est le troisième champ. Nous convertissons ces valeurs en types de données appropriés (int pour le nombre d'actions et float pour le prix) afin que nous puissions effectuer des opérations arithmétiques sur elles.
Calcule le coût : Nous multiplions le nombre d'actions par le prix par action pour calculer le coût de cet achat d'actions.
Ajoute au total : Nous ajoutons le coût de cet achat d'actions au total en cours.
Affiche des informations de débogage : Nous affichons des informations sur chaque achat d'actions pour nous aider à voir ce qui se passe. Cela inclut le symbole de l'action, le nombre d'actions, le prix par action et le coût total de l'achat.

Maintenant, exécutons le code pour voir s'il fonctionne. Ouvrez votre terminal et exécutez la commande suivante :

python3 ~/project/pcost.py

Après avoir exécuté la commande, vous devriez voir des informations détaillées sur chaque achat d'actions, suivies du coût total du portefeuille. Cette sortie vous aidera à vérifier que la fonction fonctionne correctement et que vous avez calculé le coût total avec précision.

Finalisation du programme

Maintenant, nous allons nettoyer notre code et créer la version finale du programme pcost.py. Nettoyer le code signifie supprimer toutes les parties inutiles et s'assurer que la sortie est bien formatée. C'est une étape importante en programmation car elle rend notre code plus professionnel et plus facile à comprendre.

Nous commencerons par supprimer les instructions d'impression de débogage. Ces instructions sont utilisées pendant le développement pour vérifier les valeurs des variables et le flux du programme, mais elles ne sont pas nécessaires dans la version finale. Ensuite, nous nous assurerons que la sortie finale est bien formatée.

Voici la version finale du code de pcost.py :

## pcost.py
## Calculate the total cost of a portfolio of stocks

def portfolio_cost(filename):
    """
    Computes the total cost (shares*price) of a portfolio file
    """
    total_cost = 0.0

    try:
        ## Open the file
        with open(filename, 'r') as file:
            ## Read all lines in the file
            for line in file:
                ## Strip any leading/trailing whitespace
                line = line.strip()

                ## Skip empty lines
                if not line:
                    continue

                ## Split the line into fields
                fields = line.split()

                ## Extract the relevant data
                ## fields[0] is the stock symbol (which we don't need for the calculation)
                shares = int(fields[1])  ## Number of shares (second field)
                price = float(fields[2])  ## Price per share (third field)

                ## Calculate the cost of this stock purchase and add to the total
                total_cost += shares * price

    except FileNotFoundError:
        print(f"Error: Could not find file '{filename}'")
        return 0.0
    except Exception as e:
        print(f"Error processing file: {e}")
        return 0.0

    ## Return the total cost
    return total_cost

## Main block to run when the script is executed directly
if __name__ == '__main__':
    ## Call the function with the portfolio file
    total_cost = portfolio_cost('portfolio.dat')
    print(f'Total cost: ${total_cost:.2f}')

Cette version finale du code présente plusieurs améliorations :

Gestion des erreurs : Nous avons ajouté du code pour capturer deux types d'erreurs. L'erreur FileNotFoundError est levée lorsque le fichier spécifié n'existe pas. Si cela se produit, le programme affichera un message d'erreur et retournera 0,0. Le bloc Exception capture toutes les autres erreurs qui pourraient survenir lors du traitement du fichier. Cela rend notre programme plus robuste et moins susceptible de planter de manière inattendue.
Formatage approprié : Le coût total est formaté avec deux décimales à l'aide du spécificateur de format :.2f dans la chaîne formatée (f-string). Cela rend la sortie plus professionnelle et plus facile à lire.
Vérification __name__ == '__main__' : C'est un idiome Python courant. Il garantit que le code à l'intérieur du bloc if ne s'exécute que lorsque le script est exécuté directement. Si le script est importé comme un module dans un autre script, ce code ne s'exécutera pas. Cela nous donne plus de contrôle sur le comportement de notre script.

Maintenant, exécutons le code final. Ouvrez votre terminal et entrez la commande suivante :

python3 ~/project/pcost.py

Lorsque vous exécutez cette commande, le programme lira le fichier portfolio.dat, calculera le coût total du portefeuille et affichera le résultat. Vous devriez voir le coût total du portefeuille, qui devrait être de 44671,15 $.

Félicitations ! Vous avez créé avec succès un programme Python qui lit des données à partir d'un fichier, les traite et calcule un résultat. C'est une grande réussite, et cela montre que vous êtes sur la bonne voie pour devenir un programmeur Python compétent.

Résumé

Dans ce laboratoire, vous avez appris à effectuer des opérations d'entrée/sortie de base sur les fichiers en Python. Vous pouvez ouvrir et lire des fichiers à l'aide de la fonction open() et d'un gestionnaire de contexte, traiter les données ligne par ligne, analyser des données textuelles, effectuer des calculs, gérer les erreurs et structurer un programme Python complet avec des fonctions et un bloc principal.

Ces compétences sont fondamentales pour de nombreux programmes Python et sont utiles dans diverses applications, telles que l'analyse de données et la gestion de configuration. Vous pouvez améliorer encore le programme en ajoutant des arguments en ligne de commande, en gérant différents formats de fichiers, en améliorant la vérification des erreurs et en créant des rapports plus détaillés.