Manipulando Arquivos PDF com Python: ler, juntar e dividir com pypdf

✅ Artigo atualizado em Setembro 2026 (pypdf 6.19) Nova resposta rápida, criação de PDF com texto, extração de intervalos de páginas, OCR para PDF escaneado, comparação pypdf x pdfplumber x PyMuPDF, erros comuns com traceback e 8 exercícios resolvidos. Todos os códigos foram executados.

1
2
3
4
5
6

from pypdf import PdfReader, PdfWriter

print(PdfReader("a.pdf").pages[0].extract_text())  # ler: Relatório de vendas
writer = PdfWriter()
writer.append("a.pdf"); writer.append("b.pdf")      # juntar
writer.write("a_b.pdf")                             # salvar

Salve salve Pythonista!

Neste artigo, vamos explorar como manipular arquivos PDF usando a linguagem de programação Python.

Veremos como criar arquivos PDF, ler texto de arquivos existentes, combinar vários arquivos PDF em um único, dividir um arquivo PDF em páginas separadas e até extrair texto de PDFs escaneados.

Vamos nessa!

Vá Direto ao Assunto…

• Como criar um arquivo PDF do zero com Python?
• Como ler e extrair texto de um arquivo PDF?
• Como juntar (combinar) vários arquivos PDF em um só?
• Como dividir um PDF e extrair páginas separadas?
• Como extrair um intervalo de páginas de um PDF?
• Como girar uma página de um PDF?
• Como extrair texto de PDF escaneado com Python (OCR)?
• Qual a melhor biblioteca Python para PDF: pypdf, pdfplumber ou PyMuPDF?
• Erros comuns
• Exercícios resolvidos

Os arquivos PDF são amplamente utilizados para compartilhar documentos eletrônicos, como relatórios, e-books, manuais, entre outros.

Saber manipular esses arquivos usando programação pode trazer muitos benefícios, como automatizar tarefas relacionadas a documentos, extrair informações de arquivos, criar relatórios personalizados e até mesmo modificar documentos existentes para atender a requisitos específicos.

Felizmente, a biblioteca pypdf oferece uma maneira fácil de trabalhar com arquivos PDF em Python.

Se você ainda não se sente à vontade com open(), modos "rb"/"wb" e o bloco with, vale ler antes o nosso guia sobre como manipular arquivos com Python: PDF é um arquivo binário, e os exemplos abaixo usam essas mesmas ideias.

Você ainda usa PyPDF2? O PyPDF2 foi descontinuado e fundido no pypdf - métodos antigos como PdfFileReader, .numPages e .extractText() foram removidos. Neste artigo usamos a biblioteca atual, pypdf. Consulte a documentação oficial.

Testado com pypdf 6.19 (setembro de 2026) em Python 3.10. Todos os exemplos abaixo foram executados e funcionam em conjunto. O pypdf 6 exige Python 3.9 ou superior.

Antes de mergulhar nos detalhes, aqui está um mapa rápido das principais operações e o código pypdf correspondente:

Vamos explorar cada um desses recursos em detalhes!

Como criar um arquivo PDF do zero com Python?

Vamos começar criando um arquivo PDF do zero!

Para fazer isso, precisamos instalar a biblioteca pypdf usando o gerenciador de pacotes pip.

Primeiro, crie e ative um Ambiente Virtual para esse projeto.

E se ainda não sabe o que é um Ambiente Virtual, pare tudo e leia esse artigo onde vou te mostrar como criar e utilizar Ambientes Virtuais com Virtualenv

Com seu ambiente virtual ativo, abra o terminal e execute o seguinte comando:

1

pip install pypdf

Agora, vamos ao código! O processo tem 3 passos:

1. Importar a classe PdfWriter da biblioteca pypdf e criar um objeto PdfWriter.
2. Adicionar uma página em branco ao arquivo PDF.
3. Salvar o arquivo final no disco.

1
2
3
4
5
6
7
8
9
10
11

from pypdf import PdfWriter

# Criando um objeto PdfWriter
pdf_writer = PdfWriter()

# Adicionando uma página em branco no tamanho A4 (em points)
pdf_writer.add_blank_page(width=595, height=842)

