Návody 21 min čtení

Vizualizace dat v Pythonu: Kompletní průvodce Matplotlib, Seaborn a Plotly v roce 2026

Kompletní průvodce třemi hlavními Python knihovnami pro vizualizaci dat. Porovnání Matplotlib 3.10.x, Seaborn 0.13.x a Plotly 6.0 s příklady kódu a tipy pro přístupnost.

Editorial Team

Vizualizace dat v Pythonu: Kompletni pruvodce Matplotlib, Seaborn a Plotly v roce 2026

Ruku na srdce — bez schopnosti prevest surova cisla do srozumitelnych grafu ztraci i ta nejsofistikovanejsi analyza svou hodnotu. Vizualizace dat je zkratka jednim z nejdulezitejsich kroku v celem analytickem procesu. A v roce 2026 mame stesti, protoze Python nabizi tri opravdu vyborne knihovny: Matplotlib, Seaborn a Plotly. Kazda z nich ma jiny pristup, jine silne stranky a jinou filozofii.

V tomto pruvodci se podrobne podivame na vsechny tri — od zakladnich konceptu po prakticke priklady kodu. At uz jste zacatecnik, ktery prave vytvari sve prvni grafy, nebo zkuseny analytik hledajici pokrocile techniky, tenhle clanek by vam mel poskytnout ucelenou mapu sveta vizualizace v Pythonu.

Rok 2026 mimochodem prinasi zajimave zmeny. Trend hybridniho pracovniho postupu DuckDB + Polars + Pandas se prosazuje cim dal vic a vsechny tri vizualizacni knihovny na to reaguji. Plotly 6.0 predstavilo nativni integraci s Polars pres knihovnu Narwhals, Seaborn 0.13.x nabizi provizorni podporu alternativnich datovych ramcu a Matplotlib si zachovava svou univerzalnost prostrednictvim NumPy poli. Pojdme se na to vsechno podivat poradne.

Matplotlib - zaklad vizualizace v Pythonu

Historie a soucasny stav

Matplotlib je nejstarsi a nejrozsirenejsi vizualizacni knihovnou v Pythonu. Vznikla uz v roce 2003 pod vedenim Johna Huntera jako nastroj pro vytvareni grafu podobnych tem z MATLABu. Od te doby se vyvinula v rozsahly projekt s tisici prispevovateli a miliony uzivatelu po celem svete. Je to takovy zaklad, na kterem stoji skoro vsechno ostatni.

V soucasnosti je stabilni verze Matplotlib 3.10.x (vydana v prosinci 2024, nejnovejsi opravna verze je 3.10.8). Prinasi radu vylepseni — treba novy barevny cyklus petroff10, ktery byl navrzen s vyuzitim algoritmickych omezeni pristupnosti a modelu estetiky zalozenem na strojovem uceni. Dalsi dulezitou novinkou je predbezna podpora pro free-threaded build CPythonu 3.13, coz otevrva dvere paralelnimu zpracovani bez GIL. To je celkem velka vec.

Zakladni koncepty: Figure a Axes

Pro efektivni praci s Matplotlib je nezbytne pochopit dva zakladni koncepty: Figure (obrazek) a Axes (osy, resp. oblast grafu). Figure je celkovy kontejner, ktery muze obsahovat jeden nebo vice objektu Axes. Kazdy Axes predstavuje samostatny graf s vlastnimi osami, popisky a legendou.

Zni to mozna suche, ale jakmile tohle pochopite, vsechno ostatni dava smysl.

# Zakladni struktura Matplotlib - Figure a Axes
import matplotlib.pyplot as plt
import numpy as np

# Vytvoreni figure s dvema subploty
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# Data pro ukazku
x = np.linspace(0, 10, 100)

# Prvni graf - sinusovka
ax1.plot(x, np.sin(x), color='#2196F3', linewidth=2, label='sin(x)')
ax1.plot(x, np.cos(x), color='#FF5722', linewidth=2, label='cos(x)')
ax1.set_title('Trigonometricke funkce', fontsize=14)
ax1.set_xlabel('Osa X')
ax1.set_ylabel('Osa Y')
ax1.legend()
ax1.grid(True, alpha=0.3)

# Druhy graf - exponenciala
ax2.plot(x, np.exp(x / 3), color='#4CAF50', linewidth=2, label='e^(x/3)')
ax2.set_title('Exponencialni funkce', fontsize=14)
ax2.set_xlabel('Osa X')
ax2.set_ylabel('Osa Y')
ax2.legend()
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('zakladni_grafy.png', dpi=150, bbox_inches='tight')
plt.show()

Prakticke priklady

Ted se podivejme na nejcastejsi typy grafu, ktere v Matplotlib vytvorite. Zacneme sloupcovym grafem — ten je idealni pro porovnavani kategorickych dat a pouziva ho snad kazdy.

# Sloupcovy graf s pokrocilym formatovanim
import matplotlib.pyplot as plt
import numpy as np

# Data o vykonnosti programovacich jazyku (fiktivni benchmark)
jazyky = ['Python', 'JavaScript', 'Rust', 'Go', 'Java', 'C++']
vykon_2025 = [45, 38, 95, 78, 65, 92]
vykon_2026 = [52, 42, 97, 82, 68, 93]

x = np.arange(len(jazyky))
sirka = 0.35

fig, ax = plt.subplots(figsize=(10, 6))

# Vytvoreni dvou sad sloupcu vedle sebe
sloupce1 = ax.bar(x - sirka/2, vykon_2025, sirka, label='2025',
                   color='#5C6BC0', edgecolor='white', linewidth=0.5)
sloupce2 = ax.bar(x + sirka/2, vykon_2026, sirka, label='2026',
                   color='#26A69A', edgecolor='white', linewidth=0.5)

