Reemplazar texto en PDF con Python

Estos ejemplos muestran cómo modificar o eliminar texto en un PDF existente.

Utilice esta página cuando necesite actualizar valores de texto, eliminar contenido no deseado o aplicar reglas de sustitución de texto en todas las páginas del PDF.

Reemplazar texto existente

Reemplazar texto en todas las páginas del documento PDF

Puedes intentar buscar y reemplazar el texto en el documento usando Aspose.PDF y obtener los resultados en línea en este enlace

La sustitución de texto es un requisito común al actualizar o corregir contenido en documentos PDF existentes — por ejemplo, cambiar nombres de productos, corregir errores tipográficos o actualizar la terminología en varias páginas.

Aspose.PDF for Python via .NET ofrece un método potente y eficiente para buscar y reemplazar texto programáticamente a través del TextFragmentAbsorber clase.

Este ejemplo demuestra cómo encontrar todas las apariciones de una frase específica (en este caso, “Black cat”) y reemplazarlas con una nueva frase (“White dog”) a lo largo de todo un documento PDF.

Especifique frases de búsqueda y reemplazo. Establezca el texto que desea encontrar y el texto con el que desea sustituirlo.
Cargar el documento PDF.
Crea un Text Absorber. Un TextFragmentAbsorber se inicializa con la frase de búsqueda. Escanea el documento para todas las instancias de la frase dada.
Aplicar el Absorber a Todas las Páginas. Esto itera a través de todas las páginas y recopila fragmentos de texto que coinciden con la frase.
Reemplaza cada fragmento encontrado. Cada instancia de “Black cat” debe cambiarse a “White dog”.
Guardar el PDF actualizado.

import sys
import aspose.pdf as ap
from os import path

def replace_text_on_all_pages(infile, outfile):
    search_phrase = "PDF"
    replace_phrase = "pdf"

    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber(search_phrase)
        document.pages.accept(absorber)

        for fragment in absorber.text_fragments:
            fragment.text = replace_phrase

        document.save(outfile)

Reemplazar texto en una región de página particular

A veces, es posible que necesite reemplazar texto solo dentro de un área específica de una página PDF en lugar de buscar en todo el documento — por ejemplo, actualizar un encabezado, pie de página o una celda de tabla en una posición conocida.

La biblioteca Aspose.PDF for Python via .NET habilita esta funcionalidad al utilizar la TextFragmentAbsorber en conjunto con la búsqueda de texto basada en regiones.

Este ejemplo muestra cómo encontrar y reemplazar todas las ocurrencias de una frase objetivo dentro de una región rectangular definida en una página específica.

Especificar frases de búsqueda y reemplazo.
Cargar el documento PDF.
Crear un TextAbsorber para buscar. Inicializar un TextFragmentAbsorber para encontrar el texto deseado.
Restringir el área de búsqueda. El rectángulo especifica los límites de coordenadas x e y en la página.
Aplicar el Absorber a una página específica. Esto realiza la búsqueda y recoge los fragmentos de texto coincidentes dentro del área especificada.
Reemplazar el texto encontrado. Cada aparición de ‘doc’ en la región definida se convierte en ‘DOC’.
Guardar el PDF actualizado.

import sys
import aspose.pdf as ap
from os import path

def replace_text_in_particular_page_region(infile, outfile):
    search_phrase = "doc"
    replace_phrase = "DOC"

    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber(search_phrase)
        absorber.text_search_options.limit_to_page_bounds = True
        absorber.text_search_options.rectangle = ap.Rectangle(300, 442, 500, 742, True)
        document.pages[1].accept(absorber)

        for fragment in absorber.text_fragments:
            fragment.text = replace_phrase

        document.save(outfile)

Redimensionar y desplazar texto sin cambiar el tamaño de la fuente

Al reemplazar texto en un PDF, a veces deseas ajustar o reposicionar el nuevo texto dentro de un área específica sin modificar el tamaño de la fuente. Aspose.PDF for Python via .NET proporciona opciones para ajustar el diseño y el espaciado del texto mientras mantiene intacto el tamaño original de Font.

