Automatyzacja Excela w Pythonie pozwala czytać, przetwarzać, walidować i generować arkusze bez ręcznego klikania w interfejsie programu. To jedna z najbardziej praktycznych umiejętności, jeśli pracujesz z raportami, zestawieniami sprzedaży, eksportami z systemów, plikami CSV, analizą danych albo cyklicznym przygotowywaniem dokumentów dla zespołu lub klientów.

Excel nadal jest standardem w wielu firmach, ale ręczna praca z arkuszami szybko staje się powtarzalna i podatna na błędy. Python rozwiązuje ten problem. Za pomocą bibliotek pandas i openpyxl możesz automatycznie wczytywać dane, czyścić je, sprawdzać poprawność, łączyć wiele plików, dodawać formuły, formatować komórki i generować raporty z wykresami.

W tym artykule zobaczysz praktyczne przykłady automatyzacji Excela w Pythonie: od podstawowego odczytu danych, przez zapis do wielu arkuszy, po walidację, formatowanie, raporty i batch processing wielu plików.

Pandas czy openpyxl — czego używać do Excela?

Do pracy z Excelem w Pythonie najczęściej używa się dwóch bibliotek: pandas i openpyxl.

pandas najlepiej sprawdza się wtedy, gdy traktujesz arkusz jak tabelę danych. Chcesz szybko wczytać plik, przefiltrować kolumny, policzyć sumy, pogrupować dane albo zapisać wynik do nowego arkusza.

openpyxl jest lepszy, gdy potrzebujesz kontroli nad samym plikiem Excel: formatowaniem komórek, kolorami, formułami, szerokością kolumn, wykresami, nazwami arkuszy i stylem raportu.

Najprostsza zasada:

• użyj pandas, gdy najważniejsze są dane,
• użyj openpyxl, gdy najważniejszy jest wygląd i struktura arkusza,
• połącz obie biblioteki, gdy chcesz przetworzyć dane i stworzyć gotowy raport Excel.

Instalacja bibliotek

Do większości przykładów wystarczą pandas i openpyxl.

Bash
Kopiuj
1
pip install pandas openpyxl

Jeśli pracujesz także z wykresami, raportami lub plikami CSV, te biblioteki nadal będą dobrym punktem startu.

Podstawowy odczyt z Excela w pandas

Najprostszy sposób odczytu pliku Excel to pd.read_excel(). Funkcja wczytuje arkusz do obiektu DataFrame, czyli tabeli danych, którą możesz filtrować, sortować i analizować.

Python
Kopiuj
1
2
3
4
5
6
7
import pandas as pd

df = pd.read_excel("dane.xlsx")

print(df.head())
print(df.columns)
print(df.shape)

Odczyt konkretnego arkusza:

Python
Kopiuj
1
2
3
4
5
import pandas as pd

df = pd.read_excel("dane.xlsx", sheet_name="Sprzedaż")

print(df.head())

Odczyt wybranych kolumn i liczby wierszy:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
import pandas as pd

df = pd.read_excel(
    "dane.xlsx",
    sheet_name="Sprzedaż",
    usecols="A:D",
    nrows=100
)

print(df.head())

To dobre rozwiązanie, gdy potrzebujesz szybko wczytać dane z Excela i wykonać na nich analizę.

Odczyt wielu arkuszy z jednego pliku Excel

Często plik Excel zawiera kilka arkuszy, np. sprzedaż, koszty i magazyn. Możesz wczytać je osobno albo wszystkie naraz.

Python
Kopiuj
1
2
3
4
5
6
7
import pandas as pd

sheets = pd.read_excel("raport.xlsx", sheet_name=None)

for sheet_name, df in sheets.items():
    print(f"Arkusz: {sheet_name}")
    print(df.head())

Parametr sheet_name=None zwraca słownik, w którym kluczem jest nazwa arkusza, a wartością DataFrame z danymi.

Zaawansowany odczyt z openpyxl

Jeśli potrzebujesz dostępu do konkretnych komórek, formuł, stylów lub arkuszy, użyj openpyxl.

Python
Kopiuj
1
2
3
4
5
6
7
from openpyxl import load_workbook

wb = load_workbook("dane.xlsx")
ws = wb.active

wartosc_a1 = ws["A1"].value
print(wartosc_a1)

Odczyt zakresu komórek:

Python
Kopiuj
1
2
3
4
5
6
7
8
from openpyxl import load_workbook

wb = load_workbook("dane.xlsx")
ws = wb["Arkusz1"]

