Documentation – Extrair texto de PDF usando Python

Python-Net: Extração Básica de Texto usando Python

Mon, 18 May 2026 00:00:00 +0000

Extrair texto de todas as páginas de um documento PDF

Usar TextAbsorber capturar todo o texto de cada página de um documento PDF e gravá-lo em um arquivo de texto. Essa abordagem é bem adequada para converter PDFs em texto pesquisável, executar análise de conteúdo ou preparar o texto para indexação e processamento subsequente.

Abra o documento PDF usando Document.
Criar um TextAbsorber instância.
Chamar document.pages.accept(text_absorber) para escanear todas as páginas.
Recuperar o texto extraído de text_absorber.text.
Grave o resultado em um arquivo de texto de saída.

import os
import aspose.pdf as ap


def extract_text_from_all_pages(infile, outfile):
    """
    Extract all text from every page of the PDF and write to an output text file.
    Args:
        infile (str): Path to input PDF file.
        outfile (str): Path to output text file.
    """
    # Open the PDF document
    document = ap.Document(infile)
    # Create a TextAbsorber to extract text
    text_absorber = ap.text.TextAbsorber()
    # Accept the absorber for all pages
    document.pages.accept(text_absorber)
    # Get extracted text
    extracted_text = text_absorber.text
    # Write the text to an output file
    with open(outfile, "w", encoding="utf-8") as tw:
        tw.write(extracted_text)

Extrair texto de uma página específica

Aplicar TextAbsorber para uma única página para isolar e salvar o texto daquela seção de um documento de várias páginas. Isso é útil quando você precisa de conteúdo de apenas uma página — por exemplo, uma fatura, uma seção de relatório ou um resumo de formulário.

Abra o documento PDF usando Document.
Criar um TextAbsorber instância.
Chamar accept na página de destino: document.pages[page_number].accept(text_absorber).
Recupere o texto extraído e escreva-o em um arquivo.

import os
import aspose.pdf as ap


def extract_text_from_page(infile, outfile, page_number):
    """
    Extract text from a specific page number of the PDF.
    Args:
        infile (str): Path to input PDF file.
        outfile (str): Path to output text file.
        page_number (int): 1-based page index to extract.
    """
    document = ap.Document(infile)
    text_absorber = ap.text.TextAbsorber()
    # Accept the absorber on only the specified page
    document.pages[page_number].accept(text_absorber)
    extracted_text = text_absorber.text
    with open(outfile, "w", encoding="utf-8") as tw:
        tw.write(extracted_text)

Python-Net: Extração baseada em região usando Python

Mon, 18 May 2026 00:00:00 +0000

Extrair texto de uma região específica de uma página

Usar TextAbsorber juntamente com um Rectangle para limitar a extração a uma área específica de uma página. Esta abordagem é útil para extração baseada em zonas de cabeçalhos, rodapés, células de tabela, campos de formulário, faturas ou outras regiões de layout fixo onde a posição do texto é conhecida antecipadamente.

Abra o PDF de origem como um Document.
Criar um TextAbsorber instância.
Configurar text_search_options para limitar a extração a um retângulo.
Aceite o absorvedor na página de destino.
Escreva o texto extraído em um arquivo de saída.

import aspose.pdf as ap


def extract_text_from_region(infile, page_number, rect_coords, outfile):
    """
    Extract text from a specified rectangular region on a given page.
    Args:
        infile (str): Path to input PDF file.
        page_number (int): 1-based index of the page.
        rect_coords (tuple): (llx, lly, urx, ury) coordinates of the rectangle.
        outfile (str): Output text file path.
    """
    document = ap.Document(infile)
    try:
        absorber = ap.text.TextAbsorber()
        # Set options to restrict search to the rectangle
        absorber.text_search_options.limit_to_page_bounds = True
        llx, lly, urx, ury = rect_coords
        absorber.text_search_options.rectangle = ap.Rectangle(llx, lly, urx, ury, True)
        # Accept on the specific page
        document.pages[page_number].accept(absorber)
        extracted_text = absorber.text
        with open(outfile, "w", encoding="utf-8") as tw:
            tw.write(extracted_text)
    finally:
        document.close()

