Projeto Python de até R$4.500 – Ler PDF com Python: LlamaIndex e LlamaParse

Aprenda a desenvolver um projeto Python real que pode valer até R$4.500 em apenas duas aulas! Descubra como criar um script em Python capaz de ler, extrair dados e converter arquivos em PDF.

Trabalhar com dados tornou-se uma habilidade cada vez mais essencial em diversas áreas, desde a análise de dados até o desenvolvimento de automações empresariais.

Neste projeto, vamos desenvolver um script em Python que lê arquivos PDF, extrai dados estruturados, como tabelas, e os converte em planilhas Excel.

Este projeto é inspirado em um pedido real de freelancer, que oferecia 750 euros (aproximadamente R$4.500) para a criação de um programa com essas características.

Vamos solucionar esse desafio utilizando as ferramentas de inteligência artificial LlamaIndex e LlamaParse. Assim, você aprenderá a aplicá-las para resolver problemas reais, podendo reutilizar esse conhecimento em futuros projetos para diversos cenários.

O projeto lê um PDF com o LlamaParse (a ferramenta de IA do LlamaIndex), extrai as tabelas em formato markdown e converte cada uma em planilha Excel com o pandas. São dois arquivos Python: um faz o parsing do PDF e salva um .md por página; o outro usa regex para achar as tabelas e o to_excel para gravá-las.

Aula 1 – LlamaIndex e LlamaParse – Ler PDFs com Python

Vamos iniciar nosso projeto Python! Nesta primeira aula, veremos como utilizar o LlamaIndex e o LlamaParse para ler e extrair informações de PDFs.

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

O que você aprende neste vídeo

Resposta rápida: Esta é a Aula 1 de um projeto em duas partes, inspirado num pedido real de freelancer pagando até R$4.500 por um script que lê PDF e gera Excel. A aula usa o LlamaParse para transformar as páginas de um PDF em markdown, extraindo só as tabelas via parsing_instruction; a conversão para Excel fica para a próxima aula.

Neste vídeo (26 min):

• 1:00 - O desafio do projeto: ler um PDF de relatório da Petrobras e transformar as tabelas dele em Excel, dividido em duas aulas: hoje o parse, na próxima a conversão
• 5:00 - Criação de conta gratuita no LlamaParse, que libera até 1.000 páginas por dia e 7.000 créditos por semana
• 6:00 - Geração da chave de API e configuração dela como variável de ambiente com o nome LLAMA_CLOUD_API_KEY
• 8:00 - Instalação da biblioteca com pip install llama-parse e importação de LlamaParse
• 9:00 - Configuração do result_type como markdown, formato mais fácil de tratar depois do que texto cru ou o PDF original
• 10:00 - A função load_data("resultado.pdf") devolve uma lista de documentos, um por página do PDF, 29 no exemplo usado
• 17:00 - Uso do parsing_instruction para pedir só as tabelas do PDF, deixando de fora texto e imagem
• 19:00 - Salvamento do texto de cada página num arquivo .md separado, com with open(...) as arquivo: arquivo.write(...)
• 23:00 - Erro de encoding ao salvar caracteres especiais, resolvido acrescentando o parâmetro encoding="utf8" na abertura do arquivo
• 24:00 - Resultado final: uma pasta com um arquivo markdown por página, já só com as tabelas extraídas, pronta para virar Excel na próxima aula

Trechos do vídeo:

• O LlamaParse transforma o conteúdo de um PDF em markdown, formato em que cada célula de uma tabela fica separada por barras verticais, muito mais fácil de tratar em código do que o PDF original
• A conta gratuita do LlamaParse libera até 1.000 páginas por dia e 7.000 créditos por semana, o suficiente para um PDF de 29 páginas
• O parsing_instruction direciona o modelo por trás do LlamaParse: pedir explicitamente só as tabelas faz ele deixar de fora texto e imagem na hora do parse
• No Jupyter Notebook ou no Google Colab, rodar antes import nest_asyncio e nest_asyncio.apply() evita erro do LlamaParse, por causa dos processos assíncronos que ele usa internamente

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