# Salvando o arquivo PDF no disco
with open("meu_arquivo.pdf", "wb") as output_pdf:
    pdf_writer.write(output_pdf)

No código acima, criamos um objeto PdfWriter usando PdfWriter() e, em seguida, adicionamos uma página em branco ao arquivo PDF usando o método add_blank_page(), informando a largura e a altura em points (595 x 842 corresponde ao tamanho A4).

Por fim, salvamos o arquivo final usando write(output_pdf) e especificando o nome do arquivo como "meu_arquivo.pdf".

Ao executar esse código, um PDF com uma página em branco será criado e salvo no diretório atual.

Atenção: chamar pdf_writer.add_page() sem argumento lança TypeError, pois esse método espera uma página já existente (de um PdfReader). Para criar uma página nova use add_blank_page().

E se eu quiser escrever texto no PDF? O pypdf é feito para ler e reorganizar PDFs que já existem; ele não tem uma API para “desenhar” texto em uma página. Para gerar um PDF com conteúdo (relatórios, recibos, certificados), o caminho mais comum é a biblioteca reportlab (pip install reportlab):

1
2
3
4
5
6
7
8

from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas

pdf = canvas.Canvas("relatorio.pdf", pagesize=A4)
pdf.drawString(72, 770, "Relatório de vendas - Setembro 2026")  # x, y em points
pdf.showPage()  # fecha a página atual e começa outra
pdf.drawString(72, 770, "Página 2: detalhes por região")
pdf.save()

As coordenadas são medidas em points a partir do canto inferior esquerdo da página, por isso y=770 fica perto do topo de uma folha A4 (842 points de altura). O arquivo gerado pode ser lido normalmente pelo pypdf:

1
2
3
4
5

from pypdf import PdfReader

reader = PdfReader("relatorio.pdf")
print(len(reader.pages))
print(reader.pages[0].extract_text())

1
2

2
Relatório de vendas - Setembro 2026

Esse par (reportlab para gerar, pypdf para ler e reorganizar) é o que usamos nos exercícios do fim do artigo.

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Como ler e extrair texto de um arquivo PDF?

Agora que sabemos como criar um arquivo PDF, vamos aprender como ler o texto de um arquivo PDF existente.

Para isso, usamos a classe PdfReader da biblioteca pypdf.

Vamos abrir um arquivo PDF existente, extrair o texto dele e exibi-lo no console. São 4 passos:

1. Criar um objeto PdfReader apontando para o arquivo.
2. Descobrir quantas páginas o PDF tem com len(reader.pages).
3. Percorrer as páginas e chamar extract_text() em cada uma.
4. Imprimir o texto resultante.

1
2
3
4
5
6
7
8
9
10
11
12
13

from pypdf import PdfReader

# Abrindo um arquivo PDF existente
pdf_reader = PdfReader("meu_arquivo.pdf")

# Obtendo o número de páginas do arquivo PDF
num_pages = len(pdf_reader.pages)

# Lendo o texto de cada página
for page_number in range(num_pages):
    page = pdf_reader.pages[page_number]
    text = page.extract_text()
    print("Texto da página", page_number + 1, ":", text)

No código acima, criamos um objeto PdfReader passando o caminho do arquivo diretamente - o pypdf cuida de abrir e fechar o arquivo para nós.

Usamos len(pdf_reader.pages) para obter o número total de páginas do arquivo PDF.

Depois, usamos um loop for para iterar sobre cada página do arquivo PDF.

Acessamos pdf_reader.pages[page_number] para obter uma página específica e extract_text() para extrair o texto dessa página.

Finalmente, imprimimos o texto resultante no console.

Se você rodar esse código com o meu_arquivo.pdf criado na seção anterior, o texto sai vazio, porque aquela página está em branco. Trocando o nome do arquivo pelo relatorio.pdf gerado com o reportlab, a saída é:

1
2
3

Texto da página 1 : Relatório de vendas - Setembro 2026

Texto da página 2 : Página 2: detalhes por região

A linha em branco depois de cada página aparece porque o texto extraído termina com uma quebra de linha; use text.strip() se quiser removê-la. Para PDFs com colunas ou tabelas, o pypdf também oferece page.extract_text(extraction_mode="layout"), que tenta preservar a disposição visual do texto (veja o guia de extração de texto do pypdf).

