Revisar la entrada/salida básica de archivos

Introducción

En este laboratorio, aprenderá a revisar las operaciones básicas de entrada y salida de archivos en Python. Creará un programa de Python para leer datos de un archivo con información de cartera de acciones y calcular el costo total de la cartera.

Los objetivos de este laboratorio incluyen aprender cómo abrir y leer archivos en Python, procesar los datos del archivo línea por línea, realizar cálculos con los datos y mostrar los resultados. El archivo que creará es pcost.py.

Skills Graph

Comprendiendo el problema

En este paso, primero entenderemos cuál es el problema que necesitamos resolver y luego echaremos un vistazo a los datos con los que trabajaremos. Este es un primer paso importante en cualquier tarea de programación, ya que nos ayuda a saber exactamente hacia dónde nos dirigimos y qué recursos tenemos a nuestra disposición.

En el directorio de tu proyecto, hay un archivo llamado portfolio.dat. Este archivo almacena información sobre una cartera de acciones. Una cartera es como una colección de diferentes acciones que un inversor posee. Cada línea de este archivo representa una compra individual de acciones. El formato de cada línea es el siguiente:

[Stock Symbol] [Number of Shares] [Price per Share]

El símbolo de la acción es un código corto que representa las acciones de una empresa en particular. El número de acciones nos dice cuántas unidades de esa acción se compraron, y el precio por acción es el costo de una unidad de esa acción.

Veamos un ejemplo. Consideremos la primera línea del archivo:

AA 100 32.20

Esta línea indica que se compraron 100 acciones de la acción con el símbolo "AA". Cada acción costó $32.20.

Si quieres ver lo que hay dentro del archivo portfolio.dat, puedes ejecutar el siguiente comando en la terminal. El comando cat es una herramienta útil en la terminal que te permite ver el contenido de un archivo.

cat ~/project/portfolio.dat

Ahora, tu tarea es crear un programa de Python llamado pcost.py. Este programa realizará tres tareas principales:

1. Primero, debe abrir y leer el archivo portfolio.dat. Abrir un archivo en Python permite que nuestro programa acceda a los datos almacenados dentro de él.
2. Luego, debe calcular el costo total de todas las compras de acciones en la cartera. Para hacer esto, para cada línea del archivo, necesitamos multiplicar el número de acciones por el precio por acción. Después de obtener estos valores para cada línea, los sumamos todos. Esto nos da la cantidad total de dinero gastado en todas las acciones de la cartera.
3. Finalmente, el programa debe mostrar el costo total. De esta manera, podemos ver el resultado de nuestros cálculos.

Comencemos creando el archivo pcost.py. Puedes usar el editor para abrir y editar este archivo. Ya se creó para ti durante el paso de configuración. Este archivo será el lugar donde escribirás el código de Python para resolver el problema que acabamos de discutir.

Abriendo y leyendo el archivo

En este paso, aprenderemos cómo abrir y leer un archivo en Python. La entrada/salida (I/O) de archivos es un concepto fundamental en la programación. Permite que tu programa interactúe con archivos externos, como archivos de texto, archivos CSV, etc. En Python, una de las formas más comunes de trabajar con archivos es utilizando la función open().

La función open() se utiliza para abrir un archivo en Python. Toma dos argumentos importantes. El primer argumento es el nombre del archivo que deseas abrir. El segundo argumento es el modo en el que deseas abrir el archivo. Cuando quieres leer un archivo, utilizas el modo 'r'. Esto le dice a Python que solo quieres leer el contenido del archivo y no hacer ningún cambio en él.

Ahora, agreguemos algo de código al archivo pcost.py para abrir y leer el archivo portfolio.dat. Abre el archivo pcost.py en tu editor de código y agrega el siguiente código:

## 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}')

Analicemos lo que hace este código:

1. Primero, definimos una función llamada portfolio_cost(). Esta función toma un nombre de archivo como parámetro de entrada. El propósito de esta función es calcular el costo total de una cartera de acciones basado en los datos del archivo.
2. Dentro de la función, utilizamos la función open() para abrir el archivo especificado en modo lectura. La declaración with se utiliza aquí para garantizar que el archivo se cierre correctamente después de terminar de leerlo. Esta es una buena práctica para evitar fugas de recursos.
3. Luego, utilizamos un bucle for para leer el archivo línea por línea. Para cada línea del archivo, la imprimimos. Esto es solo con fines de depuración, para que podamos ver qué datos estamos leyendo del archivo.
4. Después de leer el archivo, la función devuelve el costo total. Actualmente, el costo total se establece en 0.0 porque aún no hemos implementado el cálculo real.
5. Fuera de la función, llamamos a la función portfolio_cost() con el nombre de archivo 'portfolio.dat'. Esto significa que estamos pidiendo a la función que calcule el costo total basado en los datos del archivo portfolio.dat.
6. Finalmente, imprimimos el costo total utilizando una f-string.

Ahora, ejecutemos este código para ver qué hace. Puedes ejecutar el archivo de Python desde la terminal utilizando el siguiente comando:

python3 ~/project/pcost.py

Cuando ejecutes este comando, deberías ver cada línea del archivo portfolio.dat impresa en la terminal, seguida del costo total, que actualmente está establecido en 0.0. Esta salida te ayuda a verificar que el archivo se esté leyendo correctamente.

Procesando los datos

