Rozdzielanie i scalanie stron PDF – praktyczny poradnik

Rozdzielanie i scalanie stron PDF to zaawansowana technika automatyzacji dokumentów, która znacznie wykracza poza podstawowe łączenie plików. Dzięki niej możesz precyzyjnie wycinać zakresy stron, dzielić obszerne dokumenty na logiczne rozdziały oraz tworzyć nowe dokumenty z wybranych stron pochodzących z różnych źródeł. W Pythonie operacje te są niezwykle proste dzięki bibliotece pypdf, która oferuje pełną kontrolę nad każdą stroną dokumentu, umożliwiając tworzenie złożonych workflow'ów przetwarzania dokumentów bez użycia drogich narzędzi graficznych.

Obraz główny Rozdzielanie i scalanie stron PDF w Pythonie

Wycinanie zakresu stron

Często potrzebujesz wyciągnąć tylko wybrane strony z większego dokumentu — na przykład strony z konkretnymi rozdziałami lub sekcjami. Biblioteka pypdf umożliwia precyzyjne wycinanie pojedynczych stron lub ich grup, zachowując przy tym pełną jakość i formatowanie oryginału. Podstawowa operacja wycinania stron wygląda następująco:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from pypdf import PdfReader, PdfWriter

def extract_pages(input_pdf: str, output_pdf: str, pages: list[int]):
    """Wycina wybrane strony z dokumentu PDF."""
    reader = PdfReader(input_pdf)
    writer = PdfWriter()

    # Indeksy stron zaczynają się od 0
    for page_num in pages:
        if 0 <= page_num < len(reader.pages):
            writer.add_page(reader.pages[page_num])
        else:
            print(f"Ostrzeżenie: Strona {page_num + 1} nie istnieje (dokument ma {len(reader.pages)} stron)")

    with open(output_pdf, 'wb') as output_file:
        writer.write(output_file)
        print(f"Wycięto strony {pages} do pliku: {output_pdf}")

# Przykład: wycięcie stron 1, 3 i 5 (indeksy: 0, 2, 4)
extract_pages("dokument.pdf", "wyciete_strony.pdf", [0, 2, 4])

Wycinanie zakresu stron (od-do)

Wycinanie pojedynczych, rozproszonych stron jest przydatne, ale w praktyce znacznie częściej potrzebujesz wyciąć ciągły zakres stron — na przykład strony od 5 do 10 lub cały rozdział od strony 15 do 45. Takie podejście jest bardziej efektywne i czytelne w kodzie. Oto jak wyciąć zakres stron z dokumentu:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from pypdf import PdfReader, PdfWriter


def extract_page_range(input_pdf: str, output_pdf: str, start_page: int, end_page: int):
    """
    Wycina zakres stron z dokumentu PDF.

    start_page, end_page: numeracja od 1 (nie od 0!)
    """
    reader = PdfReader(input_pdf)
    writer = PdfWriter()

    start_idx = start_page - 1
    end_idx = end_page

    for i in range(start_idx, min(end_idx, len(reader.pages))):
        writer.add_page(reader.pages[i])

    with open(output_pdf, 'wb') as output_file:
        writer.write(output_file)

    print(f"Wycięto strony {start_page}-{min(end_page, len(reader.pages))} do: {output_pdf}")


extract_page_range("dokument.pdf", "strony_5_10.pdf", 5, 10)

Dzielenie dokumentu na rozdziały

Obszerne dokumenty — takie jak książki, raporty roczne czy kompleksowa dokumentacja — często muszą być podzielone na mniejsze, łatwiejsze w zarządzaniu pliki. Zamiast ręcznie wycinać każdy rozdział, możesz zautomatyzować ten proces, definiując granice rozdziałów w słowniku i pozwalając Pythonowi na automatyczne utworzenie osobnych plików. To szczególnie przydatne przy pracy z dokumentami o setkach stron:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
from pypdf import PdfReader, PdfWriter
from pathlib import Path


def split_pdf_by_chapters(input_pdf: str, chapters: dict):
    """
    Dzieli dokument PDF na rozdziały.

    chapters: dict w formacie {"nazwa_rozdzialu": (start_page, end_page)}
    """
    reader = PdfReader(input_pdf)
    base_name = Path(input_pdf).stem

    for chapter_name, (start, end) in chapters.items():
        writer = PdfWriter()

        start_idx = start - 1
        end_idx = min(end, len(reader.pages))

        for i in range(start_idx, end_idx):
            writer.add_page(reader.pages[i])

        output_file = f"{base_name}_{chapter_name}.pdf"
        with open(output_file, 'wb') as f:
            writer.write(f)

        print(f"Utworzono rozdział: {output_file} (strony {start}-{end_idx})")


split_pdf_by_chapters(
    "ksiazka.pdf",
    {
        "wstep": (1, 10),
        "rozdzial_1": (11, 50),
        "rozdzial_2": (51, 100),
        "zakonczenie": (101, 120)
    }
)

Dzielenie każdej strony na osobny plik