for row in ws["A1:C10"]:
    values = [cell.value for cell in row]
    print(values)

Odczyt całej kolumny:

Python
Kopiuj
1
2
3
4
5
6
7
8
from openpyxl import load_workbook

wb = load_workbook("dane.xlsx")
ws = wb.active

kolumna_a = [cell.value for cell in ws["A"]]

print(kolumna_a)

openpyxl przydaje się szczególnie wtedy, gdy plik Excel ma znaczenie nie tylko jako tabela, ale jako sformatowany dokument.

Zapisywanie danych do Excela z pandas

Najprostszy zapis danych do Excela wykonasz metodą to_excel().

Python
Kopiuj
1
2
3
4
5
6
7
8
9
import pandas as pd

df = pd.DataFrame({
    "Imię": ["Jan", "Anna", "Piotr"],
    "Wiek": [25, 30, 28],
    "Miasto": ["Warszawa", "Kraków", "Gdańsk"]
})

df.to_excel("wynik.xlsx", index=False)

Parametr index=False usuwa dodatkową kolumnę z indeksem DataFrame. W większości raportów biznesowych warto go używać.

Zapisywanie wielu arkuszy do jednego pliku

Jeśli chcesz stworzyć jeden plik Excel z kilkoma arkuszami, użyj ExcelWriter.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas as pd

sprzedaz = pd.DataFrame({
    "Miesiąc": ["Styczeń", "Luty", "Marzec"],
    "Wartość": [12000, 15000, 18000]
})

koszty = pd.DataFrame({
    "Miesiąc": ["Styczeń", "Luty", "Marzec"],
    "Koszt": [7000, 8000, 9500]
})

with pd.ExcelWriter("raport.xlsx", engine="openpyxl") as writer:
    sprzedaz.to_excel(writer, sheet_name="Sprzedaż", index=False)
    koszty.to_excel(writer, sheet_name="Koszty", index=False)

To wygodny sposób generowania raportów, które mają kilka sekcji tematycznych.

Formatowanie arkuszy z openpyxl

Same dane często nie wystarczą. Raport powinien być czytelny: mieć wyróżnione nagłówki, odpowiednie szerokości kolumn, formaty liczbowe i zamrożony pierwszy wiersz.

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 openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Alignment
from openpyxl.utils import get_column_letter

wb = Workbook()
ws = wb.active
ws.title = "Raport"

headers = ["Produkt", "Ilość", "Cena", "Wartość"]
rows = [
    ["Kurs Python", 3, 299.00, 897.00],
    ["Konsultacja", 2, 500.00, 1000.00],
    ["Audyt kodu", 1, 1200.00, 1200.00],
]

ws.append(headers)

for row in rows:
    ws.append(row)

header_font = Font(bold=True, color="FFFFFF")
header_fill = PatternFill(start_color="4472C4", end_color="4472C4", fill_type="solid")

for cell in ws[1]:
    cell.font = header_font
    cell.fill = header_fill
    cell.alignment = Alignment(horizontal="center")

for row in ws.iter_rows(min_row=2, min_col=3, max_col=4):
    for cell in row:
        cell.number_format = '#,##0.00 zł'

for column_cells in ws.columns:
    max_length = max(len(str(cell.value)) if cell.value is not None else 0 for cell in column_cells)
    column_letter = get_column_letter(column_cells[0].column)
    ws.column_dimensions[column_letter].width = max_length + 3

ws.freeze_panes = "A2"

wb.save("sformatowany_raport.xlsx")

Taki arkusz jest dużo wygodniejszy dla odbiorcy niż surowy eksport danych.

Walidacja danych w Excelu

Walidacja danych pozwala wykryć błędy przed dalszym przetwarzaniem. Możesz sprawdzać puste wartości, format dat, zakresy liczb, duplikaty i wymagane kolumny.

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
47
48
49
import pandas as pd

