Python para dados

Ler CSVs reais com a biblioteca padrão, limpar tipos e datas, rejeitar linhas inválidas com motivo, resumir por grupo e entender o que o pandas faz por baixo.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Ler um CSV com separador e decimal brasileiros usando csv.DictReader
  • Limpar e converter textos em números, datas e valores faltantes (None)
  • Validar linhas e produzir um relatório de rejeições com número da linha e motivo
  • Agregar dados com defaultdict e Counter e gravar a saída em CSV e JSON
  • Comparar o código em Python puro com o equivalente em pandas

Quase todo trabalho com dados começa com um arquivo que alguém exportou: a planilha de vendas da loja, o CSV do DATASUS, o JSON de uma API. Esses arquivos chegam com espaços sobrando, vírgula no lugar de ponto, datas em formatos diferentes e células vazias. Nesta aula você vai escrever, com Python puro, o programa que lê esse arquivo, separa o que presta do que não presta e entrega um resumo confiável. É o primeiro pipeline de verdade da sua carreira.

Arquivos reais: separador, decimal e codificação

Um CSV exportado de um sistema brasileiro. Explore as partes.

data;cidade;produto;valor
14/10/2026;Recife;Pão de queijo;12,50
  • Cabeçalho: Os nomes das colunas. O módulo csv usa essa linha para que cada linha vire um dicionário com essas chaves.
  • Data em formato brasileiro: Dia, mês e ano. Para o Python isso é só texto até você converter com datetime.
  • Separador: No Brasil, o Excel costuma usar ponto e vírgula, porque a vírgula já é usada nos decimais. Você precisa avisar isso ao ler o arquivo.
  • Decimal com vírgula: Para o Python, número decimal usa ponto. float('12,50') dá erro; é preciso trocar a vírgula antes.

Na aula de listas, dicionários e arquivos você já leu um CSV com csv.DictReader, que entrega cada linha como dicionário. Aquele arquivo era bem comportado. Agora você vai lidar com arquivos como eles chegam de verdade. Para isso, o navegador vai simular o arquivo com io.StringIO, que faz um texto se comportar como um arquivo aberto.

Seu primeiro leitor de CSV

Rode o código e veja o primeiro dicionário: as colunas não foram separadas. Corrija o leitor para usar o separador certo (delimiter=';') e imprima Total de linhas: 4.

import csv
import io

arquivo = io.StringIO("""data;cidade;produto;valor;pagamento
14/10/2026;Recife;Pão de queijo;12,50;pix
14/10/2026;Salvador;Café;6,00;dinheiro
15/10/2026;Recife;Bolo;25,90;cartao
15/10/2026;Belém;Café;6,00;pix
""")

leitor = csv.DictReader(arquivo)
linhas = list(leitor)
print(linhas[0])
  • Cada linha tem a chave cidade
  • A terceira venda é do produto Bolo
  • Imprimiu Total de linhas: 4

Tudo chega como texto: limpeza e tipos

Você já sabe que tudo que sai de um CSV é texto e que é preciso converter antes de calcular. O que muda com dados reais é que, antes de converter, quase sempre é preciso limpar: float('12,50') quebra por causa da vírgula, e uma cidade escrita ' Recife ' não é igual a 'Recife' na hora de agrupar.

A limpeza de um valor, passo a passo

bruto = '  12,50 '
limpo = bruto.strip()
com_ponto = limpo.replace(',', '.')
valor = float(com_ponto)
print(valor * 2)
  1. Linha 1: O valor chegou do arquivo com espaços antes e depois. Isso é comum em exportações feitas à mão.
  2. Linha 2: strip() remove espaços (e quebras de linha) das pontas. O texto do meio não muda.
  3. Linha 3: Troca a vírgula decimal brasileira pelo ponto que o Python entende. Ainda é texto.
  4. Linha 4: Agora sim, float() converte para número. Repare que não há mais aspas no valor.
  5. Linha 5: Com um número de verdade, a conta funciona. Saída: 25.0

Datas seguem a mesma ideia. O módulo datetime converte texto em data com datetime.strptime(texto, formato). No formato, %d é o dia, %m o mês e %Y o ano com quatro dígitos. Com uma data de verdade, você consegue pegar o mês, comparar e ordenar corretamente.