A extração de texto depende de o PDF conter texto “de verdade”. PDFs que são apenas imagens escaneadas não retornam texto - nesse caso você precisa de OCR, como mostramos em como extrair texto de PDF escaneado.

Estou construindo o Ebookr.ai, uma plataforma onde você cria ebooks profissionais com IA sobre qualquer assunto - do zero ao PDF pronto, com capas e infográficos gerados automaticamente. Dá uma olhada!

Como juntar (combinar) vários arquivos PDF em um só?

Às vezes, é necessário combinar vários arquivos PDF em um único arquivo.

Felizmente, a biblioteca pypdf oferece suporte a essa funcionalidade através do próprio PdfWriter (o antigo PdfFileMerger foi descontinuado).

Vamos criar um exemplo simples para combinar dois arquivos PDF em um único arquivo, em 3 passos:

1. Criar um objeto PdfWriter.
2. Anexar cada PDF com writer.append().
3. Salvar o arquivo combinado no disco.

1
2
3
4
5
6
7
8
9
10
11
12

from pypdf import PdfWriter

# Criando um objeto PdfWriter
pdf_writer = PdfWriter()

# Anexando os arquivos PDF ao objeto PdfWriter
pdf_writer.append("arquivo1.pdf")
pdf_writer.append("arquivo2.pdf")

# Salvando o arquivo combinado
with open("arquivo_combinado.pdf", "wb") as output_pdf:
    pdf_writer.write(output_pdf)

No código acima, criamos um objeto PdfWriter e anexamos dois arquivos PDF usando o método append(), que aceita o caminho do arquivo diretamente.

Em seguida, salvamos o arquivo combinado usando write(output_pdf).

Na prática, é comum juntar todos os PDFs de uma pasta. Com o Path.glob() do módulo pathlib você lista os arquivos, e o sorted() garante a ordem alfabética (daí a vantagem de nomear arquivos como 2026-07.pdf, 2026-08.pdf…):

1
2
3
4
5
6
7
8
9
10

from pathlib import Path
from pypdf import PdfWriter

writer = PdfWriter()
for arquivo in sorted(Path("relatorios").glob("*.pdf")):
    writer.append(arquivo)
    print("Anexado:", arquivo.name)

writer.write("todos_os_relatorios.pdf")  # write() também aceita o nome do arquivo
print("Total de páginas:", len(writer.pages))

Com uma pasta relatorios/ contendo três PDFs (de 1, 1 e 5 páginas), a saída é:

1
2
3
4

Anexado: 2026-07.pdf
Anexado: 2026-08.pdf
Anexado: 2026-09.pdf
Total de páginas: 7

Se preferir o módulo os para navegar pelas pastas, veja o nosso artigo sobre a biblioteca os do Python.

Como dividir um PDF e extrair páginas separadas?

Às vezes, temos um arquivo PDF grande e precisamos dividi-lo em várias páginas separadas. Vamos ver como fazer isso usando a biblioteca pypdf, em 4 passos:

1. Abrir o arquivo original com PdfReader.
2. Descobrir o número de páginas com len(reader.pages).
3. Para cada página, criar um PdfWriter e adicionar essa página com add_page().
4. Salvar cada página em um arquivo separado.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

from pypdf import PdfReader, PdfWriter

# Abrindo o arquivo PDF original
pdf_reader = PdfReader("arquivo_grande.pdf")

# Obtendo o número de páginas do arquivo PDF
num_pages = len(pdf_reader.pages)

# Dividindo o arquivo em várias páginas separadas
for page_number in range(num_pages):
    # Criando um objeto PdfWriter
    pdf_writer = PdfWriter()

    # Copiando a página atual para o novo arquivo
    page = pdf_reader.pages[page_number]
    pdf_writer.add_page(page)

    # Salvando a página separada
    with open(f"pagina_{page_number + 1}.pdf", "wb") as output_pdf:
        pdf_writer.write(output_pdf)

No código acima, criamos um objeto PdfReader a partir do arquivo original e usamos len(pdf_reader.pages) para obter o número total de páginas.

Usamos um loop for para iterar sobre cada página do arquivo PDF original.