Nesta aula, aprenderemos a ler arquivos PDF, extrair dados estruturados, como tabelas, e convertê-los em planilhas Excel, realizando as conversões e os tratamentos necessários.

O objetivo do projeto é demonstrar como as ferramentas LlamaIndex e LlamaParse podem ser aplicadas para resolver problemas do mundo real. Para isso, usaremos um PDF com o release de resultados financeiros da Petrobras.

Nesta primeira aula, abordaremos todo o processo, desde a configuração do ambiente para o desenvolvimento do projeto até a extração, manipulação e armazenamento dos dados obtidos pelo LlamaParse.

O que é o LlamaIndex e o LlamaParse?

O LlamaIndex e o LlamaParse são ferramentas de inteligência artificial voltadas para a leitura, processamento e extração de informações de documentos, como PDFs.

O LlamaIndex é uma plataforma projetada para facilitar a criação de soluções personalizadas de inteligência artificial, utilizando bases de dados específicas de uma empresa ou organização.

Ele permite que desenvolvedores integrem seus próprios bancos de dados e fontes de informação em sistemas de IA, como chatbots ou modelos de aprendizado de máquina.

Basicamente, o LlamaIndex atua como uma camada intermediária, transformando dados brutos em formatos que podem ser facilmente processados por sistemas de IA.

Dentro do LlamaIndex, temos a ferramenta LlamaParse, que é especializada no processo de parsing — a extração de informações estruturadas a partir de documentos não estruturados, como PDFs.

O LlamaParse é capaz de identificar e separar diferentes tipos de conteúdo em um documento, como texto, imagens e tabelas, e convertê-los em formatos mais acessíveis para manipulação.

Isso facilita a análise e a conversão das informações para outros formatos, como planilhas Excel, permitindo uma integração mais eficiente.

Para mais detalhes, confira a documentação oficial do LlamaIndex, que é uma fonte valiosa para compreender profundamente cada uma das funcionalidades dessa ferramenta.

Criar Conta no LlamaParse – Configurando a API

Para começar a usar o LlamaParse, você precisa criar uma conta. Acesse o site Llamaindex.ai e clique em Sign Up.

Com a cota gratuita, você pode ler até 1.000 páginas por dia, o que é mais do que suficiente para resolver nosso desafio.

Além disso, há um limite semanal de 7.000 créditos. Após atingir esse limite, será necessário pagar uma taxa para continuar utilizando o serviço. Portanto, para grandes volumes de dados, é importante considerar uma assinatura paga.

Após criar sua conta, será necessário gerar sua chave de API, que é única para cada usuário. Para isso, acesse o recurso API Key e clique em Generate New Key.

Com a chave da sua API criada, será necessário criar e configurar uma variável de ambiente com um nome específico: LLAMA_CLOUD_API_KEY.

Utilizaremos a biblioteca os para configurar essa variável no nosso projeto. Basta usar o comando os.environ, passando o nome da variável entre colchetes e a chave fornecida pelo site do LlamaParse.

import os

os.environ["LLAMA_CLOUD_API_KEY"] = "sua_chave_de_api"

Criar uma variável de ambiente é uma prática comum ao trabalhar com chaves e tokens de acesso de APIs. Caso queira compartilhar este projeto com outras pessoas, sem que elas tenham acesso à sua chave da API, será necessário removê-la do código.

Para saber mais sobre variáveis de ambiente e como armazená-las de forma segura no seu computador, leia também: Variáveis de ambiente no Python – O que são e como usá-las?

Instalando a Biblioteca LlamaParse

Após configurar a API, o próximo passo é instalar a biblioteca do LlamaParse. No terminal do seu editor de códigos, execute o comando: pip install llama-parse

Depois de concluída a instalação, podemos importar a biblioteca LlamaParse para dentro do código.

import os

os.environ["LLAMA_CLOUD_API_KEY"] = "sua_chave_de_api"