def validate_excel_data(file_path: str) -> list[str]:
    """Waliduje dane w pliku Excel."""
    df = pd.read_excel(file_path)
    errors = []

    required_columns = ["Imię", "Email", "Data", "Wiek"]

    missing_columns = [column for column in required_columns if column not in df.columns]
    if missing_columns:
        errors.append(f"Brak wymaganych kolumn: {missing_columns}")
        return errors

    empty_values = df[required_columns].isnull().any()
    if empty_values.any():
        columns_with_empty = empty_values[empty_values].index.tolist()
        errors.append(f"Puste wartości w kolumnach: {columns_with_empty}")

    if "Data" in df.columns:
        parsed_dates = pd.to_datetime(df["Data"], errors="coerce")
        if parsed_dates.isnull().any():
            errors.append("Nieprawidłowy format daty w kolumnie 'Data'")

    if "Wiek" in df.columns:
        invalid_age = df[(df["Wiek"] < 0) | (df["Wiek"] > 150)]
        if not invalid_age.empty:
            errors.append("Wiek poza akceptowalnym zakresem 0-150")

    if "Email" in df.columns:
        invalid_email = ~df["Email"].astype(str).str.contains("@", na=False)
        if invalid_email.any():
            errors.append(f"Nieprawidłowe adresy email: {invalid_email.sum()}")

    duplicates = df.duplicated()
    if duplicates.any():
        errors.append(f"Znaleziono duplikaty: {duplicates.sum()}")

    return errors


errors = validate_excel_data("dane.xlsx")

if errors:
    print("Błędy walidacji:")
    for error in errors:
        print(f"- {error}")
else:
    print("Dane są poprawne.")

Taki skrypt może działać przed importem danych do systemu, bazy danych albo raportu.

Automatyczne czyszczenie danych z Excela

Po walidacji często trzeba dane oczyścić: usunąć puste wiersze, poprawić nazwy kolumn, przyciąć spacje albo ujednolicić wielkość liter.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import pandas as pd

def clean_excel_data(input_file: str, output_file: str):
    df = pd.read_excel(input_file)

    df = df.dropna(how="all")
    df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")

    for column in df.select_dtypes(include="object").columns:
        df[column] = df[column].astype(str).str.strip()

    if "email" in df.columns:
        df["email"] = df["email"].str.lower()

    df = df.drop_duplicates()

    df.to_excel(output_file, index=False)

    print(f"Oczyszczone dane zapisano do: {output_file}")


clean_excel_data("dane_surowe.xlsx", "dane_czyste.xlsx")

To jeden z najczęstszych przypadków automatyzacji Excela: zamiana chaotycznego eksportu w uporządkowany plik do dalszej pracy.

Generowanie automatycznego raportu Excel

Możesz połączyć pandas i openpyxl, aby wczytać dane, przygotować podsumowanie i dodać wykres.

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
import pandas as pd
from openpyxl.chart import BarChart, Reference

def create_report(input_file: str, output_file: str):
    """Tworzy raport Excel z podsumowaniem i wykresem."""
    df = pd.read_excel(input_file)

    summary = (
        df.groupby("Kategoria")["Wartość"]
        .agg(["sum", "mean", "count"])
        .reset_index()
    )

    summary.columns = ["Kategoria", "Suma", "Średnia", "Liczba"]

    with pd.ExcelWriter(output_file, engine="openpyxl") as writer:
        df.to_excel(writer, sheet_name="Dane", index=False)
        summary.to_excel(writer, sheet_name="Podsumowanie", index=False)

        wb = writer.book
        ws = writer.sheets["Podsumowanie"]

        chart = BarChart()
        chart.type = "col"
        chart.title = "Suma wartości według kategorii"
        chart.y_axis.title = "Wartość"
        chart.x_axis.title = "Kategoria"

        data = Reference(ws, min_col=2, min_row=1, max_row=len(summary) + 1)
        categories = Reference(ws, min_col=1, min_row=2, max_row=len(summary) + 1)

        chart.add_data(data, titles_from_data=True)
        chart.set_categories(categories)

        ws.add_chart(chart, "F2")

    print(f"Raport zapisany do: {output_file}")


create_report("dane_wejsciowe.xlsx", "raport.xlsx")

Taki raport można generować codziennie, co tydzień albo po każdym imporcie nowych danych.

Przetwarzanie wielu plików Excel

W automatyzacji bardzo często trzeba połączyć wiele plików Excel w jeden. Przykład: każdy handlowiec wysyła własny raport, a Ty chcesz stworzyć jeden zbiorczy plik.

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
import pandas as pd
from pathlib import Path

def process_multiple_excel_files(directory: str, output_file: str):
    """Łączy wiele plików Excel w jeden plik."""
    excel_files = list(Path(directory).glob("*.xlsx"))

    if not excel_files:
        raise FileNotFoundError("Nie znaleziono plików Excel.")

    all_data = []

    for file in excel_files:
        print(f"Przetwarzanie: {file.name}")

        df = pd.read_excel(file)
        df["źródło"] = file.stem

        all_data.append(df)

    combined = pd.concat(all_data, ignore_index=True)
    combined.to_excel(output_file, index=False)

    print(f"Połączono {len(excel_files)} plików do: {output_file}")


