Revisão de I/O de Arquivos em Python: Aprenda a Ler e Processar Dados

Introdução

Neste laboratório, você aprenderá a revisar as operações básicas de entrada e saída de arquivos em Python. Você criará um programa Python para ler dados de um arquivo com informações de um portfólio de ações e calcular o custo total do portfólio.

Os objetivos deste laboratório incluem aprender como abrir e ler arquivos em Python, processar dados de arquivos linha por linha, realizar cálculos sobre os dados e gerar os resultados. O arquivo que você criará é pcost.py.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 89%. Recebeu uma taxa de avaliações positivas de 98% dos estudantes.

Compreendendo o Problema

Nesta etapa, primeiro entenderemos qual é o problema que precisamos resolver e, em seguida, daremos uma olhada nos dados com os quais trabalharemos. Esta é uma primeira etapa importante em qualquer tarefa de programação, pois nos ajuda a saber exatamente o que estamos almejando e quais recursos temos à nossa disposição.

No seu diretório do projeto, há um arquivo chamado portfolio.dat. Este arquivo armazena informações sobre um portfólio de ações. Um portfólio é como uma coleção de diferentes ações que um investidor possui. Cada linha neste arquivo representa uma única compra de ação. O formato de cada linha é o seguinte:

[Símbolo da Ação] [Número de Ações] [Preço por Ação]

O símbolo da ação é um código curto que representa a ação de uma empresa específica. O número de ações nos diz quantas unidades daquela ação foram compradas, e o preço por ação é o custo de uma unidade daquela ação.

Vamos dar uma olhada em um exemplo. Considere a primeira linha do arquivo:

AA 100 32.20

Esta linha indica que 100 ações da ação com o símbolo "AA" foram compradas. Cada ação custou $32.20.

Se você quiser ver o que está dentro do arquivo portfolio.dat, você pode executar o seguinte comando no terminal. O comando cat é uma ferramenta útil no terminal que permite visualizar o conteúdo de um arquivo.

cat ~/project/portfolio.dat

Agora, sua tarefa é criar um programa Python chamado pcost.py. Este programa executará três tarefas principais:

Primeiro, ele precisa abrir e ler o arquivo portfolio.dat. Abrir um arquivo em Python permite que nosso programa acesse os dados armazenados nele.
Em seguida, ele precisa calcular o custo total de todas as compras de ações no portfólio. Para fazer isso, para cada linha no arquivo, precisamos multiplicar o número de ações pelo preço por ação. Depois de obter esses valores para cada linha, somamos todos eles. Isso nos dá o valor total de dinheiro gasto em todas as ações do portfólio.
Finalmente, o programa deve gerar o custo total. Desta forma, podemos ver o resultado de nossos cálculos.

Vamos começar criando o arquivo pcost.py. Você pode usar o editor para abrir e editar este arquivo. Ele já foi criado para você durante a etapa de configuração. Este arquivo será o local onde você escreverá o código Python para resolver o problema que acabamos de discutir.

Abrindo e Lendo o Arquivo

Nesta etapa, vamos aprender como abrir e ler um arquivo em Python. A entrada/saída de arquivos (I/O) é um conceito fundamental em programação. Ele permite que seu programa interaja com arquivos externos, como arquivos de texto, arquivos CSV e muito mais. Em Python, uma das maneiras mais comuns de trabalhar com arquivos é usando a função open().

A função open() é usada para abrir um arquivo em Python. Ela recebe dois argumentos importantes. O primeiro argumento é o nome do arquivo que você deseja abrir. O segundo argumento é o modo no qual você deseja abrir o arquivo. Quando você deseja ler um arquivo, você usa o modo 'r'. Isso informa ao Python que você só deseja ler o conteúdo do arquivo e não fazer nenhuma alteração nele.

Agora, vamos adicionar algum código ao arquivo pcost.py para abrir e ler o arquivo portfolio.dat. Abra o arquivo pcost.py no seu editor de código e adicione o seguinte código:

## pcost.py
## Calcular o custo total de um portfólio de ações

def portfolio_cost(filename):
    """
    Calcula o custo total (ações*preço) de um arquivo de portfólio
    """
    total_cost = 0.0

    ## Abrir o arquivo
    with open(filename, 'r') as file:
        ## Ler todas as linhas do arquivo
        for line in file:
            print(line)  ## Apenas para depuração, para ver o que estamos lendo

    ## Retornar o custo total
    return total_cost

## Chamar a função com o arquivo do portfólio
total_cost = portfolio_cost('portfolio.dat')
print(f'Total cost: ${total_cost}')