# Pridani hodnot nad sloupce
ax.bar_label(sloupce1, padding=3, fontsize=9)
ax.bar_label(sloupce2, padding=3, fontsize=9)

# Formatovani grafu
ax.set_ylabel('Skore vykonu', fontsize=12)
ax.set_title('Porovnani vykonu programovacich jazyku (2025 vs 2026)',
             fontsize=14, fontweight='bold')
ax.set_xticks(x)
ax.set_xticklabels(jazyky, fontsize=11)
ax.legend(fontsize=11)
ax.set_ylim(0, 110)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)

plt.tight_layout()
plt.savefig('sloupcovy_graf.png', dpi=150)
plt.show()

Dalsi hodne pouzivany typ je bodovy graf (scatter plot). Je skvely pro zobrazeni vztahu mezi dvema promennymi — treba jestli vic hodin prace vede k lepsi kvalite kodu (spoiler: vetsinou ano).

# Bodovy graf s barevnou mapou a velikosti bodu
import matplotlib.pyplot as plt
import numpy as np

np.random.seed(42)

# Simulovana data o projektech - hodiny prace vs. kvalita kodu
n_projektu = 150
hodiny = np.random.exponential(scale=40, size=n_projektu)
kvalita = 30 + 0.8 * hodiny + np.random.normal(0, 10, n_projektu)
kvalita = np.clip(kvalita, 0, 100)  # Omezeni na rozsah 0-100
velikost_tymu = np.random.randint(2, 15, n_projektu)

fig, ax = plt.subplots(figsize=(10, 7))

# Bodovy graf s barevnou mapou podle velikosti tymu
scatter = ax.scatter(hodiny, kvalita, c=velikost_tymu, s=velikost_tymu * 15,
                     cmap='viridis', alpha=0.7, edgecolors='white', linewidth=0.5)

# Pridani barevne skaly
cbar = plt.colorbar(scatter, ax=ax, label='Velikost tymu')

# Trendova linie
z = np.polyfit(hodiny, kvalita, 1)
p = np.poly1d(z)
x_trend = np.linspace(hodiny.min(), hodiny.max(), 100)
ax.plot(x_trend, p(x_trend), '--', color='red', alpha=0.8,
        linewidth=2, label=f'Trend: y={z[0]:.2f}x+{z[1]:.1f}')

ax.set_xlabel('Hodiny prace na projektu', fontsize=12)
ax.set_ylabel('Skore kvality kodu (%)', fontsize=12)
ax.set_title('Vztah mezi investovanym casem a kvalitou kodu',
             fontsize=14, fontweight='bold')
ax.legend(fontsize=11)
ax.grid(True, alpha=0.2)

plt.tight_layout()
plt.savefig('bodovy_graf.png', dpi=150)
plt.show()

Pristupnost a novy barevny cyklus petroff10

Jednou z novinek, ktera me osobne potesila, je barevny cyklus petroff10 v Matplotlib 3.10. Byl vytvoren kombinaci algoritmicky vynucenych omezeni pristupnosti (vcetne modelovani barvosleposti) a modelu estetiky zalozenem na strojovem uceni. Cil byl jasny — vytvorit cyklus, ktery je hezky a zaroven pristupny osobam s poruchami barvocitu.

# Pouziti noveho barevneho cyklu petroff10
import matplotlib.pyplot as plt
import numpy as np

# Aktivace stylu petroff10
plt.style.use('petroff10')

# Ukazkova data - mesicni trzby ruznych produktu
mesice = np.arange(1, 13)
nazvy_mesicu = ['Led', 'Uno', 'Bre', 'Dub', 'Kve', 'Cer',
                'Cvc', 'Srp', 'Zar', 'Rij', 'Lis', 'Pro']

fig, ax = plt.subplots(figsize=(12, 6))

# Vytvoreni dat pro 6 produktovych linii
for i in range(6):
    zaklad = 50 + i * 20
    trzby = zaklad + np.cumsum(np.random.randn(12) * 5)
    ax.plot(mesice, trzby, marker='o', linewidth=2,
            markersize=6, label=f'Produkt {chr(65+i)}')

ax.set_xticks(mesice)
ax.set_xticklabels(nazvy_mesicu)
ax.set_xlabel('Mesic', fontsize=12)
ax.set_ylabel('Trzby (tis. Kc)', fontsize=12)
ax.set_title('Mesicni trzby podle produktovych linii (styl petroff10)',
             fontsize=14, fontweight='bold')
ax.legend(loc='upper left', fontsize=10)
ax.grid(True, alpha=0.2)

plt.tight_layout()
plt.savefig('petroff10_ukazka.png', dpi=150)
plt.show()

Seaborn - statisticka vizualizace snadno

Filozofie a zakladni principy

Seaborn je postaveny nad Matplotlib a zameruje se na statistickou vizualizaci. Uprimne receno, jeho hlavni deviza je schopnost vytvorit sofistikovane statisticke grafy s minimalnim mnozstvim kodu. Zatimco Matplotlib casto vyzaduje desitky radku kodu na formatovani, Seaborn dosahne podobneho vysledku na dvou az trech radcich. To neni prehaneni.

Aktualni verze Seaborn 0.13.x prinasi par vyznamnych novinek. Ta nejdulezitejsi je objektove rozhrani (so.Plot), ktere bylo uvedeno ve verzi 0.12 a ve verzi 0.13 vyrazne rozsireno. Toto rozhrani nabizi skladatelny a konzistentni pristup k tvorbe grafu, inspirovany gramatikou grafiky. Dalsi dulezita vec je provizorni podpora alternativnich datovych ramcu (napr. Polars) prostrednictvim DataFrame Interchange Protocol.