Em cada iteração, criamos um novo objeto PdfWriter e copiamos a página atual (pdf_reader.pages[page_number]) para esse novo arquivo usando add_page().

Em seguida, salvamos a página separada no disco usando write(output_pdf).

Como extrair um intervalo de páginas de um PDF?

Nem sempre você quer uma página por arquivo: muitas vezes precisa só de um trecho (por exemplo, as páginas 2 e 3 de um relatório). Como reader.pages se comporta como uma sequência, dá para usar o mesmo fatiamento das listas no Python, ou passar o intervalo direto para o append():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

from pypdf import PdfReader, PdfWriter

reader = PdfReader("arquivo_grande.pdf")

# Opção 1: fatiamento, igual ao de listas (do índice 1 até o 3, sem incluir o 3)
writer = PdfWriter()
for page in reader.pages[1:3]:
    writer.add_page(page)
writer.write("paginas_2_e_3.pdf")

# Opção 2: append com pages=(início, fim), mesma regra do range()
writer = PdfWriter()
writer.append("arquivo_grande.pdf", pages=(1, 3))
writer.write("paginas_2_e_3_v2.pdf")

for nome in ["paginas_2_e_3.pdf", "paginas_2_e_3_v2.pdf"]:
    textos = [page.extract_text().strip() for page in PdfReader(nome).pages]
    print(nome, textos)

Com um arquivo_grande.pdf de 5 páginas (uma por capítulo), a saída é:

1
2

paginas_2_e_3.pdf ['Capítulo 2', 'Capítulo 3']
paginas_2_e_3_v2.pdf ['Capítulo 2', 'Capítulo 3']

Repare que o intervalo (1, 3) segue a mesma lógica da função range(): começa no índice 1 (a segunda página) e para antes do índice 3. Para pegar “da página 2 até a 3” contando como gente, subtraia 1 do início e mantenha o fim.

Dividir em blocos de N páginas. Outro pedido frequente é quebrar um PDF grande em partes de tamanho fixo, por exemplo para caber no limite de upload de um sistema. Basta andar pelo arquivo de N em N páginas:

1
2
3
4
5
6
7
8
9
10
11
12

from pypdf import PdfReader, PdfWriter

reader = PdfReader("arquivo_grande.pdf")
paginas_por_parte = 2

for inicio in range(0, len(reader.pages), paginas_por_parte):
    writer = PdfWriter()
    for page in reader.pages[inicio:inicio + paginas_por_parte]:
        writer.add_page(page)
    nome = f"parte_{inicio // paginas_por_parte + 1}.pdf"
    writer.write(nome)
    print(nome, "->", len(writer.pages), "página(s)")

1
2
3

parte_1.pdf -> 2 página(s)
parte_2.pdf -> 2 página(s)
parte_3.pdf -> 1 página(s)

Como 5 não é múltiplo de 2, a última parte fica com a página que sobrou. O fatiamento não dá erro quando o fim passa do tamanho da sequência, por isso reader.pages[4:6] devolve só a página 5.

Como girar uma página de um PDF?

Outra operação comum é girar uma página - útil para corrigir documentos escaneados de lado. No pypdf, basta chamar rotate() na página (o ângulo precisa ser múltiplo de 90):

1
2
3
4
5
6
7
8
9
10
11
12
13

from pypdf import PdfReader, PdfWriter

pdf_reader = PdfReader("arquivo.pdf")
pdf_writer = PdfWriter()

# Girando a primeira página em 90 graus no sentido horário
page = pdf_reader.pages[0]
page.rotate(90)
pdf_writer.add_page(page)

# Salvando o resultado
with open("arquivo_girado.pdf", "wb") as output_pdf:
    pdf_writer.write(output_pdf)

Aqui usamos page.rotate(90) para girar a página em 90 graus e, em seguida, adicionamos a página girada ao PdfWriter antes de salvar.

Como extrair texto de PDF escaneado com Python (OCR)?

Um PDF escaneado (ou gerado por um app de “digitalizar documento” do celular) não guarda letras: cada página é uma foto. O extract_text() do pypdf só lê texto digital, então devolve uma string vazia. A própria documentação do pypdf avisa que ele não é um software de OCR e nunca vai extrair texto de imagens.