Cargar el documento PDF.
Recopile todos los fragmentos de texto en la página usando un ‘TextFragmentAbsorber’.
Seleccione el Fragmento para modificar.
Desplazar y cambiar el tamaño del rectángulo de texto.
Ajustar el espaciado del texto. Habilite el ajuste de espaciado para que el texto quepa dentro del rectángulo modificado.
Reemplaza el texto del fragmento.
Guardar el PDF actualizado.

import sys
import aspose.pdf as ap
from os import path

def replace_text_and_resize_and_shift_without_changing_font_size(infile, outfile):
    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber()
        absorber.visit(document.pages[1])
        fragment = absorber.text_fragments[1]
        text = fragment.text
        rect = fragment.rectangle
        rect.llx += 50
        rect.urx -= 50
        fragment.replace_options.rectangle = rect
        fragment.replace_options.replace_adjustment_action = (
            ap.text.TextReplaceOptions.ReplaceAdjustment.ADJUST_SPACE_WIDTH
        )
        fragment.text = f"{text} {text}"
        document.save(outfile)

Redimensionar y desplazar un párrafo en PDF

Al trabajar con PDFs, a veces es necesario reemplazar o ampliar un párrafo mientras se mantiene alineado visualmente con el diseño de la página. Aspose.PDF le permite redimensionar el rectángulo delimitador del párrafo y ajustar el espaciado para encajar el nuevo texto, todo sin cambiar el tamaño de la fuente.

Cargar el documento PDF.
Utiliza ‘TextFragmentAbsorber’ para recopilar todos los fragmentos de texto en la página.
Seleccione el Fragmento para modificar.
Redimensionar y desplazar el párrafo. Use la caja de medios de la página para determinar los límites y ajustar el rectángulo.
Ajustar espaciado. Esto modifica el espaciado entre palabras/letras en lugar de cambiar el tamaño de la fuente.
Reemplaza el texto del fragmento.
Guarda el PDF modificado.

import sys
import aspose.pdf as ap
from os import path

def replace_text_and_resize_and_shift_paragraph(infile, outfile):
    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber()
        absorber.visit(document.pages[1])
        fragment = absorber.text_fragments[1]
        text = fragment.text
        rect = document.pages[1].media_box
        rect.llx += 20
        rect.urx -= 20
        rect.ury -= 20
        fragment.replace_options.rectangle = rect
        fragment.replace_options.replace_adjustment_action = (
            ap.text.TextReplaceOptions.ReplaceAdjustment.ADJUST_SPACE_WIDTH
        )
        fragment.text = f"{text} {text}"
        document.save(outfile)

Reemplazar texto y expandir automáticamente la fuente para llenar el área objetivo

Reemplazar texto en un PDF mientras se redimensiona y expande automáticamente la fuente para llenar un área rectangular específica. Usando la biblioteca Aspose.PDF for Python via .NET, el código ajusta dinámicamente el tamaño y el espaciado de la fuente de modo que el nuevo contenido de texto encaje perfectamente dentro de un cuadro delimitador definido — sin cálculos manuales de fuentes.

Cargar el PDF.
Capturar fragmentos de texto.
Seleccionar un fragmento específico.
Definir rectángulo objetivo.
Habilitar opciones de ajuste de texto.
Reemplazar texto.
Guardar el documento.

import sys
import aspose.pdf as ap
from os import path

def replace_text_and_resize_and_expand_font(infile, outfile):
    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber()
        absorber.visit(document.pages[1])
        fragment = absorber.text_fragments[1]
        text = fragment.text
        fragment.replace_options.rectangle = ap.Rectangle(100, 300, 512, 692, True)
        fragment.replace_options.replace_adjustment_action = (
            ap.text.TextReplaceOptions.ReplaceAdjustment.ADJUST_SPACE_WIDTH
        )
        fragment.replace_options.font_size_adjustment_action = (
            ap.text.TextReplaceOptions.FontSizeAdjustment.SCALE_TO_FILL
        )
        fragment.text = f"{text} {text}"
        document.save(outfile)

Reemplazar texto y ajustarlo a un rectángulo

