Vizualizácia dát v Pythone s Matplotlib 3.10 a Seaborn: Sprievodca pre rok 2026

Úvod: Prečo vizualizácia dát stále rozhoduje

Dáta bez vizualizácie sú ako kniha bez ilustrácií — technicky kompletná, ale oveľa ťažšie stráviteľná. Uprimne, v roku 2026, keď objem dát rastie exponenciálne a rozhodnutia padajú rýchlejšie než kedykoľvek predtým, je schopnosť jasne a presvedčivo prezentovať dáta jednou z najcennejších zručností, akú môžete mať.

Python zostáva jednotkou v dátovej vede. A jeho vizualizačný ekosystém? Bohatší než kedykoľvek predtým. Dve knižnice ale naďalej tvoria jadro všetkého: Matplotlib a Seaborn. Matplotlib vám dá totálnu kontrolu nad každým pixelom, Seaborn zas elegantné štatistické vizualizácie s minimom kódu.

Tento sprievodca nadväzuje na naše predchádzajúce články o Pandas 3.0 vs Polars a Scikit-learn 1.8. Tentokrát sa zameriame na to, ako dáta, ktoré ste spracovali a namodelovali, efektívne vizualizovať. Prejdeme od úplných základov po pokročilé techniky — vrátane noviniek v Matplotlib 3.10 a Seaborn 0.13.

Čo je nové v Matplotlib 3.10 a Seaborn 0.13

Matplotlib 3.10 — kľúčové novinky

Matplotlib 3.10, vydaný v decembri 2024 s pravidelnými opravnými verziami až po aktuálnu 3.10.8, prináša niekoľko zaujímavých vylepšení:

• Podpora free-threaded CPythonu 3.13 — predbežná podpora behu bez GIL (Global Interpreter Lock). Zatiaľ experimentálna, ale pre paralelné generovanie grafov to znie veľmi sľubne
• Nový InsetIndicator artist — nová trieda na vytváranie zvýraznených oblastí s prepojením na detail (zoom insets). Predtým ste na to potrebovali oveľa viac manuálneho kódu
• Wheel balíčky pre Python 3.14 a Windows ARM — rozšírená kompatibilita s najnovšími platformami
• Opravy hi-dpi podpory pre Qt — lepšie vykresľovanie na vysokorozlíšených displejoch

Seaborn 0.13 — štatistické vizualizácie na novej úrovni

Seaborn 0.13 priniesol rozsiahly prepis kategorických vizualizácií a niekoľko dlho očakávaných vecí:

• Kompletný prepis kategorických funkcií — boxplot, violinplot, stripplot a ďalšie boli prepísané od základov
• Parameter native_scale — numerické a dátumové dáta sa teraz môžu zobrazovať na skutočnej škále namiesto kategorického spracovania
• Podpora pre Polars — provizórna podpora alternatívnych DataFrame knižníc vrátane Polars
• Vylepšený boxenplot — parameter width_method nahrádza pôvodný scale, presnejšie aproximuje hustotu rozdelenia
• Rozdelené violin ploty — pri split=True a inner="box" sa teraz kreslí samostatný mini-box pre každú polovicu

Inštalácia a nastavenie prostredia

Tak, poďme na to. Najprv si pripravíme prostredie. Odporúčam použiť virtuálne prostredie — verte mi, ušetrí vám to veľa bolesti hlavy so závislosťami:

# Vytvorenie a aktivácia virtuálneho prostredia
python -m venv vizualizacia-env
source vizualizacia-env/bin/activate  # Na Windows: vizualizacia-env\Scripts\activate

# Inštalácia potrebných knižníc
pip install matplotlib==3.10.8 seaborn==0.13.2 pandas==3.0.1 numpy==2.4.3 jupyterlab

Pre prácu v Jupyter notebooku pridajte na začiatok bunky tieto importy:

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

# Nastavenie štýlu a veľkosti grafov
plt.rcParams["figure.figsize"] = (10, 6)
plt.rcParams["figure.dpi"] = 100
sns.set_theme(style="whitegrid", palette="muted")

# V Jupyter notebooku
%matplotlib inline

Matplotlib od základov: Vaše prvé vizualizácie

Štruktúra Matplotlib grafu — Figure a Axes