Objektove rozhrani so.Plot

Rozhrani seaborn.objects predstavuje budoucnost knihovny Seaborn. Na rozdil od klasickeho funkcniho rozhrani (jako sns.scatterplot()) nabizi retezeny pristup, kde skladate vrstvy vizualizace pomoci metod .add(), .scale(), .facet() a dalsich. Je to elegantni a rychle si na to zvyknete.

# Seaborn objektove rozhrani so.Plot
import seaborn as sns
import seaborn.objects as so
import pandas as pd
import numpy as np

# Vytvoreni ukazkovych dat o studentech
np.random.seed(42)
n = 200
data = pd.DataFrame({
    'hodiny_studia': np.random.uniform(1, 12, n),
    'znamka': np.clip(np.random.normal(70, 15, n), 20, 100),
    'obor': np.random.choice(['Informatika', 'Matematika', 'Fyzika', 'Biologie'], n),
    'rocnik': np.random.choice([1, 2, 3, 4, 5], n)
})
# Pridani korelace mezi hodinami studia a znamkou
data['znamka'] = np.clip(
    data['znamka'] + data['hodiny_studia'] * 2.5 + np.random.normal(0, 5, n),
    20, 100
)

# Pouziti so.Plot pro vytvoreni grafu
(
    so.Plot(data, x='hodiny_studia', y='znamka', color='obor')
    .add(so.Dots(alpha=0.6, pointsize=5))
    .add(so.Line(), so.PolyFit(order=2))
    .facet(col='obor', wrap=2)
    .scale(color='Set2')
    .label(
        x='Hodiny studia denne',
        y='Vysledna znamka (%)',
        title='Vztah mezi casem studia a vysledky podle oboru'
    )
    .layout(size=(12, 8))
    .save('seaborn_objects.png', dpi=150)
)

Tepelna mapa a distribucni grafy

Seaborn vynika v tvorbe tepelnych map (heatmap) a distribucnich grafu. Tepelne mapy jsou idealni pro vizualizaci korelacnich matic a distribucni grafy pomahaji pochopit, jak jsou data rozdelena. Tyhle dve veci budete delat porad.

# Tepelna mapa korelacni matice a distribucni grafy
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Simulovana data o nemovitostech
np.random.seed(42)
n = 500
nemovitosti = pd.DataFrame({
    'plocha_m2': np.random.normal(75, 25, n).clip(25, 200),
    'pocet_pokoju': np.random.choice([1, 2, 3, 4, 5], n, p=[0.1, 0.25, 0.35, 0.2, 0.1]),
    'vzdalenost_centrum_km': np.random.exponential(5, n).clip(0.5, 30),
    'stari_budovy_roky': np.random.uniform(0, 80, n),
    'cena_mil_kc': None
})
# Vypocet ceny na zaklade ostatnich promennych
nemovitosti['cena_mil_kc'] = (
    0.05 * nemovitosti['plocha_m2'] +
    0.3 * nemovitosti['pocet_pokoju'] -
    0.08 * nemovitosti['vzdalenost_centrum_km'] -
    0.01 * nemovitosti['stari_budovy_roky'] +
    np.random.normal(0, 0.5, n) + 2
).clip(0.8, 15)

# Vytvoreni figure se dvema grafy
fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# 1. Tepelna mapa korelaci
korelace = nemovitosti.corr(numeric_only=True)
sns.heatmap(korelace, annot=True, fmt='.2f', cmap='RdBu_r',
            center=0, vmin=-1, vmax=1, ax=axes[0],
            square=True, linewidths=0.5,
            cbar_kws={'label': 'Korelacni koeficient'})
axes[0].set_title('Korelacni matice nemovitosti', fontsize=14, fontweight='bold')

# 2. Distribuce cen podle poctu pokoju
sns.violinplot(data=nemovitosti, x='pocet_pokoju', y='cena_mil_kc',
               palette='Set2', ax=axes[1], inner='box', density_norm='width')
axes[1].set_xlabel('Pocet pokoju', fontsize=12)
axes[1].set_ylabel('Cena (mil. Kc)', fontsize=12)
axes[1].set_title('Distribuce cen podle poctu pokoju', fontsize=14, fontweight='bold')

plt.tight_layout()
plt.savefig('seaborn_heatmap_violin.png', dpi=150)
plt.show()

Parove grafy a kategoricka vizualizace

Jedna z veci, pro ktere Seaborn proste miluju, je pairplot. Automaticky vytvori matici grafu zobrazujici vsechny dvojice promennych v datovem ramci. Pro kategoricka data pak nabizi radu specializovanych grafu — boxploty, violinove grafy, swarm ploty a dalsi.

# Parovy graf s kategorickym rozlisenim
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Nacteni vzorovych dat (Iris dataset)
iris = sns.load_dataset('iris')

# Preklad nazvu druhu do cestiny
preklad = {
    'setosa': 'Kosatec seta',
    'versicolor': 'Kosatec pestry',
    'virginica': 'Kosatec virginsky'
}
iris['druh'] = iris['species'].map(preklad)

# Vytvoreni paroveho grafu
g = sns.pairplot(
    iris,
    hue='druh',
    palette='husl',
    diag_kind='kde',
    plot_kws={'alpha': 0.6, 's': 40, 'edgecolor': 'white', 'linewidth': 0.5},
    diag_kws={'fill': True, 'alpha': 0.5},
    height=2.5,
    aspect=1.1
)

g.figure.suptitle('Parovy graf - dataset Iris', y=1.02,
                   fontsize=16, fontweight='bold')
plt.savefig('seaborn_pairplot.png', dpi=150, bbox_inches='tight')
plt.show()

Temata a konfigurace zobrazeni