E as células vazias? Um valor faltante é diferente de zero: uma venda sem valor não é uma venda grátis. Em Python, o jeito comum de representar “não sei” é None.

No CSV de pacientes de uma UBS, a coluna peso está vazia em algumas linhas. Como o seu programa deve guardar esse valor?

  • Como None, e decidir depois se a linha é rejeitada ou fica fora da média
  • Como 0, para não dar erro na conta
  • Como o texto vazio '', do jeito que veio
  • Com a média dos outros pacientes, para completar a tabela

Funções de limpeza reutilizáveis

Complete para_numero (tira espaços, devolve None se ficar vazio, senão converte com vírgula trocada por ponto) e para_data (converte dd/mm/aaaa em data).

from datetime import datetime

def para_numero(texto):
    # 1. tire os espaços com strip()
    # 2. se sobrar texto vazio, devolva None
    # 3. troque a vírgula por ponto e converta com float()
    return texto

def para_data(texto):
    # use datetime.strptime(texto.strip(), '%d/%m/%Y').date()
    return texto

print(para_numero(' 12,50 '))
print(para_numero('   '))
print(para_data('03/10/2026'))
  • para_numero(' 12,50 ') devolve 12.5
  • Texto vazio vira None
  • para_data devolve uma data com mês 10
  • para_data ignora espaços nas pontas

Validar linhas e guardar as rejeitadas

Você já separou válidos e rejeitados com try e except ValueError. Num pipeline de verdade, faltam duas coisas: saber qual linha do arquivo falhou e por quê. Sem isso, quem recebe a lista de rejeitadas não consegue corrigir nada na fonte.

Para o número da linha, use enumerate(leitor, start=2): a linha 1 do arquivo é o cabeçalho, então a primeira linha de dados é a 2. Para o motivo, faça uma verificação por vez e pare na primeira que falhar com continue, que pula direto para a próxima volta do laço.

Coloque em ordem o que o programa faz com cada linha do arquivo.

  • Ler a linha como dicionário com o DictReader
  • Tirar os espaços das pontas de cada campo
  • Verificar se algum campo obrigatório está vazio
  • Converter valor e data, capturando ValueError
  • Guardar a linha em validos ou em rejeitados com o motivo

Triagem de vendas

O código aceita tudo. Faça a validação: valor vazio vira motivo valor faltando, valor que não converte vira valor inválido, data que não converte vira data inválida. Rejeitadas vão para rejeitados como {'linha': numero, 'motivo': ...}; válidas guardam valor como float e a cidade sem espaços.

import csv
import io
from datetime import datetime

arquivo = io.StringIO("""data;cidade;valor
14/10/2026;Recife;12,50
15/10/2026;Salvador;
31/02/2026;Belém;8,00
16/10/2026;Recife;abc
16/10/2026; Manaus ;30,00
""")

validos = []
rejeitados = []

# start=2 porque a linha 1 do arquivo é o cabeçalho
for numero, linha in enumerate(csv.DictReader(arquivo, delimiter=';'), start=2):
    cidade = linha['cidade'].strip()
    texto_valor = linha['valor'].strip()
    # Complete: valide o valor e a data.
    # Se algo falhar, adicione {'linha': numero, 'motivo': '...'} em rejeitados e use continue.
    validos.append({'cidade': cidade, 'valor': texto_valor})

print(len(validos), 'válidas,', len(rejeitados), 'rejeitadas')
for r in rejeitados:
    print('Linha', r['linha'], '->', r['motivo'])
  • Sobraram 2 linhas válidas
  • As linhas 3, 4 e 5 foram rejeitadas
  • Os valores válidos são números (float)
  • A cidade Manaus foi guardada sem espaços
  • A linha 4 foi rejeitada por data inválida
A data 31/02/2026 parece bem escrita. Por que ela é rejeitada?

Porque fevereiro não tem dia 31. O formato está certo, mas o valor é impossível, e strptime verifica isso. É por isso que converter é melhor do que só conferir o formato com os olhos: a conversão valida o significado.

Resumir: somas, contagens e grupos