Para ver isso acontecer, vamos simular uma folha escaneada com o Pillow (pip install pillow), que desenha o texto dentro de uma imagem e salva essa imagem como PDF:

1
2
3
4
5
6
7
8

from PIL import Image, ImageDraw, ImageFont

# Uma "folha escaneada": o texto é desenhado dentro de uma imagem
folha = Image.new("RGB", (1240, 1754), "white")  # A4 em 150 dpi
desenho = ImageDraw.Draw(folha)
fonte = ImageFont.load_default(size=48)
desenho.text((100, 150), "Nota fiscal 2026", fill="black", font=fonte)
folha.save("escaneado.pdf")  # o Pillow salva a imagem como PDF

O primeiro passo é detectar as páginas sem texto:

1
2
3
4
5
6
7
8

from pypdf import PdfReader

reader = PdfReader("escaneado.pdf")
for numero, page in enumerate(reader.pages, start=1):
    texto = page.extract_text()
    print(repr(texto))
    if not texto.strip():
        print(f"Página {numero}: sem texto extraível, precisa de OCR")

1
2

''
Página 1: sem texto extraível, precisa de OCR

O segundo passo é o OCR (reconhecimento óptico de caracteres): converter cada página em imagem e pedir para um motor de OCR “ler” a imagem. O motor gratuito mais usado é o Tesseract, que no Python é acessado pelo pacote pytesseract. Para transformar as páginas do PDF em imagens, o pdf2image é uma opção simples:

1

pip install pytesseract pdf2image

1
2
3
4
5
6
7

from pdf2image import convert_from_path
import pytesseract

paginas = convert_from_path("escaneado.pdf", dpi=300)  # cada página vira uma imagem
for numero, imagem in enumerate(paginas, start=1):
    texto = pytesseract.image_to_string(imagem, lang="por")
    print(numero, texto.strip())

1

1 Nota fiscal 2026

Esse código foi testado no Linux com Tesseract 4.1. Pontos de atenção antes de rodar:

• Tesseract e Poppler não vêm pelo pip. O pytesseract e o pdf2image são só “pontes” para programas instalados no sistema operacional: o Tesseract (OCR) e o Poppler (renderização do PDF). No Linux eles costumam estar no gerenciador de pacotes da distribuição; no Windows e no macOS, instale os dois e garanta que estejam no PATH.
• lang="por" exige o pacote de idioma português do Tesseract. Sem ele, o OCR falha ou erra acentos. Rode tesseract --list-langs no terminal para ver os idiomas instalados.
• A qualidade do OCR depende da imagem. Digitalizações tortas, borradas ou em baixa resolução geram erros de leitura; 300 dpi é um bom ponto de partida.

Se o objetivo for um PDF pesquisável (com a camada de texto escondida por trás da imagem), existe a ferramenta de linha de comando OCRmyPDF, que também usa o Tesseract. E o PyMuPDF, comparado na próxima seção, tem integração própria com o Tesseract.

Manipular PDF é uma das automações mais pedidas no trabalho, e escolher a biblioteca certa fica bem mais fácil quando a base de Python já está redonda. É esse alicerce que ensinamos na Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Qual a melhor biblioteca Python para PDF: pypdf, pdfplumber ou PyMuPDF?

Não existe uma “melhor” para tudo. As três bibliotecas mais citadas têm focos diferentes, e a licença pesa na escolha se o seu código for comercial:

Quando usar cada uma:

• pypdf: automações de escritório (juntar relatórios, separar páginas, girar, colocar senha) e leitura de texto simples. É leve, sem dependências nativas, e a licença BSD permite uso comercial sem amarras.
• pdfplumber: quando você precisa de tabelas de extratos, notas fiscais e relatórios, ou saber onde cada palavra está na página. Não cria nem modifica PDFs. O próprio projeto avisa que funciona melhor em PDFs gerados por computador, não escaneados.
• PyMuPDF: quando velocidade importa, quando você quer transformar páginas em imagens, editar conteúdo ou fazer OCR com Tesseract. Atenção à AGPL: se você distribuir um software fechado (ou oferecer como serviço) que use o PyMuPDF, precisa cumprir a AGPL ou comprar a licença comercial.

Informações conferidas nas páginas oficiais do pypdf, do pdfplumber e do PyMuPDF em setembro de 2026.