Seaborn 0.13.x taky vylepsilo system temat a konfigurace zobrazeni pro objektove rozhrani so.Plot. Preddefinovana temata (darkgrid, whitegrid, dark, white, ticks) vam umozni rychle zmenit vzhled grafu bez manualniho nastavovani kazdeho parametru. Coz je fajn, protoze rucne ladeni stylingu muze byt dost otravne.

Plotly - interaktivni vizualizace pro web

Plotly 6.0 - revolucni aktualizace

Plotly.py 6.0, vydane 28. ledna 2025, je proste nejvyznamnejsi aktualizace teto knihovny za posledni roky. Na rozdil od statickych grafu Matplotlib a Seaborn nabizi Plotly plne interaktivni vizualizace — muzete je priblizovat, otacet, filtrovat a exportovat primo v prohlizeci.

Klicove novinky verze 6.0:

  • Integrace s Narwhals — Plotly Express je nyni agnosticky vuci datovym ramcum. Diky Narwhals funguje nativne s Polars DataFrames bez nutnosti kopirovani dat do Pandas. Narwhals obaluje puvodni DataFrame a pouziva zdrojovou knihovnu pro zpracovani, takze se eliminuje narocne duplikovani.
  • Prepracovany Kaleido — knihovna pro konverzi grafu na staticke obrazky prosla kompletni predelavkou. Nova architektura je doslova tisickrat mensi nez original a mnohem snaze udrzovatelna.
  • Base64 kodovani — NumPy pole jsou nyni kodovana do base64 pred predanim do Plotly.js. U datasetu s 500 000 body to znamena zlepseni az o 40 sekund pri prenosu pres pomalejsi site.
  • Ukonceni podpory Jupyter Notebook < 7.0 — tato zmena umoznila zjednodusit proces sestaveni a vydavani.

Plotly Express - rychla interaktivni vizualizace

Plotly Express je vysoko-urovnove rozhrani pro rychlou tvorbu interaktivnich grafu. S Plotly 6.0 a integraci Narwhals muzete primo pouzivat Polars DataFrames — zadne konverze navic.

# Interaktivni bodovy graf s Plotly Express a Polars
import plotly.express as px
import polars as pl
import numpy as np

# Vytvoreni dat pomoci Polars DataFrame
np.random.seed(42)
n = 1000
df = pl.DataFrame({
    'trzby_tisic_kc': np.random.lognormal(mean=4, sigma=0.8, size=n),
    'pocet_zamestnancu': np.random.randint(5, 500, n),
    'rok_zalozeni': np.random.randint(1990, 2024, n),
    'odvetvi': np.random.choice(
        ['IT', 'Finance', 'Vyrobce', 'Zdravotnictvi', 'Obchod'], n
    ),
    'kraj': np.random.choice(
        ['Praha', 'Brno', 'Ostrava', 'Plzen', 'Olomouc'], n
    )
})

# Plotly 6.0 pracuje primo s Polars diky Narwhals - bez kopirovani do Pandas!
fig = px.scatter(
    df,
    x='pocet_zamestnancu',
    y='trzby_tisic_kc',
    color='odvetvi',
    size='pocet_zamestnancu',
    hover_data=['kraj', 'rok_zalozeni'],
    title='Vztah mezi velikosti firmy a trzbami podle odvetvi',
    labels={
        'pocet_zamestnancu': 'Pocet zamestnancu',
        'trzby_tisic_kc': 'Trzby (tis. Kc)',
        'odvetvi': 'Odvetvi',
        'kraj': 'Kraj',
        'rok_zalozeni': 'Rok zalozeni'
    },
    color_discrete_sequence=px.colors.qualitative.Set2,
    template='plotly_white'
)

fig.update_layout(
    font=dict(family='Arial', size=12),
    title_font_size=16,
    legend_title_font_size=13,
    width=900,
    height=600
)

# Ulozeni jako interaktivni HTML a staticke PNG (pres novy Kaleido)
fig.write_html('interaktivni_scatter.html')
fig.write_image('interaktivni_scatter.png', scale=2)  # Novy Kaleido
fig.show()

3D vizualizace

Jedna z oblasti, kde Plotly opravdu nema konkurenci, jsou 3D vizualizace. Diky interaktivite si uzivatel muze graf libovolne otacet, priblizovat a zkoumat z ruznych uhlu. Tohle s Matplotlib takhle jednoduse proste neudelate.

# 3D vizualizace s Plotly
import plotly.graph_objects as go
import numpy as np

# Vytvoreni dat pro 3D povrch - topograficka data
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)

# Simulace terenu pomoci kombinace sinusoid
Z = (np.sin(np.sqrt(X**2 + Y**2)) * 3 +
     np.cos(X) * np.sin(Y) * 2 +
     np.random.normal(0, 0.1, X.shape))

fig = go.Figure(data=[
    go.Surface(
        x=X, y=Y, z=Z,
        colorscale='Earth',
        colorbar=dict(title='Nadmorska vyska (m)'),
        contours=dict(
            z=dict(show=True, usecolormap=True, project_z=True)
        )
    )
])

fig.update_layout(
    title='3D model terenu - simulovana topograficka data',
    scene=dict(
        xaxis_title='Zemepisna delka',
        yaxis_title='Zemepisna sirka',
        zaxis_title='Nadmorska vyska (m)',
        camera=dict(eye=dict(x=1.5, y=1.5, z=1.2))
    ),
    width=900,
    height=700,
    font=dict(family='Arial')
)

fig.write_html('3d_teren.html')
fig.show()

Framework Dash 3.0