Toto je niečo, čo veľa začiatočníkov preskočí, a potom sa divia, prečo im nefungujú zložitejšie layouty. Pochopenie hierarchie objektov v Matplotlib je naozaj kľúčové. Každý graf sa skladá z:

• Figure — celé plátno (okno alebo obrázok), ktoré môže obsahovať jeden alebo viac grafov
• Axes — samotná plocha grafu s osami, legendou a dátami
• Axis — jednotlivá os (x alebo y) s popiskami a mierkou

Odporúčaný prístup je vždy používať explicitné vytváranie Figure a Axes. Dáva vám to plnú kontrolu a neskôr vám to uľahčí život pri zložitejších grafoch:

# Explicitný prístup (odporúčaný)
fig, ax = plt.subplots(figsize=(10, 6))
ax.plot([1, 2, 3, 4, 5], [2, 4, 1, 8, 5], marker="o", linewidth=2)
ax.set_title("Môj prvý graf")
ax.set_xlabel("Os X")
ax.set_ylabel("Os Y")
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Základné typy grafov v Matplotlib

Poďme si prejsť najpoužívanejšie typy grafov s praktickými príkladmi. Použijeme fiktívne dáta o mesačných tržbách — niečo, s čím sa stretne asi každý:

# Príprava ukážkových dát
mesiace = ["Jan", "Feb", "Mar", "Apr", "Máj", "Jún",
           "Júl", "Aug", "Sep", "Okt", "Nov", "Dec"]
trzby_2025 = [45, 52, 48, 61, 55, 67, 72, 68, 75, 80, 85, 92]
trzby_2026 = [50, 58, 55, 68, 62, 74, 78, 75, 82, 88, None, None]

# Čiarový graf — trendy v čase
fig, ax = plt.subplots(figsize=(12, 6))
ax.plot(mesiace, trzby_2025, marker="o", label="2025", linewidth=2)
ax.plot(mesiace[:10], trzby_2026[:10], marker="s", label="2026", linewidth=2, linestyle="--")
ax.set_title("Mesačné tržby: Porovnanie 2025 vs 2026", fontsize=14, fontweight="bold")
ax.set_xlabel("Mesiac")
ax.set_ylabel("Tržby (tis. €)")
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

A teraz stĺpcový graf — ideálny na porovnanie kategórií. Všimnite si, ako pridávame hodnoty priamo nad stĺpce (to je taký malý detail, ktorý robí graf oveľa čitateľnejším):

# Stĺpcový graf — porovnanie kategórií
kategorie = ["Python", "R", "SQL", "Julia", "Scala"]
popularita = [68, 15, 42, 5, 3]
farby = ["#3776ab", "#276dc3", "#f29111", "#9558b2", "#c22d40"]

fig, ax = plt.subplots(figsize=(10, 6))
bars = ax.bar(kategorie, popularita, color=farby, edgecolor="white", linewidth=1.5)

# Pridanie hodnôt nad stĺpce
for bar, val in zip(bars, popularita):
    ax.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 1,
            f"{val} %", ha="center", va="bottom", fontweight="bold")

ax.set_title("Popularita jazykov v dátovej vede (2026)", fontsize=14, fontweight="bold")
ax.set_ylabel("Podiel používateľov (%)")
ax.set_ylim(0, 80)
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
plt.tight_layout()
plt.show()

Na záver základných typov — bodový graf. Ten sa hodí vždy, keď chcete vidieť vzťah medzi dvoma premennými:

# Bodový graf — vzťah medzi premennými
np.random.seed(42)
skusenosti = np.random.uniform(0, 15, 100)
plat = 35000 + 3500 * skusenosti + np.random.normal(0, 5000, 100)

fig, ax = plt.subplots(figsize=(10, 6))
scatter = ax.scatter(skusenosti, plat, c=skusenosti, cmap="viridis",
                     alpha=0.7, edgecolors="white", s=60)
ax.set_title("Vzťah medzi skúsenosťami a platom", fontsize=14, fontweight="bold")
ax.set_xlabel("Roky skúseností")
ax.set_ylabel("Ročný plat (€)")
plt.colorbar(scatter, ax=ax, label="Roky skúseností")
plt.tight_layout()
plt.show()

