Konwersja plików do PDF i z PDF w Pythonie to jedna z najczęstszych automatyzacji przy pracy z dokumentami. Możesz generować PDF z tekstu, tworzyć raporty z CSV, łączyć obrazy w jeden dokument, konwertować HTML do PDF albo wyciągać tekst z istniejących plików PDF do dalszego przetwarzania.

Python ma do tego kilka sprawdzonych bibliotek. reportlab pozwala generować PDF od podstaw, pypdf i pdfminer.six pomagają wyciągać tekst z dokumentów, Pillow obsługuje obrazy, a WeasyPrint dobrze sprawdza się przy konwersji HTML do PDF. Dzięki temu możesz zautomatyzować procesy, które normalnie wymagałyby ręcznego eksportu, kopiowania danych albo używania zewnętrznych narzędzi.

W tym artykule znajdziesz praktyczne przykłady: TXT → PDF, CSV → PDF, IMG → PDF, PDF → TXT, HTML → PDF oraz batch processing wielu plików naraz.

Kiedy warto automatyzować konwersję PDF w Pythonie?

Automatyzacja PDF przydaje się wszędzie tam, gdzie dokumenty są tworzone lub przetwarzane regularnie. Zamiast ręcznie generować pliki, możesz przygotować skrypt, który zrobi to za Ciebie według powtarzalnych zasad.

Najczęstsze zastosowania to:

• generowanie raportów PDF z danych tekstowych,
• tworzenie zestawień PDF z plików CSV,
• łączenie skanów lub zdjęć w jeden dokument PDF,
• wyciąganie tekstu z PDF do analizy,
• konwersja HTML do PDF, np. faktur lub raportów,
• masowe przetwarzanie wielu dokumentów,
• archiwizacja dokumentów w jednym formacie,
• przygotowanie plików do wysyłki mailowej.

Warto pamiętać, że PDF może mieć różną strukturę. Inaczej przetwarza się dokument z prawdziwym tekstem, a inaczej skan, który jest tylko obrazem zapisanym w PDF. Do zwykłego PDF wystarczy ekstrakcja tekstu. Do skanów potrzebne będzie OCR.

Instalacja bibliotek do pracy z PDF

Do przykładów z tego artykułu przydadzą się następujące pakiety:

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

W zależności od systemu WeasyPrint może wymagać dodatkowych zależności systemowych. Jeśli chcesz zacząć od najprostszych przykładów, wystarczą reportlab, pypdf i Pillow.

Generowanie PDF z tekstu, czyli TXT → PDF

Najprostszy przypadek to konwersja pliku tekstowego do PDF. Można ją wykonać za pomocą biblioteki reportlab.

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
27
28
29
30
31
32
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
from pathlib import Path

def txt_to_pdf(input_txt: str, output_pdf: str):
    """Konwertuje plik TXT do PDF."""
    input_path = Path(input_txt)

    if not input_path.exists():
        raise FileNotFoundError(f"Nie znaleziono pliku: {input_txt}")

    c = canvas.Canvas(output_pdf, pagesize=letter)
    width, height = letter

    with open(input_path, "r", encoding="utf-8") as file:
        text = file.read()

    lines = text.split("\n")
    y = height - 50

    for line in lines:
        if y < 50:
            c.showPage()
            y = height - 50

        c.drawString(50, y, line[:100])
        y -= 15

    c.save()
    print(f"Konwertowano {input_txt} do {output_pdf}")

txt_to_pdf("dokument.txt", "dokument.pdf")

Ten przykład działa dobrze dla prostych plików tekstowych. Jeśli tekst jest długi albo zawiera polskie znaki, niestandardowe fonty i formatowanie, warto rozbudować funkcję o zawijanie linii oraz rejestrację fontu obsługującego Unicode.

Lepsze generowanie PDF z zawijaniem tekstu

Przy dłuższych dokumentach zwykłe drawString może ucinać tekst. Lepszym rozwiązaniem jest użycie Paragraph z modułu platypus.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from reportlab.lib.pagesizes import A4
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
from reportlab.lib.styles import getSampleStyleSheet
from pathlib import Path