Vamos detalhar o que este código faz:

Primeiro, definimos uma função chamada portfolio_cost(). Esta função recebe um nome de arquivo como um parâmetro de entrada. O objetivo desta função é calcular o custo total de um portfólio de ações com base nos dados do arquivo.
Dentro da função, usamos a função open() para abrir o arquivo especificado no modo de leitura. A instrução with é usada aqui para garantir que o arquivo seja fechado corretamente depois de terminarmos de lê-lo. Esta é uma boa prática para evitar vazamentos de recursos.
Em seguida, usamos um loop for para ler o arquivo linha por linha. Para cada linha no arquivo, imprimimos. Isso é apenas para fins de depuração, para que possamos ver quais dados estamos lendo do arquivo.
Depois de ler o arquivo, a função retorna o custo total. Atualmente, o custo total é definido como 0.0 porque ainda não implementamos o cálculo real.
Fora da função, chamamos a função portfolio_cost() com o nome do arquivo 'portfolio.dat'. Isso significa que estamos pedindo à função para calcular o custo total com base nos dados do arquivo portfolio.dat.
Finalmente, imprimimos o custo total usando uma f-string.

Agora, vamos executar este código para ver o que ele faz. Você pode executar o arquivo Python do terminal usando o seguinte comando:

python3 ~/project/pcost.py

Quando você executa este comando, você deve ver cada linha do arquivo portfolio.dat impressa no terminal, seguida pelo custo total, que atualmente está definido como 0.0. Esta saída ajuda você a verificar se o arquivo está sendo lido corretamente.

Processando os Dados

Agora que aprendemos como ler um arquivo, a próxima etapa é processar cada linha do arquivo para calcular o custo de cada compra de ação. Esta é uma parte importante de trabalhar com dados em Python, pois nos permite extrair informações significativas do arquivo.

Cada linha no arquivo segue um formato específico: [Símbolo da Ação] [Número de Ações] [Preço por Ação]. Para calcular o custo de cada compra de ação, precisamos extrair o número de ações e o preço por ação de cada linha. Em seguida, multiplicamos esses dois valores para obter o custo daquela compra de ação específica. Finalmente, adicionamos esse custo ao nosso total acumulado para encontrar o custo geral do portfólio.

Vamos modificar a função portfolio_cost() no arquivo pcost.py para conseguir isso. Aqui está o código modificado:

def portfolio_cost(filename):
    """
    Calcula o custo total (ações*preço) de um arquivo de portfólio
    """
    total_cost = 0.0

    ## Abrir o arquivo
    with open(filename, 'r') as file:
        ## Ler todas as linhas do arquivo
        for line in file:
            ## Remover qualquer espaço em branco no início/fim
            line = line.strip()

            ## Ignorar linhas vazias
            if not line:
                continue

            ## Dividir a linha em campos
            fields = line.split()

            ## Extrair os dados relevantes
            ## fields[0] é o símbolo da ação (que não precisamos para o cálculo)
            shares = int(fields[1])  ## Número de ações (segundo campo)
            price = float(fields[2])  ## Preço por ação (terceiro campo)

            ## Calcular o custo desta compra de ação
            cost = shares * price

            ## Adicionar ao custo total
            total_cost += cost

            ## Imprimir algumas informações de depuração
            print(f'{fields[0]}: {shares} ações a ${price:.2f} = ${cost:.2f}')

    ## Retornar o custo total
    return total_cost

Vamos detalhar o que esta função modificada faz passo a passo:

Remove espaços em branco: Usamos o método strip() para remover qualquer espaço em branco no início ou no final de cada linha. Isso garante que não incluamos acidentalmente espaços extras ao dividir a linha em campos.
Ignora linhas vazias: Se uma linha estiver vazia (ou seja, contiver apenas espaços em branco), usamos a instrução continue para ignorá-la. Isso nos ajuda a evitar erros ao tentar dividir uma linha vazia.
Divide a linha em campos: Usamos o método split() para dividir cada linha em uma lista de campos com base em espaços em branco. Isso nos permite acessar cada parte da linha separadamente.
Extrai dados relevantes: Extraímos o número de ações e o preço por ação da lista de campos. O número de ações é o segundo campo, e o preço por ação é o terceiro campo. Convertemos esses valores para os tipos de dados apropriados (int para ações e float para preço) para que possamos realizar operações aritméticas neles.
Calcula o custo: Multiplicamos o número de ações pelo preço por ação para calcular o custo desta compra de ação.
Adiciona ao total: Adicionamos o custo desta compra de ação ao custo total acumulado.
Imprime informações de depuração: Imprimimos algumas informações sobre cada compra de ação para nos ajudar a ver o que está acontecendo. Isso inclui o símbolo da ação, o número de ações, o preço por ação e o custo total da compra.

