Documentation – Extraer texto de PDF usando Python

Python-Net: Extracción básica de texto usando Python

Wed, 05 Nov 2025 00:00:00 +0000

Extraer texto de todas las páginas de un documento PDF

Usar TextAbsorber para capturar todo el texto de cada página de un documento PDF y escribirlo en un archivo de texto. Este enfoque es adecuado para convertir PDFs a texto indexable, ejecutar análisis de contenido o preparar texto para la indexación y el procesamiento posterior.

Abrir el documento PDF usando Documento.
Crear un TextAbsorber instancia.
Llamar document.pages.accept(text_absorber) para escanear todas las páginas.
Recuperar el texto extraído de text_absorber.text.
Escribe el resultado en un archivo de texto de salida.

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)

Extraer texto de una página particular

Aplicar TextAbsorber a una sola página para aislar y guardar el texto de esa sección de un documento de varias páginas. Esto es útil cuando solo necesitas contenido de una página — por ejemplo, una factura, una sección de informe o un resumen de formulario.

Abrir el documento PDF usando Documento.
Crear un TextAbsorber instancia.
Llamar accept en la página de destino: document.pages[page_number].accept(text_absorber).
Recupera el texto extraído y escríbelo en un archivo.

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: Extracción basada en regiones usando Python

Thu, 16 Apr 2026 00:00:00 +0000

Extraer texto de una región específica de una página

Usar TextAbsorber junto con un Rectángulo para limitar la extracción a un área específica de una página. Este enfoque es útil para la extracción por zonas de encabezados, pies de página, celdas de tabla, campos de formulario, facturas u otras regiones de diseño fijo donde la posición del texto se conoce de antemano.

Abra el PDF de origen como un Documento.
Crear un TextAbsorber instancia.
Configurar text_search_options para limitar la extracción a un rectángulo.
Acepta el absorber en la página objetivo.
Escribe el texto extraído en un archivo de salida.

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()

Extraer párrafos iterando a través de ellos

Usar ParagraphAbsorber cuando necesitas extracción consciente de párrafos en lugar de texto plano de página. A diferencia de TextAbsorber o TextFragmentAbsorber, esta API organiza la salida por página, sección y párrafo, lo que es útil para el análisis de texto, la exportación estructurada y el procesamiento sensible al diseño.

Abra el PDF de origen como un Documento.
Crear un ParagraphAbsorber instancia.
Llamar absorber.visit(document) para analizar todas las páginas.
Iterar a través de page_markups, luego a través de cada sección y párrafo.
Leer los fragmentos de texto de cada párrafo y escribir el resultado en un archivo.

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()

Extraer párrafos con renderizado de polígono delimitador

También puede usar ParagraphAbsorber para inspeccionar la geometría de los párrafos. Además de extraer texto, este enfoque registra el rectángulo de cada sección y el polígono del párrafo, lo cual es útil para el mapeo de diseño, el análisis de documentos, herramientas de accesibilidad o el post-procesamiento dependiente de regiones.

Abra el PDF de origen como un Documento.
Crear un ParagraphAbsorber instancia.
Visita la página objetivo.
Leer el marcado de la página desde absorber.page_markups.
Itera a través de secciones y párrafos para capturar la geometría y el texto.
Escribe los datos de rectángulo, polígono y texto en el archivo de salida.

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: Mejorar la extracción de texto de PDFs de varias columnas

Thu, 16 Apr 2026 00:00:00 +0000

Reduzca el tamaño de Font manualmente y luego extraiga

En algunos diseños de varias columnas, reducir el tamaño de Font de los fragmentos de texto antes de la extracción puede mejorar el orden de lectura y reducir los problemas de superposición. Esta técnica puede ayudar con documentos con formato ajustado como revistas, artículos de investigación, folletos o informes con columnas de texto densas.

Cargue el PDF.
Usar TextFragmentAbsorber para recopilar los fragmentos de texto.
Reduce el tamaño de la fuente de cada fragmento, luego guarda y vuelve a abrir el documento.
Usar TextAbsorber para extraer el texto.
Escribe el texto extraído en un archivo de salida.

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)

Extraer texto con factor de escala

Otra opción para la extracción de múltiples columnas es configurar TextExtractionOptions con un factor de escala. Ajustar el factor de escala puede mejorar la interpretación de fragmentos muy compactos y ayudar a preservar un orden de lectura más preciso en diseños densos, tablas o documentos basados en columnas.

Cargue el PDF.
Crear un TextAbsorber.
Configurar TextExtractionOptions.scale_factor.
Asigne las opciones de extracción al absorbente.
Extraiga el texto de la página y escriba el resultado en un archivo de salida.

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: Anotaciones y Texto Especial usando Python

Wed, 05 Nov 2025 00:00:00 +0000

Extraer Texto de Anotaciones de Sello

Usar TextAbsorber para extraer texto incrustado en un StampAnnotation flujo de apariencia. Esto es útil cuando el contenido del sello se renderiza como un XObject de formulario en lugar de almacenarse como texto plano.

Abrir el Documento.
Acceder a la anotación de destino desde page.annotations.
Verifique que es un StampAnnotation, luego recupere su apariencia normal XForm.
Pasar el XForm a TextAbsorber.visit() para extraer el texto incrustado.

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()

Extraer texto resaltado

Iterar sobre las anotaciones de una página y usar HighlightAnnotation.get_marked_text() para leer los fragmentos de texto cubiertos por cada resaltado. La colección de anotaciones de la página está basada en 1.

Abrir el Documento y seleccione la página de destino.
Recorrer page.annotations.
Usar is_assignable para filtrar HighlightAnnotation instancias.
Convierta la anotación y llame get_marked_text() para recuperar el contenido resaltado.

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())

Extraer texto en superíndice y subíndice

Los superíndices y subíndices aparecen con frecuencia en fórmulas, expresiones matemáticas y nombres de compuestos químicos. Aspose.PDF for Python via .NET admite extraer este contenido a través TextFragmentAbsorber, que detecta metadatos de posicionamiento a nivel de carácter.

Abrir el Documento.
Crear un TextFragmentAbsorber instancia.
Llamar document.pages[page_number].accept(absorber) para escanear la página objetivo.
Recuperar el texto extraído completo de absorber.text.
Escriba el resultado en un archivo y cierre el 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 a través de fragmentos de texto para detectar superíndice/subíndice

Para la inspección por fragmento, iterar sobre absorber.text_fragments y leer el text_state.superscript y text_state.subscript banderas booleanas en cada TextFragment.

Abrir el Documento y crear un TextFragmentAbsorber.
Aceptar el absorber en la página de destino para poblar absorber.text_fragments.
Para cada fragmento, lea fragment.text, fragment.text_state.superscript, y fragment.text_state.subscript.
Escriba los resultados en el archivo de salida y cierre el 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()