Praca z PDF w Pythonie może oznaczać kilka zupełnie różnych zadań: łączenie plików, dzielenie dokumentów, wyciąganie tekstu, generowanie raportów, konwersję HTML do PDF, dodawanie metadanych albo analizę układu stron. Dlatego nie istnieje jedna najlepsza biblioteka do PDF. Najlepszy wybór zależy od tego, co dokładnie chcesz zrobić.

Do prostego łączenia i dzielenia dokumentów dobrze sprawdzi się pypdf. Do ekstrakcji tekstu z bardziej złożonych plików lepszy będzie pdfminer.six. Do generowania PDF od zera warto użyć reportlab, a do tworzenia PDF z HTML i CSS — WeasyPrint. Jeśli zależy Ci na wydajności, renderowaniu stron i bardziej zaawansowanej manipulacji dokumentami, warto poznać PyMuPDF.

W tym artykule znajdziesz praktyczny przegląd bibliotek PDF w Pythonie, ich zastosowania, ograniczenia i przykłady kodu.

Jak wybrać bibliotekę do PDF w Pythonie?

Najprościej zacząć od pytania: co chcesz zrobić z plikiem PDF?

Jeśli chcesz połączyć kilka dokumentów w jeden, wybierz pypdf. Jeśli chcesz wyciągnąć tekst z dokumentu, zacznij od pypdf, a przy trudniejszych plikach użyj pdfminer.six. Jeśli tworzysz fakturę, raport albo dokument od podstaw, wybierz reportlab. Jeśli masz gotowy HTML i chcesz zamienić go na PDF, użyj WeasyPrint. Jeśli potrzebujesz wysokiej wydajności, pracy ze stronami jako obrazami albo dokładniejszej kontroli nad dokumentem, sprawdź PyMuPDF.

Warto pamiętać, że PDF nie jest zwykłym formatem tekstowym. To format opisu strony. Dlatego ekstrakcja tekstu, tabel i układu bywa trudniejsza niż w plikach DOCX, HTML czy TXT.

pypdf - łączenie, dzielenie i manipulacja PDF

pypdf to jedna z najczęściej wybieranych bibliotek do podstawowej pracy z dokumentami PDF. Jest dobrym wyborem, gdy chcesz łączyć pliki, dzielić dokumenty, obracać strony, odczytywać metadane, dodawać zakładki albo wyciągać tekst z prostych PDF-ów.

Instalacja:

Bash
Kopiuj
1
pip install pypdf

Przykład: odczyt liczby stron i metadanych PDF.

Python
Kopiuj
1
2
3
4
5
6
from pypdf import PdfReader

reader = PdfReader("dokument.pdf")

print(f"Liczba stron: {len(reader.pages)}")
print(f"Metadane: {reader.metadata}")

Przykład: łączenie wielu PDF w jeden plik.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from pypdf import PdfMerger

def merge_pdfs(pdf_files: list[str], output_file: str):
    merger = PdfMerger()

    for pdf_file in pdf_files:
        merger.append(pdf_file)

    merger.write(output_file)
    merger.close()

    print(f"Utworzono plik: {output_file}")

merge_pdfs(
    ["01_wstep.pdf", "02_raport.pdf", "03_zalaczniki.pdf"],
    "polaczony.pdf"
)

Największe zalety pypdf:

• prosty interfejs,
• dobre wsparcie dla łączenia i dzielenia dokumentów,
• możliwość pracy z metadanymi,
• obsługa zakładek i stron,
• brak ciężkich zależności.

Ograniczenia:

• ekstrakcja tekstu bywa podstawowa,
• nie zawsze dobrze radzi sobie ze skomplikowanym layoutem,
• nie jest narzędziem do tworzenia zaawansowanych raportów od zera.

pypdf wybierz wtedy, gdy chcesz szybko wykonać operacje na istniejących dokumentach PDF.

pdfminer.six - ekstrakcja tekstu z PDF

pdfminer.six to biblioteka nastawiona na odczyt i analizę tekstu z PDF. Sprawdza się lepiej niż pypdf, gdy dokument ma bardziej skomplikowany układ, wiele kolumn, nietypowe odstępy albo wymaga dokładniejszej kontroli nad layoutem.

Instalacja:

Bash
Kopiuj
1
pip install pdfminer.six