Erros comuns

1. ImportError: cannot import name 'PdfFileReader' (código antigo do PyPDF2)

1

from pypdf import PdfFileReader

1

ImportError: cannot import name 'PdfFileReader' from 'pypdf' (.../site-packages/pypdf/__init__.py)

O caminho entre parênteses muda de máquina para máquina. Esse erro aparece quando você copia um tutorial antigo, feito para o PyPDF2. Se você tentar import PyPDF2 sem ele instalado, o erro é ModuleNotFoundError: No module named 'PyPDF2'. Não instale o PyPDF2: ele foi descontinuado. Troque os nomes antigos pelos atuais:

Todos os nomes da coluna da esquerda foram removidos do pypdf e geram ImportError ou AttributeError (por exemplo, AttributeError: 'PdfReader' object has no attribute 'numPages').

2. FileNotFoundError ao abrir o PDF

1
2
3

from pypdf import PdfReader

reader = PdfReader("relatorio.pdf")

1

FileNotFoundError: [Errno 2] No such file or directory: 'relatorio.pdf'

Um caminho relativo como "relatorio.pdf" é procurado na pasta de onde o script foi executado (o diretório de trabalho atual), que nem sempre é a pasta onde o .py está, principalmente quando você roda pelo botão “Run” de uma IDE. A documentação do FileNotFoundError descreve o erro. Monte o caminho a partir da pasta do script e confira se o arquivo existe:

1
2
3
4
5
6
7
8
9
10

from pathlib import Path
from pypdf import PdfReader

caminho = Path(__file__).parent / "relatorio.pdf"  # pasta do próprio script
if caminho.exists():
    reader = PdfReader(caminho)
    print(len(reader.pages))
else:
    print(f"Arquivo não encontrado: {caminho}")
    print("Pasta atual:", Path.cwd())

Se o arquivo pode ou não existir por motivos fora do seu controle, trate o erro com try/except FileNotFoundError, como explicamos no artigo sobre tratamento de erros e exceções no Python.

3. FileNotDecryptedError: PDF protegido por senha (criptografado)

1
2
3
4
5
6
7
8
9
10

from pypdf import PdfReader, PdfWriter

writer = PdfWriter()
writer.add_blank_page(width=595, height=842)
writer.encrypt("segredo123")
writer.write("protegido.pdf")

reader = PdfReader("protegido.pdf")
print(reader.is_encrypted)  # True
print(len(reader.pages))

1

pypdf.errors.FileNotDecryptedError: File has not been decrypted

O PdfReader abre o arquivo, mas não consegue acessar as páginas sem a senha. Confira reader.is_encrypted e chame reader.decrypt() antes de qualquer outra coisa. O decrypt() devolve PasswordType.NOT_DECRYPTED (que vale falso) quando a senha está errada:

1
2
3
4
5
6
7

from pypdf import PdfReader

reader = PdfReader("protegido.pdf")
if reader.is_encrypted:
    if not reader.decrypt("segredo123"):
        raise ValueError("Senha incorreta")
print(len(reader.pages))  # 1

Se o PDF usar criptografia AES (a mais comum hoje), o pypdf precisa de uma dependência extra e, sem ela, falha com pypdf.errors.DependencyError: cryptography>=3.1 is required for AES algorithm. A correção é pip install "pypdf[crypto]". O mesmo vale para criar PDFs protegidos com writer.encrypt("senha", algorithm="AES-256"), que é o recomendado: sem o parâmetro algorithm, o pypdf usa o RC4, considerado inseguro (detalhes no guia de criptografia do pypdf).

4. extract_text() devolve '' (PDF escaneado, sem texto extraível)

Não aparece traceback nenhum, e isso confunde mais do que um erro:

1
2
3
4

from pypdf import PdfReader

texto = PdfReader("escaneado.pdf").pages[0].extract_text()
print(repr(texto))

1

''

A página é uma imagem, sem camada de texto. Nenhum parâmetro do pypdf resolve isso: é preciso OCR, como mostrado na seção Como extrair texto de PDF escaneado com Python (OCR)?. Antes de concluir que o PDF é escaneado, tente selecionar o texto em um leitor de PDF: se não der para selecionar, é imagem.