from llama_parse import LlamaParse

Essa biblioteca realizará o parsing, ou seja, a extração e organização dos dados contidos no PDF para o formato desejado (como texto ou markdown).

Configurando o LlamaParse e Carregando o PDF

Com a biblioteca importada, o próximo passo é construir a lógica responsável por carregar e processar os dados do arquivo PDF.

Vamos criar um objeto da classe LlamaParse, que chamaremos de documentos. Esse objeto é uma lista, onde cada item representa uma página do PDF com as informações extraídas.

Essas informações podem ser extraídas como texto simples ou no formato markdown. O markdown é mais eficiente para trabalhar com dados, pois permite que as tabelas sejam extraídas em um formato fácil de manipular e visualizar.

Para configurar a resposta no formato markdown, definimos o parâmetro result_type como “markdown”. Além disso, passamos um segundo parâmetro, parsing_instruction, que permite fornecer instruções específicas para o processo de parsing.

Por exemplo, no nosso caso, o release de resultados financeiros da Petrobras contém textos e tabelas. Como queremos apenas as tabelas, passamos a seguinte instrução para a IA do LlamaParse:

import os

os.environ["LLAMA_CLOUD_API_KEY"] = "sua_chave_de_api"

from llama_parse import LlamaParse

documentos = LlamaParse(result_type="markdown", 
                        parsing_instruction="this file contains text and tables, I'd like to get only the tables from the text.")

Perceba que essa instrução foi fornecida em inglês para uma maior precisão da IA. Ela especifica que o arquivo contém textos e tabelas, mas que queremos extrair apenas as tabelas.

Existem outras instruções que podem ser fornecidas para a IA através de parâmetros. Quanto mais detalhadas forem as instruções, mais precisa será a extração dos dados desejados. Porém, para nosso exemplo, esses dois parâmetros são suficientes.

Em seguida, usamos o método load_data para carregar o arquivo resultado.pdf que desejamos processar e criar nosso objeto documentos.

Como o arquivo resultado.pdf está no mesmo diretório do código Python, podemos passar apenas o nome do arquivo. Se estivesse em outro diretório, seria necessário fornecer o caminho completo.

import os

os.environ["LLAMA_CLOUD_API_KEY"] = "sua_chave_de_api"

from llama_parse import LlamaParse

documentos = LlamaParse(result_type="markdown", 
                        parsing_instruction="this file contains text and tables, I'd like to get only the tables from the text.").load_data("resultado.pdf")

Contando e Visualizando as Páginas Processadas

Depois de carregar e processar nosso PDF, podemos utilizar a função len para exibir o número de páginas analisadas e para as quais as tabelas foram extraídas.

import os

os.environ["LLAMA_CLOUD_API_KEY"] = "sua_chave_de_api"

from llama_parse import LlamaParse

documentos = LlamaParse(result_type="markdown", 
                        parsing_instruction="this file contains text and tables, I'd like to get only the tables from the text.").load_data("resultado.pdf")

print(len(documentos))

Com esse comando, verificamos que as 29 páginas do PDF foram analisadas e as tabelas extraídas. Pode levar algum tempo para obter a resposta, pois a inteligência artificial está analisando e realizando o parsing do documento.

Como o objeto resultante é uma lista, cada item nela pode ser acessado usando a sintaxe documentos[índice].text. Lembre-se que o índice inicial corresponde à página 1 (índice 0), e o índice final (página 29) é 28.

import os

os.environ["LLAMA_CLOUD_API_KEY"] = "sua_chave_de_api"

from llama_parse import LlamaParse

documentos = LlamaParse(result_type="markdown", 
                        parsing_instruction="this file contains text and tables, I'd like to get only the tables from the text.").load_data("resultado.pdf")

print(documentos[2].text)

Como resposta desse código, temos as informações extraídas da página 3 em formato de texto.

Comparando com a tabela original na página 3 do PDF (tabela abaixo), podemos verificar que a inteligência artificial foi capaz de identificar e apresentar os dados estruturados da tabela.

