MENU
  1. Início
  2. Python
  3. Como Iterar Cada Linha de um Arquivo CSV Usando o Laço for em Python

Como Iterar Cada Linha de um Arquivo CSV Usando o Laço for em Python

Python

Aprender como lidar eficientemente com arquivos CSV em Python é importante para várias finalidades, como análise de dados e geração de relatórios. Em especial, ao usar um laço for para iterar sobre cada linha, você pode manipular os dados CSV de maneira intuitiva. Neste artigo, vamos explorar como usar a biblioteca padrão csv do Python, cobrindo desde os conceitos básicos até técnicas mais eficientes de processamento. Isso ajudará você a entender abordagens adequadas ao trabalhar com grandes volumes de dados.

Índice

Como Abrir um Arquivo CSV em Python


O passo básico para lidar com um arquivo CSV é abri-lo e carregar os dados corretamente. Em Python, você pode abrir um arquivo CSV utilizando a função open da biblioteca padrão.

Método Básico de Abertura de Arquivo


Usando a função open do Python, você pode abrir um arquivo CSV apenas para leitura. O exemplo abaixo mostra como abrir o arquivo chamado example.csv:

with open('example.csv', mode='r', encoding='utf-8') as file:
    print(file.read())

Por Que Usar a Declaração with


Usando a declaração with, você pode abrir e fechar o arquivo de maneira segura, sem precisar chamar explicitamente file.close(). Isso garante que, mesmo que um erro ocorra, o arquivo será fechado corretamente, prevenindo vazamentos de recursos.

Preparação para Usar o Módulo CSV


Após abrir o arquivo, você pode utilizar o módulo csv para processar o conteúdo. Este módulo fornece funcionalidades que facilitam a leitura de dados separados por vírgula. A seguir, veremos exemplos mais detalhados.

Iteração Básica Usando csv.reader


Utilizando o objeto reader do módulo csv, você pode iterar sobre cada linha de um arquivo CSV. Este método é simples e permite obter cada linha em formato de lista, facilitando o início do processamento de dados.

Uso Básico do csv.reader


O código abaixo mostra um exemplo básico de como ler um arquivo CSV utilizando o csv.reader:

import csv

# Abrir o arquivo CSV
with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)  # Criar o leitor CSV
    for row in reader:  # Iterar sobre cada linha
        print(row)  # Exibir a lista de cada linha

Formato dos Dados Retornados


O row retornado pelo csv.reader é uma lista contendo os dados de cada célula como strings. Por exemplo, ao processar o seguinte arquivo CSV:

Name,Age,City
Alice,30,New York
Bob,25,Los Angeles

A saída será a seguinte:

['Name', 'Age', 'City']
['Alice', '30', 'New York']
['Bob', '25', 'Los Angeles']

Como Pular a Primeira Linha (Cabeçalho)


Para pular a linha de cabeçalho, você pode usar a função next():

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Pular a linha de cabeçalho
    for row in reader:
        print(row)

Pontos a Observar

  • Por padrão, o csv.reader reconhece a vírgula (,) como delimitador. Caso você utilize outro delimitador, é necessário especificar o argumento delimiter.
  • Se os dados forem grandes, é importante monitorar o uso de memória durante o processamento.

No próximo tópico, vamos abordar como extrair e processar valores específicos de cada coluna.

Como Extrair e Processar Valores de Colunas


Com o csv.reader, é possível extrair facilmente valores de colunas específicas ao acessar os índices das listas retornadas. Ao usar essa técnica, você pode se concentrar nos dados necessários e processá-los de forma mais eficiente.

Exemplo Básico de Extração de Coluna Específica


O código abaixo demonstra como extrair valores de uma coluna específica (por exemplo, a segunda coluna) e processá-los:

import csv

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Pular o cabeçalho
    for row in reader:
        # Extrair o valor da segunda coluna (índice 1)
        age = row[1]
        print(f"Age: {age}")

Por exemplo, para o seguinte arquivo CSV:

Name,Age,City
Alice,30,New York
Bob,25,Los Angeles

Este código produzirá a seguinte saída:

Age: 30  
Age: 25

Processando Múltiplas Colunas Juntas


Se você precisar usar várias colunas ao mesmo tempo, pode especificar as colunas necessárias pelos índices das listas.

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Pular o cabeçalho
    for row in reader:
        name = row[0]  # Primeira coluna
        city = row[2]  # Terceira coluna
        print(f"{name} lives in {city}.")

Exemplo de saída após a execução:

Alice lives in New York.  
Bob lives in Los Angeles.

Adicionar Tratamento de Erros


Para tornar o código mais robusto, adicione tratamento de erros para lidar com falhas como células vazias ou dados incorretos.

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    next(reader)  # Pular o cabeçalho
    for row in reader:
        try:
            name = row[0]
            age = int(row[1])  # Converter a idade para número
            print(f"{name} is {age} years old.")
        except (IndexError, ValueError) as e:
            print(f"Error processing row: {row}, Error: {e}")

Exemplos Práticos


Este método é útil para diversas aplicações práticas, como:

  • Extrair dados que atendem a condições específicas (exemplo: idade maior que 30 anos).
  • Calcular valores de colunas para gerar novas informações.
  • Gerar estatísticas por coluna (soma, média, etc.).

No próximo tópico, vamos explicar como trabalhar com dados de colunas de maneira mais intuitiva usando o csv.DictReader.

Processando Dados de Linhas no Formato de Dicionário com csv.DictReader


Com o csv.DictReader, você pode tratar cada linha de um arquivo CSV como um dicionário. Isso elimina a necessidade de lembrar os índices das colunas, tornando o código mais legível ao referenciar os dados pelas chaves de coluna.

Uso Básico do csv.DictReader


Abaixo está um exemplo de como processar dados CSV usando o csv.DictReader:

import csv

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.DictReader(file)
    for row in reader:
        # Acessando os dados pela chave de coluna
        name = row['Name']
        age = row['Age']
        city = row['City']
        print(f"{name} is {age} years old and lives in {city}.")

Por exemplo, para o seguinte arquivo CSV:

Name,Age,City
Alice,30,New York
Bob,25,Los Angeles

A saída do código será:

Alice is 30 years old and lives in New York.  
Bob is 25 years old and lives in Los Angeles.

Vantagens de Usar Nomes de Colunas

  1. Melhoria na legibilidade do código: Você não precisa mais se lembrar dos índices das colunas e pode usar diretamente os nomes das colunas, tornando o código mais intuitivo.
  2. Flexibilidade: Mesmo que a ordem das colunas mude, o código não precisará ser alterado, desde que os nomes das colunas coincidam.

Detecção Automática dos Nomes das Colunas


O csv.DictReader usa automaticamente a primeira linha do arquivo como cabeçalho. Além disso, é possível personalizar os nomes das colunas:

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.DictReader(file, fieldnames=['Name', 'Age', 'City'])  # Especificando nomes de colunas personalizados
    next(reader)  # Pular a primeira linha se necessário
    for row in reader:
        print(row)

Tratamento de Dados Faltantes


Se houver dados ausentes no arquivo CSV, o valor correspondente à chave será None. Realize verificações adequadas para evitar erros.

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.DictReader(file)
    for row in reader:
        name = row.get('Name', 'Unknown')  # Definir valor padrão
        age = row.get('Age', 'N/A')
        print(f"Name: {name}, Age: {age}")

Exemplos Práticos

  • Filtragem de Dados: Selecionar linhas que atendem a determinadas condições.
  • Conversão para JSON: Converter os dados no formato de dicionário diretamente para JSON.
  • Processamento Estatístico: Realizar operações de agregação com base no nome das colunas.

Na próxima seção, abordaremos questões relacionadas à codificação dos arquivos CSV.

Cuidados com a Codificação de Arquivos CSV


Quando estiver processando arquivos CSV em Python, a codificação é um aspecto muito importante. Se a codificação não for especificada corretamente, os dados podem se corromper ou a leitura do arquivo pode falhar. Nesta seção, vamos explicar os conceitos básicos de codificação e como lidar com problemas comuns.

