Automatyzacja Excela w Pythonie: odczyt, zapis, walidacja danych

Podstawowy odczyt z Excela

Pandas oferuje najprostszy i najbardziej intuicyjny sposób czytania plików Excel — funkcja read_excel() automatycznie interpretuje strukturę arkusza, rozpoznaje nagłówki kolumn i konwertuje dane do DataFrame, który można od razu analizować. To idealne rozwiązanie do szybkiego wczytywania danych, gdy nie potrzebujesz pełnej kontroli nad formatowaniem czy komórkami. Oto podstawowe przykłady użycia:

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

# Czytanie całego arkusza
df = pd.read_excel("dane.xlsx")
print(df.head())

# Czytanie konkretnego arkusza
df = pd.read_excel("dane.xlsx", sheet_name="Arkusz1")

# Czytanie zakresu komórek w pandas
df = pd.read_excel("dane.xlsx", usecols="A:C", nrows=100)

Zaawansowany odczyt z openpyxl

Gdy potrzebujesz pełnej kontroli nad plikami Excel — na przykład dostępu do formatowania, formuł, komentarzy czy stylów komórek — biblioteka openpyxl jest idealnym wyborem. W przeciwieństwie do pandas, która skupia się na danych, openpyxl pozwala na manipulację każdym aspektem pliku Excel, co jest niezbędne przy pracy z zaawansowanymi arkuszami lub gdy musisz zachować oryginalne formatowanie. Poniżej znajdziesz przykłady dostępu do różnych elementów arkusza:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from openpyxl import load_workbook

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

# Czytanie konkretnej komórki
wartosc = ws["A1"].value

# Czytanie zakresu w openpyxl
for row in ws["A1:C10"]:
    for cell in row:
        print(cell.value)

# Czytanie całej kolumny
kolumna_a = [cell.value for cell in ws["A"]]

Zapisywanie danych do Excela

Zapisywanie danych do plików Excel to kolejny fundamentalny element automatyzacji. Pandas oferuje prostą metodę to_excel(), która umożliwia eksport DataFrame'ów do plików .xlsx z automatycznym tworzeniem arkuszy, natomiast openpyxl pozwala na bardziej zaawansowane operacje, takie jak zapisywanie do wielu arkuszy jednocześnie przy użyciu ExcelWriter. Oto praktyczne przykłady obu podejść:

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

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

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

# Zapisywanie do wielu arkuszy
with pd.ExcelWriter("raporty.xlsx") as writer:
df1.to_excel(writer, sheet_name="Raport 1")
df2.to_excel(writer, sheet_name="Raport 2")
df3.to_excel(writer, sheet_name="Raport 3")

Formatowanie arkuszy z openpyxl

Profesjonalne raporty wymagają odpowiedniego formatowania — kolorowe nagłówki, wyrównane komórki, formaty liczbowe i inne elementy wizualne, które poprawiają czytelność dokumentów. Openpyxl oferuje pełny zestaw narzędzi do formatowania, które pozwalają na tworzenie arkuszy, które wyglądają tak, jakby zostały przygotowane przez doświadczonego analityka. Poniżej znajdziesz przykłady najczęściej używanych technik formatowania:

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

wb = Workbook()
ws = wb.active

# Dodanie danych do arkusza
ws["A1"] = "Nazwa"
ws["B1"] = "Wartość"

# Formatowanie nagłówka
header_font = Font(bold=True, size=12)
header_fill = PatternFill(start_color="4472C4", end_color="4472C4", fill_type="solid")

ws["A1"].font = header_font
ws["A1"].fill = header_fill
ws["A1"].alignment = Alignment(horizontal="center")

# Formatowanie danych
for row in range(2, 10):
    ws[f"A{row}"].alignment = Alignment(horizontal="left")
    ws[f"B{row}"].number_format = "#,##0.00"

wb.save("sformatowany.xlsx")

Walidacja danych

Sprawdzanie poprawności danych w Excel:

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 datetime import datetime

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

    # Sprawdzanie pustych wartości
    empty_cols = df.isnull().any()
    if empty_cols.any():
        errors.append(f"Puste wartości w kolumnach: {empty_cols[empty_cols].index.tolist()}")

    # Sprawdzanie typów danych
    if "Data" in df.columns:
        try:
            pd.to_datetime(df["Data"])
        except:
            errors.append("Nieprawidłowy format daty w kolumnie 'Data'")

    # Sprawdzanie zakresów wartości
    if "Wiek" in df.columns:
        if df["Wiek"].min() < 0 or df["Wiek"].max() > 150:
            errors.append("Wiek poza akceptowalnym zakresem")

    # Sprawdzanie duplikatów
    duplicates = df.duplicated()
    if duplicates.any():
        errors.append(f"Znaleziono {duplicates.sum()} duplikatów")

    return errors

# Przykład walidacji danych Excel
errors = validate_excel_data("dane.xlsx")
if errors:
    print("Błędy walidacji:")
    for error in errors:
        print(f"- {error}")
else:
    print("Dane są poprawne!")

Automatyzacja raportów

Generowanie automatycznych raportów:

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

def create_report(input_file: str, output_file: str):
    """Tworzy automatyczny raport z danych."""
    # Wczytanie danych
    df = pd.read_excel(input_file)

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

    # Zapisanie raportu
    with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
        summary.to_excel(writer, sheet_name="Podsumowanie", index=False)

        # Dodanie wykresu
        wb = writer.book
        ws = writer.sheets["Podsumowanie"]

        chart = BarChart()
        chart.type = "col"
        chart.style = 10
        chart.title = "Podsumowanie wartości"
        chart.y_axis.title = "Wartość"
        chart.x_axis.title = "Kategoria"

        data = Reference(ws, min_col=2, min_row=1, max_row=len(summary)+1, max_col=2)
        cats = Reference(ws, min_col=1, min_row=2, max_row=len(summary)+1)
        chart.add_data(data, titles_from_data=True)
        chart.set_categories(cats)

        ws.add_chart(chart, "E2")

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

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

Przetwarzanie wielu plików Excel

Batch processing wielu plików:

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

def process_multiple_excel_files(directory: str, output_file: str):
    """Przetwarza wiele plików Excel i łączy je w jeden."""
    excel_files = list(Path(directory).glob("*.xlsx"))
    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)

    # Łączenie wszystkich danych
    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")

Obsługa formuł

Dodawanie formuł do arkuszy:

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

wb = Workbook()
ws = wb.active

# Dodanie danych przed formułami
ws["A1"] = 10
ws["A2"] = 20
ws["A3"] = 30

# Dodanie formuły SUM
ws["A4"] = "=SUM(A1:A3)"

# Dodanie formuły IF
ws["B1"] = "=IF(A1>15, 'Wysoka', 'Niska')"

wb.save("z_formulami.xlsx")

Podsumowanie

Automatyzacja Excela w Pythonie obejmuje:

• Odczyt i zapis plików Excel
• Walidację danych i sprawdzanie poprawności
• Formatowanie arkuszy i komórek
• Generowanie raportów z wykresami
• Przetwarzanie wielu plików naraz
• Dodawanie formuł i zaawansowanych funkcji

To wszystko bez dodatkowych wtyczek — tylko Python i odpowiednie biblioteki.

---

➡️ 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 Excel, dowiedz się też jak generować profesjonalne raporty z Pandas do różnych formatów — Excel, CSV i PDF z formatowaniem i wykresami.