Prosty przykład ekstrakcji tekstu:

Python
Kopiuj
1
2
3
4
5
6
from pdfminer.high_level import extract_text

text = extract_text("dokument.pdf")

with open("tekst.txt", "w", encoding="utf-8") as file:
    file.write(text)

Przykład z konfiguracją parametrów układu:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from pdfminer.high_level import extract_text
from pdfminer.layout import LAParams

def extract_pdf_text(input_pdf: str, output_txt: str):
    text = extract_text(
        input_pdf,
        laparams=LAParams(
            line_margin=0.5,
            word_margin=0.1,
            char_margin=2.0
        )
    )

    with open(output_txt, "w", encoding="utf-8") as file:
        file.write(text)

extract_pdf_text("raport.pdf", "raport.txt")

Zalety pdfminer.six:

• dobra ekstrakcja tekstu,
• większa kontrola nad layoutem,
• przydatny przy analizie dokumentów,
• lepszy wybór do złożonych PDF-ów niż proste narzędzia.

Ograniczenia:

• służy głównie do odczytu, nie do zapisu,
• interfejs jest mniej intuicyjny niż w pypdf,
• nie odczyta tekstu ze skanu bez OCR.

pdfminer.six wybierz wtedy, gdy najważniejsze jest wyciągnięcie tekstu z PDF do dalszego przetwarzania.

reportlab - generowanie PDF od zera

reportlab służy do tworzenia dokumentów PDF od podstaw. To dobry wybór do raportów, faktur, certyfikatów, zestawień, dokumentów generowanych automatycznie i plików tworzonych na podstawie danych z aplikacji.

Instalacja:

Bash
Kopiuj
1
pip install reportlab

Prosty przykład wygenerowania PDF:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import A4

def create_simple_pdf(output_file: str):
    c = canvas.Canvas(output_file, pagesize=A4)

    c.drawString(50, 800, "Raport wygenerowany w Pythonie")
    c.drawString(50, 770, "To jest przykładowa treść dokumentu PDF.")

    c.save()

create_simple_pdf("raport.pdf")

Przykład tabeli w PDF:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from reportlab.lib.pagesizes import A4
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle
from reportlab.lib import colors

def create_table_pdf(output_file: str):
    data = [
        ["Produkt", "Ilość", "Cena"],
        ["Kurs Python", "1", "299 zł"],
        ["Konsultacja", "2", "500 zł"],
    ]

    doc = SimpleDocTemplate(output_file, pagesize=A4)
    table = Table(data)

    table.setStyle(TableStyle([
        ("BACKGROUND", (0, 0), (-1, 0), colors.grey),
        ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
        ("GRID", (0, 0), (-1, -1), 0.5, colors.black),
        ("PADDING", (0, 0), (-1, -1), 8),
    ]))

    doc.build([table])

create_table_pdf("tabela.pdf")

Zalety reportlab:

• pełna kontrola nad generowaniem PDF,
• obsługa tekstu, tabel, obrazów i grafiki,
• dobre narzędzie do raportów i faktur,
• możliwość tworzenia dokumentów z danych.

Ograniczenia:

• nie służy do odczytu PDF,
• wymaga więcej kodu niż HTML → PDF,
• przy bardziej rozbudowanych layoutach trzeba dobrze zaplanować strukturę dokumentu.

reportlab wybierz wtedy, gdy chcesz generować PDF programistycznie, bez pliku źródłowego HTML.

WeasyPrint - konwersja HTML i CSS do PDF

WeasyPrint pozwala zamienić HTML i CSS na PDF. To bardzo wygodne rozwiązanie, gdy chcesz tworzyć estetyczne raporty, faktury, oferty lub dokumenty na podstawie szablonów HTML.

Instalacja:

Bash
Kopiuj
1
pip install weasyprint

Przykład konwersji HTML do PDF:

Python
Kopiuj
1
2
3
4
5
6
from weasyprint import HTML

def html_to_pdf(input_html: str, output_pdf: str):
    HTML(filename=input_html).write_pdf(output_pdf)

html_to_pdf("raport.html", "raport.pdf")

Przykład generowania PDF z tekstu HTML:

Python
Kopiuj
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 weasyprint import HTML