Reemplazar texto en un documento PDF asegurándose de que el nuevo contenido encaje dentro del área rectangular del texto original reduciendo automáticamente el tamaño de la fuente cuando sea necesario.

Usando la biblioteca Aspose.PDF for Python via .NET, esta función ajusta tanto el layout del texto como el tamaño de la Font de forma dinámica, preservando la estructura del documento mientras evita el desbordamiento.

Cree un objeto TextFragmentAbsorber para extraer todos los fragmentos de texto de la primera página.
Acceder a un fragmento de texto específico.
Establezca el Área de Reemplazo.
Configure las opciones de ajuste de texto. Establezca dos opciones clave de reemplazo:
- Ajuste del tamaño de fuente - ‘SHRINK_TO_FIT’ reduce automáticamente el tamaño de la fuente si el nuevo texto es demasiado largo.
- Ajuste de espaciado - ‘ADJUST_SPACE_WIDTH’ mantiene el espaciado proporcional.
Reemplazar el texto.
Guarda el PDF modificado.

import sys
import aspose.pdf as ap
from os import path

def replace_text_and_fit_text_into_rectangle(infile, outfile):
    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber()
        absorber.visit(document.pages[1])
        fragment = absorber.text_fragments[1]
        text = fragment.text
        fragment.replace_options.rectangle = fragment.rectangle
        fragment.replace_options.font_size_adjustment_action = (
            ap.text.TextReplaceOptions.FontSizeAdjustment.SHRINK_TO_FIT
        )
        fragment.replace_options.replace_adjustment_action = (
            ap.text.TextReplaceOptions.ReplaceAdjustment.ADJUST_SPACE_WIDTH
        )
        fragment.text = f"{text} {text}"
        document.save(outfile)

Reemplazar automáticamente el texto de marcador de posición y reorganizar el diseño del PDF

Reemplaza el texto de marcador de posición dentro de un PDF (p. ej., plantillas o formularios) con datos reales, como nombres o información de la empresa. Ajusta automáticamente el diseño de la página para adaptarse al nuevo texto mientras aplica formato personalizado (Font, color, size).

Importar y cargar el PDF.
Crear un TextAbsorber para el Placeholder.
Aplicar el Absorber a Todas las Páginas.
Recorrer fragmentos de texto encontrados.
Aplicar formato de texto personalizado.
Guardar el documento actualizado.

import sys
import aspose.pdf as ap
from os import path

def automatically_rearrange_page_contents(input_file, output_file):
    document = ap.Document(input_file)

    absorber = ap.text.TextFragmentAbsorber("[Long_placeholder_Long_placeholder]")
    document.pages.accept(absorber)

    for text_fragment in absorber.text_fragments:
        # text_fragment.text = "John Smith"
        text_fragment.text = "John Smith, South Development Studio"
        text_fragment.text_state.font = ap.text.FontRepository.find_font("Calibri")
        text_fragment.text_state.font_size = 12
        text_fragment.text_state.foreground_color = ap.Color.navy

    # Save PDF document
    document.save(output_file)

Reemplazar texto basado en una expresión regular

Al trabajar con documentos PDF, es posible que necesites reemplazar texto que siga un patrón en lugar de una frase específica — por ejemplo, números de teléfono, códigos o formatos tipo fecha.

Aspose.PDF for Python via .NET permite realizar tales reemplazos usando expresiones regulares (regex) con la clase TextFragmentAbsorber.

