Power Query i Power BI świetnie sprawdzają się w analizie danych, budowaniu modeli i tworzeniu raportów biznesowych. Czasem jednak dane wejściowe są zbyt chaotyczne, rozproszone albo wymagają transformacji, które wygodniej wykonać w Pythonie. Wtedy najlepszym rozwiązaniem jest przygotowanie danych przed importem do Power Query lub Power BI.

Python może działać jako warstwa czyszczenia i automatyzacji. Możesz pobierać dane z wielu plików, łączyć arkusze Excel, normalizować nazwy kolumn, usuwać duplikaty, konwertować daty, uzupełniać braki, tworzyć tabele faktów i wymiarów, a następnie zapisywać gotowe pliki CSV lub Excel, które Power BI odczyta bez dodatkowego ręcznego poprawiania.

W tym artykule zobaczysz, jak używać Pythona do przygotowania danych dla Power Query i Power BI. Przykłady wykorzystują głównie pandas, pathlib i standardowe formaty plików, które dobrze współpracują z narzędziami Microsoft.

Kiedy warto używać Pythona przed Power BI?

Power Query jest bardzo wygodne do wielu transformacji, ale Python daje większą elastyczność w bardziej technicznych lub powtarzalnych zadaniach. Szczególnie dobrze sprawdza się, gdy dane pochodzą z wielu źródeł albo wymagają zaawansowanego czyszczenia.

Python warto wykorzystać, gdy chcesz:

• połączyć wiele plików CSV lub Excel w jeden zbiór,
• oczyścić dane przed importem do Power BI,
• ujednolicić nazwy kolumn i typy danych,
• usunąć duplikaty i puste wiersze,
• przygotować osobne tabele faktów i wymiarów,
• wykryć błędy przed odświeżeniem raportu,
• wygenerować pliki źródłowe dla Power Query,
• zautomatyzować przygotowanie danych w harmonogramie,
• wykonać transformacje trudne lub niewygodne w Power Query.

Największa korzyść jest prosta: Power BI dostaje już uporządkowane dane, a model raportowy staje się stabilniejszy i łatwiejszy w utrzymaniu.

Instalacja bibliotek

Do podstawowej pracy wystarczy pandas i openpyxl.

Bash
Kopiuj
1
pip install pandas openpyxl

Jeśli pracujesz z plikami CSV, Excel i katalogami, nie potrzebujesz wielu dodatkowych narzędzi. W bardziej zaawansowanych projektach możesz dodać np. numpy, pyarrow, sqlalchemy albo konektory do baz danych.

Przygotowanie danych dla Power Query

Pierwszy przykład pokazuje, jak połączyć dane z wielu plików CSV i Excel, dodać kolumnę ze źródłem, oczyścić nazwy kolumn i zapisać gotowy plik dla Power Query.

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

def prepare_data_for_power_query(data_sources: list[str], output_file: str):
    """Przygotowuje dane z wielu źródeł dla Power Query."""
    all_data = []

    for source in data_sources:
        path = Path(source)

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

        if path.suffix.lower() == ".csv":
            df = pd.read_csv(path)
        elif path.suffix.lower() in [".xlsx", ".xls"]:
            df = pd.read_excel(path)
        else:
            print(f"Pominięto nieobsługiwany format: {source}")
            continue

        df["zrodlo"] = path.stem
        all_data.append(df)

    if not all_data:
        raise ValueError("Nie znaleziono danych do połączenia.")

    combined = pd.concat(all_data, ignore_index=True)

    combined.columns = (
        combined.columns
        .str.strip()
        .str.lower()
        .str.replace(" ", "_")
    )

    combined = combined.drop_duplicates()

    combined.to_excel(output_file, index=False)
    print(f"Dane przygotowane dla Power Query: {output_file}")


prepare_data_for_power_query(
    ["dane1.csv", "dane2.xlsx", "dane3.csv"],
    "dane_dla_power_query.xlsx"
)

Taki plik możesz później wskazać w Power Query jako źródło danych. Dzięki kolumnie zrodlo łatwiej sprawdzić, z którego pliku pochodzi konkretny rekord.

Czyszczenie danych przed importem do Power BI

Dane z systemów biznesowych często mają niespójne formaty: spacje w komórkach, różne formaty dat, puste wiersze, złamane linie, duplikaty i nazwy kolumn z polskimi znakami lub spacjami. Python pozwala to uporządkować przed importem.

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