5. IndexError ao acessar uma página

1
2
3
4
5

from pypdf import PdfReader

reader = PdfReader("arquivo_grande.pdf")
print(len(reader.pages))  # 5
ultima = reader.pages[5]

1

IndexError: Sequence index out of range

As páginas são numeradas a partir de 0: em um PDF de 5 páginas, os índices vão de 0 a 4. A “página 5” do leitor de PDF é reader.pages[4]. Para a última página, use reader.pages[-1] ou reader.pages[len(reader.pages) - 1].

Exercícios resolvidos

Quer praticar automações como essas em projetos guiados, do básico até scripts que resolvem tarefas reais do trabalho? É o que fazemos no nosso curso de Python completo. Antes, tente resolver os exercícios abaixo sem olhar a solução. Todos geram os próprios PDFs de teste, então você só precisa do pypdf instalado (e do reportlab ou do pillow quando o enunciado disser).

Exercício 1. Crie um PDF chamado tres_paginas.pdf com 3 páginas A4 em branco. Depois, abra esse arquivo com o PdfReader e imprima quantas páginas ele tem.

1
2
3
4
5
6
7
8
9

from pypdf import PdfReader, PdfWriter

writer = PdfWriter()
for _ in range(3):
    writer.add_blank_page(width=595, height=842)
writer.write("tres_paginas.pdf")

reader = PdfReader("tres_paginas.pdf")
print(len(reader.pages))

Exercício 2. Gere capa.pdf (1 página) e conteudo.pdf (4 páginas) com páginas em branco. Junte os dois, nessa ordem, em livro.pdf e imprima o total de páginas do resultado.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

from pypdf import PdfReader, PdfWriter

def criar_pdf_em_branco(nome, paginas):
    writer = PdfWriter()
    for _ in range(paginas):
        writer.add_blank_page(width=595, height=842)
    writer.write(nome)

criar_pdf_em_branco("capa.pdf", 1)
criar_pdf_em_branco("conteudo.pdf", 4)

livro = PdfWriter()
for arquivo in ["capa.pdf", "conteudo.pdf"]:
    livro.append(arquivo)
livro.write("livro.pdf")

print(len(PdfReader("livro.pdf").pages))

Exercício 3. (Estilo prova) Usando a versão atual da biblioteca pypdf, qual trecho imprime corretamente o número de páginas do arquivo a.pdf?

• a) print(PdfFileReader("a.pdf").numPages)
• b) print(len(PdfReader("a.pdf").pages))
• c) print(PdfReader("a.pdf").getNumPages())
• d) print(PdfReader("a.pdf").pages.count())

1
2
3
4
5
6
7
8

from pypdf import PdfReader, PdfWriter

writer = PdfWriter()
writer.add_blank_page(width=595, height=842)
writer.add_blank_page(width=595, height=842)
writer.write("a.pdf")

print(len(PdfReader("a.pdf").pages))

Exercício 4. Com o reportlab, gere trabalho.pdf com 3 páginas contendo os títulos “Introdução”, “Desenvolvimento” e “Conclusão” (um por página). Depois, com o pypdf, descubra em qual página aparece a palavra “Conclusão”.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from reportlab.pdfgen import canvas
from pypdf import PdfReader

# Gerando o PDF de teste com 3 páginas de texto
pdf = canvas.Canvas("trabalho.pdf")
for titulo in ["Introdução", "Desenvolvimento", "Conclusão"]:
    pdf.drawString(72, 750, titulo)
    pdf.showPage()
pdf.save()

# Procurando a palavra
reader = PdfReader("trabalho.pdf")
for numero, page in enumerate(reader.pages, start=1):
    if "Conclusão" in page.extract_text():
        print(f"Encontrado na página {numero}")

Exercício 5. Gere apostila.pdf com 6 páginas em branco e divida o arquivo em partes de 2 páginas (parte_1.pdf, parte_2.pdf…). Para cada parte, imprima o nome e o número de páginas.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from pypdf import PdfReader, PdfWriter

writer = PdfWriter()
for _ in range(6):
    writer.add_blank_page(width=595, height=842)
writer.write("apostila.pdf")