Ahora que hemos aprendido cómo leer un archivo, el siguiente paso es procesar cada línea del archivo para calcular el costo de cada compra de acciones. Esta es una parte importante de trabajar con datos en Python, ya que nos permite extraer información significativa del archivo.

Cada línea del archivo sigue un formato específico: [Stock Symbol] [Number of Shares] [Price per Share]. Para calcular el costo de cada compra de acciones, necesitamos extraer el número de acciones y el precio por acción de cada línea. Luego, multiplicamos estos dos valores juntos para obtener el costo de esa compra de acciones en particular. Finalmente, agregamos este costo a nuestro total acumulado para encontrar el costo total de la cartera.

Modifiquemos la función portfolio_cost() en el archivo pcost.py para lograr esto. Aquí está el código modificado:

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

Analicemos paso a paso lo que hace esta función modificada:

1. Elimina espacios en blanco: Utilizamos el método strip() para eliminar cualquier espacio en blanco inicial o final de cada línea. Esto asegura que no incluyamos accidentalmente espacios adicionales cuando dividimos la línea en campos.
2. Omite líneas vacías: Si una línea está vacía (es decir, contiene solo espacios en blanco), utilizamos la declaración continue para omitirla. Esto nos ayuda a evitar errores al intentar dividir una línea vacía.
3. Divide la línea en campos: Utilizamos el método split() para dividir cada línea en una lista de campos basada en espacios en blanco. Esto nos permite acceder a cada parte de la línea por separado.
4. Extrae los datos relevantes: Extraemos el número de acciones y el precio por acción de la lista de campos. El número de acciones es el segundo campo, y el precio por acción es el tercer campo. Convertimos estos valores a los tipos de datos adecuados (int para las acciones y float para el precio) para poder realizar operaciones aritméticas con ellos.
5. Calcula el costo: Multiplicamos el número de acciones por el precio por acción para calcular el costo de esta compra de acciones.
6. Agrega al total: Agregamos el costo de esta compra de acciones al total acumulado.
7. Imprime información de depuración: Imprimimos información sobre cada compra de acciones para ayudarnos a ver lo que está sucediendo. Esto incluye el símbolo de la acción, el número de acciones, el precio por acción y el costo total de la compra.

Ahora, ejecutemos el código para ver si funciona. Abre tu terminal y ejecuta el siguiente comando:

python3 ~/project/pcost.py

Después de ejecutar el comando, deberías ver información detallada sobre cada compra de acciones, seguida del costo total de la cartera. Esta salida te ayudará a verificar que la función está funcionando correctamente y que has calculado el costo total con precisión.

Finalizando el programa

Ahora, vamos a limpiar nuestro código y crear la versión final del programa pcost.py. Limpiar el código significa eliminar cualquier parte innecesaria y asegurarnos de que la salida se vea bien. Este es un paso importante en la programación porque hace que nuestro código sea más profesional y fácil de entender.

Comenzaremos eliminando las declaraciones de impresión de depuración. Estas declaraciones se utilizan durante el desarrollo para verificar los valores de las variables y el flujo del programa, pero no son necesarias en la versión final. Luego, nos aseguraremos de que la salida final esté bien formateada.

Aquí está la versión final del código 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}')

Esta versión final del código tiene varias mejoras:

1. Manejo de errores: Hemos agregado código para capturar dos tipos de errores. El FileNotFoundError se levanta cuando el archivo especificado no existe. Si esto sucede, el programa imprimirá un mensaje de error y devolverá 0.0. El bloque Exception captura cualquier otro error que pueda ocurrir mientras se procesa el archivo. Esto hace que nuestro programa sea más robusto y menos propenso a fallar inesperadamente.
2. Formato adecuado: El costo total se formatea con dos decimales utilizando el especificador de formato :.2f en la f-string. Esto hace que la salida se vea más profesional y sea más fácil de leer.
3. Verificación de __name__ == '__main__': Este es un término común en Python. Asegura que el código dentro del bloque if solo se ejecute cuando el script se ejecuta directamente. Si el script se importa como un módulo en otro script, este código no se ejecutará. Esto nos da más control sobre cómo se comporta nuestro script.

Ahora, ejecutemos el código final. Abre tu terminal y escribe el siguiente comando:

python3 ~/project/pcost.py

Cuando ejecutes este comando, el programa leerá el archivo portfolio.dat, calculará el costo total de la cartera y imprimirá el resultado. Deberías ver el costo total de la cartera, que debería ser $44671.15.

¡Felicidades! Has creado con éxito un programa en Python que lee datos de un archivo, los procesa y calcula un resultado. Este es un gran logro y muestra que estás en el camino de convertirse en un programador Python competente.

Resumen

En este laboratorio, has aprendido cómo realizar operaciones básicas de entrada/salida (I/O) de archivos en Python. Puedes abrir y leer archivos utilizando la función open() y un gestor de contexto, procesar datos línea por línea, analizar datos de texto, realizar cálculos, manejar errores y estructurar un programa Python completo con funciones y un bloque principal.

Estas habilidades son fundamentales para muchos programas de Python y son útiles en diversas aplicaciones, como el análisis de datos y la gestión de configuración. Puedes mejorar aún más el programa agregando argumentos de línea de comandos, manejando diferentes formatos de archivos, mejorando la comprobación de errores y creando informes más detallados.