Seaborn: Štatistické vizualizácie s minimom kódu

Kedy použiť Seaborn namiesto Matplotlib

Seaborn nie je náhradou za Matplotlib — je jeho nadstavbou. Toto je dôležité pochopiť. Používajte ho vtedy, keď potrebujete:

• Štatistické grafy — distribúcie, korelácie, regresie
• Rýchlu exploratórnu analýzu — pekné grafy s minimom kódu
• Prácu s Pandas DataFrame — Seaborn má natívnu integráciu s DataFrames
• Kategorické porovnania — box ploty, violin ploty, swarm ploty

V praxi väčšinou kombinácia oboch funguje najlepšie.

Distribučné grafy

Pochopenie rozdelenia dát je prvý krok v akejkoľvek analýze. A tu Seaborn naozaj žiari — stačí pár riadkov a máte krásny výstup:

# Príprava dát
np.random.seed(42)
df = pd.DataFrame({
    "plat": np.concatenate([
        np.random.normal(45000, 8000, 200),
        np.random.normal(65000, 12000, 150),
        np.random.normal(85000, 15000, 100)
    ]),
    "pozicia": (["Junior"] * 200 + ["Mid"] * 150 + ["Senior"] * 100)
})

# Histogram s KDE krivkou
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

sns.histplot(data=df, x="plat", hue="pozicia", kde=True,
             alpha=0.6, ax=axes[0])
axes[0].set_title("Rozdelenie platov podľa pozície")
axes[0].set_xlabel("Ročný plat (€)")

# Violin plot — distribúcia s detailmi
sns.violinplot(data=df, x="pozicia", y="plat", inner="box",
               palette="muted", ax=axes[1])
axes[1].set_title("Violin plot: Platy podľa pozície")
axes[1].set_ylabel("Ročný plat (€)")

plt.tight_layout()
plt.show()

Korelačná matica s heatmapou

Toto je asi jeden z najčastejších scenárov, na aký narazíte — vizualizácia korelácií medzi premennými. Osobne to považujem za jeden z najužitočnejších grafov vôbec, pretože na prvý pohľad vidíte, čo s čím súvisí:

# Vytvorenie datasetu s viacerými premennými
np.random.seed(42)
n = 300
df_korr = pd.DataFrame({
    "skusenosti": np.random.uniform(0, 20, n),
    "vzdelanie_roky": np.random.uniform(12, 22, n),
    "certifikacie": np.random.randint(0, 8, n),
    "projekty": np.random.randint(1, 30, n),
})
df_korr["plat"] = (30000
                   + 2500 * df_korr["skusenosti"]
                   + 1500 * df_korr["vzdelanie_roky"]
                   + 800 * df_korr["certifikacie"]
                   + 200 * df_korr["projekty"]
                   + np.random.normal(0, 5000, n))

# Korelačná matica
fig, ax = plt.subplots(figsize=(10, 8))
korelacia = df_korr.corr()
maska = np.triu(np.ones_like(korelacia, dtype=bool))

sns.heatmap(korelacia, mask=maska, annot=True, fmt=".2f",
            cmap="coolwarm", center=0, square=True,
            linewidths=1, ax=ax,
            cbar_kws={"shrink": 0.8})
ax.set_title("Korelačná matica: Faktory ovplyvňujúce plat",
             fontsize=14, fontweight="bold", pad=20)
plt.tight_layout()
plt.show()

Pair plot — preskúmajte vzťahy medzi všetkými premennými naraz

Pair plot je skvelý na rýchly prvý pohľad na celý dataset. Nie je to najrýchlejšia operácia (pri veľkom počte stĺpcov sa pripravte na chvíľku čakania), ale informácie, ktoré z toho dostanete, za to stoja:

# Pair plot s farebným rozlíšením
df_pair = df_korr.copy()
df_pair["uroven"] = pd.cut(df_korr["plat"],
                           bins=[0, 50000, 70000, 200000],
                           labels=["Nízky", "Stredný", "Vysoký"])

sns.pairplot(df_pair, hue="uroven", palette="Set2",
             diag_kind="kde", corner=True,
             plot_kws={"alpha": 0.5, "s": 20})