Com as linhas limpas, vem a pergunta de negócio: quanto cada cidade vendeu? Qual forma de pagamento é a mais usada? Isso se chama agregar: transformar muitas linhas em poucos números, agrupando por alguma coluna.

Com um dicionário comum, somar por cidade esbarra num problema: na primeira vez que uma cidade aparece, ela ainda não é chave, e total[cidade] += valor dá KeyError. O módulo collections tem duas ferramentas que resolvem isso.

defaultdict
Um dicionário que cria um valor inicial sozinho quando a chave não existe. defaultdict(float) começa cada chave em 0.0; defaultdict(list), numa lista vazia.
Counter
Um dicionário feito para contar. Counter(['pix', 'pix', 'cartao']) vira {'pix': 2, 'cartao': 1}, e most_common(1) devolve o mais frequente.

Vendas por cidade e forma de pagamento

Rode e veja o KeyError. Corrija total_por_cidade usando defaultdict(float), conte as formas de pagamento com Counter e imprima Mais usado: pix usando most_common.

from collections import Counter, defaultdict

vendas = [
    {'cidade': 'Recife', 'pagamento': 'pix', 'valor': 12.5},
    {'cidade': 'Salvador', 'pagamento': 'dinheiro', 'valor': 6.0},
    {'cidade': 'Recife', 'pagamento': 'cartao', 'valor': 25.9},
    {'cidade': 'Belém', 'pagamento': 'pix', 'valor': 6.0},
    {'cidade': 'Recife', 'pagamento': 'pix', 'valor': 9.6},
    {'cidade': 'Salvador', 'pagamento': 'pix', 'valor': 14.0},
]

total_por_cidade = {}
for venda in vendas:
    total_por_cidade[venda['cidade']] += venda['valor']

pagamentos = Counter()  # conte as formas de pagamento das vendas

print(dict(total_por_cidade))
# print('Mais usado:', pagamentos.most_common(1)[0][0])
  • Recife vendeu 48,00 no total
  • Salvador vendeu 20,00 no total
  • Pix aparece 4 vezes em pagamentos
  • Imprimiu Mais usado: pix

Complete o código que agrupa os produtos vendidos por cidade e conta os produtos.

from collections import Counter, ____

produtos_por_cidade = defaultdict(____)
for venda in vendas:
    produtos_por_cidade[venda['cidade']].____(venda['produto'])

contagem = ____(venda['produto'] for venda in vendas)

Entregar o resultado: CSV e JSON

Um pipeline termina quando outra pessoa, ou outro programa, consegue usar o que você produziu. Os dois formatos de saída mais comuns são CSV, para tabelas, e JSON, que você já conhece das APIs, para relatórios com estrutura. Para escrever CSV a partir de dicionários existe o par do DictReader: o csv.DictWriter, que recebe a lista de colunas (fieldnames), escreve o cabeçalho com writeheader() e uma linha por writerow().

O mesmo resumo nos dois formatos

resumo.csv

cidade,total
Recife,48.0
Salvador,20.0
Belém,6.0

rejeicoes.json

{
  "total_rejeitados": 2,
  "rejeitados": [
    { "linha": 3, "motivo": "valor faltando" },
    { "linha": 5, "motivo": "valor inválido" }
  ]
}

Resumo em CSV e relatório de rejeições em JSON

Escreva uma linha por cidade no CSV com escritor.writerow. Depois gere relatorio com json.dumps contendo total_rejeitados e a lista rejeitados, usando ensure_ascii=False para manter os acentos.

import csv
import io
import json

resumo = {'Recife': 48.0, 'Salvador': 20.0, 'Belém': 6.0}
rejeitados = [
    {'linha': 3, 'motivo': 'valor faltando'},
    {'linha': 5, 'motivo': 'valor inválido'},
]

saida = io.StringIO()
escritor = csv.DictWriter(saida, fieldnames=['cidade', 'total'])
escritor.writeheader()
# escreva uma linha por cidade: escritor.writerow({'cidade': ..., 'total': ...})

texto_csv = saida.getvalue()
print(texto_csv)

