Visión general

Combinar documentos de Word es un requisito común en muchas aplicaciones, ya sea para combinar informes, consolidar información o simplemente simplificar la gestión de documentos. En este artículo, exploraremos cómo combinar archivos DOCX utilizando Python con la biblioteca GroupDocs.Merger. Esta potente biblioteca permite a los desarrolladores manipular fácilmente documentos de Word de manera programática, garantizando un alto rendimiento y precisión.

Esta guía cubrirá:

Cómo combinar múltiples archivos DOCX

Combinar múltiples archivos DOCX es sencillo con la biblioteca GroupDocs.Merger. A continuación, describimos los pasos clave involucrados en este proceso:

  1. Importar el paquete GroupDocs.Merger: Comienza importando la biblioteca requerida.
  2. Crear una instancia de Merger: Instancia la clase Merger utilizando la ruta del primer archivo DOCX.
  3. Unir documentos adicionales: Utiliza el método join para agregar otros archivos DOCX que deseas combinar.
  4. Guardar el documento combinado: Finalmente, llama al método save para escribir el documento combinado en una ruta de salida especificada.

Aquí hay un fragmento de código en Python que demuestra estos pasos:

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Ejemplo de uso básico] # MultipleDocumentOperations # Merge : Docx")

    # Paso 1: Crear un objeto Merger con el primer documento
    with gm.Merger(constants.sample_docx) as merger:
        print(f"Información del documento recuperada con éxito")
        
        # Paso 2: Unir otro archivo DOCX para combinar
        merger.join(constants.sample_docx)
        
        # Paso 3: Guardar el documento combinado
        merger.save(constants.output_docx)
        print(f"Combinar a: {constants.output_docx}")
    
    print(f"----------------------------------------------------------------------------")

Combinar documentos DOCX sin saltos de sección

A veces, combinar documentos requiere que el contenido se una sin insertar saltos de sección. Esto puede ayudar a mantener el flujo de información a través de los documentos combinados.

  1. Crear una instancia de Merger: Al igual que antes, inicializa la clase Merger.
  2. Establecer opciones de unión: Define WordJoinOptions y establece el mode en DISABLE_SECTION_BREAKS.
  3. Unir documentos: Agrega el documento adicional para combinar.
  4. Guardar el resultado: Escribe la salida final en un nuevo archivo DOCX.

Aquí te mostramos cómo hacerlo:

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Ejemplo de uso básico] # MultipleDocumentOperations # Merge # Word : MergeWordDocumentsWithoutSectionBreaks")

    # Paso 1: Crear un objeto Merger con el documento fuente
    with gm.Merger(constants.sample_doc) as merger:
        print(f"Información del documento recuperada con éxito")
        
        # Paso 2: Definir opciones de unión Word para deshabilitar saltos de sección
        word_join_options = gm.domain.options.WordJoinOptions()
        word_join_options.mode = gm.domain.options.WordJoinMode.DISABLE_SECTION_BREAKS
        
        # Paso 3: Unir el documento sin saltos de sección
        merger.join(constants.sample_doc, word_join_options)
        
        # Paso 4: Guardar el documento combinado
        merger.save(constants.output_doc_without_section_breaks)
        print(f"Combinar a: {constants.output_doc_without_section_breaks}")
    
    print(f"----------------------------------------------------------------------------")

Combinar documentos DOCX con modos de cumplimiento predefinidos

Para casos de uso específicos, los documentos pueden necesitar cumplir con ciertos estándares. GroupDocs.Merger te permite combinar documentos con modos de cumplimiento predefinidos para asegurar, por ejemplo, que la salida cumpla con los estándares ISO.

  1. Crear una instancia de Merger: Inicializa la clase Merger con tu documento base.
  2. Establecer el modo de cumplimiento: Crea un objeto WordJoinOptions y establece la propiedad compliance.
  3. Unir documentos: Agrega el documento adicional utilizando el método join.
  4. Guardar el documento final: Guárdalo en la ubicación de salida deseada.

Aquí tienes el código para esta operación:

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Ejemplo de uso básico] # MultipleDocumentOperations # Merge # Word : MergeWordDocumentsWithPredefinedComplianceMode")

    # Paso 1: Crear un objeto Merger con el documento
    with gm.Merger(constants.sample_docx) as merger:
        print(f"Información del documento recuperada con éxito")
        
        # Paso 2: Definir opciones de unión Word con modo de cumplimiento predefinido
        word_join_options = gm.domain.options.WordJoinOptions()
        word_join_options.compliance = gm.domain.options.WordJoinCompliance.ISO_29500_2008_STRICT
        
        # Paso 3: Unir otro documento con modo de cumplimiento
        merger.join(constants.sample_docx, word_join_options)
        
        # Paso 4: Guardar el documento combinado
        merger.save(constants.output_docx_with_predefined_compliance_mode)
        print(f"Combinar a: {constants.output_docx_with_predefined_compliance_mode}")
    
    print(f"----------------------------------------------------------------------------")