def txt_to_pdf_with_paragraphs(input_txt: str, output_pdf: str):
    """Konwertuje TXT do PDF z automatycznym zawijaniem tekstu."""
    text = Path(input_txt).read_text(encoding="utf-8")

    doc = SimpleDocTemplate(output_pdf, pagesize=A4)
    styles = getSampleStyleSheet()
    elements = []

    for paragraph in text.split("\n\n"):
        elements.append(Paragraph(paragraph.replace("\n", "<br/>"), styles["BodyText"]))
        elements.append(Spacer(1, 12))

    doc.build(elements)
    print(f"Utworzono PDF: {output_pdf}")

txt_to_pdf_with_paragraphs("dokument.txt", "dokument.pdf")

To lepszy wzorzec dla dokumentów, które mają wyglądać bardziej profesjonalnie.

Generowanie PDF z CSV, czyli CSV → PDF

Pliki CSV często zawierają dane raportowe: zamówienia, listy klientów, wyniki analiz albo eksporty z systemów. Python może automatycznie zamienić taki plik na tabelę 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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import csv
from pathlib import Path
from reportlab.lib.pagesizes import letter
from reportlab.lib import colors
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle

def csv_to_pdf(input_csv: str, output_pdf: str):
    """Konwertuje plik CSV do PDF z tabelą."""
    input_path = Path(input_csv)

    if not input_path.exists():
        raise FileNotFoundError(f"Nie znaleziono pliku: {input_csv}")

    doc = SimpleDocTemplate(output_pdf, pagesize=letter)
    elements = []

    data = []
    with open(input_path, "r", encoding="utf-8") as file:
        reader = csv.reader(file)
        for row in reader:
            data.append(row)

    if not data:
        raise ValueError("Plik CSV jest pusty.")

    table = Table(data)

    table.setStyle(TableStyle([
        ("BACKGROUND", (0, 0), (-1, 0), colors.grey),
        ("TEXTCOLOR", (0, 0), (-1, 0), colors.whitesmoke),
        ("ALIGN", (0, 0), (-1, -1), "CENTER"),
        ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
        ("FONTSIZE", (0, 0), (-1, 0), 11),
        ("BOTTOMPADDING", (0, 0), (-1, 0), 10),
        ("BACKGROUND", (0, 1), (-1, -1), colors.beige),
        ("GRID", (0, 0), (-1, -1), 0.5, colors.black),
    ]))

    elements.append(table)
    doc.build(elements)

    print(f"Konwertowano {input_csv} do {output_pdf}")

csv_to_pdf("dane.csv", "raport.pdf")

To dobre rozwiązanie dla krótkich tabel. Jeśli CSV ma wiele kolumn, warto rozważyć orientację poziomą strony, mniejszy font albo generowanie raportu HTML i dopiero później konwersję HTML do PDF.

Konwersja obrazów do PDF, czyli IMG → PDF

Python pozwala też połączyć wiele obrazów w jeden plik PDF. To przydatne przy skanach, zdjęciach dokumentów, potwierdzeniach, fakturach albo materiałach graficznych.

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
from PIL import Image
from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import A4
from pathlib import Path

def images_to_pdf(image_files: list[str], output_pdf: str):
    """Konwertuje wiele obrazów do jednego pliku PDF."""
    if not image_files:
        raise ValueError("Lista obrazów jest pusta.")

    c = canvas.Canvas(output_pdf, pagesize=A4)
    page_width, page_height = A4

    for image_file in image_files:
        image_path = Path(image_file)

        if not image_path.exists():
            print(f"Pominięto brakujący plik: {image_file}")
            continue

        with Image.open(image_path) as img:
            img_width, img_height = img.size

        ratio = min(page_width / img_width, page_height / img_height) * 0.9
        new_width = img_width * ratio
        new_height = img_height * ratio

        x = (page_width - new_width) / 2
        y = (page_height - new_height) / 2

        c.drawImage(str(image_path), x, y, width=new_width, height=new_height)
        c.showPage()

    c.save()
    print(f"Utworzono PDF z obrazów: {output_pdf}")

