Przegląd

Scalanie dokumentów Word to powszechna potrzeba w wielu aplikacjach, niezależnie od tego, czy chodzi o łączenie raportów, konsolidowanie informacji czy po prostu uproszczenie zarządzania dokumentami. W tym artykule omówimy, jak scalać pliki DOCX przy użyciu Pythona z biblioteką GroupDocs.Merger. Ta potężna biblioteka umożliwia programistom łatwe manipulowanie dokumentami Word programowo, zapewniając jednocześnie wysoką wydajność i dokładność.

Niniejszy przewodnik obejmie:

Jak scalać wiele plików DOCX

Scalanie wielu plików DOCX jest proste z biblioteką GroupDocs.Merger. Poniżej przedstawiamy kluczowe kroki związane z tym procesem:

  1. Zaimportuj pakiet GroupDocs.Merger: Rozpocznij od zaimportowania wymaganej biblioteki.
  2. Utwórz instancję Merger: Zainicjuj klasę Merger, używając ścieżki do pierwszego pliku DOCX.
  3. Połącz dodatkowe dokumenty: Użyj metody join, aby dodać inne pliki DOCX, które chcesz scalać.
  4. Zapisz scalony dokument: Na koniec wywołaj metodę save, aby zapisać scalony dokument do określonej ścieżki wyjścia.

Oto fragment kodu w Pythonie ilustrujący te kroki:

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Przykład podstawowego użycia] # Operacje na wielu dokumentach # Scalanie : Docx")

    # Krok 1: Stwórz obiekt Merger z pierwszym dokumentem
    with gm.Merger(constants.sample_docx) as merger:
        print(f"Informacje o dokumencie odzyskane pomyślnie")
        
        # Krok 2: Połącz kolejny plik DOCX do scalania
        merger.join(constants.sample_docx)
        
        # Krok 3: Zapisz scalony dokument
        merger.save(constants.output_docx)
        print(f"Scalono do: {constants.output_docx}")
    
    print(f"----------------------------------------------------------------------------")

Scalanie dokumentów DOCX bez przerw sekcyjnych

Czasami scalanie dokumentów wymaga, aby treści były łączone bez wstawiania przerw sekcyjnych. Może to pomóc w utrzymaniu ciągłości informacji w scalonych dokumentach.

  1. Utwórz instancję Merger: Tak jak wcześniej, zainicjuj klasę Merger.
  2. Ustaw opcje scalania: Zdefiniuj WordJoinOptions i ustaw mode na DISABLE_SECTION_BREAKS.
  3. Scalaj dokumenty: Dodaj dodatkowy dokument do scalania.
  4. Zapisz wynik: Zapisz ostateczny wynik do nowego pliku DOCX.

Oto, jak możesz to zrobić:

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Przykład podstawowego użycia] # Operacje na wielu dokumentach # Scalanie # Word : ScalanieDokumentówWordBezPrzerwSekcyjnych")

    # Krok 1: Stwórz obiekt Merger z dokumentem źródłowym
    with gm.Merger(constants.sample_doc) as merger:
        print(f"Informacje o dokumencie odzyskane pomyślnie")
        
        # Krok 2: Zdefiniuj opcje scalania Word, aby wyłączyć przerwy sekcyjne
        word_join_options = gm.domain.options.WordJoinOptions()
        word_join_options.mode = gm.domain.options.WordJoinMode.DISABLE_SECTION_BREAKS
        
        # Krok 3: Połącz dokument bez przerw sekcyjnych
        merger.join(constants.sample_doc, word_join_options)
        
        # Krok 4: Zapisz scalony dokument
        merger.save(constants.output_doc_without_section_breaks)
        print(f"Scalono do: {constants.output_doc_without_section_breaks}")
    
    print(f"----------------------------------------------------------------------------")

Scalanie dokumentów DOCX z predefiniowanymi trybami zgodności

W specyficznych przypadkach dokumenty mogą musieć spełniać określone standardy. GroupDocs.Merger pozwala na scalanie dokumentów z predefiniowanymi trybami zgodności, aby zapewnić, na przykład, że wynik spełnia standardy ISO.

  1. Utwórz instancję Merger: Zainicjuj klasę Merger za pomocą swojego dokumentu bazowego.
  2. Ustaw tryb zgodności: Stwórz obiekt WordJoinOptions i ustaw właściwość compliance.
  3. Scalaj dokumenty: Dodaj dodatkowy dokument za pomocą metody join.
  4. Zapisz ostateczny dokument: Zapisz go w wybranym miejscu.

Oto kod dla tej operacji:

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Przykład podstawowego użycia] # Operacje na wielu dokumentach # Scalanie # Word : ScalanieDokumentówWordZPredefiniowanymTrybemZgodności")

    # Krok 1: Stwórz obiekt Merger z dokumentem
    with gm.Merger(constants.sample_docx) as merger:
        print(f"Informacje o dokumencie odzyskane pomyślnie")
        
        # Krok 2: Zdefiniuj opcje scalania Word z predefiniowanym trybem zgodności
        word_join_options = gm.domain.options.WordJoinOptions()
        word_join_options.compliance = gm.domain.options.WordJoinCompliance.ISO_29500_2008_STRICT
        
        # Krok 3: Połącz kolejny dokument z trybem zgodności
        merger.join(constants.sample_docx, word_join_options)
        
        # Krok 4: Zapisz scalony dokument
        merger.save(constants.output_docx_with_predefined_compliance_mode)
        print(f"Scalono do: {constants.output_docx_with_predefined_compliance_mode}")
    
    print(f"----------------------------------------------------------------------------")