Formatos de Codificação Comumente Usados


Abaixo estão alguns dos formatos de codificação comuns usados em arquivos CSV:

  • UTF-8: Usado globalmente e compatível com múltiplos idiomas. É a codificação padrão em Python.
  • Shift_JIS: Comumente usado no Japão, mas pode causar problemas com caracteres especiais.
  • ISO-8859-1: Usado para idiomas da Europa Ocidental.

Como Especificar a Codificação


Ao usar a função open em Python, você pode especificar a codificação com o argumento encoding.

with open('example.csv', mode='r', encoding='utf-8') as file:
    print(file.read())

Se o arquivo estiver codificado com Shift_JIS, você pode especificar assim:

with open('example.csv', mode='r', encoding='shift_jis') as file:
    print(file.read())

Tratamento de Erros de Codificação


Se ocorrerem erros devido a uma codificação inválida, você pode usar as opções para ignorar ou substituir os caracteres problemáticos.

Usando o Argumento `errors` para Ignorar ou Substituir


O argumento errors permite controlar o comportamento em caso de erros de codificação.

with open('example.csv', mode='r', encoding='utf-8', errors='ignore') as file:
    print(file.read())  # Ignorar erros

with open('example.csv', mode='r', encoding='utf-8', errors='replace') as file:
    print(file.read())  # Substituir caracteres inválidos

Detectando a Codificação Automaticamente


Se a codificação do arquivo for desconhecida, você pode utilizar bibliotecas como chardet ou charset-normalizer para detectá-la automaticamente.

import chardet

# Detectar codificação
with open('example.csv', mode='rb') as file:
    result = chardet.detect(file.read())
    print(result['encoding'])

Dicas para Operações com Codificação

  1. Verificação antecipada: Verifique a codificação do arquivo CSV e especifique o formato correto.
  2. Padronização: Sempre que possível, utilize a codificação UTF-8.
  3. Tratamento de erros: Use o argumento errors ou bibliotecas para lidar com erros inesperados.

No próximo tópico, veremos como tratar grandes arquivos CSV de forma eficiente.

Como Tratar Grandes Arquivos CSV de Forma Eficiente


Quando você lida com arquivos CSV muito grandes, é importante usar técnicas eficientes para evitar problemas como falta de memória ou aumento no tempo de processamento. Python oferece várias técnicas para lidar com arquivos CSV de grande escala.

Leitura Linha por Linha para Economizar Memória


Usando o csv.reader ou csv.DictReader, você pode ler um arquivo CSV linha por linha, evitando carregar o arquivo inteiro na memória, o que reduz o consumo de memória.

import csv