images_to_pdf(
    ["obraz1.png", "obraz2.jpg", "obraz3.png"],
    "obrazy.pdf"
)

Każdy obraz trafia na osobną stronę PDF. Jeśli chcesz umieścić kilka obrazów na jednej stronie, trzeba przygotować osobny układ współrzędnych.

Ekstrakcja tekstu z PDF, czyli PDF → TXT

Jeśli PDF zawiera tekst, można go wyciągnąć za pomocą biblioteki pypdf.

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 pathlib import Path
from pypdf import PdfReader

def pdf_to_txt(input_pdf: str, output_txt: str):
    """Ekstrahuje tekst z pliku PDF do TXT."""
    input_path = Path(input_pdf)

    if not input_path.exists():
        raise FileNotFoundError(f"Nie znaleziono pliku: {input_pdf}")

    reader = PdfReader(str(input_path))
    text_content = []

    for page_number, page in enumerate(reader.pages, start=1):
        text = page.extract_text() or ""
        text_content.append(f"=== Strona {page_number} ===\n{text}\n")

    Path(output_txt).write_text("\n".join(text_content), encoding="utf-8")

    print(f"Ekstrahowano tekst z {input_pdf} do {output_txt}")

pdf_to_txt("dokument.pdf", "dokument.txt")

Ten sposób jest prosty i szybki, ale nie zawsze idealnie zachowuje układ dokumentu. PDF nie jest formatem zaprojektowanym do łatwego odtwarzania struktury tekstu, dlatego wynik ekstrakcji może wymagać czyszczenia.

Zaawansowana ekstrakcja tekstu z pdfminer.six

W bardziej złożonych dokumentach lepiej sprawdza się pdfminer.six, który daje większą kontrolę nad analizą układu tekstu.

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

def advanced_pdf_to_txt(input_pdf: str, output_txt: str):
    """Zaawansowana ekstrakcja tekstu z PDF."""
    text = extract_text(
        input_pdf,
        laparams=LAParams(
            line_margin=0.5,
            word_margin=0.1,
            char_margin=2.0
        )
    )

    Path(output_txt).write_text(text, encoding="utf-8")

    print(f"Ekstrahowano tekst z {input_pdf} do {output_txt}")

advanced_pdf_to_txt("zlozony_dokument.pdf", "tekst.txt")

pdfminer.six jest dobrym wyborem, gdy zależy Ci na dokładniejszym odczycie tekstu. Nadal jednak nie rozwiązuje problemu skanów. Jeśli PDF zawiera tylko obrazy stron, potrzebujesz OCR, np. z użyciem Tesseract.

Batch konwersja wielu PDF do TXT

W automatyzacji dokumentów często trzeba przetworzyć nie jeden plik, ale cały katalog. Możesz przygotować funkcję, która znajdzie wszystkie PDF-y i zapisze dla każdego osobny plik TXT.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from pathlib import Path

def batch_pdf_to_txt(directory: str, output_dir: str | None = None):
    """Konwertuje wszystkie PDF-y w katalogu do plików TXT."""
    pdf_dir = Path(directory)

    if not pdf_dir.exists():
        raise FileNotFoundError(f"Nie znaleziono katalogu: {directory}")

    out_dir = Path(output_dir) if output_dir else pdf_dir
    out_dir.mkdir(parents=True, exist_ok=True)

    pdf_files = list(pdf_dir.glob("*.pdf"))

    for pdf_file in pdf_files:
        output_file = out_dir / f"{pdf_file.stem}.txt"
        pdf_to_txt(str(pdf_file), str(output_file))

    print(f"Przetworzono {len(pdf_files)} plików PDF")

batch_pdf_to_txt("./dokumenty/", "./teksty/")

To dobry wzorzec do automatycznej archiwizacji, indeksowania dokumentów lub przygotowania danych do dalszej analizy tekstu.

Konwersja HTML do PDF

Jeśli chcesz tworzyć ładne raporty, faktury albo dokumenty z tabelami i stylami CSS, często wygodniej przygotować HTML, a następnie zamienić go na PDF.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from weasyprint import HTML
from pathlib import Path