reader = PdfReader("apostila.pdf")
tamanho = 2
for inicio in range(0, len(reader.pages), tamanho):
    parte = PdfWriter()
    for page in reader.pages[inicio:inicio + tamanho]:
        parte.add_page(page)
    nome = f"parte_{inicio // tamanho + 1}.pdf"
    parte.write(nome)
    print(nome, len(PdfReader(nome).pages))

1
2
3

parte_1.pdf 2
parte_2.pdf 2
parte_3.pdf 2

Exercício 6. Gere um PDF com 4 páginas em branco e salve uma cópia em que só as páginas pares (2 e 4) estejam giradas 90 graus. Imprima a rotação de cada página da cópia.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from pypdf import PdfReader, PdfWriter

writer = PdfWriter()
for _ in range(4):
    writer.add_blank_page(width=595, height=842)
writer.write("paginas.pdf")

reader = PdfReader("paginas.pdf")
saida = PdfWriter()
for numero, page in enumerate(reader.pages, start=1):
    if numero % 2 == 0:
        page.rotate(90)
    saida.add_page(page)
saida.write("pares_girados.pdf")

print([page.rotation for page in PdfReader("pares_girados.pdf").pages])

Exercício 7. Crie secreto.pdf com 2 páginas, protegido pela senha python123. Depois, abra o arquivo, confirme que ele está criptografado e teste as senhas senha_errada e python123, mostrando qual abriu e quantas páginas o PDF tem.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from pypdf import PdfReader, PdfWriter

writer = PdfWriter()
writer.add_blank_page(width=595, height=842)
writer.add_blank_page(width=595, height=842)
writer.encrypt("python123")
writer.write("secreto.pdf")

reader = PdfReader("secreto.pdf")
print(reader.is_encrypted)
for senha in ["senha_errada", "python123"]:
    if reader.decrypt(senha):
        print(f"'{senha}' abriu: {len(reader.pages)} páginas")
        break
    print(f"'{senha}' não abriu")

1
2
3

True
'senha_errada' não abriu
'python123' abriu: 2 páginas

Exercício 8. (Estilo prova) Um aluno executou texto = PdfReader("prova_escaneada.pdf").pages[0].extract_text() e recebeu uma string vazia, sem nenhum erro. Qual é a causa mais provável?

• a) O arquivo está protegido por senha.
• b) A página é uma imagem escaneada e não tem camada de texto.
• c) Faltou abrir o arquivo com open() antes de usar o PdfReader.
• d) O extract_text() só funciona na última página do PDF.

1
2
3
4
5
6
7
8
9
10
11

from PIL import Image, ImageDraw, ImageFont
from pypdf import PdfReader

folha = Image.new("RGB", (1240, 1754), "white")
ImageDraw.Draw(folha).text((100, 150), "Prova de Python", fill="black",
                           font=ImageFont.load_default(size=48))
folha.save("prova_escaneada.pdf")

texto = PdfReader("prova_escaneada.pdf").pages[0].extract_text()
print(repr(texto))
print("Precisa de OCR" if not texto.strip() else "Tem texto")

1
2

''
Precisa de OCR

Conclusão

Neste artigo, vimos como manipular arquivos PDF usando Python.

Aprendemos como criar arquivos PDF do zero, ler texto de arquivos existentes, combinar vários arquivos PDF em um único e dividir um arquivo PDF em páginas separadas.

Também vimos como extrair intervalos de páginas, abrir PDFs com senha, reconhecer um PDF escaneado e aplicar OCR, além de quando trocar o pypdf pelo pdfplumber ou pelo PyMuPDF.

Essas habilidades podem ser úteis em uma variedade de cenários, desde automatizar tarefas relacionadas a documentos até extrair informações úteis de arquivos PDF existentes. Um próximo passo natural é levar os dados extraídos para uma planilha: veja como automatizar planilhas do Excel com Python.

A biblioteca pypdf é uma ferramenta poderosa e fácil de usar para o trabalho com arquivos PDF em Python - e, por ser a sucessora oficial do antigo PyPDF2, é a escolha recomendada hoje.

Recomendo que você explore mais recursos dessa biblioteca na documentação oficial do pypdf e experimente diferentes manipulações de arquivo PDF por conta própria.

Até a próxima!

Por Vinícius Ramos em 31/10/2023

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•