Este ejemplo muestra cómo encontrar patrones de texto (en este caso, cualquier texto que coincida con el formato ####-####, como 1234-5678) y reemplazarlos con una cadena formateada ‘ABC1-2XZY’. También muestra cómo personalizar la fuente, el color y el tamaño del texto reemplazado.

El siguiente fragmento de código le muestra cómo reemplazar texto basado en una expresión regular.

Cargar el documento PDF.
Crear un TextAbsorber basado en expresiones regulares. Inicializar el TextFragmentAbsorber con un patrón de expresión regular.
Activar el modo de expresión regular. El parámetro \u0027True\u0027 activa el modo de búsqueda de expresiones regulares.
Aplica el Absorber a una página. Esto escanea la página en busca de todos los fragmentos de texto que coinciden con el patrón regex definido.
Reemplazar cada coincidencia con nuevo texto y aplicar estilo personalizado.
Guardar el documento modificado.

import sys
import aspose.pdf as ap
from os import path

def replace_text_based_on_regex(infile, outfile):
    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber(r"\d{4}-\d{4}")
        absorber.text_search_options = ap.text.TextSearchOptions(True)
        document.pages[1].accept(absorber)

        for fragment in absorber.text_fragments:
            fragment.text = "ABC1-2XZY"
            fragment.text_state.font = ap.text.FontRepository.find_font("Verdana")
            fragment.text_state.font_size = 12
            fragment.text_state.foreground_color = ap.Color.blue
            fragment.text_state.background_color = ap.Color.light_green

        document.save(outfile)

Reemplazar fuentes o eliminar fuentes no utilizadas

Reemplazar Font en un archivo PDF existente

En ocasiones, necesitas estandarizar o actualizar fuentes en un PDF — por ejemplo, reemplazando una fuente obsoleta o propietaria por una más accesible. La biblioteca Aspose.PDF for Python via .NET permite detectar y reemplazar fuentes programáticamente, garantizando una tipografía coherente y compatibilidad del documento.

Este ejemplo muestra cómo reemplazar todas las instancias de una fuente específica (p. ej., ‘Arial-BoldMT’) con otra fuente (p. ej., ‘Verdana’) a lo largo de un documento PDF.

El siguiente fragmento de código muestra cómo reemplazar la fuente dentro del documento PDF:

Abre el documento PDF.
Inicializar un TextFragmentAbsorber.
Utilice el Absorber para extraer fragmentos de texto de cada página del documento.
Identificar y Reemplazar Fuentes. El script verifica si la fuente actual de un fragmento es ‘Arial-BoldMT’. Si es así, la reemplaza por la fuente ‘Verdana’ usando el método FontRepository.find_font().
Guardar el documento modificado.

import sys
import aspose.pdf as ap
from os import path

def replace_fonts(infile, outfile):
    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber()
        document.pages.accept(absorber)

        for fragment in absorber.text_fragments:
            if fragment.text_state.font.font_name == "Arial-BoldMT":
                fragment.text_state.font = ap.text.FontRepository.find_font("Verdana")

        document.save(outfile)

Eliminar fuentes no utilizadas

Con el tiempo, los documentos PDF pueden acumular fuentes no utilizadas o incrustadas que aumentan el tamaño del archivo y ralentizan el procesamiento. Estas fuentes no utilizadas a menudo permanecen incluso después de ediciones o reemplazos de texto, especialmente al trabajar con PDFs grandes o complejos.

La biblioteca Aspose.PDF for Python via .NET proporciona una forma eficiente de eliminar esas fuentes redundantes usando la clase TextEditOptions. Esto no solo optimiza su documento, sino que también garantiza que solo se usen las fuentes realmente aplicadas al texto visible.

El método ‘remove_unused_fonts()’ es una forma simple pero poderosa de optimizar archivos PDF al eliminar datos de fuentes redundantes.

Este ejemplo demuestra cómo:

Escanea un PDF en busca de fuentes no utilizadas.
Elimínalos de forma segura.
Reasignar fragmentos de texto activos a una fuente consistente (p. ej., Times New Roman).

Abre el documento PDF.
Configure las opciones de edición de texto. Esto instruye al motor a eliminar cualquier fuente incrustada que no se esté utilizando actualmente en el texto visible.
Crea un Text Absorber con Options. Un TextFragmentAbsorber extrae fragmentos de texto del documento para editar.
Reasignar una Standard Font. Una vez que el absorber haya recopilado todos los fragments, iterar a través de ellos y aplicar una fuente consistente.
Guarda el PDF limpio.

import sys
import aspose.pdf as ap
from os import path

def remove_unused_fonts(input_file, output_file):
    # Open PDF document
    document = ap.Document(input_file)

    # Initialize text edit options to remove unused fonts
    options = ap.text.TextEditOptions(
        ap.text.TextEditOptions.FontReplace.REMOVE_UNUSED_FONTS
    )

    # Create a TextFragmentAbsorber with the specified options
    absorber = ap.text.TextFragmentAbsorber(options)
    document.pages.accept(absorber)

    # Iterate through all TextFragments
    for text_fragment in absorber.text_fragments:
        text_fragment.text_state.font = ap.text.FontRepository.find_font(
            "TimesNewRoman"
        )

    # Save the updated PDF document
    document.save(output_file)

Eliminar todo el texto

Eliminar texto del PDF

Elimina todo el contenido de texto de un archivo PDF manteniendo intactas las imágenes, formas y estructuras de diseño. Al usar TextFragmentAbsorber, el código escanea eficientemente todo el documento y elimina cada fragmento de texto encontrado en cada página.

Cargar el documento PDF.
Se crea un objeto TextFragmentAbsorber para detectar y manejar fragmentos de texto en el PDF.
Eliminar todo el contenido de texto. El método ‘absorber.remove_all_text()’ elimina cada elemento de texto del documento cargado, dejando intactos los componentes que no son texto.
Guardar el documento actualizado.

import sys
import aspose.pdf as ap
from os import path

def remove_all_text_using_absorber1(infile, outfile):
    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber()
        absorber.remove_all_text(document)
        document.save(outfile)

Eliminar todo el texto de una página específica

Eliminar todo el texto de una sola página de un documento PDF usando la clase TextFragmentAbsorber en Aspose.PDF. A diferencia de la eliminación de todo el documento, este método realiza una limpieza de texto a nivel de página, eliminando texto solo de la página elegida mientras deja todas las demás páginas sin tocar.

Cargar el archivo PDF.
Crear una instancia de TextFragmentAbsorber.
Eliminar todo el texto de la primera página.
Guarda el PDF modificado.

import sys
import aspose.pdf as ap
from os import path

def remove_all_text_using_absorber2(infile, outfile):
    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber()
        absorber.remove_all_text(document.pages[1])
        document.save(outfile)

Eliminar todo el texto de un área específica en la página PDF

Eliminar todo el texto de una región rectangular específica en una página usando Aspose.PDF’s TextFragmentAbsorber. En lugar de borrar una página entera, este método realiza la eliminación de texto dirigida, permitiendo un control preciso sobre qué parte de la página se ve afectada.

Cargar el documento PDF.
Crear un TextFragmentAbsorber.
Definir el Área de Destino (Rectángulo).
Eliminar texto de la región especificada.
Conserve el resto del documento.
Guarda el PDF modificado.

import sys
import aspose.pdf as ap
from os import path

def remove_all_text_using_absorber3(infile, outfile):
    with ap.Document(infile) as document:
        absorber = ap.text.TextFragmentAbsorber()
        absorber.remove_all_text(
            document.pages[1], ap.Rectangle(10, 200, 120, 600, True)
        )
        document.save(outfile)

Eliminar todo el Texto oculto de un documento PDF

Cargar el documento PDF.
Crear un TextFragmentAbsorber.
Definir el Área de Destino (Rectángulo).
Eliminar texto de la región especificada.
Conserve el resto del documento.
Guarda el PDF modificado.

import sys
import aspose.pdf as ap
from os import path

def remove_hidden_text(infile, outfile):
    # Open PDF document
    with ap.Document(infile) as document:
        text_absorber = ap.text.TextFragmentAbsorber()
        # This option can be used to prevent other text fragments from moving after hidden text replacement
        text_absorber.text_replace_options = ap.text.TextReplaceOptions(
            ap.text.TextReplaceOptions.ReplaceAdjustment.NONE
        )
        document.pages.accept(text_absorber)
        # Remove hidden text
        for fragment in text_absorber.text_fragments:
            if fragment.text_state.invisible:
                fragment.text = ""
        # Save PDF document
        document.save(outfile)

Temas de texto relacionados

Usar FloatingBox para el diseño de PDF en Python Rotar texto PDF en Python