Pro tvorbu plnohodnotnych webovych datovych aplikaci nabizi Plotly framework Dash, aktualne ve verzi 3.0. Dash 3.0 prinesl revolucni system hooku, ktery umoznuje vyvojarum spoustet funkce v urcitych bodech zivotniho cyklu dashboardu — nastaveni Flask rozsireni, spousteni dodatecnych akci, zpracovani chyb a podobne.

Dash 3.3.0 z listopadu 2025 pak pridal dalsi vylepseni. Treba dash_clientside.Patch pro chirurgicke aktualizace vlastnosti komponent bez uplneho prekresleni, parametr optional=True na urovni callbacku a nativni integraci s Plotly Cloud. Celkem solidni update.

Srovnani knihoven

Tak, a ted to nejdulezitejsi — kterou knihovnu vlastne pouzit? Zalezi samozrejme na vasem konkretnim pripadu. Nasledujici tabulka shrnuje klicove rozdily.

Vlastnost Matplotlib 3.10.x Seaborn 0.13.x Plotly 6.0
Typ vystupu Staticky (PNG, SVG, PDF) Staticky (pres Matplotlib) Interaktivni (HTML, JS) + staticke
Krivka uceni Stredni az vysoka Nizka Nizka (Express) / Stredni (GO)
Prizpusobeni Maximalni (plna kontrola) Stredni (dedi z Matplotlib) Vysoke (JSON konfigurace)
Statisticke grafy Zakladni Vynikajici Dobre
3D vizualizace Zakladni (mplot3d) Nepodporuje Vynikajici (WebGL)
Webova integrace Omezena Omezena Nativni (Dash framework)
Podpora Polars Pres NumPy konverzi Provizorni (interchange protocol) Nativni (Narwhals)
Vykon (velka data) Dobry (Agg backend) Dobry (dedi z Matplotlib) Vynikajici (base64, WebGL)
Animace FuncAnimation Nepodporuje primo Vestaven (frames, sliders)
Export obrazku Vestaven Vestaven (pres Matplotlib) Kaleido (prepracovany v 6.0)
Komunita a ekosystem Nejvetsi Velka Rostouci
Idealni pro Vedecke publikace, plna kontrola Statistickou analyzu, EDA Webove dashboardy, prezentace

Kdy pouzit kterou knihovnu

  • Matplotlib: Zvolte, pokud potrebujete maximalni kontrolu nad kazdym pixelem grafu, tvorite grafy pro vedecke publikace s presnym formatovanim, nebo pracujete v prostredi bez weboveho serveru. Hodne se hodi i na automatizovane generovani velkych poctu standardizovanych grafu.
  • Seaborn: Idealni volba pro exploracni datovou analyzu (EDA), statisticke vizualizace a situace, kdy potrebujete rychle a elegantne vizualizovat distribuce, korelace a kategoricke vztahy. Nove objektove rozhrani so.Plot ho posouvа jeste dal.
  • Plotly: Prvni volba pro interaktivni vizualizace na web, dashboardy (Dash), prezentace a situace, kdy uzivatele potrebuji prozkumavat data interaktivne. Vynikajici pro 3D vizualizace a geograficke mapy.

Pokrocile techniky vizualizace

Kombinovani knihoven

V praxi se vubec nemusite omezovat na jedinou knihovnu. Caste je treba pouziti Seaborn pro rychle vytvoreni grafu a nasledne doladeni pomoci Matplotlib — protoze Seaborn grafy jsou pod kapotou Matplotlib objekty. Tenhle pristup pouzivam sam celkem casto a funguje skvele.

# Kombinace Seaborn a Matplotlib pro pokrocile prizpusobeni
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import pandas as pd
import numpy as np

# Data o spokojenosti zamestnancu
np.random.seed(42)
n = 300
data = pd.DataFrame({
    'oddeleni': np.random.choice(
        ['Vyvoj', 'Marketing', 'Finance', 'HR', 'Podpora'], n
    ),
    'spokojenost': np.random.beta(5, 2, n) * 10,
    'zkusenost_let': np.random.exponential(5, n).clip(0.5, 25),
    'plat_index': np.random.normal(100, 20, n).clip(50, 180)
})

# Vytvoreni figure s vlastnim rozlozenim pomoci GridSpec
fig = plt.figure(figsize=(14, 8))
gs = fig.add_gridspec(2, 3, hspace=0.35, wspace=0.3)

# Graf 1: Boxplot spokojenosti podle oddeleni (Seaborn)
ax1 = fig.add_subplot(gs[0, :2])
sns.boxplot(data=data, x='oddeleni', y='spokojenost',
            palette='coolwarm', ax=ax1, width=0.6)
ax1.set_title('Spokojenost podle oddeleni', fontsize=13, fontweight='bold')
ax1.set_xlabel('')
ax1.set_ylabel('Skore spokojenosti')

# Graf 2: Histogram rozdeleni platu (Matplotlib)
ax2 = fig.add_subplot(gs[0, 2])
ax2.hist(data['plat_index'], bins=25, color='#5C6BC0',
         edgecolor='white', alpha=0.8)
ax2.axvline(data['plat_index'].mean(), color='red',
            linestyle='--', linewidth=2, label='Prumer')
ax2.set_title('Rozdeleni platoveho indexu', fontsize=13, fontweight='bold')
ax2.set_xlabel('Platovy index')
ax2.set_ylabel('Cetnost')
ax2.legend()

# Graf 3: KDE plot s vyplni (Seaborn)
ax3 = fig.add_subplot(gs[1, :])
for oddeleni in data['oddeleni'].unique():
    podmnozina = data[data['oddeleni'] == oddeleni]
    sns.kdeplot(podmnozina['zkusenost_let'], ax=ax3,
                fill=True, alpha=0.3, linewidth=2, label=oddeleni)