def clean_data_for_power_bi(df: pd.DataFrame) -> pd.DataFrame:
    """Czyści dane przed importem do Power BI."""
    df = df.copy()

    # Usuwanie pustych wierszy
    df = df.dropna(how="all")

    # Normalizacja nazw kolumn
    df.columns = (
        df.columns
        .str.strip()
        .str.lower()
        .str.replace(" ", "_")
        .str.replace("-", "_")
    )

    # Usuwanie nadmiarowych spacji i znaków nowych linii
    text_columns = df.select_dtypes(include=["object"]).columns

    for col in text_columns:
        df[col] = (
            df[col]
            .astype(str)
            .str.strip()
            .str.replace(r"\s+", " ", regex=True)
            .str.replace("\n", " ")
            .str.replace("\r", " ")
            .str.replace("\t", " ")
        )

    # Konwersja dat
    date_columns = ["data", "data_utworzenia", "timestamp"]

    for col in date_columns:
        if col in df.columns:
            df[col] = pd.to_datetime(df[col], errors="coerce")

    # Usuwanie duplikatów
    df = df.drop_duplicates()

    return df


df = pd.read_excel("surowe_dane.xlsx")
clean_df = clean_data_for_power_bi(df)
clean_df.to_excel("czyste_dane_power_bi.xlsx", index=False)

Tak przygotowane dane są łatwiejsze do modelowania w Power BI. Mniej błędów pojawia się też przy cyklicznym odświeżaniu raportów.

Walidacja danych przed Power Query

Przed przekazaniem danych do Power BI warto sprawdzić, czy plik ma wymagane kolumny, poprawne daty i brak krytycznych pustych wartości.

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

def validate_power_bi_data(file_path: str) -> list[str]:
    """Sprawdza jakość danych przed importem do Power BI."""
    df = pd.read_excel(file_path)
    errors = []

    required_columns = ["data", "produkt_id", "ilosc", "wartosc"]

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

    missing_columns = [col for col in required_columns if col not in df.columns]

    if missing_columns:
        errors.append(f"Brak wymaganych kolumn: {missing_columns}")
        return errors

    if df[required_columns].isnull().any().any():
        errors.append("W wymaganych kolumnach znajdują się puste wartości.")

    df["data"] = pd.to_datetime(df["data"], errors="coerce")

    if df["data"].isnull().any():
        errors.append("Kolumna 'data' zawiera niepoprawne daty.")

    if (df["ilosc"] < 0).any():
        errors.append("Kolumna 'ilosc' zawiera wartości ujemne.")

    if (df["wartosc"] < 0).any():
        errors.append("Kolumna 'wartosc' zawiera wartości ujemne.")

    return errors


errors = validate_power_bi_data("czyste_dane_power_bi.xlsx")

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

Walidacja pomaga uniknąć sytuacji, w której raport odświeża się na błędnych danych lub kończy błędem dopiero w Power BI.

Automatyczne generowanie plików dla Power BI

Power BI dobrze pracuje z danymi w modelu gwiazdy: tabela faktów oraz tabele wymiarów. Python może generować takie pliki automatycznie.

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 pathlib import Path

def generate_power_bi_data(tables: dict[str, pd.DataFrame], output_dir: str):
    """Generuje pliki CSV i Excel gotowe do importu w Power BI."""
    output_path = Path(output_dir)
    output_path.mkdir(parents=True, exist_ok=True)

    for table_name, data in tables.items():
        clean_name = table_name.lower()

        csv_path = output_path / f"{clean_name}.csv"
        excel_path = output_path / f"{clean_name}.xlsx"

        data.to_csv(csv_path, index=False, encoding="utf-8-sig")
        data.to_excel(excel_path, index=False)

        print(f"Wygenerowano: {table_name} ({len(data)} wierszy)")


fakt_sprzedazy = pd.DataFrame({
    "data": pd.date_range("2024-01-01", periods=100, freq="D"),
    "produkt_id": range(1, 101),
    "ilosc": [10, 20, 30] * 33 + [10],
    "wartosc": range(100, 10100, 100)
})

wymiar_produkt = pd.DataFrame({
    "produkt_id": range(1, 101),
    "nazwa": [f"Produkt {i}" for i in range(1, 101)],
    "kategoria": ["A", "B", "C"] * 33 + ["A"]
})

