Parsing de arquivos Excel: planilhas, fórmulas, células mescladas e exemplos em várias linguagens

Os arquivos do Excel (.xlsx e, com menos frequência, o antigo .xls) são o formato mais comum em que as empresas enviam dados: listas de preços, estoques, relatórios, exportações dos sistemas de gestão. Ao contrário do CSV, um Excel não é texto plano, e sim um documento estruturado: dentro de um .xlsx há um arquivo ZIP com a descrição XML das planilhas, dos estilos e das fórmulas. Por isso não dá para lê-lo «como linhas de texto»: são necessárias bibliotecas que entendam a estrutura interna da pasta de trabalho. O artigo dá sequência ao nosso panorama do parsing de documentos.

O que complica o parsing de Excel

Ao contrário de um CSV plano, uma pasta de trabalho do Excel tem várias camadas de complexidade. Primeiro, as planilhas múltiplas: os dados podem estar espalhados entre abas e é preciso escolher explicitamente a correta. Segundo, as fórmulas: uma célula pode armazenar tanto a fórmula =B2*C2 quanto seu valor calculado, e o que você obtém depende do modo de leitura. Terceiro, as células mescladas, por culpa das quais um cabeçalho «paira» sobre várias colunas e surgem lacunas nos dados. Quarto, os formatos: uma data pode chegar não como 2026-06-01, mas como o número 46184 (o número de série com que o Excel guarda as datas), e um preço, como um número com o formato de moeda armazenado à parte. Tudo isso precisa ser levado em conta na extração.

Python

A ferramenta básica para .xlsx é o openpyxl. Ele dá controle total sobre a pasta de trabalho: planilhas, células, mesclagens.

from openpyxl import load_workbook

wb = load_workbook("prices.xlsx", data_only=True)  # data_only=True → valores em vez de fórmulas
ws = wb["Preços"]                                  # escolhemos a planilha pelo nome

for row in ws.iter_rows(min_row=2, values_only=True):
    sku, name, price = row[0], row[1], row[2]
    print(sku, name, price)

Repare no data_only=True: sem ele, uma célula com fórmula devolve o texto da fórmula, e não o resultado. E lembre que o valor calculado só existe se o arquivo foi aberto ao menos uma vez no Excel — o openpyxl não avalia as fórmulas por conta própria.

Quando o que se precisa não é de um percurso linha a linha, mas de análise — filtros, agregações, combinação de tabelas —, recorre-se ao pandas, que carrega a planilha em um DataFrame com uma única linha (por baixo, utiliza o openpyxl).

import pandas as pd

df = pd.read_excel("prices.xlsx", sheet_name="Preços")
print(df[df["price"] > 3000])

# se for preciso, conversão para CSV
df.to_csv("prices.csv", index=False, encoding="utf-8-sig")

Para o antigo formato binário .xls, o pandas usa um motor à parte, o xlrd; os arquivos modernos .xlsx são processados com o openpyxl.

JavaScript / Node.js

No ecossistema JS, o padrão de fato é o SheetJS (pacote xlsx). Funciona tanto no Node quanto no navegador, lê quase qualquer formato de tabela e converte com praticidade uma planilha em um array de objetos.

const XLSX = require("xlsx");

const wb = XLSX.readFile("prices.xlsx");
const sheet = wb.Sheets[wb.SheetNames[0]];   // primeira planilha
const rows = XLSX.utils.sheet_to_json(sheet); // array de objetos conforme a linha de cabeçalho

for (const row of rows) {
  console.log(row.sku, row.name, row.price);
}

Quando, além de ler, é preciso gerar pastas de trabalho complexas com estilos, a opção certa é o ExcelJS.

PHP

A biblioteca principal é a PhpSpreadsheet (a sucessora da antiga PHPExcel). Lê e escreve .xlsx e .xls, entende fórmulas e formatos.

<?php
require "vendor/autoload.php";
use PhpOffice\PhpSpreadsheet\IOFactory;

$spreadsheet = IOFactory::load("prices.xlsx");
$rows = $spreadsheet->getActiveSheet()->toArray(null, true, true, true);

foreach (array_slice($rows, 1) as $row) { // pulamos a linha de cabeçalho
    echo $row["A"] . " — " . $row["B"] . " — " . $row["C"] . "\n";
}

Go

Em Go, o padrão de fato é o excelize. Lê as planilhas como linhas e suporta fórmulas, estilos e streaming para arquivos grandes.

package main

import (
    "fmt"
    "github.com/xuri/excelize/v2"
)

func main() {
    f, err := excelize.OpenFile("prices.xlsx")
    if err != nil {
        panic(err)
    }
    defer f.Close()

    rows, _ := f.GetRows("Preços")
    for _, row := range rows[1:] {
        fmt.Println(row[0], row[1], row[2])
    }
}

Conselhos práticos

Antes de escrever o parser, convém abrir o arquivo e entender sua estrutura: onde os dados começam (as primeiras linhas costumam estar ocupadas pelo cabeçalho e pelo logotipo), se há células mescladas nos cabeçalhos, em qual planilha estão os dados necessários. Se o cabeçalho foge do padrão, é mais simples indicar ao parser a linha inicial do que tentar adivinhá-la. As datas e os números convém normalizar logo depois da leitura — levá-los a um formato único, porque dentro de um mesmo arquivo muitas vezes aparecem escritos de maneiras diferentes.

Se as pastas de trabalho são homogêneas, mas com várias planilhas, células mescladas e fórmulas, e chegam com regularidade, configuramos um parsing automático de Excel com despejo em um banco de dados ou em CSV para o processamento posterior. E quando os relatórios não chegam em Excel, mas diagramados para impressão, isso já é parsing de PDF — consulte o artigo correspondente.