ax3.set_title('Distribuce let zkusenosti podle oddeleni',
              fontsize=13, fontweight='bold')
ax3.set_xlabel('Roky zkusenosti')
ax3.set_ylabel('Hustota')
ax3.legend(title='Oddeleni', fontsize=9)

# Spolecny nadpis
fig.suptitle('Analyza zamestnanecke spokojenosti a kompenzace',
             fontsize=16, fontweight='bold', y=1.02)

plt.savefig('kombinovany_dashboard.png', dpi=150, bbox_inches='tight')
plt.show()

Animace v Matplotlib

Matplotlib nabizi modul matplotlib.animation pro tvorbu animovanych vizualizaci. Trida FuncAnimation umoznuje vytvorit plynulou animaci opakovanym volanim aktualizacni funkce. Neni to uplne trivialni, ale vysledky stoji za to.

# Animovany graf s Matplotlib
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

fig, ax = plt.subplots(figsize=(10, 6))

# Priprava dat pro animaci - rust portfolia v case
np.random.seed(42)
dny = 365
vynosy_a = np.cumsum(np.random.normal(0.001, 0.02, dny)) + 1
vynosy_b = np.cumsum(np.random.normal(0.0005, 0.015, dny)) + 1
vynosy_c = np.cumsum(np.random.normal(0.0008, 0.025, dny)) + 1

linie_a, = ax.plot([], [], linewidth=2, label='Portfolio A (agresivni)')
linie_b, = ax.plot([], [], linewidth=2, label='Portfolio B (vyvazene)')
linie_c, = ax.plot([], [], linewidth=2, label='Portfolio C (konzervativni)')

ax.set_xlim(0, dny)
ax.set_ylim(0.5, 2.0)
ax.set_xlabel('Den')
ax.set_ylabel('Relativni hodnota')
ax.set_title('Vyvoj hodnoty portfolii v prubehu roku')
ax.legend(loc='upper left')
ax.grid(True, alpha=0.3)

def aktualizuj(snimek):
    """Aktualizacni funkce pro kazdy snimek animace."""
    linie_a.set_data(range(snimek), vynosy_a[:snimek])
    linie_b.set_data(range(snimek), vynosy_b[:snimek])
    linie_c.set_data(range(snimek), vynosy_c[:snimek])
    return linie_a, linie_b, linie_c

# Vytvoreni animace
anim = animation.FuncAnimation(
    fig, aktualizuj, frames=dny, interval=20, blit=True
)

# Ulozeni jako GIF nebo MP4
anim.save('portfolio_animace.gif', writer='pillow', fps=30)
plt.show()

Vizualizace v realnem case

Pro vizualizaci dat v realnem case je nejvhodnejsi Plotly ve spojeni s Dash. Framework Dash 3.0 umoznuje vytvareni dashboardu s automatickym obnovovanim dat prostrednictvim callbacku a intervalu. Pro jednodussi pripady lze vyuzit i Matplotlib s interaktivnim backendem a funkci plt.pause(), ale uprimne — neni to tak robustni jako Dash.

Export do ruznych formatu

Vsechny tri knihovny podporuji export do ruznych formatu, ale kazda to dela trochu jinak:

  • Matplotlib: Nativne podporuje PNG, SVG, PDF, EPS a dalsi. Kvalitu vystupu ridite parametrem dpi a bbox_inches='tight' pro optimalni orezani.
  • Seaborn: Dedi exportni schopnosti z Matplotlib, takze pouzivate stejne metody savefig().
  • Plotly: Pres prepracovany Kaleido exportuje do PNG, SVG, PDF a WebP. Interaktivni vystupy se ukladaji jako HTML soubory. A ten novy Kaleido je fakt o rady mensi nez puvodni verze.

Nejlepsi postupy pro vizualizaci dat

Vyber spravneho typu grafu

Spravny vyber grafu je zakladem efektivni komunikace dat. Tady je strucny tahak, ktery se muze hodit:

  • Porovnani hodnot: Sloupcovy graf (vertikalni i horizontalni), skupinovy sloupcovy graf
  • Trendy v case: Carovy graf, plosny graf
  • Distribuce: Histogram, KDE plot, boxplot, violin plot
  • Vztahy mezi promennymi: Bodovy graf (scatter), bublinovy graf
  • Slozeni celku: Kolacovy graf (jen pro male pocty kategorii!), skladany sloupcovy graf
  • Korelace: Tepelna mapa, parovy graf
  • Geograficka data: Choropleth mapa, bodova mapa

Pristupnost barev

Tohle je tema, ktere se casto podcenouje. Priblizne 8 % muzu a 0,5 % zen trpi nekterou formou barvosleposti. To neni zanedbatelne cislo. Pri tvorbe vizualizaci je proto dulezite:

  1. Pouzivat barevne palety pristupne pro osoby s poruchami barvocitu (napr. novy petroff10 v Matplotlib nebo palety colorblind a Set2 v Seaborn).
  2. Nekombinovat cervenou a zelenou jako jedine rozlisovaci barvy.
  3. Doplnit barevne rozliseni i jinymi vizualnimi kanaly — tvary bodu, typy car (plna, carkovana, teckovana), texturami nebo popisky.
  4. Testovat vizualizace pomoci nastroju simulujicich barvoslepost.

Popisky a anotace

Kazdy graf by mel mit (a je to fakt dulezite):

  • Jasny a vystizny nadpis popisujici co graf zobrazuje
  • Popisky os vcetne jednotek (napr. "Trzby (mil. Kc)")
  • Legendu, pokud je v grafu vice datovych rad
  • Zdroj dat, pokud je graf urcen pro prezentaci nebo publikaci
  • Anotace zvyraznujici dulezite body nebo udalosti

