Matplotlib și Seaborn: Ghid Python 2026

Dacă lucrați cu date în Python, la un moment dat veți ajunge inevitabil la întrebarea: „Bun, am numerele — dar cum le arăt altcuiva?" Și, sincer, e o întrebare pe care o pun și eu de fiecare dată când deschid un CSV nou. Aici intră în scenă vizualizarea datelor, și aici devin esențiale două biblioteci pe care probabil le veți folosi zilnic: Matplotlib și Seaborn.

Pe scurt: Matplotlib e fundația ecosistemului de vizualizare din Python — o bibliotecă matură, extrem de flexibilă, capabilă să producă orice tip de grafic pe care vi-l puteți imagina. Seaborn, construită deasupra lui Matplotlib, adaugă un strat de abstractizare inteligentă: grafice statistice sofisticate cu cod minimal, teme vizuale moderne și integrare nativă cu DataFrames din pandas. Împreună formează un duo care acoperă cam orice nevoie de vizualizare — de la explorare rapidă a datelor până la grafice de calitate publicabilă.

În acest ghid vom parcurge tot ce trebuie să știți pentru a stăpâni vizualizarea datelor în Python în 2026. Pornim de la instalare și concepte fundamentale, trecem prin tipuri de grafice, personalizare avansată, subploturi, și ajungem la noile funcționalități din Matplotlib 3.10 și Seaborn 0.13. Dacă ați citit deja ghidul nostru despre Pandas 3.0 sau cel despre Polars, articolul de față e complementul natural — odată ce aveți datele pregătite, trebuie să le și vizualizați.

Instalare și Configurare Inițială

Ambele biblioteci se instalează simplu cu pip. Dacă folosiți un mediu virtual (și chiar ar trebui — întotdeauna), activați-l mai întâi:

pip install matplotlib seaborn pandas numpy

Seaborn depinde de Matplotlib, deci instalarea lui Seaborn va aduce automat și Matplotlib. Dar e o practică bună să le instalați explicit pe ambele, ca să aveți control asupra versiunilor. La momentul scrierii, versiunile curente sunt Matplotlib 3.10.8 și Seaborn 0.13.2.

Importurile standard pe care le veți scrie în aproape orice script de vizualizare:

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

# Opțional: setați tema Seaborn pentru un aspect mai plăcut
sns.set_theme(style="whitegrid")

Dacă lucrați într-un Jupyter Notebook, adăugați %matplotlib inline pentru a afișa graficele direct în notebook. E un detaliu mic, dar vă scutește de frustrare.

Anatomia unei Figuri Matplotlib

Înainte de a construi grafice, trebuie să înțelegeți structura din spate. Și recunosc — la început mi s-a părut puțin confuză. Dar odată ce o înțelegeți, totul devine mult mai clar.

Orice vizualizare Matplotlib e compusă din câteva elemente ierarhice:

Figure — containerul de nivel superior. Gândiți-vă la el ca la „pânza" pe care desenați.
Axes — zona efectivă a graficului (atenție: nu confundați cu „axis", adică axa). O figură poate conține mai multe obiecte Axes, adică subploturi.
Axis — axele X și Y propriu-zise, cu scale, tick-uri și etichete.
Artist — orice element vizibil pe figură: linii, text, markere, legende.

Această ierarhie contează enorm când vreți control precis. Iată cum creați o figură cu un singur subplot:

fig, ax = plt.subplots(figsize=(10, 6))
ax.set_title("Titlul graficului")
ax.set_xlabel("Axa X")
ax.set_ylabel("Axa Y")
plt.show()

Folosirea explicită a fig, ax = plt.subplots() în loc de plt.plot() direct vă oferă mult mai mult control. E considerată practica recomandată în 2026, și sincer — odată ce vă obișnuiți, nu vă mai întoarceți.

Grafice Fundamentale cu Matplotlib

Graficul Liniar (Line Plot)

Cel mai simplu și probabil cel mai utilizat tip de grafic — ideal pentru a arăta evoluția unei variabile în timp:

luni = ["Ian", "Feb", "Mar", "Apr", "Mai", "Iun",
        "Iul", "Aug", "Sep", "Oct", "Nov", "Dec"]
vanzari_2025 = [120, 135, 150, 145, 160, 175, 190, 185, 170, 195, 210, 230]
vanzari_2026 = [140, 155, 165, 170, 180, 195, 205, 200, 190, 215, 235, 250]

fig, ax = plt.subplots(figsize=(12, 6))
ax.plot(luni, vanzari_2025, marker="o", linewidth=2, label="2025")
ax.plot(luni, vanzari_2026, marker="s", linewidth=2, label="2026")
ax.set_title("Evoluția Vânzărilor Lunare", fontsize=16, fontweight="bold")
ax.set_xlabel("Luna")
ax.set_ylabel("Vânzări (mii RON)")
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Observați cum adăugăm markere diferite ("o" vs "s") pentru a distinge seriile. Un detaliu mic, dar face o diferență mare în lizibilitate.

Graficul cu Bare (Bar Chart)

Perfect pentru compararea valorilor între categorii discrete. E genul de grafic pe care îl vedeți peste tot în prezentări:

categorii = ["Python", "R", "SQL", "Julia", "Scala"]
utilizatori = [68, 15, 42, 5, 8]

fig, ax = plt.subplots(figsize=(10, 6))
bare = ax.bar(categorii, utilizatori, color=sns.color_palette("viridis", len(categorii)))
ax.set_title("Popularitatea Limbajelor în Data Science (2026)", fontsize=14)
ax.set_ylabel("% Utilizatori")

# Adăugăm valorile deasupra fiecărei bare
for bara in bare:
    inaltime = bara.get_height()
    ax.text(bara.get_x() + bara.get_width() / 2., inaltime + 0.5,
            f"{inaltime}%", ha="center", va="bottom", fontweight="bold")

plt.tight_layout()
plt.show()

Graficul Scatter (Scatter Plot)

Scatter plot-ul e arma voastră principală când vreți să vedeți relația dintre două variabile continue:

np.random.seed(42)
ore_studiu = np.random.uniform(1, 10, 100)
nota = 3 + 0.6 * ore_studiu + np.random.normal(0, 1, 100)
nota = np.clip(nota, 1, 10)

fig, ax = plt.subplots(figsize=(10, 6))
scatter = ax.scatter(ore_studiu, nota, c=nota, cmap="RdYlGn",
                     s=60, alpha=0.7, edgecolors="black", linewidth=0.5)
ax.set_title("Corelația dintre Orele de Studiu și Nota Obținută")
ax.set_xlabel("Ore de studiu pe zi")
ax.set_ylabel("Nota")
fig.colorbar(scatter, label="Nota")
plt.tight_layout()
plt.show()

Am folosit cmap="RdYlGn" (roșu-galben-verde) pentru a colora punctele în funcție de notă. Rezultatul e un grafic care transmite informație și prin poziție, și prin culoare.

Histograma

Esențială pentru înțelegerea distribuției unei variabile. Dacă trebuie să răspundeți la întrebarea „cum arată datele mele?", histograma e primul lucru pe care îl faceți:

date_salariu = np.random.lognormal(mean=8.5, sigma=0.5, size=1000)

fig, ax = plt.subplots(figsize=(10, 6))
ax.hist(date_salariu, bins=40, color="steelblue", edgecolor="white", alpha=0.8)
ax.axvline(np.median(date_salariu), color="red", linestyle="--",
           linewidth=2, label=f"Mediană: {np.median(date_salariu):.0f}")
ax.set_title("Distribuția Salariilor (Date Simulate)")
ax.set_xlabel("Salariu (RON)")
ax.set_ylabel("Frecvență")
ax.legend()
plt.tight_layout()
plt.show()

Grafice Statistice cu Seaborn

Acum hai să trecem la Seaborn, unde lucrurile devin cu adevărat interesante. Seaborn excelează la graficele statistice — acolo unde Matplotlib necesită 15-20 de linii de cod, Seaborn rezolvă treaba în 2-3. Vom folosi setul de date tips inclus în Seaborn:

tips = sns.load_dataset("tips")
print(tips.head())

Box Plot — Vizualizarea Distribuțiilor

Box plot-ul e unul dintre graficele mele preferate. Arată distribuția datelor prin cuartile, mediana și valorile aberante — totul într-o formă compactă:

fig, ax = plt.subplots(figsize=(10, 6))
sns.boxplot(data=tips, x="day", y="total_bill", hue="sex",
            palette="Set2", ax=ax)
ax.set_title("Distribuția Notei de Plată pe Zi și Gen")
ax.set_xlabel("Ziua Săptămânii")
ax.set_ylabel("Nota de Plată ($)")
plt.tight_layout()
plt.show()

Violin Plot — Distribuții Detaliate

Violin plot-ul combină un box plot cu o estimare a densității. Rezultatul? O imagine mult mai bogată a distribuției decât ce oferă un box plot simplu:

fig, ax = plt.subplots(figsize=(10, 6))
sns.violinplot(data=tips, x="day", y="total_bill", hue="smoker",
               split=True, inner="box", palette="muted", ax=ax)
ax.set_title("Distribuția Notei de Plată: Fumători vs. Nefumători")
plt.tight_layout()
plt.show()

Parametrul split=True e deosebit de util — împarte vioara în două jumătăți, fiecare reprezentând o categorie din variabila hue. Apropo, în Matplotlib 3.10, parametrul orientation înlocuiește vechiul vert pentru controlul orientării. Merită ținut minte dacă lucrați cu versiuni recente.

Heatmap — Matricea de Corelație

Heatmap-ul e instrumentul de bază pentru vizualizarea corelațiilor dintre variabile numerice. Îl folosesc constant în faza exploratorie:

corelatie = tips[["total_bill", "tip", "size"]].corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(corelatie, annot=True, fmt=".2f", cmap="coolwarm",
            center=0, square=True, linewidths=1, ax=ax)
ax.set_title("Matricea de Corelație — Setul de Date Tips")
plt.tight_layout()
plt.show()

Pair Plot — Relații Multiple Simultan

Pair plot-ul e extrem de util în faza exploratorie. Generează automat scatter plot-uri pentru fiecare pereche de variabile numerice, cu histograme (sau KDE) pe diagonală. E genul de grafic care vă arată imediat dacă există ceva interesant în date:

sns.pairplot(tips, hue="smoker", palette="husl",
             diag_kind="kde", corner=True)
plt.suptitle("Relații între Variabile — Dataset Tips", y=1.02)
plt.show()

Parametrul corner=True afișează doar jumătatea inferioară a matricei, eliminând duplicarea. Un mic truc care face graficul mai ușor de citit.

Subploturi și Layout-uri Complexe

Rareori veți avea nevoie de un singur grafic izolat. În practică, de obicei vreți să comparați mai multe vizualizări într-un dashboard coerent.

Subploturi Simple cu plt.subplots()

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Grafic liniar
axes[0, 0].plot(luni, vanzari_2025, "o-", color="steelblue")
axes[0, 0].set_title("Vânzări 2025")

# Grafic cu bare
axes[0, 1].bar(categorii, utilizatori, color="coral")
axes[0, 1].set_title("Limbaje Data Science")

# Histogramă
axes[1, 0].hist(date_salariu, bins=30, color="seagreen", edgecolor="white")
axes[1, 0].set_title("Distribuția Salariilor")

# Scatter plot
axes[1, 1].scatter(ore_studiu, nota, c="purple", alpha=0.5)
axes[1, 1].set_title("Ore Studiu vs. Nota")

fig.suptitle("Dashboard de Vizualizare a Datelor", fontsize=16, fontweight="bold")
plt.tight_layout()
plt.show()

Patru grafice diferite, un singur apel plt.subplots(2, 2). Simplu și eficient.

Layout-uri Neuniforme cu GridSpec

Dar ce faceți când aveți nevoie de un grafic mare în partea de sus și două mici dedesubt? Sau orice altă combinație non-uniformă? Aici intervine GridSpec:

import matplotlib.gridspec as gridspec

fig = plt.figure(figsize=(14, 10))
gs = gridspec.GridSpec(2, 2, height_ratios=[2, 1], hspace=0.3, wspace=0.3)

# Grafic mare — ocupă întregul rând de sus
ax_main = fig.add_subplot(gs[0, :])
ax_main.plot(luni, vanzari_2025, "o-", label="2025")
ax_main.plot(luni, vanzari_2026, "s-", label="2026")
ax_main.set_title("Comparație Anuală a Vânzărilor", fontsize=14)
ax_main.legend()
ax_main.grid(True, alpha=0.3)

# Grafic mic stânga
ax_left = fig.add_subplot(gs[1, 0])
ax_left.bar(categorii, utilizatori, color=sns.color_palette("pastel"))
ax_left.set_title("Limbaje Populare")

# Grafic mic dreapta
ax_right = fig.add_subplot(gs[1, 1])
ax_right.hist(date_salariu, bins=25, color="goldenrod", edgecolor="white")
ax_right.set_title("Distribuție Salarii")

fig.suptitle("Dashboard cu GridSpec", fontsize=16, fontweight="bold")
plt.show()

FacetGrid din Seaborn — Grafice Condiționate

FacetGrid e una dintre cele mai puternice funcționalități din Seaborn, și sincer, una pe care o subutilizez uneori. Vă permite să creați automat o matrice de grafice condiționate de variabile categorice:

g = sns.FacetGrid(tips, col="time", row="smoker",
                  hue="sex", height=4, aspect=1.2)
g.map_dataframe(sns.scatterplot, x="total_bill", y="tip")
g.add_legend()
g.set_titles("{row_name} | {col_name}")
g.fig.suptitle("Bacșișul în funcție de Notă, Moment și Fumător", y=1.02)
plt.show()

Un grid 2×2 (fumător/nefumător × prânz/cină) cu scatter plot-uri colorate pe gen — într-o singură comandă. Greu de bătut ca eficiență.

Personalizare Avansată și Teme

Stiluri și Palete de Culori

Seaborn oferă mai multe teme predefinite. Hai să le vedem pe toate odată, ca să puteți alege:

# Teme disponibile
stiluri = ["whitegrid", "darkgrid", "white", "dark", "ticks"]

fig, axes = plt.subplots(1, 5, figsize=(20, 4))
for ax, stil in zip(axes, stiluri):
    with sns.axes_style(stil):
        ax.plot([1, 2, 3, 4], [1, 4, 2, 3], "o-")
        ax.set_title(stil)

plt.tight_layout()
plt.show()

Preferatul meu personal? whitegrid — curat, profesional, și funcționează bine atât pe ecran cât și la print.

Matplotlib 3.10 a introdus ciclul de culori petroff10, proiectat algoritmic pentru accesibilitate (inclusiv daltonism) și estetică bazată pe sondaje de preferințe. Merită încercat:

# Utilizarea noului ciclu de culori accesibil din Matplotlib 3.10
plt.style.use("petroff10")

fig, ax = plt.subplots(figsize=(10, 6))
for i in range(5):
    ax.plot(range(10), np.random.randn(10).cumsum(), linewidth=2, label=f"Seria {i+1}")
ax.legend()
ax.set_title("Ciclul de culori petroff10 — accesibil și estetic")
plt.tight_layout()
plt.show()

Adnotări și Evidențieri

Un grafic bun nu doar arată date — evidențiază ceea ce contează. Iată cum puteți atrage atenția asupra punctelor importante:

fig, ax = plt.subplots(figsize=(12, 6))
ax.plot(luni, vanzari_2026, "o-", color="steelblue", linewidth=2)

# Evidențiem luna cu vânzări maxime
idx_max = np.argmax(vanzari_2026)
ax.annotate(f"Maxim: {vanzari_2026[idx_max]}k",
            xy=(luni[idx_max], vanzari_2026[idx_max]),
            xytext=(luni[idx_max - 3], vanzari_2026[idx_max] + 15),
            arrowprops=dict(arrowstyle="->", color="red", lw=2),
            fontsize=12, color="red", fontweight="bold")

# Zonă evidențiată
ax.axhspan(200, 260, alpha=0.1, color="green", label="Zona țintă")
ax.legend()
ax.set_title("Vânzări 2026 cu Adnotări")
plt.tight_layout()
plt.show()

Adnotările cu săgeți (ax.annotate) și zonele evidențiate (ax.axhspan) sunt instrumente simple dar incredibil de eficiente. Le folosesc în aproape fiecare prezentare.

Interfața Objects din Seaborn — Viitorul Vizualizării

Începând cu versiunea 0.12, Seaborn a introdus interfața Objects (seaborn.objects) — o abordare declarativă inspirată de Grammar of Graphics (ceva similar cu ggplot2 din R, dacă veniți din acea lume). În Seaborn 0.13.2, interfața continuă să se maturizeze:

import seaborn.objects as so

# Grafic folosind interfața Objects
(
    so.Plot(tips, x="total_bill", y="tip", color="smoker")
    .add(so.Dot(alpha=0.6))
    .add(so.Line(), so.PolyFit(order=2))
    .facet("time")
    .label(title="Bacșiș vs. Notă de Plată",
           x="Nota de plată ($)", y="Bacșiș ($)")
    .layout(size=(12, 5))
    .show()
)

Ce aduce nou interfața Objects? Câteva avantaje concrete:

Compozabilitate — adăugați straturi de vizualizare prin înlănțuire de metode, ca într-un pipeline
Consistență — aceleași concepte funcționează pentru orice tip de grafic
Faceting nativ — crearea de grafice multi-panel devine trivială
Personalizare fără Matplotlib — control complet al aspectului fără a coborî la nivelul Matplotlib

E încă în dezvoltare activă, dar dacă vreți să fiți pregătiți pentru viitor, merită să o învățați de pe acum. API-ul clasic nu dispare, dar Objects e clar direcția.

Salvarea și Exportul Graficelor

Odată ce aveți un grafic gata, trebuie să-l salvați corect. Pare simplu, dar sunt câteva detalii care fac diferența:

# Salvare în format PNG cu rezoluție înaltă
fig.savefig("grafic_vanzari.png", dpi=300, bbox_inches="tight",
            facecolor="white", transparent=False)

# Salvare în format vectorial (ideal pentru publicații)
fig.savefig("grafic_vanzari.svg", format="svg", bbox_inches="tight")

# Salvare în PDF
fig.savefig("grafic_vanzari.pdf", format="pdf", bbox_inches="tight")

Câteva sfaturi practice pentru export:

Folosiți dpi=300 pentru grafice destinate printării sau prezentărilor — 72 dpi (default-ul) arată pixelat pe print
bbox_inches="tight" elimină spațiul alb inutil din jurul graficului (o să mă mulțumiți mai târziu)
SVG e ideal pentru web — se scalează fără pierderi de calitate
Pentru rapoarte LaTeX sau publicații academice, PDF e formatul de ales

Noutăți Matplotlib 3.10 și Seaborn 0.13 în 2026

Hai să vedem ce e nou și ce merită atenția voastră.

Matplotlib 3.10 (actualizat la 3.10.8)

Ciclul de culori petroff10 — proiectat algoritmic pentru accesibilitate universală, inclusiv daltonism. Sincer, ar trebui să fie default-ul.
3 hărți de culori divergente noi — „berlin", „managua" și „vanimo". Sunt dark-mode friendly, cu luminozitate minimă la centru.
Rotire 3D îmbunătățită — stilul ARCBALL bazat pe algoritmul lui Ken Shoemake e mult mai intuitiv decât ce aveam înainte.
Parametrul orientation — înlocuiește vert: bool cu orientation: str, ceea ce e mai explicit și mai ușor de citit.
Suport Python 3.13 free-threaded — experimentare cu multi-threading nativ. Încă devreme, dar promițător.

Seaborn 0.13 (versiunea curentă: 0.13.2)

Suport provisional pentru Polars — puteți pasa DataFrames Polars direct în funcțiile Seaborn, fără conversie la pandas
Parametrul native_scale — controlează tratamentul datelor numerice în graficele categorice
Interfața Objects îmbunătățită — sistem de teme și configurare a afișării mai mature
Violin plot-uri split cu box interior — mini-box-uri separate pentru fiecare jumătate, ceea ce oferă și mai multă informație

Cele Mai Bune Practici pentru Vizualizare în 2026

După câțiva ani buni de lucru cu date și vizualizări, iată regulile care (din experiența mea) fac cu adevărat diferența:

Alegeți tipul corect de grafic — bar chart pentru comparații categorice, line plot pentru evoluție temporală, scatter pentru corelații, heatmap pentru matrici. Nu forțați datele într-un format nepotrivit.
Folosiți fig, ax = plt.subplots() — întotdeauna. API-ul orientat pe obiect oferă control complet și cod mai curat decât plt.plot() apelat direct.
Etichetați totul — titlu, axe, legendă. Un grafic fără etichete e, sincer, un grafic inutil.
Minimizați clutter-ul — eliminați gridlines excesive și detalii inutile. Raportul date-la-cerneală trebuie să fie cât mai mare (mulțumim, Edward Tufte).
Gândiți-vă la accesibilitate — folosiți palete prietenoase cu daltonismul (petroff10, viridis), markere distincte, și contrast suficient.
Salvați la rezoluție înaltă — dpi=300 e minimul pentru orice destinat prezentării.
Seaborn pentru explorare, Matplotlib pentru publicare — începeți cu Seaborn pentru analiză rapidă, apoi rafinați cu Matplotlib când aveți nevoie de control pixel-perfect. E un workflow care funcționează excelent.

Întrebări Frecvente (FAQ)

Care este diferența dintre Matplotlib și Seaborn?

Matplotlib e biblioteca fundamentală de vizualizare din Python — oferă control granular asupra fiecărui element. Seaborn e construită deasupra lui Matplotlib și vine cu o interfață de nivel superior: teme estetice predefinite, integrare nativă cu pandas și funcții specializate pentru grafice statistice. Pe scurt, folosiți Matplotlib când aveți nevoie de personalizare completă și Seaborn când vreți grafice elegante cu cod minimal.

Cum aleg tipul potrivit de grafic pentru datele mele?

Regula generală: pentru evoluție temporală folosiți grafice liniare; pentru comparații între categorii, grafice cu bare; pentru corelații între variabile continue, scatter plot-uri; pentru distribuții, histograme sau violin plot-uri; pentru matrici de corelație, heatmap-uri. Pair plot-urile din Seaborn sunt excelente pentru o vizualizare exploratorie rapidă a mai multor variabile simultan.

Pot folosi Seaborn cu Polars DataFrames în loc de pandas?

Da! Începând cu Seaborn 0.13, există suport provisional pentru DataFrames din biblioteci alternative, inclusiv Polars. Puteți pasa un DataFrame Polars direct în funcțiile Seaborn. Funcționalitatea e încă marcată ca provizorie, dar în practică funcționează bine pentru majoritatea cazurilor de utilizare comune.

Cum salvez un grafic la calitate înaltă pentru o publicație?

Folosiți fig.savefig("grafic.png", dpi=300, bbox_inches="tight") pentru format raster. Pentru calitate vectorială (ideală în publicații academice), folosiți SVG sau PDF: fig.savefig("grafic.pdf", format="pdf", bbox_inches="tight"). Nu uitați de bbox_inches="tight" — elimină automat spațiul alb inutil.

Ce este interfața Objects din Seaborn și ar trebui s-o folosesc?

Interfața Objects (seaborn.objects) e un API declarativ introdus în Seaborn 0.12, inspirat de Grammar of Graphics. Oferă compozabilitate prin înlănțuirea metodelor, faceting nativ și personalizare consistentă. E încă în dezvoltare activă, dar reprezintă clar viitorul bibliotecii. Recomandarea mea: învățați-o în paralel cu API-ul clasic, care rămâne complet funcțional.