plt.suptitle("Vzťahy medzi premennými podľa platovej úrovne",
             y=1.02, fontsize=14, fontweight="bold")
plt.show()

Integrácia s Pandas 3.0 — vizualizácia priamo z DataFrame

Pandas 3.0 s PyArrow backend-om prináša rýchlejšie spracovanie dát. A vedeli ste, že vizualizáciu z DataFrame môžete robiť priamo cez zabudovanú metódu .plot()? Interne volá Matplotlib, takže všetky nastavenia fungujú rovnako:

# Vytvorenie datasetu s Pandas 3.0
df_trzby = pd.DataFrame({
    "mesiac": pd.date_range("2026-01-01", periods=12, freq="MS"),
    "produkt_a": [120, 135, 145, 160, 175, 190, 185, 200, 210, 225, 240, 260],
    "produkt_b": [80, 85, 95, 100, 110, 105, 115, 120, 130, 140, 155, 165],
    "produkt_c": [45, 50, 55, 48, 60, 65, 70, 75, 72, 80, 85, 90]
})
df_trzby = df_trzby.set_index("mesiac")

# Odporúčaný prístup: explicitné Axes s pandas plot
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Čiarový graf
df_trzby.plot(ax=axes[0, 0], linewidth=2, marker="o", markersize=4)
axes[0, 0].set_title("Tržby podľa produktov")
axes[0, 0].set_ylabel("Tržby (tis. €)")
axes[0, 0].legend(title="Produkt")

# Plošný graf
df_trzby.plot.area(ax=axes[0, 1], alpha=0.6)
axes[0, 1].set_title("Kumulatívne tržby")
axes[0, 1].set_ylabel("Tržby (tis. €)")

# Stĺpcový graf za Q1
df_trzby.iloc[:3].plot.bar(ax=axes[1, 0], rot=0)
axes[1, 0].set_title("Tržby za Q1 2026")
axes[1, 0].set_ylabel("Tržby (tis. €)")
axes[1, 0].set_xticklabels(["Január", "Február", "Marec"])

# Box plot
df_trzby.plot.box(ax=axes[1, 1])
axes[1, 1].set_title("Rozdelenie tržieb")
axes[1, 1].set_ylabel("Tržby (tis. €)")

fig.suptitle("Dashboard tržieb — Pandas 3.0 + Matplotlib",
             fontsize=16, fontweight="bold")
plt.tight_layout()
plt.show()

Pokročilé techniky: subplot_mosaic a zložité layouty

Toto je podľa mňa jedna z najužitočnejších funkcií moderného Matplotlib. Funkcia subplot_mosaic vám namiesto práce s indexmi umožňuje definovať rozloženie grafov pomocou textového ASCII art. Keď to uvidíte v akcii, pochopíte, prečo to všetci zbožňujú:

# subplot_mosaic — komplexný layout s pomenovanými osami
fig, axd = plt.subplot_mosaic(
    """
    AABB
    CCDD
    CCEE
    """,
    figsize=(16, 12),
    layout="constrained"
)

# A — čiarový graf
np.random.seed(42)
x = np.linspace(0, 10, 100)
axd["A"].plot(x, np.sin(x), label="sin(x)", linewidth=2)
axd["A"].plot(x, np.cos(x), label="cos(x)", linewidth=2, linestyle="--")
axd["A"].set_title("Trigonometrické funkcie")
axd["A"].legend()
axd["A"].grid(True, alpha=0.3)

# B — histogram
data = np.random.normal(0, 1, 1000)
axd["B"].hist(data, bins=30, color="steelblue", edgecolor="white", alpha=0.8)
axd["B"].set_title("Normálne rozdelenie (n=1000)")
axd["B"].axvline(x=0, color="red", linestyle="--", label="Priemer")
axd["B"].legend()

# C — veľký scatter plot (zaberá 2 riadky)
x_scatter = np.random.uniform(0, 100, 200)
y_scatter = 2 * x_scatter + np.random.normal(0, 20, 200)
farby = np.random.uniform(0, 1, 200)
scatter = axd["C"].scatter(x_scatter, y_scatter, c=farby, cmap="plasma",
                           alpha=0.6, edgecolors="white", s=40)