with open('large_file.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    for row in reader:
        # Processar cada linha
        print(row)

Esse método funciona para arquivos de qualquer tamanho, processando uma linha de cada vez.

Usando Processamento em Lotes


Dividir grandes arquivos CSV em lotes e processá-los de cada vez é uma maneira eficiente de aumentar a performance. Aqui está um exemplo usando itertools.islice:

import csv
from itertools import islice

with open('large_file.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    while True:
        batch = list(islice(reader, 100))  # Ler 100 linhas por vez
        if not batch:
            break
        # Processar o lote
        for row in batch:
            print(row)

Usando Pandas para Processamento em Lotes


A biblioteca pandas do Python é excelente para processar grandes conjuntos de dados. Você pode usar o argumento chunk_size para processar os dados em partes.

import pandas as pd

for chunk in pd.read_csv('large_file.csv', chunksize=1000, encoding='utf-8'):
    # Processar cada pedaço
    print(chunk)

Este método é útil para analisar grandes volumes de dados de forma eficiente, dividindo-os em partes menores.

Usando Processamento Paralelo


Dividir os arquivos em partes e processá-los em paralelo pode melhorar a velocidade do processamento. Aqui está um exemplo usando o módulo multiprocessing:

import csv
from multiprocessing import Pool

def process_chunk(chunk):
    for row in chunk:
        print(row)

def split_file(filename, chunk_size=1000):
    with open(filename, mode='r', encoding='utf-8') as file:
        reader = csv.reader(file)
        batch = []
        for i, row in enumerate(reader):
            batch.append(row)
            if (i + 1) % chunk_size == 0:
                yield batch
                batch = []
        if batch:
            yield batch

if __name__ == "__main__":
    filename = 'large_file.csv'
    with Pool(4) as pool:  # Processamento paralelo com 4 processos
        pool.map(process_chunk, split_file(filename))

Escolha de Formatos de Dados Eficientes


Embora o CSV seja um formato simples e útil, se os dados forem muito grandes, você pode considerar usar outros formatos como Parquet ou Feather, que oferecem melhor desempenho em termos de velocidade de leitura e taxa de compressão.

Exemplo Prático: Filtrando e Salvando Dados


Este exemplo mostra como filtrar dados com base em uma condição específica e salvar em um novo arquivo, economizando memória:

import csv

with open('large_file.csv', mode='r', encoding='utf-8') as infile, \
     open('filtered_file.csv', mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        if int(row[1]) > 50:  # Condição: valor da segunda coluna maior que 50
            writer.writerow(row)

Na próxima seção, vamos abordar como usar a declaração with para operações seguras de arquivos.

Operações Seguras de Arquivos com a Declaração with


Ao manipular arquivos em Python, usar a declaração with permite abrir e fechar arquivos de maneira segura, facilitando o gerenciamento de recursos. Em particular, ao processar arquivos CSV, a declaração with garante que o arquivo seja fechado corretamente, mesmo se ocorrerem erros.

Exemplo Básico de Uso do with


A seguir, mostramos um exemplo básico de como ler um arquivo CSV usando a declaração with:

import csv

with open('example.csv', mode='r', encoding='utf-8') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

Neste código, assim que o bloco with for finalizado, o objeto file será automaticamente fechado. Não há necessidade de chamar explicitamente o método close(), o que simplifica o código.

Exemplo de Uso ao Gravar em Arquivos


Você também pode usar a declaração with ao escrever dados em um arquivo CSV de forma segura:

import csv

data = [
    ['Name', 'Age', 'City'],
    ['Alice', '30', 'New York'],
    ['Bob', '25', 'Los Angeles']
]

with open('output.csv', mode='w', encoding='utf-8', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(data)

Vantagens de Usar o with

  1. Gestão Simplificada de Recursos
    Com a declaração with, arquivos são fechados automaticamente, mesmo que erros ocorram durante o processamento.
  2. Melhoria na Legibilidade
    Não há necessidade de escrever manualmente o código para fechar o arquivo, tornando o código mais conciso e claro.
  3. Prevenção de Erros
    Com a declaração with, você evita falhas ao esquecer de fechar arquivos, o que poderia levar ao aumento do uso de memória e vazamentos de recursos.

Manipulação Simultânea de Vários Arquivos


Usando a declaração with, é possível manipular vários arquivos de forma segura e simultânea:

import csv

with open('input.csv', mode='r', encoding='utf-8') as infile, \
     open('output.csv', mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        writer.writerow(row)

Riscos ao Não Usar o with


Abaixo está um exemplo de como seria ao não usar a declaração with ao manipular arquivos:

file = open('example.csv', mode='r', encoding='utf-8')
reader = csv.reader(file)
for row in reader:
    print(row)
file.close()

Nesse caso, se você esquecer de chamar file.close() ou se ocorrer um erro, o arquivo não será fechado, o que pode levar a vazamentos de recursos, especialmente em servidores ou grandes aplicativos.

Exemplo Prático: Filtrando Dados e Salvando


A seguir, temos um exemplo de como usar a declaração with para filtrar dados de um arquivo CSV e salvá-los em um novo arquivo:

import csv

with open('input.csv', mode='r', encoding='utf-8') as infile, \
     open('filtered_output.csv', mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        if row[1] == '30':  # Condição: valor na segunda coluna igual a '30'
            writer.writerow(row)

Na próxima seção, veremos como extrair colunas específicas de um arquivo CSV e salvá-las em um novo arquivo.

Exemplo Prático: Extraindo Colunas Específicas de um Arquivo CSV


Extrair colunas específicas de um arquivo CSV e salvá-las em um novo arquivo é uma tarefa comum. Usando o módulo csv do Python, isso pode ser feito de forma simples e eficiente. Vamos agora explorar como fazer isso na prática.

Exemplo Básico de Extração de Coluna


O código abaixo mostra como extrair colunas específicas (por exemplo, nome e idade) de um arquivo CSV e salvá-las em um novo arquivo:

import csv

# Caminho dos arquivos de entrada e saída
input_file = 'input.csv'
output_file = 'output.csv'

with open(input_file, mode='r', encoding='utf-8') as infile, \
     open(output_file, mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)

    # Processamento do cabeçalho (extração de colunas específicas)
    header = next(reader)
    selected_columns = [0, 1]  # Colunas a serem extraídas (exemplo: 1ª e 2ª colunas)
    writer.writerow([header[i] for i in selected_columns])

    # Extração e escrita de colunas específicas
    for row in reader:
        writer.writerow([row[i] for i in selected_columns])

Exemplo: Conteúdo do Arquivo de Entrada


Conteúdo do arquivo input.csv:

Name,Age,City,Country
Alice,30,New York,USA
Bob,25,Los Angeles,USA
Charlie,35,London,UK

Quando o código acima for executado, o arquivo de saída output.csv terá o seguinte conteúdo:

Name,Age
Alice,30
Bob,25
Charlie,35

Extração Dinâmica de Colunas


Uma maneira conveniente de extrair colunas dinamicamente é usar os nomes das colunas. Isso garante que você sempre extraia as colunas corretas, mesmo que a ordem das colunas no arquivo mude.

with open(input_file, mode='r', encoding='utf-8') as infile, \
     open(output_file, mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.DictReader(infile)
    writer = csv.writer(outfile)

    # Colunas a serem extraídas
    columns_to_extract = ['Name', 'City']
    writer.writerow(columns_to_extract)

    # Extração das colunas selecionadas
    for row in reader:
        writer.writerow([row[col] for col in columns_to_extract])

Extração Condicional de Colunas


Você também pode filtrar os dados, extraindo apenas as linhas que atendem a uma condição específica:

with open(input_file, mode='r', encoding='utf-8') as infile, \
     open(output_file, mode='w', encoding='utf-8', newline='') as outfile:
    reader = csv.DictReader(infile)
    writer = csv.DictWriter(outfile, fieldnames=['Name', 'City'])
    writer.writeheader()

    for row in reader:
        if int(row['Age']) > 30:  # Filtrar linhas com idade maior que 30
            writer.writerow({'Name': row['Name'], 'City': row['City']})

O conteúdo do arquivo de saída será:

Name,City
Charlie,London

Exemplos Práticos

  • Análise de Dados: Extrair dados específicos para preparar para agregações e análises.
  • Conversão de Dados: Extrair os dados necessários e convertê-los para outro formato.
  • Relatórios Eficientes: Criar relatórios simples extraindo dados essenciais de grandes conjuntos de dados.

Na próxima seção, vamos recapitular os conceitos abordados ao longo deste artigo.

Resumo


Neste artigo, exploramos como processar arquivos CSV de maneira eficiente usando Python. Começamos com a iteração básica de linhas usando csv.reader, passamos para o processamento de dados em formato de dicionário com csv.DictReader, e vimos como extrair e processar colunas específicas. Também discutimos como lidar com grandes arquivos CSV de maneira eficiente e como realizar operações seguras com arquivos usando a declaração with.

Com esses conhecimentos, você pode realizar tarefas de análise de dados e ETL (Extração, Transformação e Carregamento) de maneira mais eficiente e segura. Aproveite a flexibilidade do Python para processar dados CSV com facilidade.

Python
Análise de dados Arquivos CSV Biblioteca Padrão codificação Extração de Dados Formato de dicionário Grandes Dados manipulação de arquivos manipulação de dados Módulo csv Otimização de Memória Processamento Eficiente Python
Índice