def html_to_pdf(input_html: str, output_pdf: str):
    """Konwertuje plik HTML do PDF."""
    input_path = Path(input_html)

    if not input_path.exists():
        raise FileNotFoundError(f"Nie znaleziono pliku: {input_html}")

    HTML(filename=str(input_path)).write_pdf(output_pdf)

    print(f"Konwertowano {input_html} do {output_pdf}")

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

Przykładowy plik HTML może zawierać nagłówki, tabele, style CSS, logo i stopkę. Dzięki temu raport PDF wygląda znacznie lepiej niż dokument generowany ręcznie linia po linii.

Przykład prostego raportu HTML → 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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
from pathlib import Path
from weasyprint import HTML

def create_report_pdf(output_pdf: str):
    html = """
    <!doctype html>
    <html lang="pl">
    <head>
        <meta charset="utf-8">
        <style>
            body { font-family: Arial, sans-serif; }
            h1 { font-size: 24px; }
            table { width: 100%; border-collapse: collapse; }
            th, td { border: 1px solid #cccccc; padding: 8px; }
            th { background: #eeeeee; }
        </style>
    </head>
    <body>
        <h1>Raport miesięczny</h1>
        <p>Automatycznie wygenerowany raport PDF.</p>

        <table>
            <tr>
                <th>Kategoria</th>
                <th>Wynik</th>
            </tr>
            <tr>
                <td>Sprzedaż</td>
                <td>125 000 zł</td>
            </tr>
            <tr>
                <td>Liczba zamówień</td>
                <td>430</td>
            </tr>
        </table>
    </body>
    </html>
    """

    html_file = Path("raport.html")
    html_file.write_text(html, encoding="utf-8")

    HTML(filename=str(html_file)).write_pdf(output_pdf)
    print(f"Utworzono raport: {output_pdf}")

create_report_pdf("raport.pdf")

To praktyczny sposób tworzenia dokumentów PDF, jeśli zależy Ci na kontroli wyglądu i łatwym formatowaniu.

Dobre praktyki przy konwersji PDF w Pythonie

Przy automatyzacji PDF warto pamiętać o kilku zasadach:

• sprawdzaj, czy plik wejściowy istnieje,
• obsługuj błędy odczytu i zapisu,
• używaj pathlib do pracy ze ścieżkami,
• testuj konwersję na różnych typach dokumentów,
• zapisuj pliki wynikowe do osobnego katalogu,
• nie nadpisuj ważnych dokumentów bez kopii zapasowej,
• pamiętaj, że skany PDF wymagają OCR,
• przy dużych plikach przetwarzaj dokumenty partiami,
• loguj liczbę przetworzonych plików,
• dobierz bibliotekę do rodzaju konwersji.

Dzięki temu skrypty do konwersji PDF będą stabilniejsze i łatwiejsze do utrzymania.

Podsumowanie

Python oferuje praktyczne narzędzia do konwersji plików do PDF i z PDF. Za pomocą reportlab wygenerujesz PDF z tekstu lub CSV, z użyciem Pillow połączysz obrazy w jeden dokument, pypdf i pdfminer.six pomogą wyciągnąć tekst, a WeasyPrint pozwoli tworzyć estetyczne PDF-y z HTML.

Najlepsze efekty daje dobranie narzędzia do konkretnego zadania. Prosty tekst możesz zapisać przez reportlab, raporty warto tworzyć przez HTML i CSS, a masową ekstrakcję tekstu z PDF najlepiej uruchamiać jako batch processing.

Jeśli chcesz zacząć praktycznie, wybierz jeden powtarzalny proces: np. konwersję raportów CSV do PDF albo wyciąganie tekstu z folderu dokumentów. Zautomatyzuj go najpierw dla jednego pliku, a potem rozbuduj skrypt o przetwarzanie całego katalogu.

➡️ Następny artykuł

Po opanowaniu konwersji plików naucz się tworzyć profesjonalne spisy treści w PDF:

Tworzenie spisu treści i łączenie rozdziałów w PDF — dodawanie zakładek, hierarchicznych struktur nawigacyjnych i automatyczne generowanie spisów treści w dużych dokumentach.