axd["C"].set_title("Regresná analýza s farebnými bodmi")
axd["C"].set_xlabel("Nezávislá premenná")
axd["C"].set_ylabel("Závislá premenná")
plt.colorbar(scatter, ax=axd["C"], label="Intenzita")

# D — koláčový graf
labely = ["Python", "R", "SQL", "Julia", "Iné"]
velkosti = [45, 12, 25, 5, 13]
axd["D"].pie(velkosti, labels=labely, autopct="%1.0f%%",
             startangle=90, colors=sns.color_palette("pastel"))
axd["D"].set_title("Používané jazyky")

# E — horizontálny stĺpcový graf
nastroje = ["Pandas", "NumPy", "Scikit-learn", "TensorFlow", "Matplotlib"]
hodnotenia = [4.8, 4.7, 4.5, 4.2, 4.6]
axd["E"].barh(nastroje, hodnotenia, color=sns.color_palette("viridis", 5))
axd["E"].set_title("Hodnotenie knižníc")
axd["E"].set_xlim(3.5, 5.0)
axd["E"].set_xlabel("Hodnotenie (z 5)")

fig.suptitle("Analytický dashboard — subplot_mosaic v Matplotlib 3.10",
             fontsize=18, fontweight="bold")
plt.show()

Všimnite si, ako jasne vidíte rozloženie priamo v kóde. Písmeno „C" sa v ASCII art opakuje na 4 pozíciách — a Matplotlib automaticky vytvorí jeden veľký graf, ktorý zaberá celý tento priestor. Elegantné, nie?

Seaborn Objects rozhranie — budúcnosť vizualizácií

Seaborn 0.12 predstavil úplne nové Objects rozhranie, ktoré v 0.13 dozrelo do reálne použiteľného stavu. Je inšpirované gramatikou grafiky (niečo ako ggplot2 v R) a ponúka deklaratívny, skladateľný prístup k vizualizáciám:

import seaborn.objects as so

# Príprava dát
np.random.seed(42)
df_obj = pd.DataFrame({
    "skusenosti": np.random.uniform(0, 15, 150),
    "plat": np.random.uniform(30000, 100000, 150),
    "oddelenie": np.random.choice(["Vývoj", "Analýza", "ML Inžiniering"], 150),
    "uroven": np.random.choice(["Junior", "Mid", "Senior"], 150)
})

# Deklaratívny prístup s Objects rozhraním
(
    so.Plot(df_obj, x="skusenosti", y="plat", color="oddelenie")
    .add(so.Dot(alpha=0.6, pointsize=5))
    .add(so.Line(), so.PolyFit(order=2))
    .facet("uroven")
    .label(
        x="Roky skúseností",
        y="Ročný plat (€)",
        color="Oddelenie",
        title="{} úroveň"
    )
    .layout(size=(14, 5))
    .show()
)

Objects rozhranie je stále experimentálne, ale jeho deklaratívny prístup je veľmi intuitívny. Namiesto volania rôznych funkcií skladáte graf z komponentov — čo pripomína prístup Polars k spracovaniu dát. Ak ste si obľúbili chain-based syntax, toto si zamilujete.

Ako vybrať správny typ grafu pre vaše dáta

Výber správneho grafu je rovnako dôležitý ako kvalita samotných dát. Zlý typ grafu dokáže aj perfektné dáta urobiť nečitateľnými. Tu je praktický prehľad:

• Porovnanie kategórií → stĺpcový graf (bar), horizontálny stĺpcový graf (barh)
• Trendy v čase → čiarový graf (line), plošný graf (area)
• Rozdelenie jednej premennej → histogram, KDE, box plot, violin plot
• Vzťah medzi dvoma premennými → bodový graf (scatter), regresný graf
• Korelácie viacerých premenných → heatmapa, pair plot
• Zloženie celku → koláčový graf (pie), plošný graf (area)
• Porovnanie distribúcií medzi skupinami → box plot, violin plot, swarm plot

Praktické tipy na profesionálne grafy

Konzistentný štýl naprieč projektom

Jednou z vecí, ktoré odlíšia amatérsky graf od profesionálneho, je konzistencia. Nastavte si vlastný štýl raz a potom ho používajte všade:

# Definícia vlastného štýlu
vlastny_styl = {
    "figure.figsize": (12, 7),
    "figure.dpi": 100,
    "axes.titlesize": 14,
    "axes.titleweight": "bold",
    "axes.labelsize": 12,
    "axes.spines.top": False,
    "axes.spines.right": False,
    "axes.grid": True,
    "grid.alpha": 0.3,
    "legend.fontsize": 10,
    "font.family": "sans-serif",
}

# Aplikácia štýlu na celý projekt
plt.rcParams.update(vlastny_styl)

# Alebo použitie Seaborn témy
sns.set_theme(
    style="ticks",
    palette="colorblind",  # Prístupná farebná paleta
    rc=vlastny_styl
)

Prístupnosť farieb — myslite na farbosleposť

Toto je niečo, na čo veľa ľudí zabúda. Približne 8 % mužov a 0,5 % žien má nejakú formu farbosleposti. To nie je zanedbateľné číslo. Používajte palety prispôsobené tejto skutočnosti:

# Prístupné farebné palety v Seaborn
pristupne_palety = ["colorblind", "deep", "muted"]

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
for ax, paleta in zip(axes, pristupne_palety):
    farby = sns.color_palette(paleta, 6)
    for i, farba in enumerate(farby):
        ax.bar(i, 1, color=farba, edgecolor="white")
    ax.set_title(f"Paleta: {paleta}")
    ax.set_xticks([])
    ax.set_yticks([])

plt.suptitle("Prístupné farebné palety pre farboslepých",
             fontsize=14, fontweight="bold")
plt.tight_layout()
plt.show()

Ukladanie grafov vo vysokej kvalite

Posledný, ale dôležitý krok — správne uloženie. Nič nie je horšie než krásny graf, ktorý vyzerá rozmazane v prezentácii:

# Uloženie pre rôzne účely
fig, ax = plt.subplots(figsize=(10, 6))
ax.plot([1, 2, 3], [1, 4, 9])
ax.set_title("Ukážkový graf")

# Pre web — PNG s optimálnym DPI
fig.savefig("graf_web.png", dpi=150, bbox_inches="tight",
            facecolor="white", transparent=False)

# Pre tlač / publikáciu — vektorový formát
fig.savefig("graf_publikacia.pdf", bbox_inches="tight")
fig.savefig("graf_publikacia.svg", bbox_inches="tight")

plt.close(fig)  # Uvoľnenie pamäte

Vizualizácia výsledkov strojového učenia

Pre tých z vás, ktorí pracujú so scikit-learn (ak ste čítali náš sprievodca Scikit-learn 1.8, viete o čom hovorím), tu sú vizualizácie typické pre ML workflow. Tieto tri grafy — confusion matrix, ROC krivka a dôležitosť príznakov — sú niečo, čo budete robiť takmer pri každom klasifikačnom projekte:

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split, learning_curve
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, RocCurveDisplay

# Generovanie datasetu
X, y = make_classification(n_samples=1000, n_features=10,
                           n_informative=5, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                                     random_state=42)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Vizualizácia výsledkov
fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# 1. Confusion Matrix
ConfusionMatrixDisplay.from_estimator(model, X_test, y_test,
                                      cmap="Blues", ax=axes[0])
axes[0].set_title("Matica zámien (Confusion Matrix)")

# 2. ROC krivka
RocCurveDisplay.from_estimator(model, X_test, y_test, ax=axes[1])
axes[1].set_title("ROC krivka")
axes[1].plot([0, 1], [0, 1], "k--", alpha=0.5)

# 3. Dôležitosť feature
dolezitost = model.feature_importances_
indexy = np.argsort(dolezitost)[::-1]
axes[2].barh(range(len(dolezitost)),
             dolezitost[indexy],
             color=sns.color_palette("viridis", len(dolezitost)))
axes[2].set_yticks(range(len(dolezitost)))
axes[2].set_yticklabels([f"Feature {i}" for i in indexy])
axes[2].set_title("Dôležitosť príznakov")
axes[2].set_xlabel("Dôležitosť")

fig.suptitle("Vizualizácia výsledkov Random Forest klasifikátora",
             fontsize=16, fontweight="bold")
plt.tight_layout()
plt.show()