Extrair parágrafos iterando sobre eles

Usar ParagraphAbsorber quando você precisa de extração consciente de parágrafos em vez de texto de página simples. Ao contrário TextAbsorber ou TextFragmentAbsorber, esta API organiza a saída por página, seção e parágrafo, o que é útil para análise de texto, exportação estruturada e processamento sensível ao layout.

Abra o PDF de origem como um Document.
Criar um ParagraphAbsorber instância.
Chamar absorber.visit(document) para analisar todas as páginas.
Iterar através page_markups, então através de cada seção e parágrafo.
Leia os fragmentos de texto de cada parágrafo e escreva o resultado em um arquivo.

import aspose.pdf as ap


def extract_paragraphs_from_pdf(infile, outfile):
    """
    Extract all paragraphs from a PDF document, and write each paragraph’s text into an output file.
    Args:
        infile (str): Path to input PDF file.
        outfile (str): Path to output text file.
    """
    document = ap.Document(infile)
    try:
        absorber = ap.text.ParagraphAbsorber()
        absorber.visit(document)

        with open(outfile, "w", encoding="utf-8") as tw:
            for page_markup in absorber.page_markups:
                for sec_idx, section in enumerate(page_markup.sections, start=1):
                    for para_idx, paragraph in enumerate(section.paragraphs, start=1):
                        # Concatenate all fragments/lines in the paragraph
                        parts = []
                        for line in paragraph.lines:
                            for fragment in line:
                                parts.append(fragment.text)
                            parts.append("\r\n")
                        paragraph_text = "".join(parts)
                        tw.write(
                            f"Page {page_markup.number}, Section {sec_idx}, Paragraph {para_idx}:\n"
                        )
                        tw.write(paragraph_text + "\n")
    finally:
        document.close()

Extrair Parágrafos com renderização de polígono delimitador

Você também pode usar ParagraphAbsorber para inspecionar a geometria do parágrafo. Além de extrair texto, esta abordagem registra o retângulo de cada seção e o polígono do parágrafo, o que é útil para mapeamento de layout, análise de documentos, ferramentas de acessibilidade ou pós-processamento sensível à região.

Abra o PDF de origem como um Document.
Criar um ParagraphAbsorber instância.
Visite a página de destino.
Ler a marcação da página de absorber.page_markups.
Itere pelas seções e parágrafos para capturar geometria e texto.
Escreva os dados de retângulo, polígono e texto no arquivo de saída.

import aspose.pdf as ap


def extract_paragraphs_with_geometry(infile, outfile):
    """
    Extract paragraphs and record geometry info (rectangle / polygon) for each paragraph in a PDF.
    Args:
        infile (str): Path to input PDF file.
        outfile (str): Path to output text file.
    """
    document = ap.Document(infile)
    try:
        absorber = ap.text.ParagraphAbsorber()
        absorber.visit(document.pages[1])  # Visit page 2 (pages are 1-indexed)

        page_markup = absorber.page_markups[0]
        with open(outfile, "w", encoding="utf-8") as tw:
            for sec_idx, section in enumerate(page_markup.sections, start=1):
                tw.write(f"Section {sec_idx}: rectangle = {section.rectangle}\n")
                for para_idx, paragraph in enumerate(section.paragraphs, start=1):
                    tw.write(f"  Paragraph {para_idx}: polygon = {paragraph.points}\n")
                    # Concatenate paragraph text
                    parts = []
                    for line in paragraph.lines:
                        for fragment in line:
                            parts.append(fragment.text)
                        parts.append("\r\n")
                    tw.write("    Text: " + "".join(parts) + "\n\n")
    finally:
        document.close()

Python-Net: Melhorando a Extração de Texto de PDFs Multi‑Coluna

Mon, 18 May 2026 00:00:00 +0000

Reduza o tamanho da fonte manualmente e então extraia

Em alguns layouts de múltiplas colunas, reduzir o tamanho da fonte dos fragmentos de texto antes da extração pode melhorar a ordem de leitura e reduzir problemas de sobreposição. Essa técnica pode ajudar em documentos com formatação apertada, como revistas, artigos de pesquisa, brochuras ou relatórios com colunas de texto densas.