Essa é a vantagem de trabalhar com o formato markdown: cada célula da tabela é separada e organizada por barras verticais, facilitando as próximas etapas do projeto, onde transformaremos esse texto formatado em markdown em arquivos Excel.

Leia também: Markdown para formatação de textos

Salvando as Tabelas Extraídas em Arquivos Markdown

Para finalizar, podemos utilizar um laço de repetição para percorrer cada página processada e salvar as tabelas extraídas em arquivos markdown separados.

Vamos usar a estrutura for com enumerate para percorrer a lista de páginas. O índice i representará o número da página, enquanto pagina será o objeto que contém o texto extraído.

Dentro do laço, usaremos o comando with open para criar um arquivo markdown para cada página, nomeando-os sequencialmente como pagina1.md, pagina2.md, e assim por diante.

Repare que a extensão dos arquivos é .md, pois estamos criando arquivos no formato markdown.

Por fim, o comando arquivo.write(pagina.text) escreverá o conteúdo extraído da página em seu respectivo arquivo.

import os

os.environ["LLAMA_CLOUD_API_KEY"] = "sua_chave_de_api"

from llama_parse import LlamaParse

documentos = LlamaParse(result_type="markdown", 
                        parsing_instruction="this file contains text and tables, I'd like to get only the tables from the text.").load_data("resultado.pdf")

for i, pagina in enumerate(documentos):
    with open(f"meu_pdf/pagina{i+1}.md", "w", encoding="utf-8") as arquivo:
        arquivo.write(pagina.text)

Ao salvar os arquivos, é importante especificar o caminho correto para que sejam armazenados na pasta desejada. Se nenhuma pasta for informada, os arquivos serão salvos no mesmo diretório onde o código está localizado.

Além disso, certifique-se de que a pasta de destino já exista antes de executar o código.

Executando o código, todas as tabelas extraídas serão salvas como arquivos markdown na pasta meu_pdf.

Isso conclui a primeira etapa do nosso projeto, onde configuramos o LlamaParse para extrair apenas as tabelas do PDF em formato markdown e as salvamos em arquivos separados.

Python Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agora

Aula 2 – Extração e Conversão de Tabelas Markdown para Excel

Vamos à segunda aula do nosso projeto Python! Nesta etapa, veremos como ler os arquivos markdown gerados anteriormente e convertê-los para o formato de tabela do Excel.

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

Na segunda e última aula do nosso projeto com LlamaIndex e LlamaParse, abordaremos todo o processo de leitura dos arquivos markdown, extraindo as tabelas e convertendo-as para o formato Excel.

Nesta aula iremos tratar as tabelas em markdown usando expressões regulares e, em seguida, salvar cada uma delas em um arquivo Excel próprio.

Criando um Novo Arquivo Python

O foco principal desta etapa será ler os arquivos markdown, identificar os padrões de texto das tabelas e convertê-las para arquivos Excel. Para isso, não será necessário utilizar a inteligência artificial do LlamaParse.

Para manter nosso projeto organizado e claro, criaremos um segundo arquivo chamado transformar_excel.py, que será responsável por realizar o processo de leitura e conversão das tabelas.

Dentro desse arquivo, definiremos as funções responsáveis por cada um desses processos e implementaremos a sua execução.

Função Tratar Tabelas Texto – Biblioteca re

A primeira função que precisaremos criar dentro desse novo arquivo será responsável por extrair as tabelas formatadas nos textos. Para isso, é necessário identificar os padrões textuais que estruturam essas tabelas.

Ao analisar os arquivos markdown gerados, podemos observar que cada tabela começa e termina com uma barra vertical | e não possui linhas vazias. Esse é o padrão de texto que identifica a presença de uma tabela no conteúdo.

Além disso, essas tabelas geralmente contêm informações organizadas de maneira tabular, separadas por linhas e colunas.

Para manipular esses padrões textuais nas tabelas, utilizaremos a biblioteca re, conhecida como “regex” (abreviação de regular expression ou expressão regular), que é usada para trabalhar com padrões de texto.