html = """
<!doctype html>
<html lang="pl">
<head>
    <meta charset="utf-8">
    <style>
        body { font-family: Arial, sans-serif; }
        h1 { color: #222; }
        table { width: 100%; border-collapse: collapse; }
        td, th { border: 1px solid #ccc; padding: 8px; }
    </style>
</head>
<body>
    <h1>Raport miesięczny</h1>
    <p>Dokument wygenerowany automatycznie.</p>
    <table>
        <tr><th>Kategoria</th><th>Wynik</th></tr>
        <tr><td>Sprzedaż</td><td>125 000 zł</td></tr>
    </table>
</body>
</html>
"""

HTML(string=html).write_pdf("raport.pdf")

Zalety WeasyPrint:

• wygodne tworzenie PDF z HTML,
• obsługa CSS,
• dobre do szablonów dokumentów,
• łatwiejsze formatowanie niż w niskopoziomowym generowaniu PDF.

Ograniczenia:

• wymaga przygotowania HTML,
• nie służy do odczytu istniejących PDF-ów,
• JavaScript nie jest głównym mechanizmem renderowania,
• instalacja może wymagać zależności systemowych.

WeasyPrint wybierz wtedy, gdy dokument PDF ma wyglądać jak dobrze ostylowana strona HTML.

PyMuPDF - szybka i zaawansowana praca z PDF

PyMuPDF to wydajna biblioteka do pracy z PDF i innymi formatami dokumentów. Importuje się ją jako fitz. Dobrze sprawdza się przy renderowaniu stron do obrazów, analizie dokumentów, ekstrakcji tekstu, pracy ze współrzędnymi oraz bardziej zaawansowanej manipulacji.

Instalacja:

Bash
Kopiuj
1
pip install PyMuPDF

Przykład odczytu tekstu z PDF:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
import fitz

def extract_text_with_pymupdf(input_pdf: str):
    doc = fitz.open(input_pdf)

    for page_number, page in enumerate(doc, start=1):
        text = page.get_text()
        print(f"=== Strona {page_number} ===")
        print(text)

    doc.close()

extract_text_with_pymupdf("dokument.pdf")

Przykład renderowania strony PDF do obrazu:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
import fitz

def pdf_page_to_image(input_pdf: str, page_number: int, output_png: str):
    doc = fitz.open(input_pdf)
    page = doc[page_number]

    pix = page.get_pixmap(dpi=150)
    pix.save(output_png)

    doc.close()

pdf_page_to_image("dokument.pdf", 0, "strona_1.png")

Zalety PyMuPDF:

• wysoka wydajność,
• ekstrakcja tekstu,
• renderowanie stron do obrazów,
• dostęp do informacji o położeniu tekstu,
• szeroki zakres operacji na PDF.

Ograniczenia:

• import jako fitz bywa mylący dla początkujących,
• API jest inne niż w pypdf,
• do prostego łączenia PDF może być mniej intuicyjny niż pypdf.

PyMuPDF wybierz wtedy, gdy zależy Ci na szybkości, renderowaniu, analizie stron albo bardziej technicznej pracy z dokumentami.

Porównanie bibliotek PDF w Pythonie

Typowe scenariusze i najlepsze biblioteki

Łączenie wielu plików PDF

Najlepszy wybór: pypdf.

Python
Kopiuj
1
from pypdf import PdfMerger

Użyj, gdy chcesz połączyć raporty, faktury, umowy albo skany w jeden dokument.

Dzielenie PDF na strony

Najlepszy wybór: pypdf.

Python
Kopiuj
1
from pypdf import PdfReader, PdfWriter

Użyj, gdy chcesz zapisać każdą stronę jako osobny plik albo wyciąć konkretny zakres stron.

Ekstrakcja tekstu z PDF

Najlepszy wybór: pdfminer.six albo PyMuPDF.

Python
Kopiuj
1
from pdfminer.high_level import extract_text

Użyj, gdy chcesz analizować treść dokumentów, indeksować pliki albo przygotować tekst do dalszego przetwarzania.

Generowanie faktur i raportów

Najlepszy wybór: reportlab albo WeasyPrint.

Python
Kopiuj
1
from reportlab.pdfgen import canvas

Jeśli dokument jest prosty i generowany w pełni z kodu, wybierz reportlab. Jeśli ma korzystać z HTML i CSS, wybierz WeasyPrint.

