Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Extração de Tabelas e Estrutura

Aula 6 de 16 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Tabelas: A Fraqueza Histórica do OCR
  2. O Parâmetro table_format
  3. Recuperação de Tabelas como Dados
  4. Transição para o pandas para Análise
  5. Quando as Tabelas se Tornam Complexas
  6. Pontos-chave

Atualizado em 2 de novembro de 2026 — OCR. O OCR 4.0 (mistral-ocr-4-0) foi desativado a 30 de setembro de 2026. Utilize o OCR 4.1 (mistral-ocr-4-1), geralmente disponível desde 31 de agosto pelo mesmo preço, ou o alias mistral-ocr-latest, que aponta para ele desde 16 de julho. O OCR 4.1 adiciona pontuações de confiança ao nível do bloco.

Tabelas: A Fraqueza Histórica do OCR

Peça ao Tesseract para extrair a tabela de resumo de um relatório financeiro e obterá uma sequência de linhas onde os valores da coluna “Total” se misturam com os da coluna “Quantidade”, sem qualquer indicação que os ligue às suas linhas originais. O problema não é o reconhecimento de carateres, que funciona bem; é a total falta de consciência da estrutura tabular. As soluções tradicionais leem da esquerda para a direita e de cima para baixo, perdendo pelo caminho as relações entre colunas e linhas.

O OCR 4 aborda a página de forma diferente: ele vê-a. Esta compreensão visual permite-lhe restaurar uma tabela como uma tabela, e não como texto achatado.

O Parâmetro table_format

Controla a renderização das tabelas com um único parâmetro passado na chamada ao OCR:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# Formato Markdown (recomendado para a maioria dos casos)
ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/financial-report.pdf"
    },
    table_format="markdown"
)

São possíveis três valores, e a escolha não é cosmética: determina o que pode fazer com o resultado a jusante.

Com null, o valor predefinido, as tabelas são integradas no fluxo Markdown sem formatação tabular específica. Esta configuração funciona quando não está a processar documentos tabulares e apenas quer texto para indexação.

Com "markdown", cada tabela é renderizada no formato padrão de pipes, produzindo um resultado legível tal como está e fácil de analisar:

| Produto | Quantidade | Preço Unitário | Total |
|---------|----------|------------|-------|
| Widget A | 100 | €12,50 | €1.250 |
| Widget B | 50 | €25,00 | €1.250 |
| **Total** | **150** | | **€2.500** |

Com "html", a tabela é renderizada como HTML completo, preservando a fusão de células e formatação avançada que o Markdown não consegue expressar:

<table>
  <thead>
    <tr>
      <th>Produto</th>
      <th>Quantidade</th>
      <th>Preço Unitário</th>
      <th>Total</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Widget A</td>
      <td>100</td>
      <td>€12,50</td>
      <td>€1.250</td>
    </tr>
  </tbody>
</table>

Na prática, o Markdown cobre a maioria das necessidades: indexação RAG, pesquisa ou exibição num editor. Mude para HTML assim que as suas tabelas incluírem células fundidas ou o resultado precisar de ser incorporado numa página web. Mantenha null apenas quando as tabelas não forem relevantes no seu fluxo de trabalho — digamos, um relatório narrativo ou correspondência.

Recuperação de Tabelas como Dados

Uma tabela Markdown continua a ser texto. Para a transformar em dados manipuláveis, precisa de a detetar no fluxo e dividi-la. A função abaixo percorre as linhas, identifica as que pertencem a uma tabela, ignora a linha separadora e fecha a tabela atual assim que surge uma linha normal:

import os
import re
import json
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def extract_markdown_tables(markdown: str) -> list[list[list[str]]]:
    """Extrai tabelas Markdown e converte-as em listas."""
    tables = []
    lines = markdown.split("\n")
    current_table = []
    in_table = False

    for line in lines:
        if "|" in line and line.strip().startswith("|"):
            # Ignorar linha separadora (|---|---|)
            if re.match(r"^\|[\s\-:|]+\|$", line.strip()):
                continue
            cells = [
                c.strip() for c in line.strip().strip("|").split("|")
            ]
            current_table.append(cells)
            in_table = True
        else:
            if in_table and current_table:
                tables.append(current_table)
                current_table = []
            in_table = False

    if current_table:
        tables.append(current_table)

    return tables


# Extração OCR com tabelas Markdown
ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/invoice.pdf"
    },
    table_format="markdown"
)

# Iterar pelas páginas e extrair tabelas
for page in ocr_response.pages:
    tables = extract_markdown_tables(page.markdown)
    for i, table in enumerate(tables):
        print(f"Página {page.index + 1}, Tabela {i + 1}:")
        print(json.dumps(table, indent=2, ensure_ascii=False))

A verificação final fora do ciclo não é decorativa: sem ela, uma tabela no final de uma página — um caso comum para o resumo de uma fatura — nunca seria adicionada à lista, pois nenhuma linha normal surgiria para a fechar.

Transição para o pandas para Análise

Uma lista de listas serve para exportação, não para cálculo. Converter para um DataFrame significa promover a primeira linha a cabeçalhos:

import pandas as pd

def tables_to_dataframes(markdown: str) -> list[pd.DataFrame]:
    """Converte tabelas Markdown em DataFrames pandas."""
    tables = extract_markdown_tables(markdown)
    dataframes = []

    for table in tables:
        if len(table) < 2:
            continue
        headers = table[0]
        data = table[1:]
        df = pd.DataFrame(data, columns=headers)
        dataframes.append(df)

    return dataframes

# Utilização
for page in ocr_response.pages:
    dfs = tables_to_dataframes(page.markdown)
    for df in dfs:
        print(df.to_string())
        print()

O teste len(table) < 2 filtra falsos positivos: uma linha isolada contendo um pipe, dentro de um bloco de código ou num endereço, não produzirá um DataFrame quebrado e vazio. Tenha em mente que os valores permanecem como strings; converter “€1.250” num número continua a ser da sua responsabilidade.

Quando as Tabelas se Tornam Complexas

Células fundidas, cabeçalhos de dois níveis ou layouts irregulares empurram o Markdown para além dos seus limites expressivos. Mude então para HTML e deixe o BeautifulSoup e o pandas tratar da análise:

from bs4 import BeautifulSoup
import pandas as pd

ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/complex-report.pdf"
    },
    table_format="html"
)

for page in ocr_response.pages:
    soup = BeautifulSoup(page.markdown, "html.parser")
    tables = soup.find_all("table")

    for table in tables:
        df = pd.read_html(str(table))[0]
        print(df)

Esta abordagem poupa-o de escrever um analisador: pd.read_html trata dos atributos rowspan e colspan que a sua divisão manual ignoraria. O custo é uma dependência extra e um resultado ligeiramente mais verboso — uma compensação que vale a pena para relatórios financeiros ou tabelas regulamentares.

Pontos-chave

  • O parâmetro table_format controla a renderização da tabela (null, markdown, html)
  • O formato Markdown adequa-se à maioria dos casos de uso
  • O formato HTML preserva células fundidas e formatação avançada
  • As tabelas extraídas podem ser convertidas em DataFrames pandas para análise
  • O OCR 4 reconstrói fielmente a estrutura tabular, mesmo em layouts complexos