Essa biblioteca permite realizar buscas, substituições e manipulações de strings com base em padrões específicos.

Caso tenha interesse em se aprofundar no uso e aplicação da biblioteca re e das expressões regulares, recomendo que acompanhe essa aula: Regex no Python: Aprenda como usar as expressões regulares.

Vamos começar importando a biblioteca re e definindo a função tratar_tabelas_texto, que receberá como parâmetro uma string chamada texto, representando o conteúdo onde as tabelas estão inseridas.

Dentro da função, vamos definir uma expressão regular para identificar o padrão das tabelas. Essa expressão regular será armazenada na variável regra_busca_regex e será compilada usando a função re.compile, que otimiza a busca ao longo do texto.

O padrão que utilizaremos será o seguinte: r'((?:\|.+\|(?:\n|\r))+)’.

Esse padrão busca por linhas que começam e terminam com o caractere | (barra vertical) e que podem conter qualquer caractere entre elas. Essas linhas devem ser seguidas por uma quebra de linha (\n ou \r).

Utilizando a função findall da biblioteca re, pesquisaremos dentro do texto todas as ocorrências que correspondem ao padrão definido pela regex.

O resultado dessa busca será armazenado na variável tabelas, que será uma lista contendo todas as tabelas identificadas. Essa lista de tabelas será o retorno da função, contendo as tabelas extraídas dos textos originais.

import re

def tratar_tabelas_texto(texto):
    regra_busca_regex = re.compile(r'((?:\|.+\|(?:\n|\r))+)', re.MULTILINE)
    tabelas = regra_busca_regex.findall(texto)
    return tabelas

Transformando as Tabelas Markdown em Arquivos Excel

Agora que criamos a função capaz de identificar tabelas no texto, vamos definir a função transformar_markdown_excel, responsável por converter tabelas formatadas em markdown para arquivos Excel.

Para isso, utilizaremos mais duas bibliotecas Python: pandas e io.

Assim como re, io é uma biblioteca padrão do Python, então não é necessário instalar nada adicional para usá-la. Basta importarmos a classe StringIO, que será utilizada para converter uma string em um objeto de arquivo.

Por outro lado, a biblioteca pandas, que será usada para leitura das tabelas, tratamento dos dados e exportação para Excel, não vem instalada por padrão.

Portanto, no terminal do seu editor de código, execute o comando: pip install pandas openpyxl

É necessário instalar a biblioteca openpyxl porque é ela que o pandas utiliza para lidar com arquivos Excel.

Após instalar as bibliotecas, vamos importá-las em nosso código, juntamente com a biblioteca re.

import re
import pandas as pd
from io import StringIO

Com as bibliotecas importadas, vamos implementar a função transformar_markdown_excel. Essa função receberá dois parâmetros:

• texto: contém o conteúdo onde as tabelas estão inseridas.
• num_pagina: indica o número da página de onde as tabelas foram extraídas. Essa informação será útil para nomear os arquivos Excel gerados.

Dentro dessa função, primeiro chamaremos a função tratar_tabelas_texto, que criamos anteriormente, para identificar as tabelas no texto fornecido.

def transformar_markdown_excel(texto, num_pagina):
    # identificar as tabelas que estão no texto
    lista_texto_tabelas = tratar_tabelas_texto(texto)

Em seguida, verificamos se alguma tabela foi encontrada, utilizando a função len. Se lista_texto_tabelas contiver uma ou mais tabelas, o código dentro do bloco if será executado.

Dentro do bloco if, utilizamos um laço for para iterar sobre cada tabela encontrada. A variável i representa o índice da tabela na lista, e texto_tabela é o conteúdo da tabela em formato texto.

Usamos pd.read_csv da biblioteca pandas para converter o texto da tabela em um DataFrame. O texto da tabela é lido a partir de um objeto StringIO, que permite tratar a string como um arquivo completo.