Agora, vamos executar o código para ver se ele funciona. Abra seu terminal e execute o seguinte comando:

python3 ~/project/pcost.py

Após executar o comando, você deve ver informações detalhadas sobre cada compra de ação, seguido pelo custo total do portfólio. Esta saída ajudará você a verificar se a função está funcionando corretamente e se você calculou o custo total com precisão.

Finalizando o Programa

Agora, vamos limpar nosso código e criar a versão final do programa pcost.py. Limpar o código significa remover quaisquer partes desnecessárias e garantir que a saída tenha uma boa aparência. Esta é uma etapa importante na programação porque torna nosso código mais profissional e mais fácil de entender.

Começaremos removendo as instruções de impressão de depuração. Essas instruções são usadas durante o desenvolvimento para verificar os valores das variáveis e o fluxo do programa, mas não são necessárias na versão final. Em seguida, garantiremos que a saída final seja formatada de forma agradável.

Aqui está a versão final do código pcost.py:

## pcost.py
## Calcular o custo total de um portfólio de ações

def portfolio_cost(filename):
    """
    Calcula o custo total (ações*preço) de um arquivo de portfólio
    """
    total_cost = 0.0

    try:
        ## Abrir o arquivo
        with open(filename, 'r') as file:
            ## Ler todas as linhas do arquivo
            for line in file:
                ## Remover qualquer espaço em branco no início/fim
                line = line.strip()

                ## Ignorar linhas vazias
                if not line:
                    continue

                ## Dividir a linha em campos
                fields = line.split()

                ## Extrair os dados relevantes
                ## fields[0] é o símbolo da ação (que não precisamos para o cálculo)
                shares = int(fields[1])  ## Número de ações (segundo campo)
                price = float(fields[2])  ## Preço por ação (terceiro campo)

                ## Calcular o custo desta compra de ação e adicionar ao 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

    ## Retornar o custo total
    return total_cost

## Bloco principal para executar quando o script é executado diretamente
if __name__ == '__main__':
    ## Chamar a função com o arquivo do portfólio
    total_cost = portfolio_cost('portfolio.dat')
    print(f'Total cost: ${total_cost:.2f}')

Esta versão final do código tem várias melhorias:

Tratamento de erros: Adicionamos código para capturar dois tipos de erros. O FileNotFoundError é gerado quando o arquivo especificado não existe. Se isso acontecer, o programa imprimirá uma mensagem de erro e retornará 0.0. O bloco Exception captura quaisquer outros erros que possam ocorrer durante o processamento do arquivo. Isso torna nosso programa mais robusto e menos propenso a travar inesperadamente.
Formatação adequada: O custo total é formatado para duas casas decimais usando o especificador de formato : .2f na f-string. Isso faz com que a saída pareça mais profissional e mais fácil de ler.
Verificação __name__ == '__main__': Este é um idioma Python comum. Ele garante que o código dentro do bloco if seja executado apenas quando o script for executado diretamente. Se o script for importado como um módulo em outro script, este código não será executado. Isso nos dá mais controle sobre como nosso script se comporta.

Agora, vamos executar o código final. Abra seu terminal e digite o seguinte comando:

python3 ~/project/pcost.py

Quando você executar este comando, o programa lerá o arquivo portfolio.dat, calculará o custo total do portfólio e imprimirá o resultado. Você deve ver o custo total do portfólio, que deve ser $44671.15.

Parabéns! Você criou com sucesso um programa Python que lê dados de um arquivo, os processa e calcula um resultado. Esta é uma grande conquista e mostra que você está a caminho de se tornar um programador Python proficiente.

Resumo

Neste laboratório, você aprendeu como realizar operações básicas de I/O de arquivos em Python. Você pode abrir e ler arquivos usando a função open() e um gerenciador de contexto, processar dados linha por linha, analisar dados de texto, realizar cálculos, lidar com erros e estruturar um programa Python completo com funções e um bloco principal.

Essas habilidades são fundamentais para muitos programas Python e são úteis em várias aplicações, como análise de dados e gerenciamento de configuração. Você pode aprimorar ainda mais o programa adicionando argumentos de linha de comando, lidando com diferentes formatos de arquivo, melhorando a verificação de erros e criando relatórios mais detalhados.

Revisão de I/O de Arquivos Básicos