Renderowanie PDF do obrazu

Najlepszy wybór: PyMuPDF.

Python
Kopiuj
1
import fitz

Użyj, gdy chcesz utworzyć miniatury stron, podgląd dokumentu albo zamienić stronę PDF na PNG.

Łączenie kilku bibliotek w jednym procesie

W większych automatyzacjach często używa się kilku bibliotek jednocześnie. Przykład: wyciągasz tekst z PDF, przetwarzasz go, tworzysz nowy raport i łączysz go z załącznikami.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from pdfminer.high_level import extract_text
from reportlab.pdfgen import canvas
from pypdf import PdfMerger

# 1. Ekstrakcja tekstu
text = extract_text("dokument.pdf")

# 2. Proste przetwarzanie
processed_text = text[:500].replace("\n", " ")

# 3. Generowanie nowego PDF
c = canvas.Canvas("podsumowanie.pdf")
c.drawString(50, 800, "Podsumowanie dokumentu")
c.drawString(50, 770, processed_text[:100])
c.save()

# 4. Łączenie z innym dokumentem
merger = PdfMerger()
merger.append("podsumowanie.pdf")
merger.append("dokument.pdf")
merger.write("wynik.pdf")
merger.close()

To praktyczny schemat dla automatyzacji dokumentów: odczyt, przetwarzanie, generowanie i scalanie.

Instalacja zestawu narzędzi PDF

Jeśli chcesz przetestować wszystkie opisane biblioteki, możesz zainstalować je jedną komendą:

Bash
Kopiuj
1
pip install pypdf pdfminer.six reportlab weasyprint PyMuPDF

W projekcie produkcyjnym lepiej instalować tylko te pakiety, których naprawdę używasz. Dzięki temu środowisko będzie lżejsze, łatwiejsze do utrzymania i mniej podatne na konflikty zależności.

Dobre praktyki przy pracy z PDF w Pythonie

Praca z PDF bywa nieprzewidywalna, dlatego warto od początku stosować kilka zasad:

• sprawdzaj, czy plik istnieje przed przetwarzaniem,
• testuj kod na kilku różnych dokumentach,
• rozróżniaj PDF tekstowy od skanu,
• do skanów używaj OCR,
• zapisuj pliki wynikowe w osobnym katalogu,
• nie nadpisuj oryginałów bez kopii zapasowej,
• obsługuj wyjątki przy uszkodzonych PDF-ach,
• dobieraj bibliotekę do zadania, nie odwrotnie,
• loguj liczbę przetworzonych stron i plików,
• przy większych procesach dziel kod na małe funkcje.

Dzięki temu automatyzacja PDF będzie bardziej stabilna i łatwiejsza do rozbudowy.

Podsumowanie

Wybór biblioteki do PDF w Pythonie zależy od zadania. pypdf jest najlepszym punktem startu do łączenia, dzielenia i prostych operacji na dokumentach. pdfminer.six sprawdzi się przy ekstrakcji tekstu. reportlab pozwoli generować PDF od zera. WeasyPrint ułatwi tworzenie estetycznych dokumentów z HTML i CSS. PyMuPDF będzie dobrym wyborem przy wydajności, renderowaniu i bardziej zaawansowanej analizie.

Najlepsza praktyka jest prosta: nie wybieraj biblioteki „na zapas”. Zacznij od konkretnego problemu. Jeśli chcesz scalić dokumenty, użyj pypdf. Jeśli tworzysz raport, użyj reportlab albo WeasyPrint. Jeśli analizujesz treść PDF, sprawdź pdfminer.six lub PyMuPDF.

Jeśli dopiero zaczynasz automatyzację PDF w Pythonie, zbuduj prosty proces: połącz kilka dokumentów przez pypdf, wyciągnij tekst przez pdfminer.six, a potem wygeneruj krótki raport przez reportlab. To dobry fundament pod bardziej zaawansowane narzędzia do pracy z dokumentami.

➡️ Następny artykuł

Po opanowaniu pracy z PDF przejdź do automatyzacji arkuszy kalkulacyjnych:

Automatyzacja Excela w Pythonie: odczyt, zapis, walidacja danych — kompleksowy przewodnik po pracy z Excel w Pythonie, od podstawowych operacji po generowanie zaawansowanych raportów.