Carregue o PDF.
Usar TextFragmentAbsorber para coletar os fragmentos de texto.
Reduza o tamanho da fonte de cada fragmento, então salve e reabra o documento.
Usar TextAbsorber para extrair o texto.
Escreva o texto extraído em um arquivo de saída.

import io
import aspose.pdf as ap


def extract_text_reduce_font(infile, outfile, reduce_ratio=0.7):
    """
    Extract text from a multi-column PDF by first reducing font size of all text fragments.
    Args:
        infile (str): Path to input PDF.
        outfile (str): Output text file.
        reduce_ratio (float): Ratio to reduce font size (e.g., 0.7 = 70%).
    """
    doc = ap.Document(infile)

    frag_absorber = ap.text.TextFragmentAbsorber()
    doc.pages.accept(frag_absorber)
    for frag in frag_absorber.text_fragments:
        frag.text_state.font_size = frag.text_state.font_size * reduce_ratio
    # Save to memory stream and reopen (to apply changes)
    ms = io.BytesIO()
    doc.save(ms)
    ms.seek(0)
    doc2 = ap.Document(ms)
    text_absorber = ap.text.TextAbsorber()
    doc2.pages.accept(text_absorber)
    extracted_text = text_absorber.text
    with open(outfile, "w", encoding="utf-8") as tw:
        tw.write(extracted_text)

Extrair texto com fator de escala

Outra opção para extração de múltiplas colunas é configurar TextExtractionOptions com um fator de escala. Ajustar o fator de escala pode melhorar a interpretação de fragmentos densamente compactados e ajudar a preservar uma ordem de leitura mais precisa em layouts densos, tabelas ou documentos baseados em colunas.

Carregue o PDF.
Criar um TextAbsorber.
Configurar TextExtractionOptions.scale_factor.
Atribua as opções de extração ao absorvedor.
Extraia o texto da página e escreva o resultado em um arquivo de saída.

import aspose.pdf as ap


def extract_text_scale_factor(infile, outfile, scale_factor=0.5):
    """
    Extract text from a PDF with multi-column layout using scale factor.
    Args:
        infile (str): Input PDF path.
        outfile (str): Output text file path.
        scale_factor (float): Scale factor between 0.1 and 1.0 or 0 for auto-scaling.
    """
    doc = ap.Document(infile)
    text_absorber = ap.text.TextAbsorber()
    ext_opts = ap.text.TextExtractionOptions(
        ap.text.TextExtractionOptions.TextFormattingMode.PURE
    )
    ext_opts.scale_factor = scale_factor
    text_absorber.extraction_options = ext_opts
    doc.pages.accept(text_absorber)
    extracted_text = text_absorber.text
    with open(outfile, "w", encoding="utf-8") as tw:
        tw.write(extracted_text)

Python-Net: Anotações e Texto Especial usando Python

Mon, 18 May 2026 00:00:00 +0000

Extrair Texto de Anotações de Selo

Usar TextAbsorber para extrair texto incorporado em um StampAnnotation fluxo de aparência. Isso é útil quando o conteúdo do carimbo é renderizado como um XObject de formulário em vez de ser armazenado como texto simples.

Abra o Document.
Acesse a anotação de destino a partir de page.annotations.
Verifique se é um StampAnnotation, então recupere sua aparência normal XForm.
Passe o XForm para TextAbsorber.visit() para extrair o texto incorporado.

import os
import aspose.pdf as ap


def extract_text_from_stamp(infile, page_number, annotation_index, outfile):
    """
    Extracts text from a stamp annotation on a given page in a PDF document.
    Args:
        infile (str): Path to the input PDF file.
        page_number (int): 1-based index of the page containing the stamp.
        annotation_index (int): 1-based index of the annotation in that page.
        outfile (str): Path to the output text file where extracted text will be saved.
    """
    document = ap.Document(infile)
    try:
        page = document.pages[page_number]
        annot = page.annotations[annotation_index]
        # Ensure it's a StampAnnotation
        if isinstance(annot, ap.annotations.StampAnnotation):
            # Get normal appearance XForm of the stamp
            xform = annot.appearance["N"]
            absorber = ap.text.TextAbsorber()
            absorber.visit(xform)
            extracted = absorber.text
            with open(outfile, "w", encoding="utf-8") as f:
                f.write(extracted)
    finally:
        document.close()