Vypraveni pribehu s daty

Dobra vizualizace neni jen technicky spravna — mela by vypraven pribeh. A to neni jen fraze. Konkretne to znamena:

  1. Definujte hlavni sdeleni — Co chcete, aby divak pochopil na prvni pohled?
  2. Odstrante sum — Kazdy element grafu, ktery neprispiva ke sdeleni, by mel pryc. Zbytecne mrizky, okraje, dekorace.
  3. Zvyraznete to dulezite — Pouzijte barvu, velikost nebo anotace k pritazeni pozornosti.
  4. Poskytnete kontext — Pridejte referencni cary, benchmarky nebo historicka data pro lepsi zasazeni.
  5. Sekvencni prezentace — Pri prezentaci vice grafu je budujte postupne, od jednoducheho k slozitemu.

Integrace s datovymi ramci

Prace s Pandas DataFrames

Pandas zustava i v roce 2026 nejpouzivanejsi knihovnou pro praci s tabulkovymi daty v Pythonu a vsechny tri vizualizacni knihovny s nim bezchybne spolupracuji. Pandas navic nabizi vlastni vizualizacni rozhrani postavene na Matplotlib, takze muzete volat grafy primo z DataFrame. To je docela pohodlne pro rychle prozkoumani dat.

# Vizualizace primo z Pandas DataFrame
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Vytvoreni casove rady - mesicni data o navstevnosti webu
np.random.seed(42)
datumy = pd.date_range('2024-01-01', periods=24, freq='MS')
df = pd.DataFrame({
    'datum': datumy,
    'navstevy': np.cumsum(np.random.normal(500, 200, 24)) + 10000,
    'konverze': np.cumsum(np.random.normal(20, 10, 24)) + 400,
    'prumerny_cas_min': np.random.normal(4.5, 0.8, 24).clip(1, 8)
})
df = df.set_index('datum')

# Vizualizace primo z DataFrame - Pandas pouziva Matplotlib backend
fig, axes = plt.subplots(3, 1, figsize=(12, 10), sharex=True)

# Carovy graf navstevnosti
df['navstevy'].plot(ax=axes[0], color='#1976D2', linewidth=2)
axes[0].fill_between(df.index, df['navstevy'], alpha=0.1, color='#1976D2')
axes[0].set_ylabel('Pocet navstev')
axes[0].set_title('Mesicni navstevnost webu', fontweight='bold')

# Sloupcovy graf konverzi
df['konverze'].plot(kind='bar', ax=axes[1], color='#388E3C', alpha=0.8)
axes[1].set_ylabel('Pocet konverzi')
axes[1].set_title('Mesicni konverze', fontweight='bold')
axes[1].tick_params(axis='x', rotation=45)

# Oblast - prumerny cas na strance
df['prumerny_cas_min'].plot(kind='area', ax=axes[2],
                             color='#F57C00', alpha=0.4)
axes[2].set_ylabel('Cas (minuty)')
axes[2].set_title('Prumerny cas na strance', fontweight='bold')
axes[2].tick_params(axis='x', rotation=45)

plt.tight_layout()
plt.savefig('pandas_vizualizace.png', dpi=150)
plt.show()

Prace s Polars a Narwhals abstrakce

Polars je moderny datovy ramec napsany v Rustu, ktery nabizi vyrazne lepsi vykon nez Pandas, hlavne u velkych datasetu. V roce 2026 je adopce Polars na vzestupu a vizualizacni knihovny na to reaguji.

Klicovou roli v propojeni Polars s vizualizacnimi knihovnami hraje Narwhals. Je to lehka kompatibilitni vrstva mezi knihovnami datovych ramcu. Pouziva podmnozinu Polars API s nulovymi zavislostmi, obaluje puvodni DataFrame a pro zpracovani pouziva zdrojovou knihovnu. To znamena, ze nedochazi k zadnemu kopirovani dat — coz je docela dulezity detail.

Narwhals uz pouzivaji hlavni open-source projekty vcetne Altair, Bokeh, Marimo a zejmena Plotly, kde tvori zaklad pro agnostickou podporu datovych ramcu v Plotly Express.

# Prace s Polars a vizualizace pres Plotly (nativni podpora diky Narwhals)
import polars as pl
import plotly.express as px

# Nacteni a transformace dat v Polars
df = pl.DataFrame({
    'mesto': ['Praha', 'Brno', 'Ostrava', 'Plzen', 'Liberec',
              'Olomouc', 'Hradec Kralove', 'Ceske Budejovice',
              'Usti nad Labem', 'Pardubice'] * 4,
    'rok': [2023] * 10 + [2024] * 10 + [2025] * 10 + [2026] * 10,
    'obyvatel_tisic': [
        1309, 382, 284, 175, 104, 100, 92, 94, 92, 91,
        1315, 385, 282, 177, 105, 101, 93, 95, 91, 92,
        1320, 388, 281, 178, 106, 102, 93, 96, 90, 93,
        1325, 390, 280, 180, 107, 103, 94, 97, 89, 94
    ]
})

# Agregace v Polars - prumerne obyvatelstvo a trend
trend = df.group_by('mesto').agg([
    pl.col('obyvatel_tisic').mean().alias('prumer'),
    (pl.col('obyvatel_tisic').last() - pl.col('obyvatel_tisic').first()).alias('zmena')
]).sort('prumer', descending=True)

# Plotly Express primo pouzije Polars DataFrame diky Narwhals integraci
fig = px.bar(
    trend,
    x='mesto',
    y='prumer',
    color='zmena',
    color_continuous_scale='RdYlGn',
    title='Prumerne obyvatelstvo ceskych mest (2023-2026) a demograficky trend',
    labels={
        'mesto': 'Mesto',
        'prumer': 'Prumerne obyvatelstvo (tis.)',
        'zmena': 'Zmena (tis.)'
    },
    template='plotly_white'
)