Cómo combinar DOCX desde flujos

También puedes combinar archivos DOCX desde flujos en memoria, lo que puede ser útil cuando estás lidiando con documentos generados dinámicamente.

  1. Obtener un flujo de archivo: Abre tu documento en modo binario para obtener el flujo.
  2. Crear la instancia Merger: Instancia la clase Merger utilizando el flujo.
  3. Realizar la operación de combinación: Combina según sea necesario y guarda la salida.

Aquí te mostramos cómo implementar esto:

from turtle import update
import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Ejemplo de uso avanzado] # Carga # LoadDocumentFromStream")

    # Paso 1: Obtener el flujo del documento
    stream = get_file_stream()
    
    # Paso 2: Crear una instancia de Merger utilizando el flujo
    with gm.Merger(stream) as merger:
        print(f"Documento cargado desde el flujo con éxito")
    
    print(f"----------------------------------------------------------------------------")

def get_file_stream():
    file_path = constants.sample_docx
    return open(file_path, "rb")

Ver también

Para más detalles, puedes explorar los siguientes recursos:

También puedes descargar una prueba gratuita desde releases.groupdocs.com y adquirir una licencia temporal para probar la biblioteca sin restricciones en Purchase Temporary License.

Ejemplos de código

Aquí hay algunos ejemplos adicionales para ayudarte a comprender el proceso de combinación con la biblioteca GroupDocs.Merger para Python:

Combinar documentos de Word sin comenzar desde una nueva página

Este ejemplo demuestra cómo combinar documentos de manera que la última página del primer documento sea seguida directamente por la primera página del siguiente documento, sin que se inserte una nueva página entre ellos.

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Ejemplo de uso básico] # MultipleDocumentOperations # Merge # Word : MergeWordDocumentsWithoutStartingFromNewPage")

    # Paso 1: Crear un objeto Merger con el documento
    with gm.Merger(constants.sample_doc) as merger:
        print(f"Información del documento recuperada con éxito")
        
        # Paso 2: Definir opciones de unión Word para el modo continuo
        word_join_options = gm.domain.options.WordJoinOptions()
        word_join_options.mode = gm.domain.options.WordJoinMode.CONTINUOUS
        
        # Paso 3: Unir documentos sin insertar nueva página
        merger.join(constants.sample_doc, word_join_options)
        
        # Paso 4: Guardar el documento combinado
        merger.save(constants.output_doc_without_starting_from_new_page)
        print(f"Combinar a: {constants.output_doc_without_starting_from_new_page}")
    
    print(f"----------------------------------------------------------------------------")

Combinar múltiples documentos con opciones de unión personalizadas

Aquí te mostramos cómo combinar documentos DOCX mientras estableces opciones de unión específicas, como el cumplimiento de un estándar ISO específico.

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Ejemplo de uso avanzado] # Combinar con Opciones de Unión Personalizadas")

    # Paso 1: Crear un objeto Merger con el documento base
    with gm.Merger(constants.sample_docx) as merger:
        print(f"Información del documento recuperada con éxito")
        
        # Paso 2: Establecer opciones de unión personalizadas para el modo de cumplimiento predefinido
        word_join_options = gm.domain.options.WordJoinOptions()
        word_join_options.compliance = gm.domain.options.WordJoinCompliance.ISO_29500_2008_STRICT
        
        # Paso 3: Unir otro documento con configuraciones de cumplimiento
        merger.join(constants.sample_docx, word_join_options)
        
        # Paso 4: Guardar el documento combinado
        merger.save(constants.output_docx_with_predefined_compliance_mode)
        print(f"Combinar a: {constants.output_docx_with_predefined_compliance_mode}")
    
    print(f"----------------------------------------------------------------------------")

Ver también

Para explorar más sobre GroupDocs.Merger y sus funcionalidades, puedes consultar los siguientes recursos:

Prueba gratuita y licencia temporal

Puedes descargar una prueba gratuita de GroupDocs.Merger desde nuestra página de lanzamientos. Además, puedes adquirir una licencia temporal para fines de evaluación en Purchase Temporary License. Esta licencia temporal te permite probar la biblioteca sin limitaciones y evaluar completamente sus capacidades.