relatorio = ''  # use json.dumps({...}, ensure_ascii=False, indent=2)
print(relatorio)
  • O CSV tem o cabeçalho e uma linha por cidade
  • A segunda linha do CSV é Recife,48.0
  • O JSON informa 2 rejeitados
  • Os acentos foram mantidos no JSON

E o pandas? O mesmo trabalho em menos linhas

O pandas é a biblioteca mais usada para dados em Python. Ele trabalha com um DataFrame: uma tabela inteira na memória, com colunas que têm tipo. Em vez de percorrer linha por linha, você dá ordens para colunas inteiras de uma vez.

Ler, limpar, separar rejeitadas e somar por cidade

Biblioteca padrão

validos, rejeitados = [], []
for numero, linha in enumerate(csv.DictReader(arquivo, delimiter=';'), start=2):
    try:
        valor = float(linha['valor'].strip().replace(',', '.'))
        data = datetime.strptime(linha['data'].strip(), '%d/%m/%Y')
    except ValueError:
        rejeitados.append(numero)
        continue
    validos.append({'cidade': linha['cidade'].strip(), 'valor': valor})

total = defaultdict(float)
for v in validos:
    total[v['cidade']] += v['valor']

pandas

import pandas as pd

df = pd.read_csv('vendas.csv', sep=';', dtype=str)
df['cidade'] = df['cidade'].str.strip()
df['valor'] = pd.to_numeric(df['valor'].str.replace(',', '.'), errors='coerce')
df['data'] = pd.to_datetime(df['data'], format='%d/%m/%Y', errors='coerce')

ruins = df['valor'].isna() | df['data'].isna()
rejeitados = df[ruins]
total = df[~ruins].groupby('cidade')['valor'].sum()

Repare que as ideias são as mesmas: separador, limpeza, conversão, rejeição e agrupamento. No pandas, errors='coerce' transforma o que não converte em valor vazio (NaN), e groupby faz o papel do defaultdict. Quem entende a versão em Python puro sabe exatamente o que o pandas faz por baixo.

Quando usar cada um
Biblioteca padrãopandas
InstalaçãoNenhuma, já vem com o PythonPrecisa instalar (pip install pandas)
CódigoMais longo, cada passo explícitoMais curto, operações em colunas inteiras
MemóriaPode ler linha a linha, arquivos de qualquer tamanhoCarrega a tabela toda na memória
Bom paraScripts pequenos, validações linha a linha, ambientes sem dependênciasExploração, análises e transformações em tabelas que cabem na memória

Você precisa validar um CSV de 40 GB num servidor com 8 GB de memória. Qual abordagem tem mais chance de funcionar sem travar?

  • Ler com csv.DictReader linha a linha, sem guardar todas as linhas numa lista
  • Abrir com pd.read_csv de uma vez, porque o pandas é mais rápido
  • Abrir o arquivo no Excel e salvar uma cópia menor

Fechamento

  • csv.DictReader transforma cada linha de um CSV num dicionário; confira o separador, que no Brasil costuma ser ;.
  • Tudo que vem de um arquivo é texto: limpe com strip(), troque a vírgula decimal e converta com float() e datetime.strptime().
  • Valores faltantes viram None, nunca zero, e linhas inválidas vão para um relatório de rejeições com número e motivo.
  • defaultdict e Counter resumem dados por grupo; csv.DictWriter e json.dumps entregam o resultado.
  • O pandas faz o mesmo com menos código, mas carrega tudo na memória; entender a versão em Python puro mostra o que ele faz por baixo.

Valide um CSV público de verdade

Leve o que você fez aqui para o seu computador, com um arquivo real. Escolha um CSV pequeno do Portal Brasileiro de Dados Abertos ou do OpenDataSUS.

  1. Crie uma pasta de projeto e um ambiente virtual com python -m venv .venv
  2. Baixe um CSV público e anote a origem, a data do download e a licença num README
  3. Leia o arquivo com csv.DictReader, descobrindo o separador e o encoding corretos
  4. Valide tipos e valores faltantes de pelo menos três colunas e separe as linhas rejeitadas
  5. Grave um CSV com as linhas válidas e um JSON com o relatório de rejeições (linha e motivo)
  6. Publique o projeto no GitHub sem o arquivo de dados se ele for grande, explicando como baixá-lo

Referências

Cursos relacionados