process_multiple_excel_files("./dane/", "wszystkie_dane.xlsx")

Dodanie kolumny źródło pomaga później sprawdzić, z którego pliku pochodzi dany wiersz.

Dodawanie formuł do arkusza Excel

openpyxl pozwala wpisywać formuły do komórek tak samo, jak zrobiłbyś to ręcznie w Excelu.

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
from openpyxl import Workbook

wb = Workbook()
ws = wb.active
ws.title = "Sprzedaż"

ws["A1"] = "Produkt"
ws["B1"] = "Cena"
ws["C1"] = "Ilość"
ws["D1"] = "Wartość"

products = [
    ["Kurs Python", 299, 3],
    ["Konsultacja", 500, 2],
    ["Audyt", 1200, 1],
]

for row_number, row_data in enumerate(products, start=2):
    ws[f"A{row_number}"] = row_data[0]
    ws[f"B{row_number}"] = row_data[1]
    ws[f"C{row_number}"] = row_data[2]
    ws[f"D{row_number}"] = f"=B{row_number}*C{row_number}"

ws["C6"] = "Suma"
ws["D6"] = "=SUM(D2:D4)"

wb.save("raport_z_formulami.xlsx")

Po otwarciu pliku w Excelu formuły zostaną obliczone przez program.

Dodawanie walidacji danych w Excelu

Możesz też dodać reguły walidacji bezpośrednio do arkusza, np. listę dozwolonych wartości.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from openpyxl import Workbook
from openpyxl.worksheet.datavalidation import DataValidation

wb = Workbook()
ws = wb.active
ws.title = "Zamówienia"

ws["A1"] = "Status"
ws["B1"] = "Wartość"

status_validation = DataValidation(
    type="list",
    formula1='"Nowe,W realizacji,Zakończone,Anulowane"',
    allow_blank=False
)

ws.add_data_validation(status_validation)
status_validation.add("A2:A100")

wb.save("zamowienia_z_walidacja.xlsx")

Taka walidacja pomaga ograniczyć błędy przy ręcznym uzupełnianiu pliku przez użytkowników.

Dobre praktyki automatyzacji Excela w Pythonie

Przy pracy z arkuszami warto trzymać się kilku zasad:

• nie nadpisuj oryginalnych plików bez kopii zapasowej,
• waliduj dane przed przetwarzaniem,
• zapisuj wyniki do osobnego katalogu,
• używaj jasnych nazw arkuszy,
• dodawaj kolumnę ze źródłem przy łączeniu wielu plików,
• obsługuj brakujące kolumny i puste wartości,
• formatuj raporty tak, aby były czytelne dla odbiorcy,
• trzymaj logikę przetwarzania w funkcjach,
• testuj skrypt na małej próbce danych,
• używaj pandas do danych i openpyxl do wyglądu arkusza.

Dzięki temu skrypty będą bezpieczniejsze, łatwiejsze do utrzymania i bardziej odporne na błędy w plikach wejściowych.

Podsumowanie

Automatyzacja Excela w Pythonie pozwala zamienić ręczne, powtarzalne czynności w stabilne skrypty. Za pomocą pandas szybko odczytasz, oczyścisz, połączysz i przeanalizujesz dane. Za pomocą openpyxl dodasz formatowanie, formuły, wykresy, walidacje i przygotujesz raport gotowy do wysłania.

Najlepsze efekty daje połączenie obu bibliotek: pandas odpowiada za przetwarzanie danych, a openpyxl za finalny wygląd pliku. Dzięki temu możesz tworzyć raporty, które są nie tylko poprawne, ale też czytelne dla odbiorców biznesowych.

Jeśli chcesz zacząć praktycznie, wybierz jeden proces, który dziś robisz ręcznie w Excelu: łączenie plików, czyszczenie danych albo generowanie raportu. Napisz skrypt dla jednego pliku, a potem rozbuduj go o obsługę całego katalogu i walidację danych.

➡️ Następny artykuł

Po opanowaniu automatyzacji Excela naucz się integrować Python z narzędziami Microsoft:

Power Query i Power BI: przygotowanie danych w Pythonie — wykorzystanie Pythona do zaawansowanych transformacji danych przed importem do Power Query i Power BI.

Po pracy z Excelem dowiedz się też, jak generować profesjonalne raporty z Pandas do różnych formatów — Excel, CSV i PDF z formatowaniem i wykresami.