Časté chyby pri vizualizácii dát a ako sa im vyhnúť

Na záver hlavnej časti si zhrnieme najčastejšie chyby. Niektoré z nich som robil aj ja, tak sa z nich poučte:

1. Príliš veľa informácií v jednom grafe — ak máte viac ako 5-6 kategórií v legende, rozdeľte graf na viacero panelov pomocou subplot_mosaic alebo Seaborn FacetGrid. Menej je viac
2. Nesprávne orezanie osi Y — začínanie osi Y od inej hodnoty než 0 pri stĺpcových grafoch môže zavádzať. Pri čiarových grafoch je to však často žiaduce pre lepšiu viditeľnosť trendov
3. Ignorovanie farbosleposti — vždy používajte prístupné palety ako colorblind v Seaborn. Stojí to nula námahy navyše
4. Chýbajúce popisky a titulky — každý graf musí mať jasný titulok, popisky osí a prípadne legendu. Graf bez popiskov je v podstate bezcenný
5. Nízke rozlíšenie — pri exportovaní nastavte DPI minimálne na 150 pre web a 300 pre tlač

Často kladené otázky (FAQ)

Aký je rozdiel medzi Matplotlib a Seaborn a kedy ktorý použiť?

Matplotlib je nízkoúrovňová knižnica s plnou kontrolou nad každým aspektom grafu. Seaborn je nadstavba nad Matplotlib-om, ktorá zjednodušuje tvorbu štatistických vizualizácií. Používajte Matplotlib, keď potrebujete maximálnu kontrolu a prispôsobenie. Seaborn zvoľte pre rýchlu exploratórnu analýzu, štatistické grafy (box ploty, violin ploty, heatmapy) a prácu priamo s Pandas DataFrames. Najlepšie výsledky dosiahnete kombináciou oboch — Seaborn na rýchle vytvorenie grafu a Matplotlib na doladenie detailov.

Ako vytvoriť interaktívne grafy v Pythone?

Matplotlib a Seaborn sú primárne určené na statické vizualizácie. Pre interaktívne grafy použite Plotly, ktorý generuje interaktívne HTML grafy s hover efektmi a zoomom. Ďalšou možnosťou je Bokeh pre real-time dashboardy alebo Altair pre deklaratívne interaktívne vizualizácie. Pandas 3.0 navyše podporuje výmenu vizualizačného backend-u cez pd.options.plotting.backend, takže môžete prepnúť na Plotly priamo z DataFrame.

Ako zrýchliť vykresľovanie grafov pri veľkých datasetoch?

Pri datasetoch s viac ako 100 000 bodmi skúste tieto stratégie: použite rasterized=True v scatter plotoch na zrýchlenie vykresľovania, nahraďte scatter ploty hexbin plotmi (plt.hexbin) pre lepšiu čitateľnosť, vzorkujte dáta pred vizualizáciou pomocou df.sample(), alebo použite agregované zobrazenia namiesto individuálnych bodov. Matplotlib 3.10 s podporou free-threaded CPythonu 3.13 navyše umožňuje generovať viacero grafov paralelne.

Aký formát použiť na ukladanie grafov — PNG, SVG alebo PDF?

PNG je ideálny pre web a prezentácie — nastavte DPI na 150-200 pre dobrú kvalitu. SVG je vektorový formát vhodný na webové stránky, kde potrebujete škálovateľnosť bez straty kvality. PDF je najlepší pre vedecké publikácie a tlačené materiály, pretože zachováva vektorovú kvalitu a je štandardom v akademickej sfére. Pri ukladaní vždy použite bbox_inches="tight" na odstránenie zbytočného bieleho priestoru okolo grafu.

Je Seaborn Objects rozhranie pripravené na produkčné použitie?

Seaborn Objects rozhranie (predstavené vo verzii 0.12, vylepšené v 0.13) je stále označené ako experimentálne. Na exploratórnu analýzu a prototypovanie je dostatočne stabilné, ale pre produkčné pipeline odporúčam zatiaľ používať klasické Seaborn funkcie. Napriek tomu je to budúcnosť knižnice — jeho deklaratívny prístup inšpirovaný gramatikou grafiky je veľmi intuitívny a oplatí sa ho začať používať už teraz.