A separação das colunas é feita usando | (barra vertical), que é o delimitador das nossas tabelas em markdown.

def transformar_markdown_excel(texto, num_pagina):
    # identificar as tabelas que estão no texto
    lista_texto_tabelas = tratar_tabelas_texto(texto)

    if len(lista_texto_tabelas) > 0:
        # ler a tabela
        for i, texto_tabela in enumerate(lista_texto_tabelas):
            tabela = pd.read_csv(StringIO(texto_tabela), sep="|", encoding="utf-8", engine="python")

Após a leitura, a tabela é processada para remover colunas e linhas vazias. A função dropna é usada para eliminar colunas (axis=1) e linhas (axis=0) que contenham apenas valores nulos (NaN).

def transformar_markdown_excel(texto, num_pagina):
    # identificar as tabelas que estão no texto
    lista_texto_tabelas = tratar_tabelas_texto(texto)

    if len(lista_texto_tabelas) > 0:
        # ler a tabela
        for i, texto_tabela in enumerate(lista_texto_tabelas):
            tabela = pd.read_csv(StringIO(texto_tabela), sep="|", encoding="utf-8", engine="python")
            tabela = tabela.dropna(how="all", axis=1)
            tabela = tabela.dropna(how="all", axis=0)

Finalmente, a tabela é salva em um arquivo Excel utilizando o método to_excel do DataFrame Pandas. O arquivo é nomeado de acordo com a página (num_pagina) e o número da tabela (i+1) extraída, sendo armazenado na pasta tabelas.

def transformar_markdown_excel(texto, num_pagina):
    # identificar as tabelas que estão no texto
    lista_texto_tabelas = tratar_tabelas_texto(texto)

    if len(lista_texto_tabelas) > 0:
        # ler a tabela
        for i, texto_tabela in enumerate(lista_texto_tabelas):
            tabela = pd.read_csv(StringIO(texto_tabela), sep="|", encoding="utf-8", engine="python")
            tabela = tabela.dropna(how="all", axis=1)
            tabela = tabela.dropna(how="all", axis=0)

            # salvar ela em Excel
            tabela.to_excel(f"tabelas/Pagina{num_pagina}Tabela{i+1}.xlsx", index=False)

Com isso, essa função conseguirá transformar as tabelas extraídas em markdown para arquivos Excel, automatizando o processo de conversão e organização dos dados obtidos do PDF.

Convertendo os Arquivos Markdown em Excel

Agora que as funções necessárias foram criadas e definidas, só nos resta aplicá-las para converter as tabelas em markdown para Excel. Cada tabela extraída das páginas do PDF foi salva em arquivos de texto separados e armazenada na pasta meu_pdf.

Para converter cada um desses arquivos, precisamos iterar sobre todos eles. Mas, antes disso, precisamos obter uma lista com todos os arquivos presentes na pasta meu_pdf.

Para isso, vamos importar a biblioteca os e utilizar a função listdir(), que retorna uma lista com os nomes dos arquivos.

import re
import pandas as pd
from io import StringIO
import os


def tratar_tabelas_texto(texto):
    regra_busca_regex = re.compile(r'((?:\|.+\|(?:\n|\r))+)', re.MULTILINE)
    tabelas = regra_busca_regex.findall(texto)
    return tabelas


def transformar_markdown_excel(texto, num_pagina):
    # identificar as tabelas que estão no texto
    lista_texto_tabelas = tratar_tabelas_texto(texto)

    if len(lista_texto_tabelas) > 0:
        # ler a tabela
        for i, texto_tabela in enumerate(lista_texto_tabelas):
            tabela = pd.read_csv(StringIO(texto_tabela), sep="|", encoding="utf-8", engine="python")
            tabela = tabela.dropna(how="all", axis=1)
            tabela = tabela.dropna(how="all", axis=0)

            # salvar ela em Excel
            tabela.to_excel(f"tabelas/Pagina{num_pagina}Tabela{i+1}.xlsx", index=False)


pasta_paginas = "meu_pdf"
lista_paginas = os.listdir(pasta_paginas)

