Documentation – Extraire du texte d'un PDF avec Python

Python-Net: Extraction de texte de base avec Python

Fri, 22 May 2026 00:00:00 +0000

Extraire le texte de toutes les pages d’un document PDF

Utiliser TextAbsorber pour capturer tout le texte de chaque page d’un document PDF et l’écrire dans un fichier texte. Cette approche convient parfaitement à la conversion de PDF en texte interrogeable, à l’analyse du contenu ou à la préparation du texte pour l’indexation et le traitement en aval.

Ouvrez le document PDF en utilisant Document.
Créer un TextAbsorber instance.
Appeler document.pages.accept(text_absorber) scanner toutes les pages.
Récupérer le texte extrait de text_absorber.text.
Écrivez le résultat dans un fichier texte de sortie.

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)

Extraire le texte d’une page particulière

Appliquer TextAbsorber vers une seule page pour isoler et enregistrer le texte de cette section d’un document multipage. Ceci est utile lorsque vous avez besoin du contenu d’une seule page — par exemple, une facture, une section de rapport ou un résumé de formulaire.

Ouvrez le document PDF en utilisant Document.
Créer un TextAbsorber instance.
Appeler accept sur la page cible : document.pages[page_number].accept(text_absorber).
Récupérez le texte extrait et écrivez‑le dans un fichier.

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: Extraction basée sur la région avec Python

Fri, 22 May 2026 00:00:00 +0000

Extraire du texte d’une région spécifique d’une page

Utiliser TextAbsorber avec un Rectangle pour limiter l’extraction à une zone spécifique d’une page. Cette approche est utile pour l’extraction basée sur des zones à partir des en-têtes, pieds de page, cellules de tableau, champs de formulaire, factures, ou d’autres régions à mise en page fixe où la position du texte est connue à l’avance.

Ouvrez le PDF source en tant que Document.
Créer un TextAbsorber instance.
Configurer text_search_options pour limiter l’extraction à un rectangle.
Accepter l’absorbeur sur la page cible.
Écrire le texte extrait dans un fichier de sortie.

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

Extraire les paragraphes en les parcourant

Utiliser ParagraphAbsorber lorsque vous avez besoin d’une extraction sensible aux paragraphes au lieu de texte de page simple. Contrairement TextAbsorber ou TextFragmentAbsorber, cette API organise la sortie par page, section et paragraphe, ce qui est utile pour l’analyse de texte, l’exportation structurée et le traitement sensible à la mise en page.

Ouvrez le PDF source en tant que Document.
Créer un ParagraphAbsorber instance.
Appeler absorber.visit(document) pour analyser toutes les pages.
Parcourir page_markups, puis à travers chaque section et paragraphe.
Lire les fragments de texte de chaque paragraphe et écrire le résultat dans un fichier.

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

Extraire les paragraphes avec le rendu du polygone de délimitation

Vous pouvez également utiliser ParagraphAbsorber pour inspecter la géométrie des paragraphes. En plus d’extraire le texte, cette approche enregistre chaque rectangle de section et chaque polygone de paragraphe, ce qui est utile pour la cartographie de la mise en page, l’analyse de documents, les outils d’accessibilité ou le post‑traitement sensible aux régions.

Ouvrez le PDF source en tant que Document.
Créer un ParagraphAbsorber instance.
Visitez la page cible.
Lire le balisage de la page depuis absorber.page_markups.
Parcourez les sections et les paragraphes pour capturer la géométrie et le texte.
Écrivez les données du rectangle, du polygone et du texte dans le fichier de sortie.

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: Améliorer l'extraction de texte des PDF multi‑colonnes

Fri, 22 May 2026 00:00:00 +0000

Réduisez la taille de la police manuellement, puis extrayez

Dans certaines mises en page à plusieurs colonnes, réduire la taille de la police des fragments de texte avant l’extraction peut améliorer l’ordre de lecture et réduire les problèmes de chevauchement. Cette technique peut aider avec des documents fortement formatés tels que des magazines, des articles de recherche, des brochures ou des rapports contenant des colonnes de texte denses.

Chargez le PDF.
Utiliser TextFragmentAbsorber collecter les fragments de texte.
Réduisez la taille de police de chaque fragment, puis enregistrez et rouvrez le document.
Utiliser TextAbsorber extraire le texte.
Écrire le texte extrait dans un fichier de sortie.

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)

Extraire le texte avec un facteur d’échelle

Une autre option pour l’extraction multicolonnes consiste à configurer TextExtractionOptions avec un facteur d’échelle. Ajuster le facteur d’échelle peut améliorer l’interprétation des fragments très rapprochés et aider à préserver un ordre de lecture plus précis dans les mises en page denses, les tableaux ou les documents à colonnes.

Chargez le PDF.
Créer un TextAbsorber.
Configurer TextExtractionOptions.scale_factor.
Attribuez les options d’extraction à l’absorbeur.
Extrayez le texte de la page et écrivez le résultat dans un fichier de sortie.

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: Annotations et texte spécial avec Python

Fri, 22 May 2026 00:00:00 +0000

Extraire le texte des annotations de tampon

Utiliser TextAbsorber pour extraire le texte intégré dans un StampAnnotation flux d’apparence. Ceci est utile lorsque le contenu du tampon est rendu comme un Form XObject plutôt que stocké en texte brut.

Ouvrir le Document.
Accédez à l’annotation cible depuis page.annotations.
Vérifiez que c’est un StampAnnotation, puis récupérer son apparence normale XForm.
Passez le XForm à TextAbsorber.visit() pour extraire le texte incorporé.

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

Extraire le texte surligné

Itérer sur les annotations d’une page et utiliser HighlightAnnotation.get_marked_text() pour lire les segments de texte couverts par chaque surlignage. La collection d’annotations de la page est indexée à partir de 1.

Ouvrir le Document et sélectionnez la page cible.
Parcourir page.annotations.
Utiliser is_assignable filtrer pour HighlightAnnotation instances.
Caster l’annotation et appeler get_marked_text() pour récupérer le contenu surligné.

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

Extraire le texte en exposant et en indice

Les exposants et les indices apparaissent fréquemment dans les formules, les expressions mathématiques et les noms de composés chimiques. Aspose.PDF for Python via .NET prend en charge l’extraction de ce contenu via TextFragmentAbsorber, qui détecte les métadonnées de positionnement au niveau des caractères.

Ouvrir le Document.
Créer un TextFragmentAbsorber instance.
Appeler document.pages[page_number].accept(absorber) scanner la page cible.
Récupérer le texte complet extrait de absorber.text.
Écrivez le résultat dans un fichier et fermez le document.

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

Itérer à travers les fragments de texte pour détecter les exposants/sous‑exposants

Pour l’inspection fragment par fragment, itérez sur absorber.text_fragments et lire le text_state.superscript et text_state.subscript drapeaux booléens sur chaque TextFragment.

Ouvrir le Document et créer un TextFragmentAbsorber.
Accepter l’absorbeur sur la page cible afin de le remplir absorber.text_fragments.
Pour chaque fragment, lire fragment.text, fragment.text_state.superscript, et fragment.text_state.subscript.
Écrivez les résultats dans le fichier de sortie et fermez le document.

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