Jak scalać DOCX ze strumieni

Możesz również scalać pliki DOCX z pamięci strumieni, co może być przydatne, gdy masz do czynienia z dynamicznie generowanymi dokumentami.

  1. Uzyskaj strumień pliku: Otwórz dokument w trybie binarnym, aby uzyskać strumień.
  2. Utwórz instancję Merger: Zainicjuj klasę Merger, używając strumienia.
  3. Wykonaj operację scalania: Scalaj zgodnie z wymaganiami i zapisz wynik.

Oto jak można to zaimplementować:

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

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Przykład zaawansowanego użycia] # Ładowanie # ŁadowanieDokumentuZeStrumienia")

    # Krok 1: Uzyskaj strumień dokumentu
    stream = get_file_stream()
    
    # Krok 2: Stwórz instancję Merger używając strumienia
    with gm.Merger(stream) as merger:
        print(f"Dokument załadowany ze strumienia pomyślnie")
    
    print(f"----------------------------------------------------------------------------")

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

Zobacz także

Aby uzyskać więcej informacji, możesz zbadać następujące zasoby:

Możesz również pobrać darmową wersję próbną z releases.groupdocs.com oraz zakupić tymczasową licencję, aby wypróbować bibliotekę bez ograniczeń, pod Zakup tymczasowej licencji.

Przykłady kodu

Oto kilka dodatkowych przykładów, które pomogą Ci zrozumieć proces scalania z biblioteką GroupDocs.Merger dla Pythona:

Scalanie dokumentów Word bez zaczynania od nowej strony

Ten przykład pokazuje, jak scalać dokumenty, aby ostatnia strona pierwszego dokumentu była bezpośrednio zgodna z pierwszą stroną następnego dokumentu, bez wstawiania nowej strony pomiędzy.

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Przykład podstawowego użycia] # Operacje na wielu dokumentach # Scalanie # Word : ScalanieDokumentówWordBezZaczynaniaOdNowejStrony")

    # Krok 1: Stwórz obiekt Merger z dokumentem
    with gm.Merger(constants.sample_doc) as merger:
        print(f"Informacje o dokumencie odzyskane pomyślnie")
        
        # Krok 2: Zdefiniuj opcje scalania Word w trybie ciągłym
        word_join_options = gm.domain.options.WordJoinOptions()
        word_join_options.mode = gm.domain.options.WordJoinMode.CONTINUOUS
        
        # Krok 3: Połącz dokumenty bez wstawiania nowej strony
        merger.join(constants.sample_doc, word_join_options)
        
        # Krok 4: Zapisz scalony dokument
        merger.save(constants.output_doc_without_starting_from_new_page)
        print(f"Scalono do: {constants.output_doc_without_starting_from_new_page}")
    
    print(f"----------------------------------------------------------------------------")

Scalanie wielu dokumentów z niestandardowymi opcjami scalania

Oto jak scalać dokumenty DOCX, ustawiając konkretne opcje scalania, takie jak zgodność z określonym standardem ISO.

import groupdocs.merger as gm
import constants

def run():
    print(f"----------------------------------------------------------------------------")
    print(f"[Przykład zaawansowanego użycia] # Scalanie z niestandardowymi opcjami scalania")

    # Krok 1: Stwórz obiekt Merger z dokumentem bazowym
    with gm.Merger(constants.sample_docx) as merger:
        print(f"Informacje o dokumencie odzyskane pomyślnie")
        
        # Krok 2: Ustaw niestandardowe opcje scalania dla predefiniowanego trybu zgodności
        word_join_options = gm.domain.options.WordJoinOptions()
        word_join_options.compliance = gm.domain.options.WordJoinCompliance.ISO_29500_2008_STRICT
        
        # Krok 3: Połącz kolejny dokument z ustawieniami zgodności
        merger.join(constants.sample_docx, word_join_options)
        
        # Krok 4: Zapisz scalony dokument
        merger.save(constants.output_docx_with_predefined_compliance_mode)
        print(f"Scalono do: {constants.output_docx_with_predefined_compliance_mode}")
    
    print(f"----------------------------------------------------------------------------")

Zobacz także

Aby poznać więcej na temat GroupDocs.Merger i jego funkcjonalności, możesz sprawdzić następujące zasoby:

Wersja próbna i tymczasowa licencja

Możesz pobrać darmową wersję próbną GroupDocs.Merger z naszej strony wydania. Dodatkowo możesz uzyskać tymczasową licencję do celów oceny pod adresem Zakup tymczasowej licencji. Ta tymczasowa licencja pozwala na pełne wypróbowanie biblioteki bez żadnych ograniczeń.