generate_power_bi_data(
    {
        "Fakt_Sprzedazy": fakt_sprzedazy,
        "Wymiar_Produkt": wymiar_produkt
    },
    "./power_bi_data/"
)

Pliki CSV z kodowaniem utf-8-sig są wygodne przy pracy z polskimi znakami i narzędziami Microsoft.

Łączenie danych z wielu katalogów

W praktyce dane często są podzielone na foldery według miesięcy, regionów albo działów. Python może przejść po całym katalogu i połączyć pliki automatycznie.

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

def combine_monthly_files(input_dir: str, output_file: str):
    """Łączy miesięczne pliki Excel w jeden plik dla Power BI."""
    files = sorted(Path(input_dir).glob("**/*.xlsx"))

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

    frames = []

    for file in files:
        print(f"Wczytuję: {file}")
        df = pd.read_excel(file)

        df["plik_zrodlowy"] = file.name
        df["folder_zrodlowy"] = file.parent.name

        frames.append(df)

    combined = pd.concat(frames, ignore_index=True)
    combined = clean_data_for_power_bi(combined)

    combined.to_csv(output_file, index=False, encoding="utf-8-sig")

    print(f"Zapisano plik dla Power BI: {output_file}")


combine_monthly_files("./dane_miesieczne/", "./power_bi_data/sprzedaz.csv")

To dobry schemat, gdy raport Power BI ma być odświeżany na podstawie stale rosnącej liczby plików.

Przygotowanie tabeli kalendarza w Pythonie

Tabela kalendarza jest częstym elementem modeli Power BI. Możesz ją wygenerować w Pythonie i zapisać jako osobny 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

def create_calendar_table(start_date: str, end_date: str, output_file: str):
    """Tworzy tabelę kalendarza dla Power BI."""
    dates = pd.date_range(start=start_date, end=end_date, freq="D")

    calendar = pd.DataFrame({
        "data": dates,
        "rok": dates.year,
        "miesiac": dates.month,
        "nazwa_miesiaca": dates.strftime("%B"),
        "kwartal": dates.quarter,
        "dzien": dates.day,
        "dzien_tygodnia": dates.dayofweek + 1,
        "czy_weekend": dates.dayofweek >= 5
    })

    calendar.to_csv(output_file, index=False, encoding="utf-8-sig")

    print(f"Tabela kalendarza zapisana do: {output_file}")


create_calendar_table(
    "2024-01-01",
    "2024-12-31",
    "./power_bi_data/kalendarz.csv"
)

Taka tabela może być później połączona w Power BI z tabelą faktów po kolumnie data.

Eksport danych do formatu przyjaznego dla Power Query

Power Query dobrze odczytuje CSV i Excel, ale w procesach automatycznych CSV bywa wygodniejszy: jest lżejszy, prostszy i mniej podatny na ukryte formatowanie.

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

def export_for_power_query(df: pd.DataFrame, output_file: str):
    """Eksportuje dane w formacie przyjaznym dla Power Query."""
    output_path = Path(output_file)
    output_path.parent.mkdir(parents=True, exist_ok=True)

    df.to_csv(
        output_path,
        index=False,
        encoding="utf-8-sig",
        sep=","
    )

    print(f"Plik zapisany dla Power Query: {output_path}")


df = pd.read_excel("dane_wejsciowe.xlsx")
clean_df = clean_data_for_power_bi(df)
export_for_power_query(clean_df, "./power_bi_data/dane.csv")

Dzięki temu Power Query może pobierać stale ten sam plik, a Python odpowiada za jego aktualizację.

Integracja z Power BI Desktop

Python nie musi bezpośrednio modyfikować pliku .pbix, aby wspierać Power BI Desktop. Najczęstszy wzorzec jest prostszy: Python generuje pliki źródłowe w stałej lokalizacji, a Power BI Desktop ma skonfigurowane połączenie do tych plików.

Przykład przygotowania danych i instrukcji odświeżania:

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