fig.update_layout(
    xaxis_tickangle=-45,
    font=dict(family='Arial', size=12),
    coloraxis_colorbar_title='Zmena
(tis. obyvatel)'
)

fig.write_html('polars_plotly.html')
fig.show()

Hybridni pracovni postup DuckDB + Polars + Pandas

V roce 2026 se prosazuje trend, ktery mi prijde hodne prakticky — hybridni pracovni postup kombinujici silne stranky tri ruznych nastroju:

  1. DuckDB pro robustni pripravu dat pomoci SQL — dotazovani velkych souboru (Parquet, CSV) primo z disku bez nutnosti nacitat vse do pameti. V benchmarcich je DuckDB nejrychlejsi s prumernym casem 3,84 sekundy na typickych analytickych dotazech.
  2. Polars pro vysokorychlostni transformace s prumernym casem 5,77 sekundy — temer petinarobny narust oproti Pandas (19,57 sekundy). Ten rozdil je fakt znatelny.
  3. Pandas pro finalni analyzu, modelovani a vizualizace diky jeho neprekonatelne sirce ekosystemu a vyzralym API.

DuckDB muze primo dotazovat Pandas, Polars i Arrow DataFrames, propojovat je s velkymi externimi soubory a vracet vysledky v ruznych formatech. Kazdy nastroj pouzijete tam, kde exceluje — DuckDB pro I/O a SQL, Polars pro rychlost, Pandas pro ergonomii.

# Hybridni pracovni postup: DuckDB + Polars + Plotly vizualizace
import duckdb
import polars as pl
import plotly.express as px

# 1. DuckDB - nacteni a agregace velkych dat pomoci SQL
conn = duckdb.connect()

# Simulace dotazu na velky dataset (v praxi by to byl Parquet soubor)
vysledek = conn.execute("""
    SELECT
        odvetvi,
        kraj,
        COUNT(*) as pocet_firem,
        AVG(trzby) as prumerne_trzby,
        MEDIAN(pocet_zamestnancu) as median_zamestnancu
    FROM 'firemni_data.parquet'
    GROUP BY odvetvi, kraj
    HAVING COUNT(*) > 10
    ORDER BY prumerne_trzby DESC
""")

# 2. Prevod do Polars pro dalsi transformace
# DuckDB muze vracet vysledky primo jako Polars DataFrame
df_polars = vysledek.pl()

# Dalsi transformace v Polars - pridani vypocitanych sloupcu
df_polars = df_polars.with_columns([
    (pl.col('prumerne_trzby') / pl.col('median_zamestnancu'))
    .alias('trzby_na_zamestnance'),
    pl.col('prumerne_trzby')
    .rank('ordinal')
    .alias('poradi_trzeb')
])

# 3. Vizualizace v Plotly - primo z Polars DataFrame
fig = px.treemap(
    df_polars,
    path=['odvetvi', 'kraj'],
    values='pocet_firem',
    color='trzby_na_zamestnance',
    color_continuous_scale='Viridis',
    title='Struktura firem podle odvetvi a kraju'
)

fig.show()

Zaver

Vizualizace dat v Pythonu v roce 2026 nabizi opravdu bezprecedentni moznosti. Kazda ze tri hlavnich knihoven ma sve nezastupitelne misto v ekosystemu a spis nez se je snazit porovnavat, davа smysl pochopit, kdy kterou pouzit.

Matplotlib 3.10.x zustava zakladem. S novym barevnym cyklem petroff10, podporou pro free-threaded CPython 3.13 a desitkami let vyvoje je nenahraditelny pro vedecke publikace a pripady, kde potrebujete absolutni kontrolu nad vystupem. Je to knihovna, na ktere stoji i Seaborn.

Seaborn 0.13.x s objektovym rozhranim so.Plot meni zpusob, jakym vytvarime statisticke vizualizace. Provizorni podpora Polars ukazuje smer budouciho vyvoje. Pro exploracni analyzu a statistiku zustava neprekonanym nastrojem.

Plotly 6.0 udelalo obri krok vpred — nativni podpora Polars pres Narwhals, prepracovany Kaleido, base64 kodovani pro rychlejsi komunikaci. Ve spojeni s Dash 3.0 tvori komplexni platformu pro webove datove aplikace.

Doporuceni pro ruzne pripady pouziti

  • Vedecke clanky a publikace: Matplotlib (pripadne se Seaborn pro statisticke grafy) — maximalni kontrola nad formatovanim, nativni export do vektorovych formatu.
  • Exploracni datova analyza (EDA): Seaborn s objektovym rozhranim so.Plot — nejrychlejsi cesta k pochopeni struktury dat.
  • Interaktivni dashboardy a webove aplikace: Plotly + Dash — nativni interaktivita, snadne nasazeni, integrace s modernimi datovymi ramci.
  • Prezentace a reporty: Plotly Express pro interaktivni HTML reporty, Matplotlib/Seaborn pro staticke PDF.
  • Prace s velkymi daty: Plotly 6.0 diky base64 kodovani a Narwhals integraci, nebo Matplotlib s downsamplovanim.
  • Hybridni datovy postup: DuckDB (SQL dotazy) + Polars (rychle transformace) + libovolna vizualizacni knihovna dle potreby.

At uz si vyberete jakoukoli knihovnu, pamatujte na zaklady — spravny typ grafu, pristupne barvy, popsane osy a legendy. A hlavne: nechte data vypraven svuj pribeh. V roce 2026 mate k dispozici ty nejlepsi nastroje, ktere Python kdy nabidl. Tak je vyuzijte.