W niektórych scenariuszach potrzebujesz podzielić dokument na pojedyncze strony — na przykład podczas przygotowania materiałów do prezentacji, gdzie każda strona musi być osobnym plikiem, lub przy tworzeniu archiwum z możliwością łatwego dostępu do konkretnych stron. Automatyzacja tego procesu oszczędza ogromne ilości czasu, szczególnie przy dużych dokumentach:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from pypdf import PdfReader, PdfWriter
from pathlib import Path


def split_every_page(input_pdf: str, output_dir: str = None):
    """Dzieli dokument PDF na pojedyncze strony."""
    reader = PdfReader(input_pdf)
    base_name = Path(input_pdf).stem

    if output_dir:
        Path(output_dir).mkdir(parents=True, exist_ok=True)
        prefix = f"{output_dir}/{base_name}"
    else:
        prefix = base_name

    for i, page in enumerate(reader.pages, 1):
        writer = PdfWriter()
        writer.add_page(page)

        output_file = f"{prefix}_strona_{i:03d}.pdf"
        with open(output_file, 'wb') as f:
            writer.write(f)

    print(f"Podzielono {len(reader.pages)} stron na osobne pliki z prefiksem: {prefix}")


split_every_page("dokument.pdf", "strony")

Łączenie stron z różnych źródeł

Najbardziej zaawansowanym scenariuszem jest tworzenie nowego dokumentu z wybranych stron pochodzących z różnych źródeł. Możesz na przykład wybrać stronę tytułową z jednego dokumentu, wprowadzenie z drugiego, a rozdziały z kolejnych, tworząc spersonalizowany dokument dopasowany do konkretnych potrzeb. To wymaga elastycznego podejścia do wyboru stron:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
from pypdf import PdfReader, PdfWriter


def merge_pages_from_sources(sources: list[dict], output_pdf: str):
    """
    Łączy wybrane strony z różnych źródeł.

    sources: list[dict] gdzie każdy dict ma:
    {
        "file": "ścieżka_do_pliku.pdf",
        "pages": [1, 2, 3] lub (start, end) lub None (wszystkie strony)
    }
    """
    writer = PdfWriter()

    for source in sources:
        file_path = source["file"]
        pages = source.get("pages", None)

        reader = PdfReader(file_path)

        if pages is None:
            for page in reader.pages:
                writer.add_page(page)
        elif isinstance(pages, tuple):
            start, end = pages
            for i in range(start - 1, min(end, len(reader.pages))):
                writer.add_page(reader.pages[i])
        else:
            for page_num in pages:
                if 0 <= page_num - 1 < len(reader.pages):
                    writer.add_page(reader.pages[page_num - 1])

    with open(output_pdf, 'wb') as f:
        writer.write(f)

    print(f"Połączono strony z {len(sources)} źródeł do: {output_pdf}")


merge_pages_from_sources(
    [
        {"file": "dok1.pdf", "pages": [1, 2, 3]},
        {"file": "dok2.pdf", "pages": (1, 5)},
        {"file": "dok3.pdf", "pages": None}
    ],
    "polaczony_dokument.pdf"
)

Rotacja i manipulacja stronami

Oprócz wycinania i łączenia stron, biblioteka pypdf pozwala również na manipulację orientacją stron. Czasem dokumenty mają strony obrócone o 90, 180 lub 270 stopni, co może utrudniać czytanie. Możesz automatycznie korygować orientację podczas wycinania stron, zapewniając spójność w finalnym dokumencie:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from pypdf import PdfReader, PdfWriter


def extract_and_rotate(input_pdf: str, output_pdf: str, pages: list[int], rotation: int = 90):
    """
    Wycina strony i obraca je.

    rotation: 90, 180, lub 270 stopni
    """
    reader = PdfReader(input_pdf)
    writer = PdfWriter()

    for page_num in pages:
        if 0 <= page_num - 1 < len(reader.pages):
            page = reader.pages[page_num - 1]
            page.rotate(rotation)
            writer.add_page(page)

    with open(output_pdf, 'wb') as f:
        writer.write(f)

    print(f"Wycęto i obrócono strony {pages} o {rotation}° do: {output_pdf}")


extract_and_rotate("dokument.pdf", "obrocone.pdf", [1, 2, 3], rotation=90)

Podsumowanie

Operacje na stronach PDF w Pythonie pozwalają na:

Wycinanie konkretnych stron lub zakresów
Dzielenie dokumentów na rozdziały
Tworzenie osobnych plików z każdej strony
Łączenie stron z różnych źródeł
Rotację i manipulację stronami

Te techniki są niezbędne w zaawansowanej automatyzacji pracy z dokumentami PDF.

➡️ Następny artykuł

Po opanowaniu operacji na stronach PDF, naucz się konwertować pliki do i z formatu PDF:

Konwersja plików do PDF i z PDF w Pythonie — generowanie PDF z tekstu, obrazów i CSV oraz ekstrakcja tekstu z dokumentów PDF dla dalszego przetwarzania.

Rozwiązania

Wsparcie zespołu

Nauka

Wiedza

Rozdzielanie i scalanie stron PDF w Pythonie