Em seguida, vamos percorrer essa lista de arquivos com um loop for. Vamos abrir cada um dos arquivos markdown presentes na pasta e ler seu conteúdo, armazenando-o na variável texto.

pasta_paginas = "meu_pdf"
lista_paginas = os.listdir(pasta_paginas)

for i, pagina in enumerate(lista_paginas):
    with open(f"meu_pdf/{pagina}", "r", encoding="utf-8") as arquivo:
        texto = arquivo.read()

O enumerate é usado para obter o índice i. O índice i nos ajudará a identificar a página correspondente.

Dentro do laço, usamos o índice para calcular o número da página (num_pagina), que começa em 1 (por isso somamos 1 ao índice Python que começa em 0).

pasta_paginas = "meu_pdf"
lista_paginas = os.listdir(pasta_paginas)

for i, pagina in enumerate(lista_paginas):
    with open(f"meu_pdf/{pagina}", "r", encoding="utf-8") as arquivo:
        texto = arquivo.read()

    num_pagina = i + 1

Após carregar o texto de cada página, passamos o conteúdo para a função transformar_markdown_excel, que identificará as tabelas no formato markdown e fará a conversão para o arquivo Excel.

pasta_paginas = "meu_pdf"
lista_paginas = os.listdir(pasta_paginas)

for i, pagina in enumerate(lista_paginas):
    with open(f"meu_pdf/{pagina}", "r", encoding="utf-8") as arquivo:
        texto = arquivo.read()

    num_pagina = i + 1
    transformar_markdown_excel(texto, num_pagina)

Ao executar todo o nosso código, teremos dentro da pasta tabelas todas as tabelas que estavam presentes no PDF inicial, mas agora separadas em arquivos Excel.

Perguntas frequentes

Conclusão – Projeto Python de até R$4.500 – Ler PDF com Python: LlamaIndex e LlamaParse

Ao longo dessas duas aulas, mostrei como desenvolver um projeto Python real, que pode ter um valor de mercado de até R$ 4.500! Você aprendeu a integrar e utilizar ferramentas de inteligência artificial em Python para leitura e manipulação de PDFs, usando o LlamaIndex e o LlamaParse.

Também vimos como converter tabelas em markdown para o formato Excel, utilizando um código otimizado e automatizado que trata e converte as tabelas rapidamente, salvando-as em uma pasta organizada.

Trabalhar com dados, especialmente em grandes volumes, tem se tornado cada vez mais importante. Com este projeto, você estará preparado para criar soluções completas em diferentes cenários que envolvem a manipulação e o tratamento de dados.

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Posts mais recentes de Python

• 
  Curso Básico de Python: Saia do Zero em 10 Aulas Grátis18 de setembro de 2026
  Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.
• 
  Agentes RAG com Python: como criar um assistente de IA17 de setembro de 2026
  Aprenda a criar Agentes RAG com Python do zero: LangChain, FAISS e OpenAI para montar um assistente de IA que responde com base nos seus documentos.
• 
  25 Tipos de Gráficos em Python: Guia Completo com Código26 de agosto de 2026
  Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Posts mais recentes da Hashtag Treinamentos

• 
  Planilha de Controle de Notas Fiscais no Excel [Grátis]2 de outubro de 2026
  Baixe a planilha de controle de notas fiscais no Excel grátis: calcule ISS e retenções, veja o que está em aberto e gere a cobrança de cada nota de serviço.
• 
  Qual IA usar na empresa: ChatGPT, Claude ou Perplexity?2 de outubro de 2026
  Qual IA usar na empresa: veja as diferenças entre ChatGPT, Claude e Perplexity e quando cada um rende mais em cada área da sua equipe.
• 
  Apostilas Gratuitas em PDF: Excel, Power BI, Python e IA30 de setembro de 2026
  Baixe apostilas gratuitas em PDF de Excel, Power BI, Python, Claude e agentes de IA, com exercícios e gabarito. Escolha a sua e comece hoje.