def create_refresh_package(data_file: str, pbix_template: str):
    """Przygotowuje dane i instrukcję odświeżenia raportu Power BI."""
    df = pd.read_excel(data_file)
    clean_df = clean_data_for_power_bi(df)

    output_dir = Path("power_bi_data")
    output_dir.mkdir(exist_ok=True)

    output_file = output_dir / "dane_aktualne.csv"
    clean_df.to_csv(output_file, index=False, encoding="utf-8-sig")

    instructions = {
        "krok_1": "Otwórz Power BI Desktop",
        "krok_2": f"Sprawdź, czy źródło danych wskazuje na: {output_file.absolute()}",
        "krok_3": "Kliknij Odśwież",
        "krok_4": "Sprawdź poprawność wizualizacji",
        "krok_5": "Zapisz i opublikuj raport",
        "szablon_pbix": str(Path(pbix_template).absolute())
    }

    with open("instrukcja_odswiezania.json", "w", encoding="utf-8") as file:
        json.dump(instructions, file, ensure_ascii=False, indent=2)

    print(f"Dane zapisane do: {output_file}")
    print("Instrukcja zapisana do: instrukcja_odswiezania.json")


create_refresh_package("dane.xlsx", "raport.pbix")

Dzięki temu proces jest przewidywalny: Python zawsze nadpisuje dane w tym samym miejscu, a Power BI odświeża model z ustalonego źródła.

Harmonogram przygotowania danych

Przygotowanie danych można uruchamiać cyklicznie. Do prostych lokalnych zadań wystarczy biblioteka schedule.

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 schedule
import time
from datetime import datetime

def power_bi_data_job():
    """Cykliczne przygotowanie danych dla Power BI."""
    print(f"[{datetime.now()}] Start przygotowania danych")

    combine_monthly_files(
        "./dane_miesieczne/",
        "./power_bi_data/sprzedaz.csv"
    )

    create_calendar_table(
        "2024-01-01",
        "2024-12-31",
        "./power_bi_data/kalendarz.csv"
    )

    print(f"[{datetime.now()}] Dane dla Power BI gotowe")


schedule.every().day.at("07:30").do(power_bi_data_job)

while True:
    schedule.run_pending()
    time.sleep(60)

W środowisku produkcyjnym możesz zamiast tego użyć crona, APScheduler, GitHub Actions, Azure Functions lub innego narzędzia harmonogramowania.

Dobre praktyki przygotowania danych dla Power BI

Przygotowanie danych w Pythonie powinno być stabilne i powtarzalne. Warto od początku trzymać się kilku zasad:

• zapisuj pliki wynikowe w stałej lokalizacji,
• używaj prostych nazw kolumn bez spacji,
• trzymaj jeden typ danych w jednej kolumnie,
• waliduj dane przed eksportem,
• zapisuj CSV z kodowaniem utf-8-sig,
• dodawaj kolumnę źródła przy łączeniu wielu plików,
• nie nadpisuj surowych danych bez kopii,
• oddziel dane surowe od danych przygotowanych,
• twórz tabele faktów i wymiarów zamiast jednego chaotycznego arkusza,
• loguj liczbę wczytanych i zapisanych wierszy.

Tak przygotowane dane są łatwiejsze do użycia w Power Query, Power BI Desktop i Power BI Service.

Podsumowanie

Python jest bardzo dobrym uzupełnieniem Power Query i Power BI. Pozwala przygotować dane zanim trafią do modelu raportowego: połączyć pliki, oczyścić tekst, ujednolicić kolumny, sprawdzić błędy, wygenerować tabele faktów i wymiarów oraz zapisać dane w formacie gotowym do importu.

Najprostszy i skuteczny workflow wygląda tak: dane surowe trafiają do folderu wejściowego, Python je czyści i zapisuje do stałego pliku CSV lub Excel, a Power Query pobiera ten plik do Power BI. Dzięki temu raport jest bardziej stabilny, a proces odświeżania mniej podatny na błędy.

Jeśli chcesz zacząć praktycznie, wybierz jeden raport Power BI i przygotuj dla niego dane w Pythonie: połącz pliki, oczyść kolumny, dodaj walidację i zapisz wynik do CSV. To pierwszy krok do automatyzacji całego procesu raportowania.

➡️ Następny artykuł

Po przygotowaniu danych w Pythonie naucz się automatyzować raportowanie w Power BI:

Raporty Power BI z Pythona: eksport, harmonogram, publikacja — automatyzacja odświeżania datasetów, eksportu raportów i dystrybucji wyników analiz.