Power Query i Power BI: przygotowanie danych w Pythonie

Przygotowanie danych dla Power Query

Tworzenie plików CSV/Excel gotowych do importu:

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
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:
        if source.endswith('.csv'):
            df = pd.read_csv(source)
        elif source.endswith('.xlsx'):
            df = pd.read_excel(source)
        else:
            continue

        df["Źródło"] = Path(source).stem
        all_data.append(df)

    # Łączenie i czyszczenie
    combined = pd.concat(all_data, ignore_index=True)

    # Normalizacja kolumn
    combined.columns = combined.columns.str.strip()
    combined.columns = combined.columns.str.replace(' ', '_')

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

    # Zapisywanie dla Power Query
    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"
)

Czyszczenie danych przed importem

Automatyczne czyszczenie danych:

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

def clean_data_for_power_bi(df: pd.DataFrame) -> pd.DataFrame:
    """Czyści dane przed importem do Power BI."""
    # Usuwanie pustych wierszy
    df = df.dropna(how='all')

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

    # 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')

    # Normalizacja tekstu
    text_columns = df.select_dtypes(include=['object']).columns
    for col in text_columns:
            df[col] = df[col].astype(str).str.strip()
            df[col] = df[col].str.replace(r'\s+', ' ', regex=True)

    # Usuwanie znaków specjalnych
    df = df.replace({'\n': ' ', '\r': ' ', '\t': ' '}, regex=True)

    return df

# Przykład użycia
df = pd.read_excel("surowe_dane.xlsx")
clean_df = clean_data_for_power_bi(df)
clean_df.to_excel("czyste_dane.xlsx", index=False)

Automatyczne generowanie plików dla Power BI

Tworzenie strukturyzowanych plików danych:

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


def generate_power_bi_data(tables: dict, output_dir: str):
    """Generuje pliki danych dla Power BI."""
    Path(output_dir).mkdir(parents=True, exist_ok=True)

    for table_name, data in tables.items():
        csv_path = f"{output_dir}/{table_name}.csv"
        data.to_csv(csv_path, index=False, encoding='utf-8-sig')

        excel_path = f"{output_dir}/{table_name}.xlsx"
        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),
    "Ilość": [10, 20, 30] * 33 + [10],
    "Wartość": 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/"
)

Integracja z Power BI Desktop

Tworzenie skryptów do automatycznego 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
import pandas as pd
import json
from pathlib import Path


def create_refresh_script(data_file: str, pbix_template: str):
    """Przygotowuje dane i wskazówki do odświeżenia Power BI."""
    df = pd.read_excel(data_file)

    output_file = "dane_aktualne.xlsx"
    df.to_excel(output_file, index=False)

    instructions = {
        "krok_1": "Otwórz Power BI Desktop",
        "krok_2": f"Zmień źródło danych na: {Path(output_file).absolute()}",
        "krok_3": "Kliknij 'Odśwież' w Power Query Editor",
        "krok_4": "Zapisz i opublikuj raport",
        "informacja": f"Szablon PBIX: {Path(pbix_template).absolute()}",
    }

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

    print(f"Dane zaktualizowane: {output_file}")
    print("Instrukcje zapisane w: instrukcja_odswiezania.json")


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

Podsumowanie

Python pozwala na:

• Przygotowanie danych z wielu źródeł przed importem
• Czyszczenie i normalizację danych
• Generowanie plików gotowych dla Power BI
• Automatyzację procesu przygotowania danych

To znacznie rozszerza możliwości Power Query i Power BI o zaawansowane transformacje dostępne w Pythonie.

---

➡️ 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.