Extrair Texto Realçado

Iterar sobre as anotações de uma página e usar HighlightAnnotation para ler os trechos de texto cobertos por cada realce. A coleção de anotações da página usa indexação a partir de 1.

Abra o Document e selecione a página de destino.
Percorrer page.annotations.
Usar is_assignable para filtrar HighlightAnnotation instâncias.
Faça o cast da anotação e chame get_marked_text() para recuperar o conteúdo destacado.

def extract_highlight_text(infile):
    """
    Extract text from highlight annotations.

    Args:
        infile (str): Input PDF filename

    Returns:
        None

    Example:
        extract_highlight_text("sample.pdf")

    Note:
        Prints marked text from each highlight annotation on first page.
    """
    document = ap.Document(infile)
    page = document.pages[1]

    for annotation in page.annotations:
        if is_assignable(annotation, ap.annotations.HighlightAnnotation):
            highlight_annotation = cast(ap.annotations.HighlightAnnotation, annotation)
            print(highlight_annotation.get_marked_text())

Extrair texto sobrescrito e subscrito

Sobrescritos e subscritos aparecem com frequência em fórmulas, expressões matemáticas e nomes de compostos químicos. Aspose.PDF for Python via .NET suporta a extração desse conteúdo através de TextFragmentAbsorber, que detecta metadados de posicionamento ao nível de caracteres.

Abra o Document.
Criar um TextFragmentAbsorber instância.
Chamar document.pages[page_number].accept(absorber) para digitalizar a página de destino.
Recupere o texto extraído completo de absorber.text.
Escreva o resultado em um arquivo e feche o documento.

import os
import aspose.pdf as ap


def extract_super_sub_text(infile, outfile, page_number=1):
    """
    Extract text (including superscript/subscript) from a specified page of a PDF and write to a text file.
    Args:
        infile (str): Path to input PDF file.
        outfile (str): Path to output text file.
        page_number (int): 1‑based index of the page to extract.
    """
    document = ap.Document(infile)
    try:
        absorber = ap.text.TextFragmentAbsorber()
        # Accept only the specific page for extraction
        document.pages[page_number].accept(absorber)
        extracted_text = absorber.text
        with open(outfile, "w", encoding="utf-8") as f:
            f.write(extracted_text)
    finally:
        document.close()

Iterar pelos Fragmentos de Texto para Detectar Sobrescrito/Subscrito

Para inspeção por fragmento, itere sobre absorber.text_fragments e leia o text_state.superscript e text_state.subscript bandeiras booleanas em cada TextFragment.

Abra o Document e criar um TextFragmentAbsorber.
Aceite o absorvedor na página de destino para preencher absorber.text_fragments.
Para cada fragmento, leia fragment.text, fragment.text_state.superscript, e fragment.text_state.subscript.
Escreva os resultados no arquivo de saída e feche o documento.

import os
import aspose.pdf as ap


def extract_super_sub_details(infile, outfile, page_number=1):
    """
    Extract details of each text fragment on a page, identifying superscript and subscript items.
    Args:
        infile (str): Path to input PDF file.
        outfile (str): Path to output text file.
        page_number (int): 1‑based page index.
    """
    document = ap.Document(infile)
    try:
        absorber = ap.text.TextFragmentAbsorber()
        document.pages[page_number].accept(absorber)

        with open(outfile, "w", encoding="utf-8") as f:
            for fragment in absorber.text_fragments:
                text = fragment.text
                is_sup = fragment.text_state.superscript  # True if superscript
                is_sub = fragment.text_state.subscript  # True if subscript
                f.write(
                    f"Text: '{text}' | Superscript: {is_sup} | Subscript: {is_sub}\n"
                )
    finally:
        document.close()