...
Pregătire interviuri

100 de întrebări de interviu Python pentru analiza datelor, cu răspunsuri

Întrebările despre Python pentru analiza datelor care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Data Analysis with Python: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 51junior
  • 35mid
  • 14senior
  • 132 minde citit
Întrebări de interviu Python pentru analiza datelor cu răspunsuri

La un interviu pentru un rol de analiză a datelor, partea de Python înseamnă aproape mereu NumPy și pandas: cum selectezi, filtrezi, cureți, grupezi și unești tabele, cum lucrezi cu date calendaristice și cum transformi rezultatul într-un grafic sau într-un fișier. Întrebările vin în trei forme: teorie scurtă („care e diferența dintre loc și iloc?”), cod de citit („ce afișează…?”, „unde e bug-ul?”) și exerciții live sau teme pe un CSV real, în care contează și cât de curat și verificabil e codul.

De la un junior se așteaptă să stăpânească selecția, filtrarea, valorile lipsă, groupby, merge și graficele de bază, fără greșeli de sintaxă și fără bucle acolo unde există o operație vectorizată. De la un mid se așteaptă să anticipeze capcanele: chei duplicate la merge, alinierea după index, tipuri greșite la citire, memorie, performanță, rezultate care nu se potrivesc cu sursa. La senior apar întrebări despre organizarea codului de analiză, testare, depanare în producție și alegerea uneltelor.

Folosește pagina activ: citește întrebarea, încearcă să răspunzi cu voce tare sau să scrii codul într-un notebook, abia apoi deschide răspunsul. Rulează exemplele: toate sunt scrise pentru pandas 2.x și NumPy 1.26 sau mai nou. Bazele limbajului Python și machine learning-ul au pagini separate, așa că aici ne concentrăm strict pe uneltele de analiză.

NumPy: array-uri și vectorizare

1 Junior

Ce afișează fiecare linie și de ce sunt rezultatele diferite?

PYTHON
import numpy as np
print([1, 2, 3] * 2)
print(np.array([1, 2, 3]) * 2)
print(np.array([1, "2", 3]))

Răspuns scurt: Prima linie repetă lista: [1, 2, 3, 1, 2, 3]. A doua înmulțește fiecare element: [2 4 6]. A treia transformă totul în text, pentru că un array are un singur tip: ['1' '2' '3'].

O listă Python este o colecție de referințe către obiecte oarecare, iar operatorul * pe listă înseamnă repetare. Un ndarray din NumPy este un bloc de memorie cu elemente de același tip (dtype), iar operatorii aritmetici se aplică element cu element. Asta e baza vectorizării: scrii operația o dată, iar NumPy o execută în cod compilat pe tot array-ul.

PYTHON
a = np.array([1, 2, 3])
a * 2        # array([2, 4, 6])
a + a        # array([2, 4, 6])
[1, 2] + [3] # listă: [1, 2, 3], concatenare

A treia linie arată cealaltă față a omogenității: dacă amesteci numere și text, NumPy alege un tip comun care le poate reprezenta pe toate, aici un șir de caractere (<U21). Calculele numerice nu mai merg după asta: np.array([1, "2", 3]).sum() dă eroare.

În practică, verifică mereu arr.dtype după ce construiești un array din date venite din afară. Un dtype de tip text sau object acolo unde te așteptai la numere e primul semn că datele au valori murdare.

Ce urmărește intervievatorul: Verifică dacă înțelegi că un array nu este o listă mai rapidă, ci o structură cu alt model: tip unic și operații element cu element. Mulți candidați uită de conversia la text la tipuri amestecate.

2 Junior

Ce afișează codul? Explică shape, ndim, size și ce înseamnă -1 în reshape.

PYTHON
a = np.arange(12)
b = a.reshape(3, -1)
print(b.shape, b.ndim, b.size)
print(b[1])

Răspuns scurt: Afișează (3, 4) 2 12, apoi [4 5 6 7]. Valoarea -1 îi cere lui NumPy să calculeze singur dimensiunea care lipsește: 12 elemente pe 3 rânduri înseamnă 4 coloane.

shape este tuplul cu dimensiunile, ndim numărul de dimensiuni (lungimea lui shape), iar size numărul total de elemente (produsul dimensiunilor). np.arange(12) produce un vector cu shape (12,), deci o singură dimensiune.

reshape reorganizează aceleași date într-o altă formă, cu condiția ca numărul de elemente să rămână același. Cu -1 lași o dimensiune să fie dedusă; poți folosi -1 o singură dată. Elementele se așază rând cu rând (ordinea C), deci rândul cu indicele 1 conține 4, 5, 6, 7.

PYTHON
a.reshape(4, 3)    # 4 rânduri, 3 coloane
a.reshape(-1, 1)   # coloană: shape (12, 1)
a.reshape(5, -1)   # ValueError: 12 nu se împarte la 5

Distincția dintre (12,) și (12, 1) contează mult: prima este un vector, a doua o matrice cu o coloană, iar la broadcasting se comportă diferit. De multe ori reshape întoarce o vedere (view) a acelorași date, nu o copie, așa că modificarea lui b se vede și în a.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că poți raționa despre forma datelor fără să rulezi codul. Greșeala tipică este confuzia dintre un vector 1D și o matrice cu o singură coloană.

Eroarea, în practică:cannot reshape array of size 10 into shapetoo many indices for array (1-dimensional)

3 Junior

Ai o matrice cu vânzări: rândurile sunt magazine, coloanele sunt zilele săptămânii. Cum calculezi totalul pe fiecare magazin și media pe fiecare zi? Ce înseamnă axis?

PYTHON
v = np.array([[10, 20, 30],
              [ 5, 15, 25]])

Răspuns scurt: Totalul pe magazin este v.sum(axis=1), adică [60 45], iar media pe zi este v.mean(axis=0), adică [7.5 17.5 27.5]. axis indică dimensiunea care dispare prin agregare.

Cel mai simplu mod de a ține minte axis este că numește dimensiunea de-a lungul căreia mergi și care se reduce. Pentru o matrice 2D, axis=0 înseamnă că mergi în jos, pe rânduri, și obții un rezultat per coloană; axis=1 înseamnă că mergi pe orizontală și obții un rezultat per rând.

PYTHON
v.sum(axis=1)    # array([60, 45])       un total pe magazin
v.mean(axis=0)   # array([ 7.5, 17.5, 27.5]) o medie pe zi
v.sum()          # 105, totalul general
v.argmax(axis=1) # array([2, 2]) ziua cu vânzări maxime pe magazin

Aceeași regulă se aplică în pandas: df.sum() are implicit axis=0 și întoarce un total pe coloană, iar df.sum(axis=1) un total pe rând. df.drop(..., axis=1) respectă aceeași logică, eliminând o coloană.

Dacă vrei ca rezultatul să păstreze forma pentru a-l folosi apoi în calcule cu matricea originală, folosește keepdims=True: v.sum(axis=1, keepdims=True) are shape (2, 1) și se poate împărți direct cu v ca să obții ponderile fiecărei zile în totalul magazinului.

Ce urmărește intervievatorul: Se verifică dacă știi direcția lui axis; foarte mulți o inversează sub presiune. Un răspuns bun are și verificarea prin shape a rezultatului.

Eroarea, în practică:axis 1 is out of bounds for array of dimension 1

4 Junior

Ai un array cu notele unor elevi. Cum afli câte note sunt peste 8, ce procent reprezintă și cum etichetezi fiecare notă ca „promovat” sau „respins” fără buclă?

Răspuns scurt: Construiești o mască booleană: (note > 8).sum() dă numărul, (note > 8).mean() procentul, iar np.where(note >= 5, "promovat", "respins") etichetele. Condițiile multiple se combină cu &, | și ~, fiecare între paranteze.

O comparație pe un array întoarce un array de valori True și False, numit mască booleană. Pentru că True valorează 1 și False 0, suma măștii numără elementele care respectă condiția, iar media ei este direct proporția.

PYTHON
note = np.array([9.5, 4, 7, 8.5, 10, 3])
mask = note > 8
mask.sum()          # 3
mask.mean() * 100   # 50.0 (procent)
note[mask]          # array([ 9.5,  8.5, 10. ])
np.where(note >= 5, "promovat", "respins")

Pentru condiții compuse nu poți folosi and și or, care cer o singură valoare de adevăr și dau ValueError pe un array. Folosești operatorii pe biți &, |, ~. Parantezele sunt obligatorii, pentru că & are prioritate mai mare decât comparațiile:

PYTHON
note[(note >= 5) & (note < 8)]   # corect
# note >= 5 & note < 8          # greșit: se evaluează 5 & note

np.where(cond, a, b) alege element cu element între două valori sau două array-uri și este echivalentul vectorizat al unui if/else aplicat pe fiecare element.

Ce urmărește intervievatorul: Verifică stăpânirea măștilor, care sunt baza filtrării și în pandas. Greșeala clasică este lipsa parantezelor sau folosirea lui and.

Eroarea, în practică:truth value of an array is ambiguous

5 Junior

Ce afișează codul și ce lecție scoți de aici despre dtype?

PYTHON
a = np.array([1, 2, 3])
a[0] = 2.9
print(a)

b = np.array([100, 100], dtype=np.int8)
print(b + b)

Răspuns scurt: Afișează [2 2 3], pentru că un array de întregi trunchiază valoarea zecimală la atribuire. Apoi afișează [-56 -56]: int8 ține doar valori între -128 și 127, iar 200 depășește intervalul și „dă peste cap”.

Tipul unui array este fixat la creare. np.array([1, 2, 3]) primește un tip întreg (de obicei int64), iar când atribui 2.9 unui element, NumPy nu schimbă tipul array-ului, ci convertește valoarea la întreg prin trunchiere, fără niciun avertisment. Dacă vrei zecimale, creezi array-ul cu dtype=float sau îl convertești cu a.astype(float).

Al doilea exemplu arată overflow-ul. Tipurile cu lățime fixă au un interval limitat: int8 între -128 și 127, int16 până la 32.767, int32 până la aproximativ 2,1 miliarde. Aritmetica pe array-uri nu verifică depășirea, ci face wraparound: 200 devine 200 - 256 = -56.

PYTHON
np.iinfo(np.int8)          # min=-128, max=127
b.astype(np.int16) + b     # array([200, 200], dtype=int16)

În analiză, problema apare când reduci memoria alegând tipuri mici (de exemplu int8 pentru o coloană care pare mică), iar apoi o înmulțești sau o aduni. Regula practică: folosește tipuri mici doar pentru stocare și verifică intervalul (min, max) înainte de downcast.

Ce urmărește intervievatorul: Intervievatorul caută conștientizarea faptului că NumPy nu protejează împotriva pierderii silențioase de informație. Un candidat bun pomenește și verificarea intervalului înainte de optimizarea tipurilor.

Eroarea, în practică:Python integer 300 out of bounds for uint8

6 Junior

De ce np.nan == np.nan este False și ce afișează codul de mai jos? Cum calculezi corect media?

PYTHON
x = np.array([4.0, np.nan, 8.0])
print(x.mean(), np.nanmean(x), (x == np.nan).sum())

Răspuns scurt: Afișează nan 6.0 0. NaN nu este egal cu nimic, nici cu el însuși, deci comparația dă mereu False. Media obișnuită se „contaminează” cu NaN; folosești np.nanmean sau filtrezi cu ~np.isnan(x).

NaN (Not a Number) este o valoare specială din standardul IEEE 754 pentru numere în virgulă mobilă. Prin definiție, orice comparație cu NaN întoarce False, inclusiv np.nan == np.nan. De aceea (x == np.nan).sum() dă 0 chiar dacă array-ul conține un NaN. Testul corect este np.isnan(x).

Orice operație aritmetică cu NaN produce NaN, deci x.mean() întoarce nan. NumPy are variante care ignoră valorile lipsă:

PYTHON
np.isnan(x)            # array([False,  True, False])
np.isnan(x).sum()      # 1 valoare lipsă
np.nanmean(x)          # 6.0
np.nansum(x), np.nanmax(x)
x[~np.isnan(x)].mean() # 6.0, filtrare explicită

Atenție la două lucruri. NaN există doar pentru tipuri float, deci un array de întregi nu poate conține valori lipsă fără conversie la float. Și pandas are comportamentul invers față de NumPy: Series.mean() ignoră implicit valorile lipsă (skipna=True). Când treci date între cele două biblioteci, rezultatele pot diferi exact din acest motiv.

Ce urmărește intervievatorul: Se testează dacă știi cum se detectează corect valorile lipsă la nivel de NumPy. Mulți încearcă == np.nan și nu înțeleg de ce nu găsesc nimic.

7 Junior

Cum generezi date aleatoare reproductibile în NumPy și ce diferență este între np.random.seed și np.random.default_rng?

Răspuns scurt: Creezi un generator cu np.random.default_rng(42) și apelezi metodele pe el. Același seed dă aceleași numere. np.random.seed setează o stare globală, veche și ușor de stricat de alt cod, deci în cod nou se recomandă generatorul local.

Numerele „aleatoare” din NumPy sunt pseudo-aleatoare: un algoritm determinist pornit dintr-o valoare inițială, seed-ul. Același seed produce aceeași secvență, ceea ce face o simulare sau un eșantion reproductibil pentru colegi și pentru tine peste o lună.

API-ul recomandat din NumPy 1.17 încoace este Generator:

PYTHON
rng = np.random.default_rng(42)
rng.normal(loc=100, scale=15, size=5)   # 5 valori normale
rng.integers(1, 7, size=10)             # zaruri, 7 exclus
rng.choice(["A", "B"], size=8, p=[0.7, 0.3])
rng.permutation(10)

Vechiul np.random.seed(42) urmat de np.random.rand() modifică o stare globală comună. Orice altă funcție, inclusiv dintr-o bibliotecă, care consumă numere din aceeași stare schimbă rezultatele tale. Un generator local îl poți transmite explicit funcțiilor, așa că știi exact cine îl folosește.

În pandas, df.sample(n=100, random_state=42) acceptă fie un întreg, fie un generator. Într-o analiză, pune seed-ul o singură dată, la începutul notebook-ului sau ca parametru al funcției, și menționează-l în raport atunci când rezultatul depinde de eșantionare.

Ce urmărește intervievatorul: Se verifică grija pentru reproductibilitate și cunoașterea API-ului modern. Răspunsul slab este „pun seed(0)” fără să știe de ce starea globală e o problemă.

8 Mid

Ce afișează codul și cum explici diferența dintre o vedere (view) și o copie în NumPy?

PYTHON
a = np.arange(6)
b = a[:3]
b[0] = 99
c = a[[1, 2]]
c[0] = -1
print(a)

Răspuns scurt: Afișează [99 1 2 3 4 5]. Slicing-ul a[:3] întoarce o vedere peste aceeași memorie, deci modificarea lui b schimbă a. Indexarea cu o listă (fancy indexing) întoarce o copie, deci modificarea lui c nu afectează a.

O vedere este un array nou care privește aceeași zonă de memorie, cu altă formă sau alt pas. Slicing-ul cu : și reshape (de cele mai multe ori) întorc vederi, pentru că se pot descrie doar prin început, pas și dimensiuni. Avantajul: nu se copiază nimic, deci e rapid și ieftin chiar pe array-uri mari. Dezavantajul: o modificare prin vedere se vede în original.

Indexarea cu o listă de poziții sau cu o mască booleană nu se poate descrie printr-un pas regulat, așa că NumPy creează o copie.

PYTHON
b.base is a          # True: b este o vedere peste a
c.base is None       # True: c are memoria lui
np.shares_memory(a, b)  # True
sub = a[:3].copy()   # copie explicită, sigură de modificat

În practică, problema apare când extragi o porțiune ca să o normalizezi sau să înlocuiești valori și, fără să vrei, modifici datele originale folosite mai departe în analiză. Dacă intenția ta este să lucrezi pe o bucată independentă, scrie explicit .copy(). Aceeași idee stă la baza avertismentelor din pandas legate de copii și atribuiri în lanț.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi care operații copiază și care nu. Candidații presupun adesea că orice selecție creează un obiect independent.

9 Mid

Ai o matrice X cu 1.000 de rânduri (clienți) și 5 coloane (indicatori). Cum scazi media fiecărei coloane și cum împarți fiecare rând la suma lui, fără bucle?

Răspuns scurt: Prin broadcasting: X - X.mean(axis=0) scade un vector de 5 elemente din fiecare rând, iar X / X.sum(axis=1, keepdims=True) împarte fiecare rând la un vector coloană de forma (1000, 1).

Broadcasting-ul este regula prin care NumPy combină array-uri de forme diferite. Formele se compară de la dreapta la stânga, iar două dimensiuni sunt compatibile dacă sunt egale sau dacă una dintre ele este 1. Dimensiunea 1 se „întinde” virtual, fără copiere.

PYTHON
X.shape                    # (1000, 5)
mu = X.mean(axis=0)        # (5,)
Xc = X - mu                # (1000, 5) - (5,) -> funcționează

s = X.sum(axis=1)          # (1000,)
# X / s                    # ValueError: (1000,5) vs (1000,)
X / s[:, None]             # (1000,5) / (1000,1) -> ponderi pe rând
X / X.sum(axis=1, keepdims=True)  # același lucru

Primul caz merge direct, pentru că un vector (5,) se aliniază cu ultima dimensiune. Al doilea nu merge fără ajustare: (1000,) se aliniază tot cu ultima dimensiune, adică cu 5, și formele nu se potrivesc. Soluția este să transformi vectorul în coloană cu [:, None], reshape(-1, 1) sau keepdims=True.

Pentru standardizare completă: (X - X.mean(axis=0)) / X.std(axis=0). Verifică întotdeauna forma rezultatului cu .shape. Cel mai periculos caz nu este eroarea, ci un broadcasting reușit pe direcția greșită, de exemplu când matricea este pătrată și ambele variante rulează fără eroare.

Ce urmărește intervievatorul: Se verifică dacă aplici regulile de broadcasting pe un caz concret de analiză, nu doar le recunoști. Un răspuns bun pomenește riscul matricei pătrate, unde direcția greșită nu dă eroare.

Eroarea, în practică:operands could not be broadcast together

10 Mid

Scrie vectorizat calculul comisionului: 0% pentru vânzări sub 1.000 lei, 5% între 1.000 și 5.000 lei și 8% peste 5.000 lei, pentru un array cu un milion de valori.

Răspuns scurt: Folosești np.select cu o listă de condiții și una de valori: np.select([v < 1000, v <= 5000], [0, 0.05], default=0.08) * v. Condițiile se evaluează în ordine, iar prima adevărată câștigă.

Varianta cu buclă for și if/elif pe un milion de valori rulează în interpretorul Python, element cu element, și este de zeci sau sute de ori mai lentă decât o operație pe tot array-ul. np.where imbricat funcționează, dar devine greu de citit de la trei ramuri în sus. np.select este forma curată:

PYTHON
rng = np.random.default_rng(0)
v = rng.uniform(0, 10_000, size=1_000_000)

conditii = [v < 1000, v <= 5000]
rate = [0.0, 0.05]
comision = np.select(conditii, rate, default=0.08) * v

np.select alege, pentru fiecare element, valoarea corespunzătoare primei condiții adevărate. Ordinea contează: a doua condiție nu mai trebuie să verifice v >= 1000, pentru că elementele sub 1.000 au fost deja prinse de prima.

Pentru praguri numerice există și o variantă și mai compactă, np.digitize sau pd.cut, care întoarce indicele intervalului:

PYTHON
idx = np.digitize(v, [1000, 5000], right=True)  # 0, 1 sau 2
comision = np.array([0, 0.05, 0.08])[idx] * v

Merită să verifici granițele explicit, cu câteva valori de test (999, 1000, 5000, 5001), pentru că exact acolo apar diferențele față de cerința de business.

Ce urmărește intervievatorul: Intervievatorul urmărește dacă gândești vectorizat pentru reguli cu mai multe ramuri și dacă ai grijă la valorile de la granițe, unde se ascund cele mai multe bug-uri.

11 Senior

Un coleg calculează distanța dintre fiecare pereche de puncte din 100.000 de locații folosind broadcasting: d = np.sqrt(((P[:, None, :] - P[None, :, :])**2).sum(-1)). Pe date mici merge, pe datele reale procesul moare. De ce și ce faci?

Răspuns scurt: Broadcasting-ul creează intermediar un array de 100.000 x 100.000 x 2 valori float64, adică sute de GB. Soluția: lucrezi pe bucăți, folosești float32 unde precizia permite sau o structură spațială (KD-tree) care evită calculul tuturor perechilor.

Broadcasting-ul nu copiază datele de intrare, dar rezultatul și intermediarele sunt materializate complet. Aici diferența P[:, None, :] - P[None, :, :] are forma (n, n, 2). Pentru n = 100.000 înseamnă 2 x 10^10 valori, iar la 8 octeți pe float64 ajungi la aproximativ 160 GB, la care se adaugă pătratul și suma. Codul este corect matematic, dar complexitatea în memorie este O(n²).

Opțiunile, în ordinea în care le-aș evalua:

  • Întreb ce se cere de fapt. Rareori ai nevoie de toate perechile; de obicei vrei cel mai apropiat punct sau punctele dintr-o rază. Atunci o structură precum scipy.spatial.cKDTree răspunde fără matricea completă.
  • Dacă îți trebuie chiar toate distanțele, le calculezi pe blocuri de rânduri și agregi rezultatul pe loc, de exemplu minimul pe fiecare rând:
PYTHON
def cel_mai_apropiat(P, bloc=2000):
    rez = np.empty(len(P))
    for i in range(0, len(P), bloc):
        d = ((P[i:i+bloc, None, :] - P[None, :, :])**2).sum(-1)
        np.fill_diagonal(d[:, i:i+bloc], np.inf)
        rez[i:i+bloc] = np.sqrt(d.min(axis=1))
    return rez
  • float32 înjumătățește memoria, cu precizie de circa 7 cifre semnificative, de obicei suficientă pentru coordonate.

Lecția generală: înainte de o operație vectorizată pe date mari, estimează forma și dimensiunea în octeți a fiecărui intermediar (arr.nbytes).

Ce urmărește intervievatorul: Se verifică dacă înțelegi costul în memorie al vectorizării și dacă poți estima dimensiuni înainte să rulezi. Un senior întreabă întâi ce problemă de business se rezolvă.

Eroarea, în practică:operands could not be broadcast together

Series, DataFrame și selecție

12 Junior

Ce afișează codul și de ce apar valori NaN?

PYTHON
import pandas as pd
s1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
s2 = pd.Series([10, 20, 30], index=["b", "c", "d"])
print(s1 + s2)

Răspuns scurt: Afișează a NaN, b 12.0, c 23.0, d NaN. pandas aliniază Series după etichetele indexului, nu după poziție; etichetele care există doar într-una dintre ele primesc NaN. Cu s1.add(s2, fill_value=0) obții 1, 12, 23, 30.

O Series este un array cu etichete. Spre deosebire de NumPy, operațiile între două Series nu se fac pe poziție, ci după index: pandas face întâi reuniunea etichetelor, apoi adună valorile cu aceeași etichetă. Pentru „a” și „d” lipsește un termen, deci rezultatul este NaN, iar tipul devine float64, pentru că NaN este float.

PYTHON
s1 + s2
# a     NaN
# b    12.0
# c    23.0
# d     NaN

s1.add(s2, fill_value=0)   # a 1, b 12, c 23, d 30
s1.values + s2.values      # array([11, 22, 33]) pe poziție

Alinierea este utilă: dacă ai vânzările pe județ din două luni, iar unele județe lipsesc dintr-o lună, nu riști să aduni Clujul cu Iașiul doar pentru că erau pe același rând. Același mecanism se aplică între coloane de DataFrame-uri diferite și la atribuirea unei Series într-un DataFrame.

Când vrei explicit calcul pe poziție, treci prin .to_numpy(). Când vrei aliniere fără NaN, folosește metodele add, sub, mul, div cu fill_value.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai înțeles conceptul central din pandas, indexul. Candidații care gândesc ca în Excel sau NumPy se așteaptă la adunare pe poziție.

13 Junior

Care este diferența dintre df["pret"] și df[["pret"]]? Ce întorc df[["produs", "pret"]] și df["produs", "pret"]?

Răspuns scurt: df["pret"] întoarce o Series, iar df[["pret"]] un DataFrame cu o singură coloană. O listă de nume selectează mai multe coloane; df["produs", "pret"] caută o singură coloană cu numele tuplu ("produs", "pret") și dă KeyError.

Parantezele pătrate pe un DataFrame au reguli simple, dar ușor de încurcat. Cu un singur nume de coloană primești o Series, adică o dimensiune, cu indexul DataFrame-ului. Cu o listă de nume primești un DataFrame, chiar dacă lista are un singur element.

PYTHON
df["pret"]               # Series
df[["pret"]]             # DataFrame, shape (n, 1)
df[["produs", "pret"]]   # DataFrame cu două coloane, în ordinea cerută
df["produs", "pret"]     # KeyError: ('produs', 'pret')

Ultima formă eșuează pentru că virgula dintre paranteze creează un tuplu, iar pandas îl tratează ca pe un singur nume (tuplurile sunt nume valide de coloane într-un MultiIndex).

Diferența dintre Series și DataFrame contează mai departe: metodele disponibile, formatul la afișare, comportamentul la merge sau to_csv și forma cerută de unele funcții. De exemplu, df[["pret"]].mean() întoarce o Series cu o valoare, în timp ce df["pret"].mean() întoarce direct un număr.

Accesul prin atribut, df.pret, funcționează doar pentru nume fără spații care nu se suprapun cu metode (o coloană numită count sau size nu se poate accesa așa) și nu poate crea coloane noi. În cod de producție, forma cu paranteze este mai sigură.

Ce urmărește intervievatorul: Se verifică precizia la operațiile de bază. Greșeala tipică este presupunerea că orice selecție întoarce același tip de obiect.

Eroarea, în practică:KeyError: 'Pret' (coloană inexistentă)KeyError: None of [Index(...)] are in the [columns]

14 Junior

Câte rânduri întoarce fiecare linie, pentru un DataFrame cu indexul implicit 0, 1, 2, 3, 4?

PYTHON
df = pd.DataFrame({"x": range(5)})
print(len(df.loc[1:3]), len(df.iloc[1:3]))
df2 = df.sort_values("x", ascending=False)
print(df2.loc[0, "x"], df2.iloc[0]["x"])

Răspuns scurt: Prima linie afișează 3 2: slicing-ul cu loc include capătul, cu iloc nu. A doua afișează 0 4: loc caută eticheta 0, care după sortare a rămas pe rândul cu x = 0, iar iloc ia primul rând fizic.

loc lucrează cu etichete, iloc cu poziții, iar consecințele merg mai departe decât sintaxa.

La slicing, iloc[1:3] urmează regula din Python: începe la poziția 1 și se oprește înainte de 3, deci rândurile 1 și 2. loc[1:3] înseamnă „de la eticheta 1 până la eticheta 3”, inclusiv capătul, pentru că la etichete (de exemplu df.loc["2025-01":"2025-03"] sau df.loc["Arad":"Cluj"]) nu există un „element următor” natural față de care să te oprești.

A doua parte arată de ce contează distincția. După sort_values, indexul nu se renumerotează: rândurile își păstrează etichetele originale, doar ordinea se schimbă. Indexul lui df2 este 4, 3, 2, 1, 0.

PYTHON
df2.loc[0, "x"]     # 0: eticheta 0, aflată acum pe ultimul rând
df2.iloc[0]["x"]    # 4: primul rând din ordinea curentă
df2.reset_index(drop=True).loc[0, "x"]  # 4

Același lucru se întâmplă după filtrare, dropna sau drop_duplicates. Regula practică: folosește iloc când vrei „primul rând” sau „ultimele 10”, loc când știi eticheta sau ai o condiție, și resetează indexul dacă vrei din nou numerotarea 0..n-1.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că indexul supraviețuiește sortării și filtrării. Răspunsul greșit tipic presupune că loc[0] înseamnă primul rând.

Eroarea, în practică:KeyError: 0 (rând după poziție)single positional indexer is out-of-bounds

15 Junior

Scrie filtrul pentru comenzile din Cluj sau Iași, cu valoare între 100 și 500 de lei inclusiv, care nu au statusul „anulată”. Arată și varianta cu query.

Răspuns scurt: df[df["oras"].isin(["Cluj", "Iași"]) & df["valoare"].between(100, 500) & (df["status"] != "anulată")]. Cu query: df.query('oras in ["Cluj", "Iași"] and 100 <= valoare <= 500 and status != "anulată"').

Pentru filtre cu mai multe valori posibile, isin înlocuiește lanțurile de == legate cu |. between(a, b) include implicit ambele capete (inclusive="both"), iar negarea se face cu ~ sau cu !=.

PYTHON
mask = (
    df["oras"].isin(["Cluj", "Iași"])
    & df["valoare"].between(100, 500)
    & (df["status"] != "anulată")
)
rez = df[mask]

# varianta cu query
orase = ["Cluj", "Iași"]
rez = df.query("oras in @orase and 100 <= valoare <= 500 and status != 'anulată'")

Păstrarea măștii într-o variabilă cu nume are avantaje reale: poți afișa mask.sum() ca să vezi câte rânduri trec, poți reutiliza filtrul și poți depana fiecare condiție separat.

query primește un șir de caractere în care poți scrie and, or, not și comparații înlănțuite. Variabilele Python se folosesc cu prefixul @, iar coloanele cu spații se scriu între backticks: ` data comenzii > '2025-01-01' `. Este mai lizibil pentru filtre lungi, dar erorile apar abia la rulare și editorul nu te ajută cu numele coloanelor.

O capcană: df["status"] != "anulată" păstrează și rândurile unde statusul lipsește (NaN), pentru că NaN este diferit de orice. Dacă vrei să le excluzi, adaugă df["status"].notna().

Ce urmărește intervievatorul: Se verifică fluența la filtrare și cunoașterea scurtăturilor isin, between și query. Un candidat atent menționează comportamentul valorilor lipsă la !=.

Eroarea, în practică:The truth value of a Series is ambiguousCannot perform 'rand_' ... scalar of type [bool]

16 Junior

Când folosești set_index și reset_index? Ce face reset_index(drop=True)?

Răspuns scurt: set_index mută o coloană în index, ca să selectezi și să aliniezi după ea (de exemplu cod produs sau dată). reset_index readuce indexul într-o coloană și pune numerotarea 0..n-1; cu drop=True renunță la indexul vechi în loc să-l transforme în coloană.

Indexul nu este doar numărul rândului. Poate fi o cheie cu sens: codul produsului, CNP-ul anonimizat, data. Cu set_index obții:

  • selecție rapidă și lizibilă după cheie: produse.loc["P-102", "pret"];
  • aliniere automată la operații între tabele cu aceeași cheie;
  • operații pe timp, dacă indexul este de tip dată (resample, selecție pe interval).
PYTHON
p = produse.set_index("cod")
p.loc[["P-102", "P-200"], ["nume", "pret"]]

reset_index face invers. Apare foarte des după groupby, unde cheile de grupare ajung în index, iar tu vrei un tabel simplu pentru export sau pentru un nou merge:

PYTHON
rap = df.groupby("oras")["valoare"].sum().reset_index()
filtrat = df[df["valoare"] > 0].reset_index(drop=True)

Fără drop=True, indexul vechi devine o coloană numită index, de obicei inutilă după o filtrare. Cu drop=True obții din nou o numerotare continuă.

Două capcane: set_index nu verifică unicitatea, deci loc poate întoarce mai multe rânduri dacă cheia se repetă (verifică cu df.index.is_unique); și ambele metode întorc un obiect nou, deci trebuie să atribui rezultatul.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi rolul indexului ca cheie. Mulți candidați resetează sau setează indexul mecanic, fără să știe de ce.

Eroarea, în practică:KeyError: 0 (rând după poziție)cannot reindex on an axis with duplicate labels

17 Junior

Cum afli ce procent din comenzi vine din fiecare canal (web, aplicație, telefon), inclusiv comenzile fără canal completat? Ce diferență e între unique și nunique?

Răspuns scurt: df["canal"].value_counts(normalize=True, dropna=False) * 100 dă procentul pe fiecare canal, inclusiv NaN. unique() întoarce valorile distincte ca array, nunique() doar numărul lor și ignoră implicit NaN.

value_counts numără aparițiile fiecărei valori și le sortează descrescător. Parametrii care contează în practică:

  • normalize=True întoarce proporții în loc de numere absolute;
  • dropna=False include valorile lipsă ca o categorie separată (implicit sunt excluse, iar procentele se calculează doar din valorile completate);
  • sort=False păstrează ordinea apariției, util pentru categorii ordonate.
PYTHON
df["canal"].value_counts(dropna=False)
df["canal"].value_counts(normalize=True, dropna=False).mul(100).round(1)
df[["canal", "oras"]].value_counts()   # combinații, din pandas 1.1

Diferența dintre dropna=True și dropna=False nu e un detaliu: dacă 20% din comenzi nu au canal, procentele calculate fără ele arată o distribuție care nu există în realitate. Într-un raport, menționează explicit categoria „necunoscut”.

unique() întoarce un array cu valorile distincte, în ordinea apariției, inclusiv NaN. nunique() întoarce un număr și exclude NaN, dacă nu dai dropna=False. Pentru o primă explorare a unui tabel, df.nunique() pe tot DataFrame-ul arată rapid care coloane sunt identificatori (aproape toate valorile distincte), care sunt categorii (puține valori) și care sunt constante (o singură valoare, deci inutile).

Ce urmărește intervievatorul: Se verifică dacă știi să descrii rapid o coloană categorială și dacă ții cont de valorile lipsă în procente. Greșeala frecventă este ignorarea lor fără să o spui.

Eroarea, în practică:'DataFrame' object has no attribute 'unique'

18 Junior

Unde e bug-ul? Codul trebuie să elimine coloana „cost” și să păstreze rezultatul sortat după preț.

PYTHON
df.drop("cost")
df = df.sort_values("pret", inplace=True)
print(df.head())

Răspuns scurt: Două bug-uri. drop("cost") caută implicit un rând cu eticheta „cost” și dă KeyError; trebuie columns="cost" sau axis=1, iar rezultatul trebuie atribuit. Cu inplace=True, sort_values întoarce None, deci df devine None.

Prima linie greșește de două ori. drop are implicit axis=0, adică elimină rânduri după etichetă; cum nu există un rând cu eticheta „cost”, apare KeyError. Chiar și cu axa corectă, drop întoarce un DataFrame nou, iar rezultatul nu este atribuit, deci linia nu are efect.

A doua linie combină două stiluri incompatibile. Cu inplace=True, metoda modifică obiectul și întoarce None. Atribuirea df = ... suprascrie DataFrame-ul cu None, iar df.head() dă AttributeError: 'NoneType' object has no attribute 'head'.

Varianta corectă și idiomatică:

PYTHON
df = df.drop(columns="cost").sort_values("pret")

columns= este mai explicit decât axis=1 și se citește fără să ții minte numerele axelor. Pentru coloane care s-ar putea să nu existe, errors="ignore" evită excepția.

În general, în codul modern se evită inplace=True. Nu aduce economie reală de memorie în majoritatea cazurilor, împiedică înlănțuirea metodelor, și mai multe metode au pierdut sau urmează să piardă parametrul. Stilul „atribui rezultatul” este mai previzibil: fiecare pas produce un obiect nou, iar codul se citește de sus în jos.

Ce urmărește intervievatorul: Intervievatorul verifică atenția la API: axa implicită și ce întoarce o metodă. E o capcană clasică la exercițiile de tip „găsește bug-ul”.

Eroarea, în practică:['telefon'] not found in axis (drop)'NoneType' ... 'head' (după inplace=True)

19 Junior

Cum afișezi primele 5 produse după preț și, la preț egal, pe cele cu stocul cel mai mare? Ce diferență este între sort_values().head() și nlargest?

Răspuns scurt: df.sort_values(["pret", "stoc"], ascending=[False, False]).head(5) sortează după preț, apoi după stoc la egalitate. nlargest(5, "pret") este mai rapid și mai scurt, dar sortează după o singură coloană principală; prin keep="all" păstrează toate egalitățile de la limită.

sort_values acceptă o listă de coloane și o listă de direcții, câte una pentru fiecare coloană. Al doilea criteriu se aplică doar între rândurile egale după primul.

PYTHON
top = df.sort_values(["pret", "stoc"], ascending=[False, False]).head(5)

df.nlargest(5, "pret")                 # top 5 după preț
df.nlargest(5, ["pret", "stoc"])       # departajare după stoc
df.nlargest(5, "pret", keep="all")     # include toate egalitățile de la locul 5
df.nsmallest(3, "pret")

nlargest nu sortează tot tabelul, ci selectează direct cele mai mari n valori, ceea ce contează pe milioane de rânduri. Parametrul keep decide ce se întâmplă cu egalitățile de la limită: "first" (implicit) păstrează primele apărute, "last" ultimele, iar "all" le păstrează pe toate, deci poți primi mai mult de n rânduri.

Câteva detalii utile: sort_values pune valorile lipsă la final, indiferent de direcție, dacă nu schimbi na_position; sortarea nu renumerotează indexul; iar dacă vrei un rezultat stabil și reproductibil la egalități, adaugă un ultim criteriu unic (de exemplu codul produsului). Altfel, două rulări pe date ordonate diferit pot da topuri diferite, ceea ce în rapoarte creează confuzie.

Ce urmărește intervievatorul: Se verifică sortarea pe mai multe criterii și atenția la egalități. Candidații buni spun cum fac rezultatul determinist.

Eroarea, în practică:sort_values() missing argument: 'by'

20 Junior

Ai un DataFrame de comenzi cu coloanele „Preț unitar” și „Cantitate”. Cum redenumești coloanele în nume simple și adaugi valoarea totală și valoarea cu TVA de 19%, într-un mod ușor de citit?

Răspuns scurt: Redenumești cu rename(columns={...}) sau normalizezi toate numele dintr-o dată, apoi creezi coloanele vectorizat: df["valoare"] = df["pret"] * df["cantitate"]. În lanț, assign(valoare=..., valoare_tva=lambda d: d["valoare"] * 1.19) face același lucru fără să modifice originalul.

Numele cu spații, diacritice și majuscule sunt incomode: nu merg cu accesul prin atribut și sunt ușor de scris greșit. Ai două variante, punctuală sau generală:

PYTHON
df = df.rename(columns={"Preț unitar": "pret", "Cantitate": "cantitate"})

# sau o normalizare a tuturor numelor
df.columns = (df.columns.str.strip().str.lower()
              .str.replace(" ", "_"))

Coloanele calculate se obțin prin operații pe coloane întregi, nu rând cu rând:

PYTHON
df["valoare"] = df["pret"] * df["cantitate"]
df["valoare_tva"] = (df["valoare"] * 1.19).round(2)

Varianta cu assign întoarce un DataFrame nou și se potrivește în lanțuri de prelucrare. Funcțiile lambda primesc DataFrame-ul de la acel pas, deci poți folosi o coloană creată chiar în același apel:

PYTHON
rez = df.assign(
    valoare=lambda d: d["pret"] * d["cantitate"],
    valoare_tva=lambda d: (d["valoare"] * 1.19).round(2),
)

Două verificări utile: tipurile (dacă pret este text, înmulțirea cu un întreg repetă șirul în loc să dea eroare, deci verifică df.dtypes înainte) și rotunjirea. Rotunjește doar la final, la afișare sau export; dacă rotunjești fiecare valoare intermediară, totalurile din raport nu se mai potrivesc cu cele din contabilitate.

Ce urmărește intervievatorul: Se verifică dacă scrii transformări vectorizate și lizibile și dacă te gândești la tipuri și rotunjiri. Candidații slabi creează coloane cu apply rând cu rând.

Eroarea, în practică:KeyError: 'Pret' (coloană inexistentă)KeyError: None of [Index(...)] are in the [columns]

21 Mid

Ce afișează codul? Când folosești map și când replace?

PYTHON
s = pd.Series(["RO", "MD", "BG"])
print(s.map({"RO": "România", "MD": "Moldova"}).tolist())
print(s.replace({"RO": "România", "MD": "Moldova"}).tolist())

Răspuns scurt: Prima linie dă ['România', 'Moldova', nan], a doua ['România', 'Moldova', 'BG']. map cu dicționar transformă în NaN valorile care nu au cheie; replace înlocuiește doar ce găsește și lasă restul neschimbat.

Series.map primește un dicționar, o Series sau o funcție și construiește o coloană nouă, valoare cu valoare. Cu un dicționar, fiecare valoare este căutată ca cheie; dacă lipsește, rezultatul este NaN. E comportamentul dorit când vrei o traducere completă și vrei să observi imediat codurile necunoscute:

PYTHON
tari = s.map(dictionar)
necunoscute = s[tari.isna() & s.notna()].unique()
assert len(necunoscute) == 0, f"Coduri fără traducere: {necunoscute}"

replace este gândit pentru corecturi punctuale: înlocuiește valorile menționate și le lasă pe celelalte. E potrivit pentru a corecta câteva variante greșite („Bucuresti” în „București”), dar ascunde silențios cazurile pe care nu le-ai prevăzut.

Mai sunt diferențe practice. map pe un dicționar mare este de obicei mai rapid decât replace. replace poate lucra și pe tot DataFrame-ul, cu dicționare pe coloane, și acceptă expresii regulate (regex=True). Iar map cu o funcție aplică funcția element cu element, deci nu este vectorizat.

Dacă vrei comportamentul lui map, dar fără NaN, poți completa explicit: s.map(d).fillna(s). Asta face intenția vizibilă pentru cine citește codul.

Ce urmărește intervievatorul: Intervievatorul caută înțelegerea diferenței de comportament la valorile neacoperite. Răspunsul bun leagă alegerea de dorința de a detecta sau de a ignora cazurile neprevăzute.

22 Mid

Ce afișează codul și cum se explică? Cum ar trebui scrisă selecția ca să nu depindă de tipul indexului?

PYTHON
s = pd.Series([10, 20, 30], index=[2, 1, 0])
print(s[0], s.iloc[0])

Răspuns scurt: Afișează 30 10. Când indexul este format din întregi, s[0] caută eticheta 0, nu prima poziție. iloc[0] ia mereu primul element. Pentru cod clar, folosește explicit loc pentru etichete și iloc pentru poziții.

Operatorul [] simplu pe o Series încearcă să ghicească intenția. Dacă indexul conține întregi, un întreg dat în paranteze este interpretat ca etichetă. Dacă indexul este format din text, în versiunile mai vechi un întreg era interpretat ca poziție, comportament marcat ca depreciat în pandas 2.x și planificat să dispară, tocmai pentru că este ambiguu.

PYTHON
s[0]          # 30: eticheta 0
s.loc[0]      # 30: explicit etichetă
s.iloc[0]     # 10: explicit poziție
s[0:2]        # slicing cu întregi: pe poziție, rezultatul 10, 20

Ultima linie arată cât de confuză este regula: slicing-ul cu întregi pe [] merge pe poziții, chiar dacă selecția unui singur element merge pe etichete.

Situația nu e teoretică. Un index cu întregi nesortați apare natural după sort_values, după un set_index("id_client") sau după filtrare. Codul scris pe un eșantion cu index 0..n-1 merge, apoi pe date reale întoarce alt rând sau KeyError, fără nicio eroare de sintaxă.

Regula pe care o recomand: [] doar pentru coloane și măști booleene, loc pentru etichete, iloc pentru poziții, at și iat pentru o singură valoare.

Ce urmărește intervievatorul: Se verifică dacă știi regulile ambigue ale operatorului [] și dacă ai un stil care le evită. Candidații juniori folosesc s[0] presupunând că e primul element.

Eroarea, în practică:KeyError: 0 (rând după poziție)Location based indexing can only have [integer...]

23 Mid

După df.groupby(["judet", "oras"])["valoare"].sum() ai o Series cu MultiIndex. Cum selectezi toate orașele din județul Cluj, doar orașul Turda și totalul pe orașele numite „Florești” din toate județele?

Răspuns scurt: r.loc["Cluj"] dă toate orașele din Cluj, r.loc[("Cluj", "Turda")] o singură valoare, iar r.xs("Florești", level="oras") selectează după al doilea nivel. Cu reset_index revii la un tabel simplu.

Un MultiIndex este un index cu mai multe niveluri, iar fiecare etichetă este un tuplu. Apare natural după groupby pe mai multe coloane, după pivot_table sau set_index cu o listă.

PYTHON
r = df.groupby(["judet", "oras"])["valoare"].sum()

r.loc["Cluj"]                  # Series indexată doar după oraș
r.loc[("Cluj", "Turda")]       # o valoare
r.loc[[("Cluj", "Turda"), ("Iași", "Pașcani")]]
r.xs("Florești", level="oras") # toate județele cu un oraș Florești
r.loc[pd.IndexSlice[:, "Florești"]]   # echivalent cu xs

Selecția după primul nivel este directă. Pentru niveluri interioare ai xs (cross-section) sau pd.IndexSlice, iar pe un DataFrame cu MultiIndex pe rânduri slicing-ul pe niveluri cere un index sortat: r = r.sort_index(), altfel apare UnsortedIndexError sau un avertisment de performanță.

Alte operații frecvente: r.unstack("oras") mută un nivel în coloane, r.groupby(level="judet").sum() agregă pe un nivel, iar r.index.get_level_values("judet") extrage etichetele unui nivel ca să construiești o mască.

În multe echipe, MultiIndex-ul se folosește ca etapă intermediară, iar rezultatele se aduc la formă plată cu reset_index() înainte de export sau de grafic. E o alegere bună pentru lizibilitate, dar trebuie să știi să navighezi indexul atunci când îl primești.

Ce urmărește intervievatorul: Intervievatorul verifică dacă te descurci cu rezultatul tipic al unei agregări pe mai multe chei. Mulți candidați resetează indexul din reflex, fără să știe să selecteze pe niveluri.

Valori lipsă, tipuri și curățare

Exersează capitolul cu exerciții reale: Curs analiza datelor Python →
24 Junior

Cum alegi între dropna() cu subset, how și thresh? Dă un exemplu pentru fiecare.

Răspuns scurt: subset limitează verificarea la anumite coloane, how="all" elimină doar rândurile complet goale, iar thresh=n păstrează rândurile cu cel puțin n valori completate. Alegerea depinde de coloanele fără de care rândul nu mai are sens.

df.dropna() fără parametri elimină orice rând cu cel puțin o valoare lipsă, în oricare coloană. Pe date reale asta poate șterge jumătate din tabel din cauza unei coloane secundare, de exemplu „observații”. De aceea, aproape întotdeauna specifici ce contează.

PYTHON
# comenzi fără valoare sau fără client nu pot intra în raport
df = df.dropna(subset=["valoare", "id_client"])

# rânduri goale de la finalul unui export Excel
df = df.dropna(how="all")

# păstrează rândurile care au cel puțin 4 câmpuri completate
df = df.dropna(thresh=4)

# coloane aproape goale
df = df.dropna(axis=1, thresh=int(len(df) * 0.5))

Ultimul exemplu elimină coloanele care nu au măcar jumătate din valori completate. thresh numără valorile prezente, nu pe cele lipsă, o confuzie frecventă.

Înainte de a șterge, măsoară impactul: câte rânduri pleacă și dacă sunt distribuite aleator. Dacă lipsurile sunt concentrate într-un oraș sau o perioadă, ștergerea introduce o distorsiune în rezultate. Un obicei bun este să loghezi diferența:

PYTHON
n0 = len(df)
df = df.dropna(subset=["valoare"])
print(f"Eliminate {n0 - len(df)} rânduri fără valoare ({(n0 - len(df)) / n0:.1%})")

Ce urmărește intervievatorul: Se verifică dacă poți elimina lipsurile țintit, nu cu ciocanul. Un răspuns bun include și măsurarea impactului asupra datelor.

25 Junior

Ce afișează codul și de ce? Cum selectezi corect rândurile cu statusul lipsă?

PYTHON
df = pd.DataFrame({"status": ["livrat", None, "anulat"]})
print(len(df[df["status"] != "livrat"]))
print(len(df[df["status"] == None]))

Răspuns scurt: Afișează 2 și 0. Valoarea lipsă este „diferită de livrat”, deci intră la !=. Comparația == None nu găsește nimic, pentru că pandas compară element cu element și lipsa nu este egală cu nimic. Corect este df["status"].isna().

În pandas, valorile lipsă se comportă la comparații ca NaN din NumPy: orice == dă False, iar orice != dă True. Asta are două consecințe practice.

Prima: df[df["status"] != "livrat"] include rândurile fără status. Dacă raportul se cheamă „comenzi nelivrate”, ai amestecat comenzi anulate cu comenzi despre care nu știi nimic.

A doua: == None și == np.nan nu găsesc niciodată valorile lipsă. Linterele semnalează des == None, dar în pandas nici is None nu ajută, pentru că se aplică obiectului Series, nu elementelor.

PYTHON
df["status"].isna()                   # True unde lipsește
df[df["status"].isna()]               # rândurile fără status
df[df["status"].ne("livrat") & df["status"].notna()]
df["status"].fillna("necunoscut").value_counts()

isna() recunoaște toate formele de lipsă: None, np.nan, pd.NaT pentru date și pd.NA pentru tipurile nullable. Atenție însă la șirurile goale "" sau la text ca „N/A” și „-”: pentru pandas sunt valori valide. Le transformi explicit, de exemplu cu df["status"].replace({"": pd.NA, "N/A": pd.NA}) sau, la citire, cu parametrul na_values din read_csv.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că lipsa se propagă neintuitiv prin comparații. Este o sursă frecventă de cifre greșite în rapoarte.

26 Junior

Ai citiri zilnice de temperatură și stocuri de produse, ambele cu zile lipsă. Când folosești ffill, bfill sau interpolate și când niciuna?

Răspuns scurt: ffill propagă ultima valoare cunoscută, potrivit pentru stări valabile până la schimbare (stoc, preț). interpolate estimează între vecini, pentru mărimi continue (temperatură). bfill folosește viitorul, deci rar. Vânzările lipsă nu se completează prin estimare.

Metoda de completare trebuie să corespundă felului în care se comportă mărimea în realitate, nu comodității.

  • ffill (forward fill) copiază ultima valoare cunoscută înainte. Are sens pentru stări: prețul afișat, stocul raportat, statusul unui contract. Dacă stocul de luni este 40 și marți lipsește raportarea, cea mai bună estimare este tot 40.
  • bfill copiază următoarea valoare cunoscută înapoi. Se folosește rar, de exemplu pentru începutul unei serii, și implică folosirea unei informații din viitor, ceea ce poate fi problematic în analize pe timp.
  • interpolate estimează între două valori cunoscute, liniar sau după timp. Se potrivește pentru mărimi care variază continuu: temperatură, nivel, cursuri valutare.
PYTHON
stoc = stoc.sort_values("data")
stoc["cant"] = stoc.groupby("produs")["cant"].ffill(limit=3)

temp = temp.set_index("data").sort_index()
temp["grade"] = temp["grade"].interpolate(method="time", limit=2)

Datele trebuie sortate înainte, iar la mai multe entități completarea se face pe grupe, altfel ultima valoare a unui produs ajunge la următorul. limit împiedică propagarea peste goluri lungi, unde estimarea nu mai e credibilă.

Pentru mărimi de tip flux, cum ar fi vânzările zilnice, niciuna dintre metode nu e potrivită: o zi fără înregistrare înseamnă fie zero vânzări, fie o problemă de colectare, iar asta afli de la sursă, nu ghicești.

Ce urmărește intervievatorul: Se verifică dacă alegi metoda de completare după sensul datelor. Greșeala frecventă este ffill pe tot tabelul, fără sortare și fără grupare pe entitate.

Eroarea, în practică:fillna() got an unexpected keyword argument 'method'

27 Junior

Un client apare de mai multe ori în export, cu adrese actualizate în timp. Cum păstrezi doar cea mai recentă înregistrare pentru fiecare client și cum verifici câte duplicate ai eliminat?

Răspuns scurt: Sortezi după dată și elimini duplicatele pe cheia clientului păstrând ultima apariție: df.sort_values("actualizat").drop_duplicates(subset="id_client", keep="last"). Înainte, df.duplicated(subset="id_client").sum() îți spune câte rânduri vor dispărea.

drop_duplicates fără argumente elimină doar rândurile identice pe toate coloanele. Aici înregistrările diferă prin adresă și dată, deci trebuie să spui care coloane definesc identitatea (subset) și care apariție rămâne (keep).

PYTHON
dup = df.duplicated(subset="id_client", keep=False)
print(dup.sum(), "rânduri aparțin clienților cu mai multe înregistrări")
df[dup].sort_values(["id_client", "actualizat"]).head(10)

ultim = (df.sort_values("actualizat")
           .drop_duplicates(subset="id_client", keep="last"))
assert ultim["id_client"].is_unique

keep="first" este implicit, deci fără sortare păstrezi o apariție oarecare, dependentă de ordinea din fișier. Sortarea explicită face rezultatul corect și reproductibil. Dacă două înregistrări au aceeași dată, adaugă un criteriu secundar de departajare, de exemplu un ID de rând crescător.

Variantă echivalentă, utilă când vrei și alte informații din grup:

PYTHON
idx = df.groupby("id_client")["actualizat"].idxmax()
ultim = df.loc[idx]

keep=False marchează toate aparițiile, nu doar pe cele în plus, și e util pentru inspecție. Înainte de eliminare, merită să te uiți la câteva exemple: uneori „duplicatele” sunt clienți diferiți cu același ID din cauza unei erori de import, iar asta trebuie raportat, nu șters.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să definești ce înseamnă duplicat și care apariție contează. Răspunsul slab folosește drop_duplicates() fără subset și fără sortare.

28 Junior

Coloana pret dintr-un export are valori ca „1.234,56 lei”, „89,90 lei” și „n/a”. Scrie conversia la număr și spune cum verifici că nu ai pierdut valori pe drum.

Răspuns scurt: Elimini „lei” și spațiile, scoți punctul de mii, înlocuiești virgula cu punct și aplici pd.to_numeric(..., errors="coerce"). Apoi compari valorile devenite NaN cu cele care lipseau dinainte, ca să vezi exact ce text nu s-a putut converti.

Formatul românesc folosește punctul pentru mii și virgula pentru zecimale, opusul formatului pe care îl așteaptă Python. Ordinea înlocuirilor contează: întâi scoți punctul de mii, abia apoi transformi virgula în punct.

PYTHON
curat = (df["pret"].astype("string")
         .str.replace("lei", "", regex=False)
         .str.strip()
         .str.replace(".", "", regex=False)
         .str.replace(",", ".", regex=False))
numeric = pd.to_numeric(curat, errors="coerce")

pierdute = df.loc[numeric.isna() & df["pret"].notna(), "pret"]
print(pierdute.value_counts().head(20))
df["pret"] = numeric

regex=False este important: în expresiile regulate punctul înseamnă „orice caracter”, iar str.replace(".", "") cu regex ar șterge tot textul. errors="coerce" transformă în NaN tot ce nu se poate converti, în loc să oprească execuția. E comod, dar periculos dacă nu verifici ce a dispărut. Pasul cu pierdute îți arată dacă au rămas doar valorile „n/a” sau și altele, de exemplu „1 234,56” cu spațiu de mii sau „-” pentru zero.

Dacă tot fișierul folosește formatul românesc, e mai simplu să rezolvi direct la citire: pd.read_csv(f, sep=";", decimal=",", thousands="."), cu condiția ca textul „lei” să nu apară în celule.

Ce urmărește intervievatorul: Se verifică o problemă extrem de frecventă în datele locale și disciplina de a verifica pierderile. Candidații buni nu folosesc errors="coerce" fără un control după.

Eroarea, în practică:could not convert string to float (pandas)Unable to parse string at position

29 Junior

Coloana locatie are valori ca „Cluj-Napoca, Cluj” și „Sectorul 3, București”. Cum o împarți în două coloane, oras și judet?

Răspuns scurt: Cu df[["oras", "judet"]] = df["locatie"].str.split(",", n=1, expand=True), apoi aplici .str.strip() pe ambele. n=1 împarte doar la prima virgulă, iar expand=True întoarce un DataFrame în loc de liste.

Accesorul .str aplică operații de text pe toată coloana, vectorizat și tolerant la valori lipsă. str.split fără expand întoarce o Series de liste, greu de folosit mai departe. Cu expand=True primești direct un DataFrame cu câte o coloană pentru fiecare bucată.

PYTHON
parti = df["locatie"].str.split(",", n=1, expand=True)
df["oras"] = parti[0].str.strip()
df["judet"] = parti[1].str.strip()

n=1 limitează împărțirea la prima virgulă, ca să nu obții coloane în plus dacă textul conține mai multe virgule. Dacă știi că partea relevantă este ultima, folosește str.rsplit(",", n=1, expand=True).

Verifică rezultatul înainte să mergi mai departe:

PYTHON
df.loc[df["judet"].isna(), "locatie"].unique()   # valori fără virgulă
df["judet"].value_counts().head(20)

Rândurile fără separator primesc None în a doua coloană. În date reale vei găsi variante ca „Cluj-Napoca - Cluj” sau „Cluj-Napoca (CJ)”, care cer fie o expresie regulată cu str.extract, fie o normalizare înainte. Pentru adrese complicate, o listă de referință cu orașele și județele, folosită la un merge, dă rezultate mai sigure decât orice regulă de text.

Ce urmărește intervievatorul: Intervievatorul verifică folosirea accesorului .str și atenția la cazurile care nu respectă formatul. Mulți uită de expand=True sau de spațiile rămase după split.

Eroarea, în practică:Columns must be same length as key'float' object has no attribute 'split'

30 Junior

Care e diferența dintre pd.cut și pd.qcut? Împarte clienții după valoarea totală a comenzilor în trei segmente, în ambele feluri.

Răspuns scurt: pd.cut folosește praguri fixe, alese de tine (de exemplu sub 500, 500–2000, peste 2000 lei). pd.qcut folosește cuantile, deci fiecare segment are aproximativ același număr de clienți, iar pragurile rezultă din date.

Ambele funcții transformă o coloană numerică într-o coloană categorială cu intervale, dar răspund la întrebări diferite.

pd.cut răspunde la „în ce interval de valori se află clientul?”. Pragurile au sens de business și rămân stabile de la o lună la alta:

PYTHON
df["segment"] = pd.cut(
    df["total"],
    bins=[0, 500, 2000, float("inf")],
    labels=["mic", "mediu", "mare"],
    right=False,          # [0, 500), [500, 2000), [2000, inf)
)

Implicit intervalele sunt închise la dreapta, (0, 500], iar o valoare exact egală cu limita inferioară a primului interval (aici 0) rămâne în afara lor și primește NaN dacă nu adaugi include_lowest=True sau nu schimbi închiderea, cum am făcut cu right=False.

pd.qcut răspunde la „în ce treime se află clientul față de ceilalți?”:

PYTHON
df["tertila"] = pd.qcut(df["total"], q=3, labels=["jos", "mijloc", "sus"])
pd.qcut(df["total"], q=3).cat.categories   # pragurile calculate

Pragurile depind de date, deci se schimbă la fiecare actualizare, iar comparațiile între perioade devin delicate. Pe date cu multe valori identice (de exemplu mulți clienți cu exact o comandă), qcut dă eroare „Bin edges must be unique”; duplicates="drop" o evită, dar poți rămâne cu mai puține segmente decât ai cerut, deci verifică rezultatul cu value_counts().

Ce urmărește intervievatorul: Se verifică diferența conceptuală dintre praguri fixe și cuantile, plus detaliile de închidere a intervalelor. Valorile de la limite sunt locul unde candidații greșesc.

Eroarea, în practică:Bin labels must be one fewer than ... bin edgesbins must increase monotonically

31 Mid

După read_csv, coloana id_client are valori ca 1001.0 și 1002.0 în loc de numere întregi. De ce s-a întâmplat și cum păstrezi ID-urile întregi fără să pierzi valorile lipsă?

Răspuns scurt: Coloana are măcar o valoare lipsă, iar tipul int64 din NumPy nu poate reprezenta NaN, așa că pandas o face float64. Folosești tipul nullable Int64 (cu majusculă), care acceptă pd.NA: dtype={"id_client": "Int64"} la citire sau astype("Int64").

Tipurile din NumPy pe care se sprijină pandas nu au o reprezentare pentru „lipsă” la întregi. NaN există doar în virgulă mobilă. Când o coloană de întregi conține o celulă goală, pandas alege float64, iar ID-urile apar cu „.0”. Pe lângă aspect, apar probleme reale: un merge cu o altă tabelă unde ID-ul este int64 sau text nu mai găsește potriviri, iar ID-urile foarte mari pot pierde precizie în float.

Soluția sunt tipurile nullable, cu majusculă, care folosesc o mască separată pentru valorile lipsă și marcajul pd.NA:

PYTHON
df = pd.read_csv("clienti.csv", dtype={"id_client": "Int64"})
# sau după citire
df["id_client"] = df["id_client"].astype("Int64")
df["id_client"].isna().sum()

Există variante și pentru alte tipuri: "boolean" pentru adevărat/fals cu lipsă, "string" pentru text, "Float64". Cu pd.read_csv(..., dtype_backend="numpy_nullable"), disponibil din pandas 2.0, toate coloanele primesc tipuri nullable.

Totuși, pentru identificatori, întrebarea corectă este dacă trebuie să fie numere deloc. Nu faci calcule cu un ID, iar coduri precum „00123” își pierd zerourile din față ca numere. De multe ori cel mai sigur tip pentru ID-uri este textul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi legătura dintre valori lipsă și tipuri. Răspunsul bun se întreabă și dacă ID-ul ar trebui să fie numeric.

Eroarea, în practică:IntCastingNaNError: non-finite values to integercannot convert to 'int64'-dtype NumPy array with NA

32 Mid

Ai produse cu greutatea lipsă la unele rânduri. Cum completezi fiecare valoare lipsă cu mediana categoriei produsului, nu cu mediana generală?

Răspuns scurt: Cu df["greutate"] = df["greutate"].fillna(df.groupby("categorie")["greutate"].transform("median")). transform întoarce o Series aliniată cu rândurile originale, cu mediana categoriei pe fiecare rând, iar fillna o folosește doar unde lipsește valoarea.

Mediana generală amestecă produse foarte diferite: un frigider și o husă de telefon au greutăți care nu au nimic în comun. Completarea pe grupe păstrează diferențele dintre categorii.

Cheia este transform. Spre deosebire de agg, care întoarce câte o valoare pe grup, transform întoarce un rezultat de aceeași lungime cu tabelul, cu valoarea grupului pusă pe fiecare rând. Rezultatul are același index cu DataFrame-ul, deci se aliniază corect cu fillna.

PYTHON
mediana_cat = df.groupby("categorie")["greutate"].transform("median")
df["greutate_completata"] = df["greutate"].isna()
df["greutate"] = df["greutate"].fillna(mediana_cat)

# categorii în care toate valorile lipsesc rămân NaN
rest = df["greutate"].isna().sum()
df["greutate"] = df["greutate"].fillna(df["greutate"].median())

Câteva bune practici incluse mai sus. Păstrează un indicator al rândurilor completate, ca să poți arăta în raport cât din rezultat se bazează pe estimări și ca să poți exclude acele rânduri într-o analiză de sensibilitate. Tratează explicit grupele care nu au nicio valoare, unde mediana grupului este și ea NaN.

Mediana e de obicei preferată mediei pentru completare, pentru că nu e trasă de valori extreme. Și, dacă datele vor fi folosite mai târziu pentru un model, calculul medianei trebuie făcut doar pe datele de antrenare, altfel informația din datele de test se scurge în completare.

Ce urmărește intervievatorul: Se verifică stăpânirea lui transform și gândirea despre ce completezi și cum marchezi completarea. E un exercițiu foarte des întâlnit în teme.

33 Mid

Din coloana descriere cu texte ca „Comanda #12345 - Cluj” trebuie să extragi numărul comenzii și orașul. Cum faci asta cu pandas?

Răspuns scurt: Cu str.extract și o expresie regulată cu grupuri: df["descriere"].str.extract(r"#(\d+)\s*-\s*(.+)"). Fiecare grup devine o coloană; rândurile care nu se potrivesc primesc NaN, deci le poți număra și inspecta.

str.extract aplică o expresie regulată pe fiecare valoare și întoarce un DataFrame cu câte o coloană pentru fiecare grup de captură din paranteze. Cu grupuri numite, coloanele primesc direct numele dorite:

PYTHON
model = r"#(?P<nr_comanda>\d+)\s*-\s*(?P<oras>.+)"
extras = df["descriere"].str.extract(model)
df = df.join(extras)
df["nr_comanda"] = pd.to_numeric(df["nr_comanda"])
df["oras"] = df["oras"].str.strip()

nepotrivite = df.loc[df["nr_comanda"].isna(), "descriere"]
print(len(nepotrivite), nepotrivite.head().tolist())

Explicația modelului: # caută caracterul diez, (\d+) captează una sau mai multe cifre, \s*-\s* acceptă cratima cu sau fără spații, iar (.+) captează restul textului. Prefixul r (raw string) evită dublarea backslash-urilor.

Metode înrudite: str.contains(model) pentru filtrare, cu case=False și na=False ca valorile lipsă să nu strice masca; str.extractall când un text conține mai multe potriviri, de exemplu mai multe coduri de produs; str.findall pentru liste.

Testează modelul pe un eșantion de valori reale, inclusiv cele „ciudate”, înainte să-l aplici. Raportul de rânduri nepotrivite îți spune dacă formatul este stabil sau dacă există variante (de exemplu „Cmd. 12345”) de care trebuie să ții cont.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți extrage structură din text vectorizat și dacă măsori ce nu s-a potrivit. Mulți scriu bucle cu re.search pe fiecare rând.

Eroarea, în practică:pattern contains no capture groups

34 Mid

Când folosești tipul category în pandas? Ce afișează codul de mai jos?

PYTHON
marime = pd.Series(pd.Categorical(
    ["mic", "mare", "mediu"],
    categories=["mic", "mediu", "mare"], ordered=True))
print(marime.sort_values().tolist(), (marime > "mic").tolist())

Răspuns scurt: Afișează ['mic', 'mediu', 'mare'] [False, True, True]. Cu ordered=True sortarea și comparațiile urmează ordinea logică a categoriilor, nu cea alfabetică. category se folosește pentru coloane cu puține valori distincte, ca să economisești memorie și să impui o ordine.

Tipul category stochează fiecare valoare distinctă o singură dată, iar pe rânduri păstrează doar un cod întreg mic. Pentru o coloană judet cu un milion de rânduri și 42 de valori distincte, memoria scade de la zeci de MB (fiecare șir fiind un obiect Python separat) la circa 1 MB pentru coduri.

Al doilea avantaj este ordinea. Fără categorii ordonate, „mare” < „mediu” < „mic” alfabetic, deci graficele și sortările ies într-o ordine fără sens. Cu ordered=True, sortarea, min, max și comparațiile urmează ordinea definită.

PYTHON
df["judet"] = df["judet"].astype("category")
df["judet"].cat.categories
df.memory_usage(deep=True)

tip = pd.CategoricalDtype(["mic", "mediu", "mare"], ordered=True)
df["marime"] = df["marime"].astype(tip)

Capcanele merită spuse la interviu:

  • o valoare care nu este în listă devine NaN la conversie, fără eroare;
  • la groupby pe o coloană categorială, parametrul observed decide dacă apar și categoriile fără rânduri; implicit, în pandas 2.x, ele apar (cu avertisment că implicitul se va schimba), ceea ce poate umple rezultatul cu combinații goale;
  • nu poți atribui o valoare nouă necunoscută fără cat.add_categories.

Nu are sens pentru coloane cu aproape toate valorile unice, cum ar fi emailul, unde categoriile ar ocupa la fel de multă memorie ca datele.

Ce urmărește intervievatorul: Se verifică dacă știi ambele beneficii ale tipului category, memoria și ordinea, plus capcanele lui. Candidații menționează de obicei doar memoria.

Eroarea, în practică:Cannot setitem on a Categorical with a new categoryUnordered Categoricals can only compare equality

35 Senior

Raportul lunar se construiește automat dintr-un export trimis de alt departament. Cum ai scrie o funcție care verifică datele înainte de calcule și oprește procesul când ceva nu e în regulă?

Răspuns scurt: Scrii o funcție care verifică explicit așteptările: coloane și tipuri, unicitatea cheii, intervale valide, procent maxim de lipsuri, perioada corectă și un volum plauzibil. La încălcare ridică o excepție cu un mesaj clar sau marchează raportul, în loc să producă cifre greșite în tăcere.

Ideea este să transformi presupunerile din cap în verificări executabile. Un raport greșit trimis conducerii costă mult mai mult decât un raport întârziat cu o explicație.

PYTHON
def valideaza_comenzi(df, luna):
    erori = []
    lipsa = {"id_comanda", "data", "valoare", "id_client"} - set(df.columns)
    if lipsa:
        raise ValueError(f"Coloane lipsă: {lipsa}")
    if not df["id_comanda"].is_unique:
        erori.append(f"{df['id_comanda'].duplicated().sum()} ID-uri duplicate")
    if (df["valoare"] < 0).any():
        erori.append("valori negative")
    pct = df["id_client"].isna().mean()
    if pct > 0.02:
        erori.append(f"{pct:.1%} comenzi fără client")
    afara = ~df["data"].dt.to_period("M").eq(pd.Period(luna))
    if afara.any():
        erori.append(f"{afara.sum()} comenzi în afara lunii {luna}")
    if erori:
        raise ValueError("Date invalide: " + "; ".join(erori))
    return df

Funcția se folosește ca pas explicit în pipeline, de exemplu df.pipe(valideaza_comenzi, "2025-03"). Colectează toate erorile înainte să oprească execuția, ca persoana care repară exportul să le primească pe toate odată.

Pragurile (2% lipsuri, volum între anumite limite) se stabilesc cu cei care cunosc datele și se notează. Pe lângă regulile fixe, adaug o comparație cu luna anterioară: numărul de rânduri sau totalul care se schimbă brusc nu e neapărat o eroare, dar trebuie explicat înainte de publicare. Pentru proiecte mai mari există biblioteci dedicate, precum pandera sau Great Expectations, care exprimă aceleași reguli declarativ.

Ce urmărește intervievatorul: La nivel senior se urmărește dacă tratezi calitatea datelor ca parte a procesului, nu ca verificare vizuală ocazională. Răspunsul bun spune și cine primește erorile și cum se stabilesc pragurile.

groupby și agregări

36 Junior

Ce afișează codul? Explică diferența dintre size, count și nunique după un groupby.

PYTHON
df = pd.DataFrame({"oras": ["Cluj", "Cluj", "Iași"],
                   "client": ["A", "A", None]})
g = df.groupby("oras")["client"]
print(g.size().tolist(), g.count().tolist(), g.nunique().tolist())

Răspuns scurt: Afișează [2, 1] [2, 0] [1, 0]. size numără toate rândurile din grup, count doar valorile nelipsă, iar nunique valorile distincte nelipsă. Pentru Cluj sunt 2 rânduri, 2 valori completate și un singur client distinct.

Cele trei răspund la întrebări diferite, iar confuzia lor dă cifre greșite fără erori.

  • size() numără rândurile din fiecare grup, indiferent de conținut. Pe DataFrame întoarce o Series.
  • count() numără valorile care nu lipsesc, pentru fiecare coloană. Pe DataFrame întoarce câte un număr pentru fiecare coloană, deci rezultatul poate diferi de la o coloană la alta.
  • nunique() numără valorile distincte, ignorând implicit valorile lipsă.
PYTHON
df.groupby("oras").size()              # numărul de comenzi pe oraș
df.groupby("oras")["client"].count()   # comenzi cu client cunoscut
df.groupby("oras")["client"].nunique() # clienți unici pe oraș
df.groupby("oras").agg(
    comenzi=("client", "size"),
    clienti=("client", "nunique"),
)

În Iași există un rând, dar clientul lipsește, deci size dă 1, iar count și nunique dau 0.

La un raport de tipul „număr de comenzi și număr de clienți pe oraș”, size este alegerea pentru comenzi, iar nunique pentru clienți. Dacă folosești count pe o coloană cu lipsuri pentru numărul de comenzi, raportul scade comenzile fără client, iar diferența față de sistemul sursă e greu de explicat ulterior.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi exact ce numără fiecare funcție. Diferențele apar doar pe date cu lipsuri, de aceea e o întrebare preferată.

37 Junior

Calculează totalul vânzărilor pe județ și lună ca un tabel cu coloane obișnuite, nu cu index pe mai multe niveluri. Ce rol are as_index=False?

Răspuns scurt: df.groupby(["judet", "luna"], as_index=False)["valoare"].sum() întoarce un DataFrame cu coloanele judet, luna și valoare. Fără as_index=False, cheile ajung într-un MultiIndex, pe care îl aduci la coloane cu reset_index().

Implicit, groupby pune cheile de grupare în index. Cu o singură cheie e comod; cu două sau mai multe obții un MultiIndex, util pentru selecție, dar incomod pentru export, merge sau grafice care așteaptă coloane.

PYTHON
r1 = df.groupby(["judet", "luna"])["valoare"].sum()
# Series cu MultiIndex (judet, luna)

r2 = df.groupby(["judet", "luna"], as_index=False)["valoare"].sum()
# DataFrame: judet | luna | valoare

r3 = df.groupby(["judet", "luna"])["valoare"].sum().reset_index()
# același rezultat ca r2

Ordinea cheilor contează pentru citire: rezultatul este sortat după prima cheie, apoi după a doua. Sortarea implicită (sort=True) se poate dezactiva cu sort=False dacă vrei viteză pe date mari și ordinea nu contează.

Dacă luna vine dintr-o coloană de tip dată, nu trebuie să creezi o coloană separată: poți grupa direct după o expresie, cu condiția să-i dai un nume:

PYTHON
r = (df.groupby(["judet", df["data"].dt.to_period("M").rename("luna")])
       ["valoare"].sum().reset_index())

Pentru un raport cu județele pe rânduri și lunile pe coloane, pasul următor este unstack("luna") sau direct pivot_table.

Ce urmărește intervievatorul: Se verifică dacă știi forma rezultatului unui groupby pe mai multe chei și cum o controlezi. Mulți se blochează când primesc un MultiIndex neașteptat.

Eroarea, în practică:cannot insert oras, already exists

38 Junior

Construiește un raport pe categorie cu: venitul total, valoarea medie a comenzii, numărul de comenzi și cea mai mare comandă, cu nume de coloane clare.

Răspuns scurt: Folosești agregarea cu nume: df.groupby("categorie").agg(venit=("valoare", "sum"), medie=("valoare", "mean"), comenzi=("id_comanda", "count"), maxim=("valoare", "max")). Fiecare argument este nume_nou=(coloană, funcție), iar rezultatul are coloane simple.

Varianta mai veche, cu dicționar de liste, produce coloane pe două niveluri, greu de folosit:

PYTHON
df.groupby("categorie").agg({"valoare": ["sum", "mean", "max"]})
# coloane: ('valoare', 'sum'), ('valoare', 'mean'), ...

Named aggregation, disponibilă din pandas 0.25, rezolvă problema: fiecare coloană a rezultatului primește un nume ales de tine, iar sintaxa spune clar din ce coloană și cu ce funcție se calculează.

PYTHON
raport = (df.groupby("categorie")
            .agg(venit=("valoare", "sum"),
                 medie=("valoare", "mean"),
                 comenzi=("id_comanda", "nunique"),
                 maxim=("valoare", "max"))
            .sort_values("venit", ascending=False)
            .round(2))

Am folosit nunique pentru comenzi pentru că, dacă tabelul are câte un rând pe produs din comandă, count ar număra liniile, nu comenzile. E o întrebare pe care o pui întotdeauna: ce reprezintă un rând?

Funcțiile pot fi date ca text ("sum", "median", "first") sau ca funcții proprii, de exemplu p90=("valoare", lambda s: s.quantile(0.9)). Funcțiile date ca text rulează pe implementări optimizate; o funcție lambda se apelează în Python pentru fiecare grup și devine lentă la multe grupuri.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii rapoarte lizibile și dacă te gândești la granularitatea datelor. Detaliul cu count față de nunique separă candidații atenți.

Eroarea, în practică:Label(s) ['valoare'] do not exist (agg)SpecificationError: nested renamer is not supported

39 Junior

Ai comenzile pe produs și categorie. Cum calculezi ponderea fiecărui produs în venitul categoriei lui și ponderea fiecărei categorii în venitul total?

Răspuns scurt: Ponderea în categorie: df["valoare"] / df.groupby("categorie")["valoare"].transform("sum"). Ponderea categoriei în total: agregi pe categorie, apoi împarți la suma generală: t = df.groupby("categorie")["valoare"].sum(); t / t.sum().

Cele două ponderi au numitori diferiți, iar asta decide tehnica.

Pentru ponderea în total ai nevoie de un singur numitor, deci agregi și împarți:

PYTHON
cat = df.groupby("categorie")["valoare"].sum()
pondere_cat = (cat / cat.sum() * 100).round(1).sort_values(ascending=False)

Pentru ponderea în categorie, fiecare rând are nevoie de totalul propriei categorii. transform("sum") pune acel total pe fiecare rând, cu același index ca tabelul original, deci împărțirea se aliniază automat:

PYTHON
prod = df.groupby(["categorie", "produs"], as_index=False)["valoare"].sum()
total_cat = prod.groupby("categorie")["valoare"].transform("sum")
prod["pondere_in_cat"] = prod["valoare"] / total_cat * 100

Verificare rapidă, care merită făcută cu voce tare la interviu: ponderile din fiecare categorie trebuie să însumeze 100.

PYTHON
prod.groupby("categorie")["pondere_in_cat"].sum().round(6).eq(100).all()

Observă că am agregat întâi pe produs. Dacă împarți direct fiecare rând de comandă la totalul categoriei, obții ponderea fiecărei comenzi, nu a produsului. Și rotunjește doar la afișare: ponderile rotunjite individual pot să nu mai însumeze exact 100, iar asta trebuie explicat într-o notă, nu ajustat manual.

Ce urmărește intervievatorul: Se verifică dacă știi să alegi numitorul corect și să folosești transform. Exercițiul apare foarte des în live coding.

40 Junior

Ai un tabel cu vizitatori, câte un rând pe sesiune, cu coloanele sursa (google, facebook, direct) și a_cumparat (True/False). Cum calculezi rata de conversie pe sursă și cum o prezinți corect?

Răspuns scurt: df.groupby("sursa")["a_cumparat"].agg(sesiuni="size", conversii="sum", rata="mean"). Media unei coloane booleene este proporția de True, deci exact rata de conversie. O prezinți împreună cu numărul de sesiuni, ca să se vadă care rate se bazează pe puține date.

Pentru o coloană booleană, sum numără valorile True, iar mean dă proporția lor. Asta face calculul ratelor foarte scurt:

PYTHON
r = (df.groupby("sursa")["a_cumparat"]
       .agg(sesiuni="size", conversii="sum", rata="mean")
       .sort_values("sesiuni", ascending=False))
r["rata_%"] = (r["rata"] * 100).round(2)

Dacă a_cumparat conține valori lipsă, mean le ignoră, deci rata se calculează doar din sesiunile cu informație. Hotărăște explicit dacă o lipsă înseamnă „nu a cumpărat” (fillna(False)) sau trebuie exclusă și spune asta în raport.

Prezentarea contează la fel de mult ca formula. O rată de 12% din 25 de sesiuni și una de 3% din 40.000 nu au aceeași greutate. Pune volumul lângă rată, sortează după volum și, dacă cineva vrea să compare surse mici, arată un interval de încredere sau grupează sursele mici în „altele”.

Nu calcula o rată totală ca medie a ratelor pe surse: media ratelor ignoră diferențele de volum. Rata totală corectă este df["a_cumparat"].mean(), adică suma conversiilor împărțită la suma sesiunilor.

Ce urmărește intervievatorul: Intervievatorul verifică trucul cu media booleană și maturitatea în prezentarea ratelor. Răspunsul slab dă doar procentul, fără volum.

41 Mid

Explică diferența dintre agg, transform și apply după groupby. Ce formă are rezultatul fiecăruia pe un tabel cu 1.000 de rânduri și 10 grupe?

Răspuns scurt: agg reduce fiecare grup la o valoare: 10 rânduri. transform întoarce un rezultat pe fiecare rând original: 1.000 de rânduri, aliniate la index. apply poate întoarce orice formă; e cel mai flexibil și cel mai lent.

Cele trei metode diferă prin ce primește funcția și ce trebuie să întoarcă.

PYTHON
g = df.groupby("magazin")["valoare"]

g.agg("mean")          # 10 valori, index = magazin
g.transform("mean")    # 1.000 valori, index = indexul original
df["abatere"] = df["valoare"] - g.transform("mean")

df.groupby("magazin").apply(lambda x: x.nlargest(2, "valoare"))
# până la 20 de rânduri, cu MultiIndex (magazin, index original)
  • agg este pentru rapoarte: un rând pe grup. Funcțiile date ca text sunt optimizate intern.
  • transform este pentru a aduce o statistică de grup înapoi pe fiecare rând: abaterea față de media grupului, ponderea în grup, completarea lipsurilor cu mediana grupului, scor z pe grupe. Funcția trebuie să întoarcă fie o valoare, fie un rezultat de aceeași lungime cu grupul.
  • apply este pentru logică ce nu se poate exprima altfel, de exemplu o operație pe mai multe coloane ale grupului sau un rezultat de formă variabilă. Funcția rulează în Python pentru fiecare grup, iar la zeci de mii de grupe diferența de timp devine mare.

Regula mea: încerc întâi agg sau transform cu funcții predefinite, apoi o combinație de operații vectorizate, și abia la final apply. În pandas 2.2, apply pe un DataFrame grupat emite un avertisment dacă funcția atinge coloanele de grupare; parametrul include_groups=False îl elimină.

Ce urmărește intervievatorul: Se verifică dacă alegi metoda după forma rezultatului dorit. Candidații care folosesc apply pentru tot ajung la cod lent și la indexuri neașteptate.

Eroarea, în practică:'DataFrameGroupBy' ... no attribute 'sort_values'

42 Mid

Scrie codul care întoarce cele mai vândute 3 produse din fiecare categorie, după cantitatea totală.

Răspuns scurt: Agregi pe categorie și produs, sortezi descrescător după cantitate, apoi iei primele 3 rânduri din fiecare categorie cu groupby("categorie").head(3). Varianta e vectorizată și păstrează coloanele ca tabel simplu.

Problema are doi pași care se confundă des: întâi totalul pe produs, apoi topul în cadrul categoriei. Dacă sari peste primul pas, obții cele mai mari comenzi, nu cele mai vândute produse.

PYTHON
top3 = (df.groupby(["categorie", "produs"], as_index=False)["cantitate"].sum()
          .sort_values(["categorie", "cantitate"], ascending=[True, False])
          .groupby("categorie")
          .head(3))

groupby(...).head(3) păstrează primele 3 rânduri din fiecare grup, în ordinea existentă, deci sortarea dinainte e cea care face din el un top. Rezultatul păstrează indexul și coloanele originale, fără MultiIndex.

Alternativa cu nlargest funcționează pe o Series grupată:

PYTHON
s = df.groupby(["categorie", "produs"])["cantitate"].sum()
s.groupby(level="categorie", group_keys=False).nlargest(3)

Spune la interviu ce faci cu egalitățile. Dacă al treilea și al patrulea produs au aceeași cantitate, head(3) îl alege pe primul apărut. Dacă cerința este „toate produsele de pe primele 3 locuri”, folosești un clasament:

PYTHON
agg = df.groupby(["categorie", "produs"], as_index=False)["cantitate"].sum()
agg["loc"] = agg.groupby("categorie")["cantitate"].rank(method="min", ascending=False)
top = agg[agg["loc"] <= 3]

Ce urmărește intervievatorul: Exercițiul e clasic la live coding. Se urmărește ordinea corectă a pașilor și dacă ridici singur problema egalităților.

43 Mid

Cum păstrezi doar clienții care au cel puțin 5 comenzi și o valoare totală de peste 1.000 de lei, cu toate comenzile lor?

Răspuns scurt: Cu filter: df.groupby("id_client").filter(lambda g: len(g) >= 5 and g["valoare"].sum() > 1000). Pe date mari e mai rapid să calculezi statisticile cu transform și să construiești o mască: n = g.transform("size"), s = g["valoare"].transform("sum").

groupby().filter() evaluează o condiție pe fiecare grup și păstrează sau elimină grupul întreg. Rezultatul are rândurile originale, nu agregate, deci poți continua analiza pe comenzi.

PYTHON
activi = df.groupby("id_client").filter(
    lambda g: len(g) >= 5 and g["valoare"].sum() > 1000
)

Funcția primește un DataFrame pentru fiecare client și trebuie să întoarcă un singur True sau False. Aici and este corect, pentru că ambele părți sunt valori scalare, nu Series.

Problema lui filter este viteza: funcția lambda se execută în Python pentru fiecare grup. Cu un milion de clienți, diferența față de varianta vectorizată devine considerabilă:

PYTHON
g = df.groupby("id_client")
n = g["id_comanda"].transform("size")
total = g["valoare"].transform("sum")
activi = df[(n >= 5) & (total > 1000)]

O a treia variantă calculează lista de clienți și filtrează cu isin, utilă când vrei să reutilizezi lista:

PYTHON
st = g.agg(n=("id_comanda", "size"), total=("valoare", "sum"))
ids = st.index[(st["n"] >= 5) & (st["total"] > 1000)]
activi = df[df["id_client"].isin(ids)]

Atenție la definiția „comenzii”: dacă tabelul are un rând pe produs, numărul de comenzi este nunique pe ID-ul comenzii, nu numărul de rânduri.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că există filtrare pe grupe și dacă îi cunoști costul. Un candidat bun propune și varianta vectorizată.

44 Mid

Cum faci un clasament al agenților de vânzări în fiecare regiune, astfel încât doi agenți cu aceeași valoare să primească același loc, iar următorul să nu sară peste numere?

Răspuns scurt: Cu df.groupby("regiune")["vanzari"].rank(method="dense", ascending=False). method="dense" dă 1, 2, 2, 3; method="min" ar da 1, 2, 2, 4, ca la competiții sportive; method="first" departajează după ordinea apariției.

rank atribuie fiecărei valori locul ei, iar pe un groupby clasamentul începe de la 1 în fiecare grup. Parametrul method decide cum se tratează egalitățile:

  • average (implicit): media locurilor ocupate, de exemplu 2,5 și 2,5;
  • min: locul cel mai bun pentru toți cei egali, apoi un salt: 1, 2, 2, 4;
  • dense: același loc, fără salt: 1, 2, 2, 3;
  • first: locuri diferite, în ordinea apariției;
  • max: locul cel mai slab pentru cei egali.
PYTHON
df["loc"] = (df.groupby("regiune")["vanzari"]
               .rank(method="dense", ascending=False)
               .astype(int))
df.sort_values(["regiune", "loc"])

Rezultatul este float, chiar și cu dense, pentru că metoda average poate produce zecimale; de aici conversia la int, sigură doar dacă nu ai valori lipsă. Valorile lipsă primesc implicit rang NaN; na_option="bottom" le pune la final.

rank(pct=True) dă percentila fiecărei valori în grup, utilă pentru „agentul este în primii 10% din regiune”. Pentru topuri cu egalități, filtrarea după rang (loc <= 3) este mai corectă decât head(3), care taie arbitrar între cei egali. Echivalentele din SQL sunt RANK, DENSE_RANK și ROW_NUMBER, util de menționat dacă echipa lucrează în ambele.

Ce urmărește intervievatorul: Se verifică cunoașterea metodelor de tratare a egalităților. Mulți nu știu că rank întoarce float și că implicitul este average.

45 Mid

Pentru fiecare client, calculează câte zile au trecut între fiecare comandă și comanda lui anterioară. Ce greșeală trebuie evitată?

Răspuns scurt: Sortezi după client și dată, apoi df["zile"] = df.groupby("id_client")["data"].diff().dt.days. Greșeala de evitat este diff sau shift fără groupby, care ar scădea data ultimei comenzi a clientului anterior din prima comandă a clientului următor.

shift(1) mută valorile cu un rând în jos, iar diff() calculează diferența față de rândul anterior. Aplicate direct pe tabel, ele traversează granițele dintre clienți. Pe un groupby, fiecare client este tratat separat, iar primul rând al fiecăruia primește NaN.

PYTHON
df = df.sort_values(["id_client", "data"])
g = df.groupby("id_client")

df["zile_de_la_anterioara"] = g["data"].diff().dt.days
df["valoare_anterioara"] = g["valoare"].shift(1)
df["nr_comanda"] = g.cumcount() + 1
df["total_cumulat"] = g["valoare"].cumsum()

Pentru coloane de tip dată, diff() întoarce Timedelta, iar .dt.days extrage numărul de zile. Coloana data trebuie să fie de tip datetime64; dacă e text, diff dă eroare.

Sortarea este obligatorie. groupby păstrează ordinea rândurilor din cadrul grupului așa cum apar în tabel, deci fără sortare compari comenzi într-o ordine arbitrară.

Cu aceste coloane poți răspunde la întrebări frecvente: intervalul median dintre cumpărături (df.groupby("id_client")["zile_de_la_anterioara"].median()), câți clienți fac a doua comandă în 30 de zile sau ce valoare are prima comandă față de următoarele. Dacă un client are două comenzi în aceeași zi, diferența este 0; decide dacă le numeri separat sau le unești în prealabil.

Ce urmărește intervievatorul: Intervievatorul verifică operațiile pe rânduri consecutive în cadrul grupurilor. Bug-ul clasic este diff fără groupby sau fără sortare.

46 Mid

Ce afișează codul și de ce lipsesc din raport vânzările fără regiune?

PYTHON
df = pd.DataFrame({"regiune": ["Nord", None, "Sud"],
                   "valoare": [100, 50, 200]})
print(df.groupby("regiune")["valoare"].sum().sum(), df["valoare"].sum())

Răspuns scurt: Afișează 300 350. groupby exclude implicit rândurile în care cheia de grupare lipsește, așa că cei 50 de lei dispar din raport. Cu dropna=False (din pandas 1.1) valorile lipsă formează un grup separat.

Comportamentul implicit din groupby este dropna=True: rândurile cu cheia NaN nu intră în niciun grup. Nu primești nicio eroare și niciun avertisment, iar suma pe grupe ajunge mai mică decât totalul. Într-un raport pe regiuni, asta înseamnă că totalul raportului nu se potrivește cu totalul din sistem.

PYTHON
df.groupby("regiune", dropna=False)["valoare"].sum()
# Nord 100, Sud 200, NaN 50

df["regiune"].fillna("Necunoscut")   # alternativă, cu etichetă lizibilă

Am două obiceiuri care prind problema devreme:

  • verific că suma pe grupe este egală cu totalul: assert r.sum() == df["valoare"].sum();
  • înainte de grupare, număr valorile lipsă ale cheilor: df["regiune"].isna().sum().

Un caz înrudit apare la coloanele de tip category: cu observed=False, implicit în pandas 2.x, apar și categoriile fără niciun rând, cu suma 0. Cu mai multe chei categoriale, rezultatul poate conține produsul cartezian al categoriilor, adică multe rânduri goale. Setează explicit observed=True când vrei doar combinațiile existente.

Pe scurt, la orice raport agregat, întrebarea „unde sunt rândurile care nu se încadrează în nicio categorie?” trebuie pusă înainte de publicare.

Ce urmărește intervievatorul: Se verifică dacă știi comportamentul implicit al lui groupby cu chei lipsă. E o cauză foarte frecventă de diferențe între rapoarte.

47 Senior

Ai 20 de milioane de rânduri cu categorie, pret și cantitate. Cum calculezi prețul mediu ponderat cu cantitatea pe fiecare categorie fără apply, și de ce contează?

Răspuns scurt: Calculezi întâi o coloană cu pret * cantitate, apoi agregi sume: (df["pret"] * df["cantitate"]).groupby(df["categorie"]).sum() / df.groupby("categorie")["cantitate"].sum(). Sunt doar operații vectorizate și sume optimizate, deci rulează în secunde, nu în minute.

Varianta intuitivă folosește apply cu np.average:

PYTHON
df.groupby("categorie").apply(
    lambda g: np.average(g["pret"], weights=g["cantitate"]))

Pentru fiecare grup, pandas construiește un DataFrame, apelează funcția în Python și combină rezultatele. La câteva grupe e suportabil; la zeci de mii de grupe, overhead-ul per apel domină timpul.

Media ponderată se poate rescrie ca raport de două sume, iar sumele pe grupe sunt implementate în cod compilat:

PYTHON
tmp = df.assign(venit=df["pret"] * df["cantitate"])
s = tmp.groupby("categorie", observed=True)[["venit", "cantitate"]].sum()
s["pret_mediu_ponderat"] = s["venit"] / s["cantitate"]

Același principiu se aplică la multe statistici: varianța pe grupe se poate obține din sumele lui x și x², rata de conversie din sumă și număr. Reformularea în termeni de agregări simple este una dintre cele mai eficiente optimizări în pandas.

Detalii pentru date reale: cantitățile zero sau negative (retururi) pot da împărțiri la zero sau rezultate fără sens, deci decide cum le tratezi; categorie ca tip category accelerează gruparea și scade memoria; iar pentru volume și mai mari, aceeași formulă se scrie aproape identic în SQL, Polars sau DuckDB, deci logica rămâne portabilă.

Ca verificare, compar rezultatul cu varianta apply pe un eșantion mic, folosind np.allclose.

Ce urmărește intervievatorul: La nivel senior se urmărește dacă poți reformula o problemă ca să rămână vectorizată și dacă verifici echivalența. Răspunsul slab acceptă apply pentru că „merge”.

merge, concat și remodelare

48 Junior

Ai trei fișiere CSV lunare cu aceleași coloane, dar al treilea are în plus coloana „reducere”. Ce obții după pd.concat, cum păstrezi luna de proveniență și de ce folosești ignore_index=True?

Răspuns scurt: concat pune rândurile unele sub altele și face reuniunea coloanelor: în primele două luni „reducere” va fi NaN. Cu keys=[...] sau o coloană adăugată înainte păstrezi proveniența, iar ignore_index=True renumerotează indexul, care altfel ar avea etichete repetate.

pd.concat lipește obiecte de-a lungul unei axe. Implicit, axis=0, adică rânduri sub rânduri. Coloanele se aliniază după nume, nu după poziție, iar o coloană care lipsește într-unul din tabele se completează cu NaN (join="outer" implicit; cu join="inner" ar rămâne doar coloanele comune).

PYTHON
from pathlib import Path

frames = []
for f in sorted(Path("date").glob("vanzari_2025_*.csv")):
    t = pd.read_csv(f)
    t["sursa"] = f.stem
    frames.append(t)

toate = pd.concat(frames, ignore_index=True)

Fără ignore_index=True, fiecare fișier își aduce indexul 0..n-1, iar rezultatul are etichete repetate. Atunci toate.loc[0] întoarce câte un rând din fiecare lună, iar unele operații de aliniere dau rezultate ciudate.

Pentru proveniență ai două opțiuni: o coloană adăugată înainte, ca mai sus, sau keys, care creează un nivel suplimentar în index: pd.concat(frames, keys=["ian", "feb", "mar"]).

După concatenare, verifică: suma rândurilor (len(toate) == sum(len(t) for t in frames)), tipurile coloanelor (o coloană numerică într-un fișier și text în altul devine object) și coloanele noi apărute din greșeli de scriere, de exemplu „Pret” față de „pret”.

Ce urmărește intervievatorul: Se verifică înțelegerea alinierii coloanelor la concat și grija pentru index și proveniență. Mulți nu se așteaptă la NaN-urile din coloanele lipsă.

Eroarea, în practică:'DataFrame' object has no attribute 'append'No objects to concatenate

49 Junior

Faci merge între comenzi și clienti, unde cheia se numește client_id, respectiv id, iar ambele tabele au o coloană oras. Cum scrii merge-ul și ce coloane primești?

Răspuns scurt: comenzi.merge(clienti, left_on="client_id", right_on="id", how="left", suffixes=("_livrare", "_client")). Primești ambele coloane-cheie, client_id și id, plus oras_livrare și oras_client. Coloana id duplicată o poți elimina după.

Când cheile au nume diferite, folosești left_on și right_on. Ambele coloane rămân în rezultat, pentru că pandas nu presupune că vrei să renunți la vreuna.

Când ambele tabele au o coloană cu același nume care nu e cheie, pandas adaugă sufixe ca să le deosebească. Cele implicite, _x și _y, nu spun nimic cititorului, așa că e mai bine să alegi sufixe cu sens.

PYTHON
rez = (comenzi.merge(
          clienti,
          left_on="client_id", right_on="id",
          how="left",
          suffixes=("_livrare", "_client"))
       .drop(columns="id"))

how="left" păstrează toate comenzile, chiar dacă unele nu au clientul în tabelul de clienți; acolo coloanele clientului vor fi NaN. Alegerea este de obicei corectă pentru un tabel de fapte îmbogățit cu atribute: nu vrei să pierzi vânzări pentru că lipsește un client din nomenclator.

O alternativă care evită coloanele duplicate este redenumirea înainte: clienti.rename(columns={"id": "client_id"}), apoi on="client_id". Pentru claritate, mulți preferă și să selecteze dinainte doar coloanele necesare din tabelul din dreapta, ca rezultatul să nu se umple de coloane nefolosite: clienti[["id", "oras", "segment"]].

Ce urmărește intervievatorul: Intervievatorul verifică detaliile practice ale lui merge. Răspunsul bun alege conștient tipul de join și sufixe cu sens.

Eroarea, în practică:KeyError la merge (cheie cu nume diferite)MergeError: No common columns to perform merge on

50 Junior

Un merge între comenzi și produse dă eroarea „You are trying to merge on int64 and object columns” sau, în altă variantă, nu găsește nicio potrivire. Ce verifici?

Răspuns scurt: Tipul și formatul cheii în ambele tabele: număr într-unul și text în celălalt, zerouri în față („00123” față de 123), spații sau majuscule diferite. Aduci cheile la același tip și format înainte de merge și verifici rata de potrivire cu indicator=True.

merge compară cheile valoare cu valoare, iar 123 (int) și „123” (text) nu sunt egale. În pandas 2.x, combinarea unei coloane numerice cu una de tip object dă direct ValueError. Mai insidios este cazul în care ambele sunt text, dar formatul diferă: „00123” față de „123”, „P-10 ” cu spațiu, „p-10” cu literă mică. Acolo merge-ul rulează fără eroare și pur și simplu nu potrivește nimic.

Pașii pe care îi urmez:

PYTHON
print(comenzi["cod"].dtype, produse["cod"].dtype)
print(comenzi["cod"].head().tolist(), produse["cod"].head().tolist())

def norm(s):
    return s.astype("string").str.strip().str.upper().str.zfill(6)

comenzi["cod"] = norm(comenzi["cod"])
produse["cod"] = norm(produse["cod"])

rez = comenzi.merge(produse, on="cod", how="left", indicator=True)
print(rez["_merge"].value_counts())
print(rez.loc[rez["_merge"] == "left_only", "cod"].unique()[:20])

indicator=True adaugă coloana _merge cu valorile both, left_only și right_only, deci vezi imediat ce procent s-a potrivit și care chei au rămas pe dinafară.

Pe termen lung, cel mai bine e să fixezi tipul cheii chiar la citire, de exemplu dtype={"cod": str}, ca să nu pierzi zerourile din față și să nu depinzi de ghicirea tipului de către pandas.

Ce urmărește intervievatorul: Se verifică depanarea sistematică a unei probleme foarte frecvente la combinarea surselor. Candidații buni măsoară rata de potrivire, nu doar repară eroarea.

Eroarea, în practică:You are trying to merge on int64 and str columns

51 Junior

Construiește un tabel cu regiunile pe rânduri, trimestrele pe coloane, venitul în celule, zero unde nu există vânzări și un rând plus o coloană de total.

Răspuns scurt: df.pivot_table(index="regiune", columns="trimestru", values="valoare", aggfunc="sum", fill_value=0, margins=True, margins_name="Total"). aggfunc decide cum se agregă valorile repetate, fill_value completează combinațiile goale, iar margins adaugă totalurile.

pivot_table este echivalentul tabelului pivot din Excel: grupează după două dimensiuni și pune una dintre ele pe coloane.

PYTHON
df["trimestru"] = df["data"].dt.to_period("Q").astype(str)

tab = df.pivot_table(
    index="regiune",
    columns="trimestru",
    values="valoare",
    aggfunc="sum",
    fill_value=0,
    margins=True,
    margins_name="Total",
)

Detalii care contează:

  • aggfunc are implicit valoarea "mean", nu "sum". Dacă uiți să-l setezi, tabelul arată valori medii, iar cifrele par plauzibile, deci greșeala trece ușor neobservată.
  • fill_value=0 pune 0 în combinațiile fără rânduri. Fără el apar NaN, care sunt corecte tehnic, dar arată prost într-un raport.
  • margins=True calculează totalurile cu aceeași funcție de agregare, pe datele originale. Cu aggfunc="mean", totalul este media generală, nu media mediilor.
  • Poți da mai multe funcții (aggfunc=["sum", "count"]) sau mai multe coloane de valori, iar coloanele rezultatului devin un MultiIndex.

pd.crosstab(df["regiune"], df["trimestru"]) este scurtătura pentru tabele de frecvență, cu normalize="index" pentru procente pe rând. Pentru export în Excel, tabelul pivot se scrie direct cu to_excel, iar coloanele sortate cronologic se obțin natural dacă trimestrele sunt Period sau text în format „2025Q1”.

Ce urmărește intervievatorul: Se verifică stăpânirea parametrilor practici ai lui pivot_table. Capcana preferată a intervievatorilor este aggfunc implicit mean.

Eroarea, în practică:Index contains duplicate entries, cannot reshape

52 Junior

Primești un fișier Excel cu un rând pe produs și câte o coloană pentru fiecare lună: „ian”, „feb”, „mar”... Transformă-l într-un tabel cu coloanele produs, luna, vanzari și explică de ce formatul acesta e mai ușor de analizat.

Răspuns scurt: Cu df.melt(id_vars="produs", var_name="luna", value_name="vanzari"). Formatul lung are o singură coloană pentru fiecare variabilă, deci poți filtra, grupa și desena grafice după lună fără să enumeri coloane, iar o lună nouă înseamnă rânduri noi, nu o coloană nouă.

melt transformă coloanele într-o pereche de coloane: una cu numele vechii coloane și una cu valoarea. Coloanele din id_vars se repetă pe fiecare rând.

PYTHON
lung = df.melt(id_vars="produs", var_name="luna", value_name="vanzari")

ordine = ["ian", "feb", "mar", "apr", "mai", "iun",
          "iul", "aug", "sep", "oct", "noi", "dec"]
lung["luna"] = pd.Categorical(lung["luna"], categories=ordine, ordered=True)
lung = lung.sort_values(["produs", "luna"])

Formatul lat (wide) este bun pentru citit de oameni. Formatul lung (long, numit uneori și „tidy”) este bun pentru calcule, pentru că fiecare variabilă este o coloană și fiecare observație un rând. Cu el, întrebările devin operații standard:

PYTHON
lung.groupby("luna", observed=True)["vanzari"].sum()
lung.groupby("produs")["vanzari"].agg(["sum", "mean", "max"])
lung.loc[lung["vanzari"] == 0, ["produs", "luna"]]

În formatul lat, aceleași calcule cer liste de coloane scrise de mână, care se strică atunci când apare o lună nouă. Bibliotecile de grafice precum seaborn așteaptă și ele format lung, ca să poată colora sau separa după o coloană.

Conversia inversă se face cu pivot sau pivot_table. Ordinea lunilor e un detaliu important: ca text, sortarea alfabetică pune „apr” înaintea lui „ian”, de aceea am folosit o categorie ordonată sau, și mai bine, se poate construi o dată reală.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să normalizezi un tabel lat și dacă înțelegi de ce formatul lung e preferat pentru analiză. Ordinea lunilor e un detaliu pe care mulți îl ratează.

Eroarea, în practică:id_vars or value_vars are not present (melt)

53 Mid

Cum găsești în pandas produsele din nomenclator care nu au avut nicio vânzare luna aceasta? Arată două variante.

Răspuns scurt: Varianta 1: produse[~produse["cod"].isin(vanzari["cod"])]. Varianta 2: un merge left cu indicator=True, apoi păstrezi rândurile cu _merge == "left_only". Este un anti-join: rândurile din stânga fără corespondent în dreapta.

Pandas nu are o funcție dedicată pentru anti-join, dar se obține ușor.

Varianta cu isin este cea mai scurtă și cea mai rapidă pentru o singură cheie:

PYTHON
vandute = vanzari.loc[vanzari["data"].dt.to_period("M") == "2025-03", "cod"]
fara_vanzari = produse[~produse["cod"].isin(vandute)]

Varianta cu merge și indicator funcționează și pentru chei compuse și îți spune explicit ce s-a potrivit:

PYTHON
m = produse.merge(vandute.drop_duplicates().to_frame(), on="cod",
                  how="left", indicator=True)
fara_vanzari = m.loc[m["_merge"] == "left_only"].drop(columns="_merge")

Pentru chei pe mai multe coloane, de exemplu produs și magazin, merge cu on=["cod", "magazin"] este varianta naturală. Am eliminat duplicatele din tabelul din dreapta, ca merge-ul să nu multiplice rândurile din stânga.

Două capcane. Prima: valorile lipsă din cheie. Spre deosebire de SQL, unde NULL nu se potrivește cu nimic, merge-ul din pandas potrivește NaN cu NaN, iar isin tratează NaN ca valoare căutabilă, dar nu și None dintr-o coloană de text. Comportamentul diferă după tip, așa că elimini sau tratezi explicit cheile lipsă înainte. A doua: tipurile cheii trebuie să coincidă; dacă un cod e text într-un tabel și număr în celălalt, toate produsele vor apărea „fără vânzări”. Un rezultat suspect de mare este un semn bun că trebuie verificat tipul.

Ce urmărește intervievatorul: Se verifică dacă știi să exprimi un anti-join în pandas și dacă știi capcanele cheilor. Răspunsul bun menționează diferența față de SQL la NaN.

54 Mid

Codul de mai jos dă eroarea „Index contains duplicate entries, cannot reshape”. De ce și cum o rezolvi?

PYTHON
df.pivot(index="magazin", columns="luna", values="valoare")

Răspuns scurt: pivot doar rearanjează datele și cere ca fiecare combinație magazin–lună să apară o singură dată. Ai mai multe rânduri pe aceeași combinație (de exemplu câte unul pe comandă), deci trebuie să agregi: pivot_table cu aggfunc="sum" sau groupby urmat de unstack.

pivot nu agregă. Fiecare celulă a rezultatului trebuie să corespundă exact unui rând din tabel. Dacă magazinul „Cluj 1” are 300 de comenzi în martie, pandas nu știe ce valoare să pună în celula (Cluj 1, martie) și se oprește cu eroare.

Înainte de a repara, află de ce există duplicate, pentru că răspunsul decide soluția:

PYTHON
dup = df.duplicated(subset=["magazin", "luna"], keep=False)
df[dup].sort_values(["magazin", "luna"]).head()

Dacă rândurile sunt tranzacții individuale, ai nevoie de o agregare:

PYTHON
tab = df.pivot_table(index="magazin", columns="luna",
                     values="valoare", aggfunc="sum", fill_value=0)
# echivalent
tab = df.groupby(["magazin", "luna"])["valoare"].sum().unstack(fill_value=0)

Dacă tabelul ar trebui să aibă un singur rând pe combinație, de exemplu un raport lunar deja agregat, duplicatele sunt o problemă de date: un import repetat, o lună încărcată de două ori. În cazul acesta, pivot_table cu sum ar ascunde eroarea dublând valorile. Corect este să elimini duplicatele reale sau să afli de la sursă care e versiunea bună.

De aceea prefer pivot atunci când mă aștept la unicitate: eroarea lui este o verificare gratuită a presupunerii mele.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi diferența dintre remodelare și agregare și dacă investighezi cauza duplicatelor. Răspunsul slab trece automat la pivot_table.

Eroarea, în practică:Index contains duplicate entries, cannot reshape

55 Mid

Ce fac stack și unstack? Pornind de la df.groupby(["an", "luna"])["valoare"].sum(), cum obții un tabel cu anii pe coloane, ca să compari lunile între ani?

Răspuns scurt: unstack mută un nivel din indexul rândurilor în coloane, stack face inversul. r.unstack("an") pune anii pe coloane și lunile pe rânduri, deci fiecare rând compară aceeași lună în ani diferiți.

Gândește un MultiIndex ca pe un tabel lung cu chei compuse. unstack(nivel) ia un nivel al indexului și îl transformă în antet de coloane, lărgind tabelul. stack() face drumul invers: coloanele devin un nivel interior al indexului.

PYTHON
r = df.groupby([df["data"].dt.year.rename("an"),
                df["data"].dt.month.rename("luna")])["valoare"].sum()

comp = r.unstack("an")          # rânduri: luna, coloane: an
comp["dif_%"] = (comp[2025] / comp[2024] - 1) * 100

inapoi = comp.drop(columns="dif_%").stack()   # Series cu MultiIndex

Nivelul se poate da după nume sau după poziție (unstack(0), unstack(-1); implicit este ultimul nivel). Combinațiile fără date devin NaN, iar unstack(fill_value=0) le completează.

stack elimina implicit NaN-urile în versiunile mai vechi; în pandas 2.1 a apărut o implementare nouă, activată cu future_stack=True, care nu mai elimină valorile lipsă și devine comportamentul standard în pandas 3.0.

Un caz frecvent este aplatizarea coloanelor pe două niveluri după agg cu mai multe funcții:

PYTHON
t = df.groupby("magazin").agg({"valoare": ["sum", "mean"]})
t.columns = ["_".join(c) for c in t.columns]   # valoare_sum, valoare_mean

Pentru comparații an la an, formatul cu anii pe coloane este și cel mai ușor de transformat într-un grafic: comp[[2024, 2025]].plot() desenează o linie pentru fiecare an.

Ce urmărește intervievatorul: Se verifică manipularea MultiIndex-ului, necesară după groupby pe mai multe chei. Candidații confundă des direcția lui stack și unstack.

Eroarea, în practică:Index contains duplicate entries, cannot reshape

56 Mid

Primești de la un API comenzi în JSON, fiecare cu un obiect client imbricat și o listă produse. Cum ajungi la un DataFrame cu un rând pe produs, care să aibă și ID-ul comenzii și numele clientului?

Răspuns scurt: Cu pd.json_normalize(date, record_path="produse", meta=["id", ["client", "nume"]]), care desface lista și aduce câmpurile din nivelurile superioare. Dacă ai deja o coloană cu liste, explode face câte un rând pentru fiecare element.

Datele imbricate nu încap direct într-un tabel. pd.DataFrame(date) ar crea o coloană client cu dicționare și una produse cu liste, pe care nu poți grupa sau filtra.

pd.json_normalize aplatizează structura:

PYTHON
date = [
    {"id": 1, "client": {"nume": "Ana", "oras": "Cluj"},
     "produse": [{"sku": "A1", "cant": 2}, {"sku": "B7", "cant": 1}]},
]

comenzi = pd.json_normalize(date)
# coloane: id, produse, client.nume, client.oras

linii = pd.json_normalize(
    date,
    record_path="produse",
    meta=["id", ["client", "nume"]],
)
# coloane: sku, cant, id, client.nume

record_path indică lista care devine rânduri, iar meta câmpurile din nivelurile superioare care se repetă pe fiecare rând. Câmpurile imbricate primesc nume cu punct, configurabile cu sep.

Când lista este deja într-o coloană a unui DataFrame, folosești explode:

PYTHON
df = df.explode("produse", ignore_index=True)
detalii = pd.json_normalize(df["produse"])
df = pd.concat([df.drop(columns="produse"), detalii], axis=1)

Atenție la cazurile limită: o listă goală devine un rând cu NaN la explode, iar la json_normalize comanda dispare din tabelul de linii. Dacă unele comenzi nu au câmpul deloc, json_normalize cu record_path dă KeyError, deci normalizezi structura sau tratezi lipsa înainte. Verifică numărul de comenzi unice înainte și după transformare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să lucrezi cu date semistructurate, des întâlnite la API-uri. Răspunsul bun discută cazurile limită care fac comenzi să dispară.

57 Mid

Ai două surse de date despre clienți: CRM-ul, considerat de încredere, și formularul de pe site, mai complet, dar mai puțin sigur. Cum construiești un tabel care ia valorile din CRM și completează golurile din formular?

Răspuns scurt: Aliniezi ambele tabele pe aceeași cheie (set_index("id_client")) și folosești crm.combine_first(formular): păstrează valorile din CRM și le ia din formular doar unde CRM-ul are NaN. Rezultatul include și clienții care apar doar într-una dintre surse.

combine_first este „coalesce” la nivel de tabel: pentru fiecare celulă, ia valoarea din primul obiect, iar dacă lipsește, pe cea din al doilea. Alinierea se face după index și după numele coloanelor, deci cheia trebuie pusă în index.

PYTHON
crm = crm.set_index("id_client")
form = formular.set_index("id_client")

unit = crm.combine_first(form)

# câte valori au venit din formular, pe coloană
din_form = crm.reindex(unit.index).isna() & unit.notna()
print(din_form.sum())

Diferențe față de alternative:

  • crm.fillna(form) completează la fel, dar păstrează doar rândurile și coloanele din crm;
  • crm.update(form) face invers: suprascrie valorile din crm cu cele nelipsă din form, modificând obiectul pe loc;
  • un merge urmat de fillna pe coloane cu sufixe e mai explicit, dar mai lung.

Două lucruri de verificat. Cheia trebuie să fie unică în ambele surse; cu duplicate, alinierea devine ambiguă. Iar regula „completez golurile” e bună doar dacă un gol înseamnă cu adevărat „necunoscut”: un text gol sau „-” nu este NaN și blochează completarea. Păstrează și o coloană care spune sursa fiecărei valori pentru câmpurile importante, de exemplu telefonul, ca să poți explica ulterior de unde vine o informație greșită.

Ce urmărește intervievatorul: Se verifică dacă știi unelte pentru reconcilierea surselor și dacă te gândești la trasabilitate. Mulți scriu manual np.where pe fiecare coloană.

58 Senior

Ai 10.000 de comenzi. După comenzi.merge(preturi, on="cod_produs") ai 13.500 de rânduri, iar venitul total a crescut. Cum previi asta și cum faci merge-ul sigur într-un pipeline care rulează automat?

Răspuns scurt: Tabelul de prețuri are coduri repetate (de exemplu un preț pe fiecare perioadă), deci merge-ul multiplică rândurile. Verifici unicitatea cheii în dreapta și folosești validate="many_to_one", care oprește execuția dacă presupunerea e încălcată. Apoi alegi corect prețul valabil, nu ștergi duplicatele la întâmplare.

Un merge produce, pentru fiecare cheie, produsul cartezian al rândurilor potrivite. Dacă un cod apare de trei ori în preturi, fiecare comandă cu acel cod apare de trei ori în rezultat. Nu există eroare, doar cifre mai mari.

Diagnosticul:

PYTHON
preturi["cod_produs"].is_unique
preturi[preturi["cod_produs"].duplicated(keep=False)].sort_values("cod_produs")

În pipeline-uri automate, transform presupunerea într-o verificare. Parametrul validate face asta direct:

PYTHON
rez = comenzi.merge(preturi, on="cod_produs", how="left",
                    validate="many_to_one", indicator=True)
assert len(rez) == len(comenzi)
assert (rez["_merge"] == "both").mean() > 0.99

Valorile posibile sunt "one_to_one", "one_to_many", "many_to_one" și "many_to_many". La încălcare apare MergeError cu un mesaj clar, iar raportul nu se mai generează pe date greșite.

Rezolvarea depinde de cauză. Dacă tabelul are istoricul prețurilor, cheia reală este compusă: produsul plus perioada de valabilitate, iar potrivirea se face după data comenzii (de exemplu cu merge_asof sau cu un filtru pe interval). Dacă sunt duplicate accidentale, le raportezi celor care întrețin sursa. drop_duplicates aplicat orbește alege un preț arbitrar și ascunde problema.

Pe lângă validate, verific mereu numărul de rânduri și un total de control (de exemplu cantitatea totală) înainte și după fiecare merge important.

Ce urmărește intervievatorul: La nivel senior se urmărește transformarea presupunerilor în verificări automate și înțelegerea cauzei de business a duplicatelor. Răspunsul slab propune doar drop_duplicates.

Eroarea, în practică:Merge keys are not unique in right dataset

Date calendaristice și serii de timp

Exersează capitolul cu exerciții reale: Curs analiza datelor Python →
59 Junior

Ce afișează codul și cum citești corect datele dintr-un export românesc cu formatul zi/lună/an?

PYTHON
print(pd.to_datetime("01/02/2025"))
print(pd.to_datetime("01/02/2025", dayfirst=True))

Răspuns scurt: Prima linie afișează 2025-01-02 (2 ianuarie), pentru că pandas presupune formatul american lună/zi. A doua afișează 2025-02-01. Pentru date românești, cel mai sigur este format="%d/%m/%Y", plus errors="coerce" și o verificare a valorilor care nu s-au convertit.

Șirul „01/02/2025” este ambiguu, iar pandas îl interpretează implicit ca lună/zi/an. Pentru exporturile din sisteme românești sau europene asta înseamnă că 1 februarie devine 2 ianuarie, fără nicio eroare. Problema se vede abia când apar zile mai mari de 12, care nu se pot interpreta ca lună.

dayfirst=True schimbă preferința, dar un format explicit este mai sigur și mai rapid:

PYTHON
df["data"] = pd.to_datetime(df["data_text"], format="%d.%m.%Y", errors="coerce")

invalide = df.loc[df["data"].isna() & df["data_text"].notna(), "data_text"]
print(invalide.value_counts().head())

Cu format explicit, orice valoare care nu respectă formatul devine NaT (Not a Time) cu errors="coerce", în loc să fie ghicită. Începând cu pandas 2.0, formatul este dedus din primul element nenul și aplicat consecvent pe toată coloana, ceea ce reduce amestecurile, dar nu rezolvă ambiguitatea dacă primul element este el însuși ambiguu.

La citire poți face conversia direct: pd.read_csv(f, parse_dates=["data"], dayfirst=True) sau, mai explicit, cu date_format="%d.%m.%Y" (pandas 2.0+).

Verificarea finală: intervalul datelor (df["data"].min(), max()) și distribuția pe luni. Dacă vânzările din primele 12 zile ale fiecărei luni par mutate în altă lună, ai o problemă de ordine zi-lună.

Ce urmărește intervievatorul: Se verifică o problemă foarte comună cu datele locale. Răspunsul bun preferă formatul explicit și verifică intervalul rezultat.

Eroarea, în practică:time data doesn't match formatCan only use .dt accessor with datetimelike values

60 Junior

Ai o coloană data de tip datetime. Cum adaugi coloanele an, lună, ziua săptămânii și „luna” ca perioadă, și cum afli vânzările medii pe zile ale săptămânii?

Răspuns scurt: Prin accesorul .dt: df["data"].dt.year, .dt.month, .dt.day_name() sau .dt.dayofweek (0 = luni) și .dt.to_period("M"). Media pe zi a săptămânii: df.groupby(df["data"].dt.dayofweek)["valoare"].mean(), pe totaluri zilnice, nu pe tranzacții.

Accesorul .dt expune componentele unei coloane datetime, vectorizat:

PYTHON
d = df["data"]
df["an"] = d.dt.year
df["luna_nr"] = d.dt.month
df["zi_sapt"] = d.dt.dayofweek          # 0 = luni, 6 = duminică
df["weekend"] = d.dt.dayofweek >= 5
df["luna"] = d.dt.to_period("M")        # Period: 2025-03
df["saptamana"] = d.dt.isocalendar().week

day_name() întoarce numele în engleză; pentru rapoarte în română e mai sigur un dicționar aplicat pe dayofweek decât parametrul locale, care depinde de sistemul de operare.

to_period("M") este mai bun decât perechea an–lună pentru grupare: o singură coloană, sortată corect cronologic și ușor de transformat înapoi în dată cu .dt.to_timestamp().

Pentru vânzările medii pe zi a săptămânii există o capcană. df.groupby(zi_sapt)["valoare"].mean() dă valoarea medie a unei tranzacții în acea zi, nu vânzarea medie a zilei. Corect este să agregi întâi pe zi calendaristică, apoi să faci media pe ziua săptămânii:

PYTHON
zilnic = df.groupby(df["data"].dt.normalize())["valoare"].sum()
medie = zilnic.groupby(zilnic.index.dayofweek).mean()

Și zilele fără nicio vânzare trebuie incluse cu 0, altfel media e supraestimată. Asta se face reindexând seria zilnică pe un interval complet de date.

Ce urmărește intervievatorul: Intervievatorul verifică folosirea accesorului .dt și grija la nivelul de agregare. Capcana medie pe tranzacție versus medie pe zi apare des la studiile de caz.

Eroarea, în practică:Can only use .dt accessor with datetimelike values'DatetimeIndex' object has no attribute 'dt'

61 Junior

Ai un DataFrame cu indexul de tip dată. Ce selectează fiecare linie?

PYTHON
ts.loc["2025-03"]
ts.loc["2025-03-01":"2025-03-15"]
ts[ts.index.year == 2024]

Răspuns scurt: Prima linie selectează toată luna martie 2025, a doua intervalul 1–15 martie inclusiv toată ziua de 15, a treia toate rândurile din 2024 printr-o mască. Merge doar pe un DatetimeIndex, sortat pentru slicing.

Pe un DatetimeIndex, pandas acceptă partial string indexing: un șir incomplet este interpretat ca perioada întreagă pe care o descrie. „2025-03” înseamnă de la 1 martie 00:00 până la 31 martie 23:59:59.999. Iar la slicing cu loc, capătul din dreapta este inclus la rezoluția dată: „2025-03-15” acoperă toată ziua de 15.

PYTHON
ts = df.set_index("data").sort_index()

ts.loc["2025-03"]                     # toată luna
ts.loc["2025-03-01":"2025-03-15"]     # inclusiv 15 martie, toată ziua
ts.loc["2025"]                        # tot anul
ts.loc["2025-03-10 08:00":"2025-03-10 12:00"]

Comportamentul acesta evită o greșeală clasică, cea a filtrului pe coloană cu df["data"] <= "2025-03-15", unde șirul este convertit la miezul nopții și tranzacțiile din ziua de 15 de după ora 00:00 sunt excluse. Pe coloană, varianta sigură este o limită exclusivă: df["data"] < "2025-03-16".

Indexul trebuie sortat pentru slicing pe intervale. Pe un index nesortat poți primi KeyError sau un avertisment, iar operațiile sunt mai lente. ts.index.is_monotonic_increasing verifică asta.

Măștile pe componente (ts.index.year == 2024, ts.index.month.isin([6, 7, 8])) sunt utile pentru filtre care nu sunt intervale continue, de exemplu „toate verile”. Pentru intervale orare zilnice există ts.between_time("09:00", "17:00").

Ce urmărește intervievatorul: Se verifică dacă știi selecția pe timp cu DatetimeIndex și dacă ești conștient de capcana capătului de interval. Răspunsul bun explică diferența față de filtrul pe coloană.

62 Junior

Ai data comenzii și data livrării. Cum calculezi durata livrării în zile calendaristice și în zile lucrătoare și cum afli procentul de comenzi livrate în cel mult 3 zile lucrătoare?

Răspuns scurt: Durata calendaristică este (df["livrare"] - df["comanda"]).dt.days. Zilele lucrătoare le numeri cu np.busday_count, cu lista sărbătorilor legale. Procentul este (zile_lucr <= 3).mean() * 100, spunând explicit ce faci cu comenzile nelivrate.

Diferența dintre două coloane datetime este de tip Timedelta. .dt.days extrage zilele întregi, iar .dt.total_seconds() / 3600 durata în ore.

PYTHON
df["zile_cal"] = (df["livrare"] - df["comanda"]).dt.days

Pentru zile lucrătoare, np.busday_count(start, end) numără zilele de luni până vineri din intervalul [start, end). Primește date la rezoluție de zi și acceptă o listă de sărbători:

PYTHON
sarbatori = ["2025-01-01", "2025-01-02", "2025-01-06", "2025-01-07",
             "2025-01-24", "2025-05-01"]   # listă de completat

livrate = df.dropna(subset=["livrare"]).copy()
livrate["zile_lucr"] = np.busday_count(
    livrate["comanda"].values.astype("datetime64[D]"),
    livrate["livrare"].values.astype("datetime64[D]"),
    holidays=sarbatori,
)
pct = (livrate["zile_lucr"] <= 3).mean() * 100

Lista de sărbători trebuie întreținută: în România câteva se mută de la an la an, cum ar fi Paștele și Rusaliile. Biblioteca holidays sau un tabel calendar intern al firmei sunt surse mai sigure decât o listă scrisă de mână.

Definește înainte ce înseamnă „în 3 zile”: o comandă plasată vineri seara și livrată luni are 1 zi lucrătoare în calculul de mai sus. Discută și comenzile încă nelivrate: dacă le excluzi, procentul pare mai bun decât este. Un raport corect le arată separat sau le tratează ca întârziate după un termen.

Ce urmărește intervievatorul: Intervievatorul verifică lucrul cu Timedelta și zile lucrătoare, plus atenția la definiții. Excluderea tacită a comenzilor nelivrate este o greșeală des întâlnită.

Eroarea, în practică:unsupported operand for -: 'str' and 'str' (date)'Series' object has no attribute 'days'

63 Junior

Cum calculezi venitul cumulat de la începutul anului (year-to-date) pe fiecare lună, care repornește de la zero în fiecare an?

Răspuns scurt: Agregi venitul pe lună, apoi aplici cumsum pe grupe de an: lunar.groupby(lunar.index.year).cumsum(). Fără gruparea pe an, suma cumulată ar continua peste anul nou.

Pașii sunt: un total pe lună, apoi o sumă cumulată resetată la fiecare an.

PYTHON
lunar = (df.set_index("data")["valoare"]
           .resample("MS").sum())         # MS = început de lună
ytd = lunar.groupby(lunar.index.year).cumsum()

raport = pd.DataFrame({"luna": lunar, "ytd": ytd})

resample("MS") creează un rând pentru fiecare lună din interval, inclusiv lunile fără vânzări, cu suma 0. E important: dacă folosești groupby pe perioadă, lunile goale lipsesc, iar într-o comparație cu anul trecut liniile nu se mai aliniază.

Pentru comparația cu anul anterior pe aceeași perioadă:

PYTHON
raport["an"] = raport.index.year
raport["luna_nr"] = raport.index.month
comp = raport.pivot(index="luna_nr", columns="an", values="ytd")
comp["crestere_%"] = (comp[2025] / comp[2024] - 1) * 100

Dacă anul curent nu e complet, comparația se face doar pe lunile încheiate. Altfel luna curentă, parțială, apare ca o scădere bruscă.

Variante înrudite: cummax pentru „cel mai bun nivel atins până acum”, expanding().mean() pentru media cumulată, iar dacă anul fiscal nu începe în ianuarie, grupezi după o cheie de an fiscal, de exemplu (index + pd.DateOffset(months=3)).year pentru un an fiscal care începe în octombrie.

Ce urmărește intervievatorul: Se verifică dacă știi să resetezi o operație cumulativă pe grupe și dacă tratezi lunile goale. Răspunsul bun discută și luna curentă incompletă.

64 Mid

Ce diferență este între df.resample("ME") și df.groupby(df["data"].dt.to_period("M")) pentru totaluri lunare? De ce în pandas 2.2 apare un avertisment când scrii resample("M")?

Răspuns scurt: resample creează toate intervalele dintre prima și ultima dată, inclusiv lunile goale, și cere un DatetimeIndex sau parametrul on=. groupby pe perioadă întoarce doar lunile care au date. În pandas 2.2, aliasul „M” a fost înlocuit cu „ME” (month end), iar „M” emite FutureWarning.

Ambele dau totaluri lunare, dar au comportamente diferite.

resample este gândit pentru serii de timp. Construiește un calendar regulat, de la primul la ultimul interval, și agregă în fiecare. Lunile fără date apar cu 0 la sum și cu NaN la mean. Funcționează pe un DatetimeIndex sau pe o coloană indicată cu on:

PYTHON
lunar = df.resample("ME", on="data")["valoare"].sum()
pe_magazin = (df.groupby("magazin")
                .resample("ME", on="data")["valoare"].sum())

groupby pe perioadă dă doar grupele existente și se combină ușor cu alte chei:

PYTHON
lunar2 = df.groupby(df["data"].dt.to_period("M"))["valoare"].sum()

Diferența contează la grafice și la calcule pe rânduri consecutive: pct_change sau shift pe un rezultat fără lunile goale compară martie cu ianuarie dacă februarie lipsește. Cu resample, seria are pas regulat.

Aliasurile s-au schimbat în pandas 2.2: "ME" pentru sfârșit de lună, "MS" pentru început, "QE" și "YE" pentru trimestru și an, "h" pentru oră. Vechile "M", "Q", "Y", "H" emit FutureWarning. Eticheta rezultatului diferă: cu "ME" martie apare ca 2025-03-31, cu "MS" ca 2025-03-01, iar cu to_period ca 2025-03. Pentru rapoarte, Period este de obicei cea mai lizibilă variantă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi conștient între cele două și dacă ești la curent cu schimbările din pandas 2.2. Lunile lipsă sunt detaliul care separă răspunsurile.

Eroarea, în practică:Invalid frequency: M (folosește 'ME')Only valid with DatetimeIndex ... 'RangeIndex'

65 Mid

Ce afișează codul? Când folosești o fereastră pe număr de rânduri și când una pe timp?

PYTHON
t = pd.DataFrame({"v": [1, 2, 3]},
    index=pd.to_datetime(["2025-01-01", "2025-01-02", "2025-01-09"]))
print(t["v"].rolling(2).sum().tolist())
print(t["v"].rolling("7D").sum().tolist())

Răspuns scurt: Prima linie afișează [nan, 3.0, 5.0], a doua [1.0, 3.0, 3.0]. rolling(2) adună ultimele 2 rânduri, oricât de departe ar fi în timp. rolling("7D") adună rândurile din ultimele 7 zile calendaristice, deci pe 9 ianuarie include doar acea zi.

O fereastră pe număr de rânduri presupune că rândurile sunt echidistante. Pe date cu goluri, „ultimele 7 rânduri” pot acoperi trei săptămâni, iar media mobilă devine fără sens. O fereastră pe timp, scrisă ca offset („7D”, „24h”), se uită la intervalul calendaristic, indiferent câte rânduri conține.

În exemplu, pentru 9 ianuarie fereastra „7D” acoperă intervalul (2 ianuarie, 9 ianuarie]: capătul stâng este exclus implicit, deci rămâne doar valoarea 3. Fereastra pe rânduri adună 2 și 3, deși sunt la o săptămână distanță.

Alte diferențe:

  • rolling(n) întoarce NaN până se adună n valori; min_periods controlează pragul;
  • rolling("7D") are implicit min_periods=1 și cere un index datetime sortat crescător (sau parametrul on);
  • closed="both" sau "left" schimbă includerea capetelor.
PYTHON
zilnic = df.resample("D", on="data")["comenzi"].sum()   # completează zilele goale cu 0
zilnic.rolling(7, min_periods=7).mean()                 # medie pe 7 zile pline
zilnic.rolling(7, center=True).mean()                   # pentru grafice de tendință

Prima linie din acest exemplu e de obicei cea mai sănătoasă abordare: transformi seria într-una regulată, cu zilele goale completate cu 0 unde asta e corect, apoi o fereastră pe rânduri are din nou sens. Pe grupe, folosește df.groupby("magazin").rolling("7D", on="data").

Ce urmărește intervievatorul: Se verifică înțelegerea ferestrelor glisante pe date cu goluri, o problemă reală în seriile de vânzări. Mulți aplică rolling(7) pe date neregulate.

66 Mid

Graficul vânzărilor zilnice „sare” peste zilele fără comenzi, iar media zilnică pare prea mare. Cum construiești o serie completă, cu 0 în zilele fără vânzări, pentru fiecare magazin?

Răspuns scurt: Creezi intervalul complet de zile cu pd.date_range și reindexezi seria cu fill_value=0. Pentru mai multe magazine construiești un MultiIndex din produsul cartezian magazin x zi și reindexezi, sau folosești groupby cu resample("D").

Un tabel de tranzacții nu conține rânduri pentru zilele fără tranzacții. Agregarea pe zi produce doar zilele existente, așa că graficele unesc direct punctele vecine, iar media se calculează doar din zilele cu vânzări.

Pentru o singură serie:

PYTHON
zilnic = df.groupby(df["data"].dt.normalize())["valoare"].sum()
zile = pd.date_range("2025-01-01", "2025-03-31", freq="D")
zilnic = zilnic.reindex(zile, fill_value=0)

Intervalul îl stabilești explicit, după perioada raportului, nu după prima și ultima tranzacție: dacă un magazin nu a vândut nimic în prima săptămână, și acele zile trebuie să apară.

Pentru mai multe magazine:

PYTHON
z = df.groupby(["magazin", df["data"].dt.normalize().rename("zi")])["valoare"].sum()
idx = pd.MultiIndex.from_product([df["magazin"].unique(), zile],
                                 names=["magazin", "zi"])
complet = z.reindex(idx, fill_value=0).reset_index()

Atenție la semnificația lui 0. O zi fără vânzări într-un magazin deschis e un 0 real. O zi în care magazinul a fost închis (sărbătoare, renovare) sau încă nu exista nu ar trebui să tragă media în jos. Dacă există un calendar de funcționare, îl folosești ca să marchezi aceste zile ca NaN în loc de 0.

Cu seria completă, media zilnică, ferestrele glisante și comparațiile pe zile ale săptămânii devin corecte.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ești conștient că lipsa unui rând nu înseamnă lipsa unei zile și dacă știi să completezi grila. Răspunsul matur discută diferența dintre zero real și zi închisă.

67 Senior

Primești timestamp-uri dintr-o aplicație, fără fus orar, despre care știi că sunt ora României. La conversie în UTC, unele rânduri dau NonExistentTimeError sau AmbiguousTimeError. De ce și cum tratezi corect situația?

Răspuns scurt: Sunt ore din nopțile de schimbare a orei: în ultima duminică din martie, 03:00–03:59 nu există, iar în ultima duminică din octombrie apare de două ori. Dai tz_localize reguli explicite prin nonexistent și ambiguous, iar la sursă ceri salvare în UTC.

tz_localize atașează un fus orar unor ore „naive”, fără să le modifice. tz_convert mută ore deja localizate în alt fus. Problemele apar la localizare, pentru că ora locală nu este o funcție continuă:

  • la trecerea la ora de vară, ceasul sare de la 03:00 la 04:00, deci 03:30 nu există;
  • la revenirea la ora de iarnă, intervalul 03:00–03:59 apare de două ori, deci 03:30 este ambiguu.
PYTHON
loc = df["ts"].dt.tz_localize(
    "Europe/Bucharest",
    nonexistent="shift_forward",   # 03:30 inexistent devine 04:00
    ambiguous="NaT",               # orele duble devin lipsă, de analizat
)
df["ts_utc"] = loc.dt.tz_convert("UTC")

Pentru ambiguous poți da și un array boolean care spune, pentru fiecare rând, dacă e ora de vară. Dacă datele sunt sortate cronologic și înregistrate continuu, ambiguous="infer" încearcă să deducă asta din ordine.

Ce aș face în practică:

  • număr rândurile afectate; de obicei sunt foarte puține, dar într-un sistem de facturare pe oră contează;
  • cer echipei care produce datele să salveze timpul în UTC sau cu offset explicit, de exemplu în format ISO 8601 cu „+03:00”;
  • păstrez în analiză coloana UTC pentru calcule și o convertesc în ora locală doar la afișare și la agregări pe zi locală.

O agregare pe zile făcută direct pe UTC mută comenzile de după miezul nopții ora locală în ziua anterioară, de aceea ziua de raportare trebuie calculată după conversia în ora României.

Ce urmărește intervievatorul: La nivel senior se urmărește înțelegerea reală a fusurilor orare și a schimbării orei, plus o soluție la sursă. Mulți candidați nu știu că unele ore locale nu există.

Eroarea, în practică:Cannot subtract tz-naive and tz-aware datetime-likeMixed timezones detected. Pass utc=True

68 Senior

Ai tranzacții în euro, cu dată și oră, și un tabel cu cursul BNR publicat în zilele lucrătoare. Cum atașezi fiecărei tranzacții ultimul curs valabil la momentul ei, inclusiv în weekend?

Răspuns scurt: Cu pd.merge_asof(tranzactii.sort_values("data"), curs.sort_values("data"), on="data", direction="backward"), care ia pentru fiecare tranzacție ultimul curs cu data mai mică sau egală. Un tolerance de câteva zile împiedică folosirea unui curs prea vechi.

Un merge obișnuit cere egalitate pe cheie, iar tranzacțiile din weekend sau dintr-o zi fără curs publicat nu ar găsi nimic. merge_asof face o potrivire „cea mai apropiată”, ca un VLOOKUP aproximativ pe o coloană sortată.

PYTHON
tr = tranzactii.sort_values("data")
cr = curs.sort_values("data")[["data", "eur_ron"]]

rez = pd.merge_asof(
    tr, cr,
    on="data",
    direction="backward",          # ultimul curs <= data tranzacției
    tolerance=pd.Timedelta("4D"),  # nu folosi cursuri mai vechi de 4 zile
)
rez["valoare_ron"] = rez["valoare_eur"] * rez["eur_ron"]
print(rez["eur_ron"].isna().sum(), "tranzacții fără curs")

Condiții și detalii importante:

  • ambele tabele trebuie sortate după cheie, altfel apare ValueError;
  • tipurile cheii trebuie să coincidă, inclusiv fusul orar;
  • by="moneda" face potrivirea separat pe fiecare monedă, într-un singur apel;
  • direction poate fi și "forward" sau "nearest", dar pentru cursuri contabile "backward" evită folosirea unei informații publicate după tranzacție;
  • allow_exact_matches=False exclude egalitatea, util când o valoare devine valabilă abia după momentul publicării.

Merită confirmată regula de business cu echipa financiară: unele firme folosesc cursul din ziua anterioară facturii, nu cel din aceeași zi. Formula rămâne aceeași, doar cheia se decalează, de exemplu cu o zi. Rezultatul se validează pe câteva tranzacții calculate de mână, inclusiv una de sâmbătă și una dintr-o zi de sărbătoare.

Ce urmărește intervievatorul: Se verifică dacă știi unealta potrivită pentru potriviri pe intervale de timp și dacă te gândești la regula contabilă. Un senior întreabă de regulă înainte de cod.

Performanță și cod pandas solid

69 Junior

Unde e bug-ul? Colegul vrea să aplice o reducere de 10% produselor din categoria „promo”, dar tabelul rămâne neschimbat.

PYTHON
for i, row in df.iterrows():
    if row["categorie"] == "promo":
        row["pret"] = row["pret"] * 0.9

Răspuns scurt: iterrows întoarce pentru fiecare rând o Series nouă, iar modificarea ei nu ajunge în DataFrame. Varianta corectă și mult mai rapidă este o atribuire cu mască: df.loc[df["categorie"] == "promo", "pret"] *= 0.9.

iterrows() produce perechi (index, Series), iar Series-ul este construit pentru fiecare rând. Nu este o vedere spre tabel, deci row["pret"] = ... modifică un obiect temporar care dispare la pasul următor. Documentația pandas avertizează explicit că nu trebuie să modifici obiectele peste care iterezi.

Mai e o problemă: construirea unei Series pentru fiecare rând este scumpă și nu păstrează tipurile (un rând cu întregi și float devine tot float). Pe sute de mii de rânduri, bucla durează de ordinul secundelor sau minutelor, unde varianta vectorizată durează milisecunde.

PYTHON
mask = df["categorie"] == "promo"
df.loc[mask, "pret"] = df.loc[mask, "pret"] * 0.9

# sau, fără mască separată
df["pret"] = np.where(df["categorie"] == "promo", df["pret"] * 0.9, df["pret"])

Dacă ai nevoie de o buclă, de exemplu pentru apeluri către un serviciu extern pe fiecare rând, itertuples() este mult mai rapid decât iterrows() și păstrează tipurile, iar rezultatele le colectezi într-o listă pe care o atribui la final ca o coloană nouă:

PYTHON
rez = [functie(r.id, r.pret) for r in df.itertuples(index=False)]
df["rezultat"] = rez

Rețeta generală: gândește în coloane și măști, nu în rânduri. Bucla rămâne ultima soluție, nu prima.

Ce urmărește intervievatorul: Se verifică dacă știi că iterrows nu oferă acces de scriere și dacă reflexul tău e vectorizarea. E o capcană clasică pentru cei care vin din programare procedurală.

Eroarea, în practică:ChainedAssignmentError (fostul SettingWithCopy)

70 Mid

Un DataFrame cu 5 milioane de rânduri ocupă 3 GB în memorie. Cum afli ce coloane ocupă cel mai mult și cum reduci memoria fără să pierzi informație?

Răspuns scurt: Rulezi df.memory_usage(deep=True) sau df.info(memory_usage="deep") ca să vezi consumul real pe coloană. Apoi transformi textele repetitive în category, faci downcast la tipurile numerice după verificarea intervalului și elimini coloanele de care nu ai nevoie.

Primul pas este măsurarea. Fără deep=True, pandas raportează pentru coloanele de tip object doar dimensiunea pointerilor, nu a textelor, deci subestimează mult consumul.

PYTHON
mem = df.memory_usage(deep=True).sort_values(ascending=False) / 1e6
print(mem.head(10))          # MB pe coloană
print(df.nunique().sort_values())

De obicei, coloanele de text domină. Pașii în ordinea impactului:

  • coloane inutile: renunță la ele, ideal chiar la citire, cu usecols;
  • text cu puține valori distincte (județ, status, canal): astype("category"), adesea de zeci de ori mai mic;
  • numere: pd.to_numeric(s, downcast="integer") sau "float" alege cel mai mic tip care încape;
  • text cu multe valori distincte (emailuri, descrieri): tipul string[pyarrow], mai compact decât obiectele Python;
  • booleene stocate ca text „Da”/„Nu”: conversie la bool.
PYTHON
for c in ["judet", "status", "canal"]:
    df[c] = df[c].astype("category")
for c in df.select_dtypes("integer"):
    df[c] = pd.to_numeric(df[c], downcast="integer")

Atenție la float32: are circa 7 cifre semnificative, deci sumele mari de bani pot pierde precizie la nivel de bani. Pentru valori monetare rămân la float64 sau lucrez în bani ca întregi. Iar după downcast, operațiile aritmetice pot depăși intervalul tipurilor mici.

Ca regulă, aplic tipurile direct la citire, cu dtype= în read_csv, ca vârful de memorie din timpul citirii să fie și el mai mic.

Ce urmărește intervievatorul: Intervievatorul verifică dacă măsori înainte de a optimiza și dacă știi compromisurile tipurilor mici. Lipsa lui deep=True e o greșeală frecventă.

71 Mid

Rescrie codul de mai jos ca un lanț de metode. Ce avantaje are stilul acesta și când devine o problemă?

PYTHON
df = pd.read_csv("comenzi.csv")
df = df[df["status"] == "livrat"]
df["valoare"] = df["pret"] * df["cantitate"]
df = df.groupby("oras")["valoare"].sum()
df = df.sort_values(ascending=False)

Răspuns scurt: Cu (pd.read_csv(...).query('status == "livrat"').assign(valoare=lambda d: d["pret"] * d["cantitate"]).groupby("oras")["valoare"].sum().sort_values(ascending=False)). Lanțul nu are stări intermediare, evită SettingWithCopyWarning și se citește ca o rețetă, dar e mai greu de depanat dacă e foarte lung.

Varianta în lanț:

PYTHON
def adauga_valoare(d):
    return d.assign(valoare=d["pret"] * d["cantitate"])

top_orase = (
    pd.read_csv("comenzi.csv")
      .query("status == 'livrat'")
      .pipe(adauga_valoare)
      .groupby("oras")["valoare"].sum()
      .sort_values(ascending=False)
)

Avantajele:

  • fiecare pas primește rezultatul pasului anterior, fără variabile reutilizate cu sensuri diferite (în codul original, df este pe rând tabel, tabel filtrat și Series);
  • nu mai apare SettingWithCopyWarning, pentru că assign creează un obiect nou în loc să atribuie într-o porțiune filtrată;
  • reexecutarea celulei într-un notebook dă același rezultat, fiindcă nu modifică o variabilă globală;
  • pipe permite inserarea funcțiilor proprii, testate separat, ca pași cu nume.

Când devine o problemă: un lanț de 25 de pași e greu de depanat, pentru că nu poți inspecta rezultatele intermediare. Soluții practice: împarți lanțul în 2–3 etape cu nume (curat, imbogatit, raport), comentezi temporar pașii de la final sau inserezi un pas de inspecție:

PYTHON
def arata(d, msg=""):
    print(msg, d.shape)
    return d
# ... .pipe(arata, "după filtrare") ...

Performanța este aproximativ aceeași: lanțul nu face pandas mai rapid, doar codul mai clar.

Ce urmărește intervievatorul: Se verifică dacă scrii cod pandas lizibil și reutilizabil și dacă știi limitele stilului. Răspunsul bun nu spune că lanțul e mai rapid.

72 Mid

De ce codul de mai jos devine foarte lent pe 50.000 de fișiere sau rânduri și cum îl rescrii? Mai merge df.append în pandas 2.x?

PYTHON
rez = pd.DataFrame()
for f in fisiere:
    rez = pd.concat([rez, pd.read_csv(f)])

Răspuns scurt: Fiecare concat copiază tot ce s-a acumulat până atunci, deci costul crește pătratic cu numărul de pași. Corect: colectezi bucățile într-o listă și faci un singur pd.concat la final. df.append a fost eliminat în pandas 2.0.

Un DataFrame nu este o listă la care adaugi elemente ieftin. Fiecare pd.concat([rez, nou]) alocă un tabel nou și copiază atât rez, cât și nou. La pasul 1 copiezi un fișier, la pasul 2 două, la pasul n copiezi n fișiere: totalul este proporțional cu n², iar timpul crește rapid odată cu volumul.

PYTHON
bucati = [pd.read_csv(f) for f in fisiere]
rez = pd.concat(bucati, ignore_index=True)

Lista conține doar referințe către DataFrame-uri, deci adăugarea în ea e ieftină, iar copierea datelor se face o singură dată.

Același tipar se aplică la construirea unui DataFrame rând cu rând dintr-o buclă, de exemplu din răspunsurile unui API:

PYTHON
randuri = []
for r in raspunsuri:
    randuri.append({"id": r["id"], "valoare": r["total"]})
df = pd.DataFrame(randuri)

DataFrame.append a fost marcat ca depreciat în pandas 1.4 și eliminat în 2.0, exact pentru că încuraja tiparul pătratic. Codul vechi care îl folosește trebuie rescris cu concat sau cu lista de dicționare.

Pentru foarte multe fișiere mai e o optimizare: dacă dai dtype și usecols la citire, fiecare bucată e mai mică și concatenarea nu mai trebuie să reconcilieze tipuri diferite (o coloană citită ca int într-un fișier și ca object în altul devine object după concat).

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea costului copierii și cunoașterea API-ului actual. Tiparul pătratic este o cauză clasică de scripturi lente.

Eroarea, în practică:'DataFrame' object has no attribute 'append'

73 Mid

Ce afișează codul și cum se explică? Cum ar trebui atribuită coloana?

PYTHON
a = pd.DataFrame({"x": [10, 20, 30]})
b = a.sort_values("x", ascending=False)
b = b[b["x"] > 10]
a["y"] = b["x"]
print(a["y"].tolist())

Răspuns scurt: Afișează [nan, 20.0, 30.0]. Atribuirea unei Series într-un DataFrame se aliniază după index, nu după poziție: b păstrează etichetele 2 și 1, deci valorile ajung înapoi pe rândurile lor originale, iar eticheta 0 primește NaN.

Alinierea după index, utilă la operațiile între Series, are o consecință surprinzătoare la atribuire. a["y"] = b["x"] nu pune valorile lui b în ordinea lor, ci caută pentru fiecare etichetă din a aceeași etichetă în b. Sortarea și filtrarea au păstrat etichetele originale, deci 30 se întoarce pe rândul 2, 20 pe rândul 1, iar rândul 0, eliminat de filtru, primește NaN. Tipul devine float64 din cauza lui NaN.

Rezultatul este corect dacă intenția era „pune valoarea înapoi pe rândul de unde a venit”. E greșit dacă te așteptai la o lipire pe poziție.

PYTHON
# lipire pe poziție, intenție explicită
a["y"] = b["x"].to_numpy()        # ValueError dacă lungimile diferă

# sau resetezi ambele indexuri când ordinea e cea care contează
a = a.reset_index(drop=True)
b = b.reset_index(drop=True)

Problema apare frecvent când cineva calculează ceva pe o copie sortată sau filtrată, apoi atribuie rezultatul înapoi tabelului original. Al doilea scenariu tipic: datele vin din două surse cu indexuri diferite și sunt „lipite” cu atribuire sau pd.concat(axis=1), iar rândurile se aliniază după etichete care nu înseamnă nimic.

Când combini informații din tabele diferite, e mai sigur un merge pe o cheie reală decât o atribuire care se bazează pe index.

Ce urmărește intervievatorul: Se verifică dacă înțelegi alinierea implicită la atribuire, sursa unor bug-uri greu de observat. Candidații se așteaptă de obicei la lipire pe poziție.

Eroarea, în practică:cannot reindex on an axis with duplicate labelsUnalignable boolean Series provided as indexer

74 Senior

Ce aduce backend-ul PyArrow în pandas 2.x și când l-ai folosi? Ce riscuri vezi la migrarea unui proiect existent?

Răspuns scurt: Tipurile bazate pe Apache Arrow (de exemplu string[pyarrow], int64[pyarrow]) aduc text mai compact și mai rapid, valori lipsă native pentru toate tipurile și citire mai rapidă cu engine="pyarrow". Riscurile: funcții care se comportă diferit, biblioteci care așteaptă tipuri NumPy și diferențe subtile la NA.

Pandas a fost construit pe NumPy, care nu are un tip eficient pentru text și nici valori lipsă pentru întregi sau booleene. Din pandas 2.0, coloanele pot folosi tipuri din Apache Arrow, un format columnar standard folosit și de Parquet, Polars, DuckDB și Spark.

PYTHON
df = pd.read_csv("comenzi.csv", engine="pyarrow", dtype_backend="pyarrow")
df.dtypes      # int64[pyarrow], string[pyarrow], timestamp[...][pyarrow]

df["email"] = df["email"].astype("string[pyarrow]")

Beneficiile practice:

  • textul ocupă mult mai puțină memorie decât obiectele Python, iar operațiile .str sunt de obicei mai rapide;
  • valorile lipsă sunt native pentru orice tip, deci întregii nu mai devin float;
  • citirea CSV cu engine="pyarrow" folosește mai multe fire de execuție;
  • schimbul de date cu Parquet și alte unelte Arrow se face cu puține copieri.

Riscurile la migrare, care trebuie testate:

  • pd.NA se propagă altfel decât NaN în comparații: pd.NA == 1 dă NA, iar o mască cu NA folosită la indexare poate da eroare;
  • unele operații nu sunt implementate nativ pentru tipurile Arrow și revin la NumPy, uneori mai lent;
  • biblioteci precum scikit-learn sau unele grafice convertesc oricum la NumPy;
  • testele care compară tipuri exacte vor eșua.

În pandas 3.0, textul primește implicit un tip dedicat de string, bazat pe PyArrow dacă e instalat, deci migrarea merită pregătită. Aș începe cu coloanele de text, unde câștigul e cel mai mare, și aș rula testele pe date reale înainte de schimbarea globală.

Ce urmărește intervievatorul: La nivel senior se urmărește cunoașterea evoluției pandas și evaluarea realistă a unei migrări. Răspunsul slab promite doar „e mai rapid”.

75 Senior

Un pipeline pandas care pregătește datele pentru raport durează 40 de minute. Cum afli unde se pierde timpul și ce optimizări încerci, în ce ordine?

Răspuns scurt: Măsori înainte de a schimba: cronometrezi fiecare etapă, apoi profilezi etapa cea mai lentă (cProfile, line_profiler, %timeit pe date reprezentative). De obicei câștigurile mari vin din eliminarea apply și a buclelor, citirea doar a coloanelor necesare, tipuri potrivite și evitarea calculelor repetate.

Intuiția despre ce e lent greșește des, așa că primul pas este măsurarea.

  • Cronometrare pe etape: împart pipeline-ul în funcții (citire, curățare, îmbogățire, agregare, export) și măsor fiecare cu time.perf_counter(). Adesea o singură etapă consumă cea mai mare parte din timp.
  • Profilare țintită: cProfile sau %prun în Jupyter arată funcțiile care consumă timp, iar line_profiler (%lprun) arată liniile. %timeit compară variante pe un eșantion.
  • Memorie: dacă procesul folosește swap, totul încetinește; memory_usage(deep=True) și monitorul sistemului arată asta.

Optimizările cu cel mai mare câștig, în ordinea în care le verific:

  • apply(axis=1), iterrows și funcții Python pe fiecare rând, înlocuite cu operații vectorizate, np.select, map cu dicționar sau agregări reformulate;
  • citire: usecols, dtype, engine="pyarrow", Parquet în loc de CSV pentru date citite repetat;
  • merge și groupby pe chei text lungi: categorii sau coduri întregi;
  • calcule repetate: aceeași agregare făcută de mai multe ori sau același fișier citit în mai multe locuri; rezultatele intermediare se pot salva;
  • operații pe text cu .str pe milioane de rânduri: pe valorile unice (s.map(f, na_action="ignore") pe o coloană category lucrează doar cu categoriile).

Dacă după toate acestea limita este volumul, evaluez alte unelte: DuckDB pentru agregări SQL direct pe fișiere Parquet sau Polars, care rulează în paralel și cu evaluare amânată (lazy). După fiecare schimbare compar rezultatul cu versiunea veche, cu pd.testing.assert_frame_equal, ca optimizarea să nu schimbe cifrele.

Ce urmărește intervievatorul: La nivel senior se urmărește o metodă, nu o listă de trucuri: măsurare, ipoteză, schimbare, verificare. Răspunsul slab începe cu „rescriu totul în altă bibliotecă”.

76 Senior

Ai scris o funcție curata_comenzi(df) folosită în fiecare raport. Cum o testezi, ce cazuri incluzi și cum compari DataFrame-uri în teste?

Răspuns scurt: Scrii teste cu pytest pe DataFrame-uri mici construite de mână, câte unul pentru fiecare regulă și caz limită (lipsuri, duplicate, tipuri greșite, tabel gol), și compari rezultatul cu cel așteptat prin pd.testing.assert_frame_equal, care verifică valori, tipuri, index și coloane.

Funcțiile de transformare sunt locul unde o greșeală se propagă în toate rapoartele, deci merită testate ca orice alt cod. Principiul este simplu: date de intrare mici, scrise explicit, și rezultatul așteptat, tot explicit.

PYTHON
import pandas as pd
import pytest
from analiza.curatare import curata_comenzi

def test_elimina_duplicate_si_pastreaza_ultima():
    intrare = pd.DataFrame({
        "id": [1, 1, 2],
        "valoare": ["10,5", "12,0", None],
        "data": ["2025-03-01", "2025-03-02", "2025-03-01"],
    })
    asteptat = pd.DataFrame({
        "id": [1, 2],
        "valoare": [12.0, float("nan")],
        "data": pd.to_datetime(["2025-03-02", "2025-03-01"]),
    })
    pd.testing.assert_frame_equal(curata_comenzi(intrare), asteptat)

def test_tabel_gol():
    gol = pd.DataFrame(columns=["id", "valoare", "data"])
    assert curata_comenzi(gol).empty

def test_nu_modifica_intrarea():
    intrare = pd.DataFrame({"id": [1], "valoare": ["1,0"], "data": ["2025-01-01"]})
    copie = intrare.copy()
    curata_comenzi(intrare)
    pd.testing.assert_frame_equal(intrare, copie)

assert_frame_equal dă un mesaj clar despre ce diferă: o coloană, un tip, indexul. Are parametri utili: check_dtype=False când tipul exact nu contează, check_like=True pentru ordinea coloanelor, iar rtol și atol pentru toleranțe la valori zecimale. Pentru Series există assert_series_equal.

Cazurile pe care le acopăr de obicei: valori lipsă, duplicate, formate de număr și dată locale, valori la limite, tabel gol, o coloană lipsă (eroare clară) și faptul că funcția nu modifică datele primite. Când apare un bug în producție, primul pas este un test care îl reproduce.

Ce urmărește intervievatorul: La nivel senior se urmărește dacă tratezi codul de analiză ca pe cod de producție. Testul că funcția nu modifică intrarea este un detaliu care arată experiență.

77 Senior

Ce se întâmplă în fiecare caz? Explică ce schimbă Copy-on-Write în pandas 2.x și 3.0.

PYTHON
df[df["stoc"] == 0]["status"] = "epuizat"     # A
df["status"][df["stoc"] == 0] = "epuizat"     # B
df.loc[df["stoc"] == 0, "status"] = "epuizat" # C

Răspuns scurt: A nu modifică df: filtrarea creează un obiect nou, iar atribuirea se face pe el, cu SettingWithCopyWarning. B a funcționat istoric, dar sub Copy-on-Write, implicit în pandas 3.0, nu mai modifică df. C este singura variantă corectă în toate versiunile.

Varianta A este o atribuire în lanț: df[mask] produce un DataFrame nou (indexarea cu mască copiază), iar ["status"] = ... scrie în acel obiect temporar. df rămâne neschimbat, iar pandas emite SettingWithCopyWarning, pentru că nu poate ști sigur dacă obiectul intermediar e o copie sau o vedere.

Varianta B selectează întâi coloana, care istoric era o vedere peste date, apoi modifică pe loc. În pandas 1.x și 2.x fără CoW modificarea ajungea de obicei în df, dar comportamentul depindea de detalii interne, așa că nu era garantat.

Copy-on-Write (CoW) simplifică regulile: orice obiect obținut dintr-un alt obiect se comportă ca o copie, iar copierea reală se face doar când cineva scrie. Consecințele:

  • atribuirile în lanț, ca A și B, nu mai modifică niciodată obiectul original și emit un avertisment;
  • extragerea unui subset și modificarea lui nu mai afectează originalul, deci dispare nevoia de .copy() defensiv;
  • multe operații devin mai ieftine, pentru că nu mai copiază date până la prima scriere.
PYTHON
pd.options.mode.copy_on_write = True   # pandas 2.x, opțional
df.loc[df["stoc"] == 0, "status"] = "epuizat"
df = df.assign(status=lambda d: d["status"].mask(d["stoc"] == 0, "epuizat"))

În pandas 3.0, CoW este singurul comportament. La migrarea unui proiect, activez opțiunea în 2.x, rulez testele și caut avertismentele de atribuire în lanț; fiecare dintre ele indică un loc care fie nu funcționa nici înainte, fie se va strica.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului de copii din pandas, nu doar soluția din StackOverflow. Un senior știe ce se schimbă la trecerea la Copy-on-Write și cum pregătește migrarea.

Eroarea, în practică:ChainedAssignmentError (fostul SettingWithCopy)assignment destination is read-only

Fișiere, SQL și Jupyter

78 Junior

Un CSV exportat dintr-un program de contabilitate se citește cu toate datele într-o singură coloană, iar diacriticele apar ca „î” sau dau UnicodeDecodeError. Ce parametri ai lui read_csv folosești?

Răspuns scurt: sep=";" pentru separatorul folosit de setările regionale românești, encoding potrivit (de obicei "utf-8-sig" sau, la exporturi vechi, "cp1250"), decimal="," și thousands="." pentru numere. Pe lângă acestea, usecols, dtype, na_values și parse_dates fac citirea corectă din prima.

Toate datele într-o coloană înseamnă că separatorul nu e virgula. În setările regionale românești, Excel și multe programe exportă cu punct și virgulă, pentru că virgula e separator zecimal. Deschide fișierul ca text sau citește primele rânduri ca să vezi separatorul real.

Diacriticele stricate țin de encoding. „î” în loc de „î” apare când un fișier UTF-8 este citit ca Latin-1. UnicodeDecodeError apare când un fișier în altă codificare, de exemplu Windows-1250 (cp1250), folosită de programe vechi pentru limbile din Europa Centrală, este citit ca UTF-8.

PYTHON
df = pd.read_csv(
    "export.csv",
    sep=";",
    encoding="utf-8-sig",          # elimină și BOM-ul de la început
    decimal=",",
    thousands=".",
    usecols=["Data", "Cod client", "Valoare"],
    dtype={"Cod client": "string"},
    na_values=["", "-", "N/A"],
    parse_dates=["Data"],
    dayfirst=True,
)

sep=None, engine="python" încearcă să detecteze separatorul automat, util la explorare, dar în cod de producție prefer valoarea explicită. Atenție: un fișier în cp1250 conține ș și ț cu sedilă, nu cu virgulă, deci la comparațiile de text e nevoie de o normalizare: înlocuiești cele patru litere cu sedilă (codurile Unicode U+015E, U+015F, U+0162, U+0163) cu variantele cu virgulă, de exemplu printr-un dicționar dat lui str.translate.

După citire verific mereu: df.shape, df.dtypes, câteva rânduri și coloanele cu valori neașteptat de multe lipsă, semn că na_values sau separatorul nu sunt cele corecte.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai lucrat cu date reale locale, nu doar cu seturi didactice. Encoding-ul și separatorul sunt problemele din prima zi la orice job.

Eroarea, în practică:UnicodeDecodeError: 'utf-8' codec can't decodeParserError: Error tokenizing data

79 Junior

Codurile poștale „010011” și CNP-urile citite din CSV apar fără zero în față sau în formă științifică (1.96e+12). De ce și cum le citești corect?

Răspuns scurt: read_csv deduce tipurile, iar o coloană doar cu cifre devine număr: zerourile din față dispar, iar numerele lungi pot apărea în notație științifică sau pot pierde precizie. Le citești ca text, cu dtype={"cod_postal": str, "cnp": str}.

Pandas încearcă să ghicească tipul fiecărei coloane. Dacă toate valorile sunt formate din cifre, coloana devine int64 sau, dacă are lipsuri, float64. Ca număr, „010011” este 10011, deci zeroul din față se pierde definitiv. Un CNP de 13 cifre încape într-un int64, dar într-o coloană float64 (de exemplu din cauza unei celule goale) apare ca 1.96e+12 la afișare, iar valorile peste 2^53 nu mai pot fi reprezentate exact.

Regula: un identificator nu este o cantitate. Nu aduni coduri poștale și nu calculezi media CNP-urilor, deci le citești ca text:

PYTHON
df = pd.read_csv(
    "clienti.csv",
    dtype={"cod_postal": "string", "cnp": "string", "telefon": "string"},
)
df["cod_postal"].str.len().value_counts()   # verifici lungimea

Dacă datele au fost deja stricate, de exemplu salvate și redeschise în Excel, poți reface codurile cu lungime fixă: df["cod_postal"].astype(str).str.zfill(6). Pentru CNP-uri pierdute în float, nu există reparare sigură; trebuie recitit fișierul sursă.

La export, aceeași problemă apare când un coleg deschide CSV-ul în Excel, care convertește din nou coloanele. Pentru schimburi în care contează tipurile, Excel-ul scris cu to_excel (unde textul rămâne text) sau Parquet sunt variante mai sigure. Și, fiind date personale, CNP-urile ar trebui să ajungă într-o analiză doar dacă e nevoie, ideal pseudonimizate.

Ce urmărește intervievatorul: Se verifică înțelegerea diferenței dintre număr și identificator. E o greșeală foarte comună, cu efecte ireversibile dacă nu e prinsă la citire.

80 Junior

După df.to_csv("raport.csv") și recitire apare o coloană „Unnamed: 0”, iar colega care deschide fișierul în Excel vede diacriticele stricate. Ce corectezi?

Răspuns scurt: to_csv scrie implicit și indexul, care la recitire devine „Unnamed: 0”; folosești index=False. Pentru Excel, scrii cu encoding="utf-8-sig", care adaugă marcajul BOM după care Excel recunoaște UTF-8, și eventual sep=";" și decimal="," pentru setările regionale românești.

Parametrul index=True este implicit la to_csv, deci prima coloană a fișierului conține etichetele indexului, fără nume. La recitire, read_csv nu știe că acea coloană era un index și o numește „Unnamed: 0”. După câteva cicluri de scriere și citire apar „Unnamed: 0.1” și așa mai departe.

PYTHON
df.to_csv("raport.csv", index=False)

# dacă indexul are sens (de exemplu după groupby), îl transformi în coloană
rap.reset_index().to_csv("raport.csv", index=False)

# sau, la citire, îl folosești ca index
pd.read_csv("raport.csv", index_col=0)

Diacriticele stricate în Excel au altă cauză. Pandas scrie implicit UTF-8 fără BOM (Byte Order Mark), iar Excel pe Windows deschide adesea un astfel de CSV cu codificarea locală. Cu encoding="utf-8-sig", fișierul începe cu marcajul BOM, iar Excel îl recunoaște corect.

PYTHON
df.to_csv("raport.csv", index=False, encoding="utf-8-sig",
          sep=";", decimal=",", date_format="%d.%m.%Y")

Separatorul ; și virgula zecimală fac ca Excel cu setări românești să împartă coloanele și să recunoască numerele. Dacă destinatarul lucrează oricum în Excel, cel mai simplu este să-i trimiți direct un fișier .xlsx cu to_excel, unde tipurile și diacriticele nu mai depind de setări. CSV-ul rămâne formatul potrivit pentru schimburi între programe.

Ce urmărește intervievatorul: Intervievatorul verifică detalii practice de export pe care le întâlnești din prima săptămână. Răspunsul bun ține cont de cine folosește fișierul.

81 Junior

Un fișier Excel are câte o foaie pentru fiecare lună, cu un antet de 3 rânduri decorative deasupra tabelului. Cum citești toate foile într-un singur DataFrame și cum scrii un raport cu mai multe foi?

Răspuns scurt: pd.read_excel(f, sheet_name=None, skiprows=3) întoarce un dicționar foaie → DataFrame, pe care îl unești cu pd.concat(..., names=["luna"]). Pentru scriere folosești pd.ExcelWriter și apelezi to_excel cu sheet_name diferit pentru fiecare tabel.

read_excel citește implicit doar prima foaie. Cu sheet_name=None primești un dicționar cu toate foile, iar skiprows sau header sar peste rândurile de deasupra tabelului.

PYTHON
foi = pd.read_excel("vanzari_2025.xlsx", sheet_name=None, skiprows=3)
toate = (pd.concat(foi, names=["luna", "rand"])
           .reset_index(level="luna")
           .reset_index(drop=True))

pd.concat pe un dicționar folosește cheile ca nivel în index, deci numele foii devine o coloană după reset_index. Alte opțiuni utile: usecols="A:F" pentru un interval de coloane, nrows pentru tabele urmate de note, dtype pentru coduri. Pentru fișiere .xlsx e nevoie de pachetul openpyxl.

Verifică foile una câte una înainte de concatenare: în fișierele completate manual, o foaie are adesea alt antet, o coloană în plus sau un rând de total la final, care ar dubla sumele.

PYTHON
for nume, t in foi.items():
    print(nume, t.shape, list(t.columns)[:5])

Pentru scriere, ExcelWriter păstrează fișierul deschis și adaugă foi pe rând:

PYTHON
with pd.ExcelWriter("raport.xlsx") as w:
    sumar.to_excel(w, sheet_name="Sumar", index=False)
    pe_orase.to_excel(w, sheet_name="Pe orașe")
    detalii.to_excel(w, sheet_name="Detalii", index=False)

Numele de foi au maximum 31 de caractere și nu pot conține unele simboluri, ca / sau ?. Pentru formatare (lățimi de coloane, formate numerice), motorul xlsxwriter oferă acces la obiectele foii.

Ce urmărește intervievatorul: Se verifică lucrul cu fișiere Excel reale, cu formatare de om, nu de mașină. Rândurile de total și antetele diferite între foi sunt capcanele de menționat.

82 Junior

Colegul îți trimite un notebook care „la el mergea”, dar la tine dă NameError la celula 12. Ce s-a întâmplat probabil și cum previi asta în notebook-urile tale?

Răspuns scurt: Notebook-ul a fost rulat în altă ordine decât cea de pe pagină sau o celulă care definea variabila a fost ștearsă după rulare, iar variabila a rămas în memoria kernel-ului lui. Previi cu Restart & Run All înainte de a-l trimite.

Un notebook Jupyter păstrează variabilele în memoria kernel-ului cât timp acesta rulează. Ordinea în care ai executat celulele contează, nu ordinea în care apar pe pagină. Numerele din stânga, In [7], arată ordinea reală a execuției. Situațiile tipice:

  • o celulă care definea df_curat a fost redenumită sau ștearsă, dar variabila veche a rămas în memorie, așa că la autor totul mergea;
  • celula 15 a fost rulată înainte de 12 și a creat ceva de care 12 depinde;
  • o celulă a fost rulată de mai multe ori, de exemplu una care face df["pret"] = df["pret"] * 1.19, și rezultatul depinde de câte ori.

Obiceiuri care previn problema:

  • Kernel → Restart & Run All înainte de a trimite sau de a trage concluzii; dacă rulează curat de sus în jos, e reproductibil;
  • importurile și citirea datelor în primele celule, apoi pași în ordine;
  • celule idempotente: în loc să modifici df pe loc, creezi variabile noi (df_tva = df.assign(...)), ca o celulă rulată de două ori să dea același rezultat;
  • căile spre fișiere relative la proiect, nu de pe calculatorul tău;
  • versiunile bibliotecilor într-un requirements.txt sau mediu conda.

Pentru notebook-uri lungi, mut funcțiile reutilizabile într-un modul .py importat în notebook. Cu %load_ext autoreload și %autoreload 2, modificările din modul se văd fără restartarea kernel-ului.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi modelul de execuție din Jupyter și dacă ai disciplina reproductibilității. Răspunsul slab este „am rerulat și a mers”.

83 Junior

Ce comenzi magice și setări din Jupyter folosești des în analiză? Cum afișezi toate coloanele unui DataFrame lat și cum compari viteza a două variante de cod?

Răspuns scurt: %timeit măsoară o linie rulată de mai multe ori, %%time cronometrează o celulă o dată, iar pd.set_option("display.max_columns", None) afișează toate coloanele. Utile mai sunt %who, autoreload și display().

Comenzile magice sunt instrucțiuni ale lui IPython, nu cod Python. Cele cu % se aplică unei linii, cele cu %% întregii celule.

PYTHON
%timeit df["a"] * 2                      # rulează de multe ori, dă media
%timeit df["a"].apply(lambda x: x * 2)

%%time
rezultat = proces_lung(df)               # o singură rulare, timp total

%timeit repetă instrucțiunea și raportează media și abaterea standard, potrivit pentru operații scurte comparate între ele. %%time rulează o dată, potrivit pentru pași lungi. Măsoară pe date de dimensiuni realiste: o variantă poate fi mai rapidă pe 100 de rânduri și mai lentă pe un milion.

Setări de afișare pandas:

PYTHON
pd.set_option("display.max_columns", None)
pd.set_option("display.max_rows", 100)
pd.set_option("display.float_format", "{:,.2f}".format)

with pd.option_context("display.max_rows", None):
    display(df["judet"].value_counts())

option_context aplică setarea doar temporar, util pentru o singură afișare lungă. display() afișează mai multe tabele formatate într-o celulă, unde altfel apare doar ultima expresie.

Alte comenzi utile: %who și %whos listează variabilele din memorie; %load_ext autoreload cu %autoreload 2 reîncarcă modulele proprii; !pip list rulează comenzi de sistem; %run script.py execută un script. Pentru tabele mari, df.sample(10) dă o imagine mai corectă decât head(), pentru că fișierele sunt adesea sortate și primele rânduri nu sunt reprezentative.

Ce urmărește intervievatorul: Se verifică fluența practică în mediul de lucru zilnic al unui analist. Diferența dintre %timeit și %%time și alegerea datelor de test sunt detaliile relevante.

84 Mid

Când ai salva datele intermediare în Parquet în loc de CSV? Ce câștigi și ce pierzi?

Răspuns scurt: Parquet este un format binar pe coloane: păstrează tipurile, e comprimat și se citește mult mai repede, inclusiv doar coloanele cerute. E bun pentru date citite repetat de cod; nu îl mai deschizi direct în Excel.

Un CSV este text: la fiecare citire, pandas trebuie să parseze toate valorile și să ghicească din nou tipurile. Datele calendaristice redevin text, categoriile redevin object, codurile cu zerouri în față se pot pierde, iar un fișier de câțiva GB se citește în zeci de secunde sau minute.

Parquet salvează datele pe coloane, cu schema inclusă:

PYTHON
df.to_parquet("comenzi_curat.parquet", index=False)   # necesită pyarrow

c = pd.read_parquet("comenzi_curat.parquet", columns=["data", "valoare"])
c.dtypes   # tipurile sunt exact cele salvate

Câștigurile practice:

  • tipurile se păstrează, deci etapa de curățare nu trebuie repetată la fiecare citire;
  • compresie: fișiere de obicei de câteva ori mai mici decât CSV-ul;
  • citire selectivă: doar coloanele cerute, cu filtre pe rânduri prin filters=, ceea ce economisește timp și memorie;
  • interoperabilitate: același fișier îl citesc Polars, DuckDB, Spark sau un data warehouse.

Ce pierzi: nu îl deschizi în Excel sau Notepad ca să arunci o privire, iar pentru schimbul cu oameni din afara echipei tehnice CSV-ul sau Excel-ul rămân mai practice. Ai nevoie de pyarrow sau fastparquet instalat.

Un tipar frecvent într-un proiect de analiză: datele brute rămân în formatul primit, neatinse; după curățare, rezultatul se salvează în Parquet; notebook-urile de analiză citesc doar Parquet-ul curat. Recitirea devine rapidă, iar curățarea se face într-un singur loc.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi formate potrivite pentru date intermediare și compromisurile lor. Răspunsul bun descrie și un tipar de organizare a datelor.

85 Senior

Datele sunt într-o bază PostgreSQL cu 200 de milioane de rânduri de tranzacții. Cum le aduci în pandas pentru un raport pe ultima lună, pe ce rulezi calculele și cum transmiți parametrii în interogare?

Răspuns scurt: Filtrezi și agregi în baza de date, nu în pandas: pd.read_sql(sql, engine, params=...) cu o interogare care întoarce doar luna, doar coloanele necesare sau direct agregatele. Parametrii se transmit prin params, nu prin f-string-uri, ca să eviți SQL injection și problemele de format.

Baza de date are indexuri, paralelism și datele lângă procesor. Pandas lucrează în memoria unui singur proces. A aduce 200 de milioane de rânduri ca să filtrezi o lună în pandas înseamnă transfer prin rețea și memorie irosită. Regula: tot ce se poate exprima ca filtru, join sau agregare se face în SQL, iar pandas primește rezultatul de dimensiunea raportului.

PYTHON
from sqlalchemy import create_engine, text

engine = create_engine("postgresql+psycopg2://user@host/db")  # parola din variabile de mediu

sql = text('''
    SELECT date_trunc('day', data) AS zi, magazin,
           SUM(valoare) AS venit, COUNT(*) AS tranzactii
    FROM tranzactii
    WHERE data >= :start AND data < :end
    GROUP BY 1, 2
''')
df = pd.read_sql(sql, engine, params={"start": "2025-03-01", "end": "2025-04-01"},
                 parse_dates=["zi"])

Parametrii trimiși prin params ajung separat de textul interogării, iar driverul se ocupă de tipuri și de escapare. Construirea interogării cu f-string-uri din valori primite de la utilizatori deschide calea pentru SQL injection și se strică la ghilimele din nume.

Limita superioară exclusivă (< '2025-04-01') prinde toată ziua de 31 martie, indiferent de oră.

Dacă ai totuși nevoie de date detaliate mari, chunksize= întoarce un iterator de bucăți, procesate pe rând. Scrierea înapoi se face cu to_sql(..., if_exists="append", chunksize=...), dar pentru volume mari uneltele native de import ale bazei de date (de exemplu COPY în PostgreSQL) sunt mult mai rapide. Credențialele nu se scriu în notebook; vin din variabile de mediu sau dintr-un manager de secrete.

Ce urmărește intervievatorul: La nivel senior se urmărește împărțirea corectă a muncii între baza de date și pandas, plus securitatea interogărilor. Aducerea tabelului întreg în pandas e semnalul de alarmă.

Vizualizare și statistică descriptivă

Exersează capitolul cu exerciții reale: Curs analiza datelor Python →
86 Junior

Care e diferența dintre stilul plt.plot(...) și stilul fig, ax = plt.subplots() în matplotlib? Desenează evoluția lunară a vânzărilor cu titlu, etichete pe axe și format de mii pe axa Y.

Răspuns scurt: plt.plot lucrează pe „figura curentă”, implicit, comod pentru grafice rapide. Cu fig, ax = plt.subplots() ai obiecte explicite pe care apelezi metode (ax.plot, ax.set_title), ceea ce e clar și necesar când ai mai multe grafice. pandas desenează direct pe un ax dat: lunar.plot(ax=ax).

Matplotlib are două interfețe. Interfața pyplot (plt.plot, plt.title) ține minte o figură și o axă „curente” și aplică fiecare comandă pe ele. E rapidă în explorare, dar devine confuză când ai mai multe subgrafice sau funcții care desenează.

Interfața orientată pe obiecte separă clar Figure (pânza întreagă) de Axes (un grafic cu axele lui). Toate setările se fac pe obiecte numite:

PYTHON
import matplotlib.pyplot as plt
from matplotlib.ticker import StrMethodFormatter

lunar = df.set_index("data")["valoare"].resample("MS").sum()

fig, ax = plt.subplots(figsize=(10, 4))
lunar.plot(ax=ax, marker="o")
ax.set_title("Vânzări lunare, 2025")
ax.set_xlabel("")
ax.set_ylabel("lei")
ax.yaxis.set_major_formatter(StrMethodFormatter("{x:,.0f}"))
ax.set_ylim(bottom=0)
ax.grid(axis="y", alpha=0.3)
fig.tight_layout()

Metodele pe Axes au prefixul set_: ax.set_title, ax.set_xlabel, ax.set_ylim, spre deosebire de plt.title sau plt.xlabel. E o confuzie frecventă la cei care trec de la un stil la altul.

ax.set_ylim(bottom=0) merită o mențiune: pentru mărimi precum vânzările, o axă care nu pornește de la zero exagerează vizual variațiile. La linii, uneori e acceptabil, dar la bare nu.

Funcțiile proprii care desenează ar trebui să primească un ax ca parametru. Le poți compune apoi în orice grilă de subgrafice, fără să depindă de starea globală a lui pyplot.

Ce urmărește intervievatorul: Se verifică dacă știi cele două interfețe și dacă produci grafice lizibile, nu doar corecte. Candidații amestecă des plt.title cu ax.set_title.

Eroarea, în practică:'numpy.ndarray' object has no attribute 'plot''Axes' object has no attribute 'xlabel'

87 Junior

Unde e bug-ul? Scriptul salvează o imagine albă.

PYTHON
fig, ax = plt.subplots()
df.groupby("oras")["valoare"].sum().plot(kind="bar", ax=ax)
plt.show()
plt.savefig("vanzari.png")

Răspuns scurt: După plt.show() figura este închisă, iar plt.savefig salvează o figură nouă, goală. Salvezi înainte de show și, ideal, pe obiectul explicit: fig.savefig("vanzari.png", dpi=150, bbox_inches="tight").

plt.show() afișează figurile deschise și, într-un script rulat normal, le închide la final. Apoi plt.savefig lucrează pe „figura curentă”; cum nu mai există una, pyplot creează o figură nouă, goală, și o salvează. În Jupyter, efectul e asemănător dacă salvezi într-o celulă ulterioară: după terminarea celulei, figura a fost deja afișată și închisă.

Varianta corectă:

PYTHON
fig, ax = plt.subplots(figsize=(8, 4))
(df.groupby("oras")["valoare"].sum()
   .sort_values(ascending=False)
   .plot(kind="bar", ax=ax))
ax.set_ylabel("lei")
fig.savefig("vanzari.png", dpi=150, bbox_inches="tight")
plt.show()

Folosind fig.savefig în loc de plt.savefig, nu mai depinzi de care figură este curentă. bbox_inches="tight" elimină marginile albe și previne tăierea etichetelor lungi de pe axe, iar dpi controlează rezoluția (150–200 e suficient pentru documente și prezentări). Formatul se deduce din extensie: .png pentru imagini, .svg sau .pdf pentru grafice vectoriale care rămân clare la mărire.

În scripturi care generează multe grafice, de exemplu câte unul pe magazin, închide figurile după salvare cu plt.close(fig). Altfel ele rămân în memorie, iar matplotlib avertizează după 20 de figuri deschise.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea ciclului de viață al unei figuri. E un bug clasic în scripturile de raportare automată.

88 Junior

Desenează un grafic cu primele 10 produse după venit, ușor de citit, cu valoarea scrisă pe fiecare bară. Ce tip de grafic alegi și de ce?

Răspuns scurt: Un grafic cu bare orizontale (barh), sortat astfel încât cel mai mare produs să fie sus, pentru că numele lungi se citesc ușor pe axa Y. Valorile le adaugi cu ax.bar_label(ax.containers[0], fmt="{:,.0f}"), disponibil din matplotlib 3.4.

Barele orizontale sunt alegerea naturală pentru clasamente cu etichete text: numele produselor se citesc pe orizontală, fără rotiri la 45 de grade, iar ochiul compară ușor lungimi aliniate la aceeași origine.

PYTHON
top = (df.groupby("produs")["valoare"].sum()
         .nlargest(10)
         .sort_values())            # crescător: cel mai mare ajunge sus

fig, ax = plt.subplots(figsize=(8, 5))
top.plot(kind="barh", ax=ax, color="#4C72B0")
ax.bar_label(ax.containers[0], fmt="{:,.0f} lei", padding=3)
ax.set_xlabel("")
ax.set_ylabel("")
ax.set_title("Top 10 produse după venit, martie 2025")
ax.spines[["top", "right"]].set_visible(False)
ax.set_xlim(0, top.max() * 1.15)    # loc pentru etichete
fig.tight_layout()

Sortarea crescătoare înainte de barh pare contraintuitivă: matplotlib desenează primul element jos, deci pentru ca locul 1 să fie sus, ultimul element trebuie să fie cel mai mare.

bar_label primește un container de bare și scrie valorile la capete. Parametrul fmt acceptă din matplotlib 3.7 și un șir cu acolade, ca în exemplu; în versiunile mai vechi se folosea stilul "%.0f". Cu valorile scrise pe bare, axa X devine aproape redundantă, iar graficul se poate simplifica.

O singură culoare e suficientă; culorile diferite pe fiecare bară sugerează categorii care nu există. Dacă vrei să evidențiezi un produs, colorează doar bara lui. Titlul spune perioada și metrica, ca graficul să poată fi înțeles și scos din context, de exemplu într-o prezentare.

Ce urmărește intervievatorul: Se verifică dacă alegi forma potrivită pentru un clasament și dacă te gândești la cititor. Detaliul cu sortarea pentru barh îl prinde pe cine a făcut grafice reale.

89 Junior

Vrei să compari evoluția lunară a vânzărilor în 4 regiuni. De ce ai folosi 4 grafice mici în loc de 4 linii pe același grafic și cum le construiești?

Răspuns scurt: Patru linii pe același grafic se suprapun și, dacă o regiune e mult mai mare, celelalte par plate. Graficele mici (small multiples) cu aceeași axă Y, construite cu plt.subplots(2, 2, sharex=True, sharey=True), arată fiecare tendință clar și păstrează comparabilitatea.

Pe un singur grafic, liniile se încrucișează, culorile trebuie căutate în legendă, iar o regiune cu vânzări de zece ori mai mari comprimă celelalte linii lângă zero. Small multiples înseamnă aceeași diagramă repetată pentru fiecare categorie, cu aceleași axe, așa încât ochiul compară forma fiecărei serii.

PYTHON
lunar = (df.groupby(["regiune", pd.Grouper(key="data", freq="MS")])
           ["valoare"].sum().unstack("regiune"))

fig, axes = plt.subplots(2, 2, figsize=(10, 6), sharex=True, sharey=True)
for ax, reg in zip(axes.flat, lunar.columns):
    lunar[reg].plot(ax=ax)
    ax.set_title(reg)
    ax.set_xlabel("")
fig.suptitle("Vânzări lunare pe regiuni (lei)")
fig.tight_layout()

axes este un array NumPy 2x2 de obiecte Axes, iar axes.flat îl parcurge ca listă. sharey=True dă aceeași scală pe toate graficele, deci nivelurile se pot compara direct. Dacă te interesează doar forma tendinței, nu nivelul, poți renunța la sharey, dar atunci spune explicit asta în titlu, pentru că cititorul presupune scale egale.

Scurtătura din pandas face același lucru: lunar.plot(subplots=True, layout=(2, 2), sharey=True). În seaborn, sns.relplot(data=lung, x="data", y="valoare", col="regiune", col_wrap=2, kind="line") construiește grila direct din formatul lung.

Totuși, când întrebarea este „care regiune a crescut mai mult față de ianuarie”, o singură diagramă cu valorile indexate (ianuarie = 100) poate fi mai bună. Alegerea graficului pornește de la întrebarea la care trebuie să răspundă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi forma vizuală în funcție de întrebare și dacă stăpânești subgraficele. Răspunsul bun discută și scala comună.

90 Junior

Interpretează ieșirea lui df["valoare_comanda"].describe() de mai jos. Ce îți spune despre distribuție și ce verifici mai departe?

count    48210.0
mean       236.4
std        512.9
min          0.0
25%         45.0
50%         99.0
75%        210.0
max      38500.0

Răspuns scurt: Distribuția e puternic asimetrică la dreapta: media (236) e mult peste mediană (99), deviația standard depășește media, iar maximul e foarte departe de quartila a treia. Verifici valorile extreme, comenzile cu valoarea 0 și raportezi mediana și percentilele, nu doar media.

describe() dă pe o coloană numerică numărul de valori nelipsă, media, deviația standard, minimul, quartilele și maximul. Citit atent, e un rezumat al formei distribuției.

  • count este 48.210; îl compari cu len(df) ca să vezi câte valori lipsesc.
  • Media de 236 este de peste două ori mediana de 99. Câteva comenzi foarte mari trag media în sus, deci „comanda tipică” e mai apropiată de 99.
  • Deviația standard de 513 este mai mare decât media, semn de împrăștiere mare și coadă lungă la dreapta.
  • Între 75% (210) și maxim (38.500) e un salt uriaș: există valori extreme care trebuie înțelese, nu șterse automat. Pot fi comenzi B2B legitime, erori de introducere sau teste.
  • Minimul 0 cere o explicație: comenzi gratuite, anulate sau înregistrări greșite?

Pașii următori:

PYTHON
s = df["valoare_comanda"]
s.quantile([0.9, 0.95, 0.99])
s.skew()
(s == 0).sum()
df.nlargest(10, "valoare_comanda")
s.plot(kind="hist", bins=100, logy=True)

Un detaliu tehnic: std din pandas folosește implicit ddof=1, adică deviația standard de eșantion, cu împărțire la n-1, în timp ce np.std folosește implicit ddof=0. Pe 48.000 de valori diferența e neglijabilă, dar pe tabele mici rezultatele diferă și apar întrebări. describe(include="all") adaugă și coloanele text, cu numărul de valori unice și valoarea cea mai frecventă.

Ce urmărește intervievatorul: Se verifică dacă poți citi un rezumat statistic și trage concluzii despre formă și calitate. Răspunsul slab doar recită ce înseamnă fiecare rând.

91 Mid

De ce seaborn lucrează cel mai bine cu date în format lung? Desenează distribuția valorii comenzilor pe canal, ca boxplot, cu o culoare separată pentru clienții noi și cei recurenți.

Răspuns scurt: seaborn mapează coloane pe roluri vizuale (x, y, hue, col), deci vrea o coloană pentru fiecare variabilă, nu câte o coloană pe categorie. sns.boxplot(data=df, x="canal", y="valoare", hue="tip_client") desenează direct, iar datele late le aduci la format lung cu melt.

Seaborn este construit pe ideea unei gramatici a graficelor: îi spui ce coloană merge pe axa X, ce coloană pe Y, după ce coloană se colorează (hue) și după ce coloană se împarte în subgrafice (col, row). Pentru asta, fiecare variabilă trebuie să fie o singură coloană, iar fiecare observație un rând, adică formatul lung.

PYTHON
import seaborn as sns

fig, ax = plt.subplots(figsize=(9, 4))
sns.boxplot(data=df, x="canal", y="valoare", hue="tip_client",
            showfliers=False, ax=ax)
ax.set_ylabel("Valoare comandă (lei)")
ax.set_xlabel("")

Dacă datele vin late, de exemplu câte o coloană pentru fiecare canal, le transformi întâi:

PYTHON
lung = lat.melt(var_name="canal", value_name="valoare")

Despre alegerile din exemplu: showfliers=False ascunde punctele extreme, utile la explorare, dar care pe date cu coadă lungă comprimă cutiile într-o linie. Dacă le ascunzi, spune asta în nota graficului. O alternativă este scala logaritmică, ax.set_yscale("log"), potrivită pentru valori monetare cu distribuție asimetrică.

Boxplot-ul arată mediana, quartilele și „mustățile” (implicit până la 1,5 x IQR), dar ascunde forma distribuției și numărul de observații. sns.violinplot sau sns.stripplot peste boxplot completează imaginea, iar numărul de comenzi pe grup merită scris în etichete, ca o cutie construită din 12 valori să nu fie citită la fel ca una din 12.000.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi modelul de date al lui seaborn și dacă iei decizii vizuale conștiente. Mulți luptă cu date late în loc să le aducă la format lung.

92 Mid

Cum calculezi și cum vizualizezi corelațiile dintre coloanele numerice ale unui DataFrame care are și coloane text? Ce se schimbă în pandas 2.0 și când alegi Spearman în loc de Pearson?

Răspuns scurt: df.corr(numeric_only=True) sau df.select_dtypes("number").corr(); din pandas 2.0, numeric_only este implicit False, deci coloanele text dau eroare. Spearman (method="spearman") măsoară relații monotone pe ranguri și e mai robust la outlieri. Vizualizezi cu sns.heatmap(..., annot=True, vmin=-1, vmax=1, cmap="vlag").

Până la pandas 2.0, df.corr() ignora silențios coloanele care nu erau numerice. Din 2.0, parametrul numeric_only are implicit valoarea False, iar o coloană text provoacă eroare. Schimbarea e intenționată: e mai bine să alegi explicit coloanele decât să descoperi că lipsesc din rezultat.

PYTHON
num = df.select_dtypes("number").drop(columns=["id_client"])
c = num.corr(method="spearman")

mask = np.triu(np.ones_like(c, dtype=bool))
fig, ax = plt.subplots(figsize=(7, 6))
sns.heatmap(c, mask=mask, annot=True, fmt=".2f",
            vmin=-1, vmax=1, center=0, cmap="vlag", ax=ax)

Am eliminat ID-ul: e numeric, dar corelația lui cu orice nu are sens. Masca ascunde triunghiul superior, care repetă informația, iar paleta divergentă centrată pe 0, cu limitele fixate la -1 și 1, face ca intensitatea culorii să însemne același lucru în orice raport.

Pearson măsoară relația liniară și e sensibil la valori extreme: câteva comenzi uriașe pot crea sau ascunde o corelație. Spearman calculează Pearson pe ranguri, deci prinde orice relație monotonă (de exemplu „cu cât mai mult, cu atât mai mult”, chiar dacă nu liniar) și e robust la outlieri. Pe date financiare cu coadă lungă e adesea alegerea mai sigură.

Cu multe perechi de coloane, câteva corelații moderate apar întâmplător. Iar o corelație apropiată de zero exclude doar o relație liniară sau monotonă, nu orice relație: un grafic de dispersie pe perechile interesante rămâne obligatoriu.

Ce urmărește intervievatorul: Se verifică cunoașterea schimbării din pandas 2.0 și alegerea metodei de corelație după date. Răspunsul bun exclude coloanele numerice fără sens, cum sunt ID-urile.

93 Mid

Managerul de logistică vrea să știe, pe fiecare oraș, timpul de livrare „pe care îl respectăm în 90% din cazuri”. Cum calculezi și cum prezinți asta?

Răspuns scurt: Calculezi percentila 90 pe oraș: df.groupby("oras")["ore_livrare"].quantile(0.9), alături de mediană și numărul de livrări. Percentila 90 spune timpul sub care se încadrează 90% din livrări, deci răspunde direct la întrebare, spre deosebire de medie.

Media nu răspunde la întrebarea pusă: o medie de 30 de ore e compatibilă atât cu „aproape toate livrările în 30 de ore”, cât și cu „jumătate în 10 ore și restul în 50”. Percentila 90 este valoarea sub care se află 90% din observații, deci e exact angajamentul cerut.

PYTHON
r = (df.groupby("oras")["ore_livrare"]
       .agg(livrari="size",
            mediana="median",
            p90=lambda s: s.quantile(0.9))
       .sort_values("p90", ascending=False))
r = r[r["livrari"] >= 30]      # orașele cu prea puține date separat

Pe un groupby, quantile se poate apela și direct: df.groupby("oras")["ore_livrare"].quantile([0.5, 0.9]).unstack(), care dă o coloană pentru fiecare percentilă.

Detalii de spus la interviu:

  • interpolarea: implicit quantile interpolează liniar între valorile vecine, deci rezultatul poate fi o valoare care nu apare în date. Pentru un angajament comunicat clienților, interpolation="higher" dă o valoare observată efectiv și e mai prudentă;
  • volumul: P90 pe 15 livrări depinde practic de una sau două valori; orașele mici le raportezi separat sau grupat;
  • definiția: ore calendaristice sau lucrătoare, de la plasare sau de la expediere, și ce faci cu livrările încă în curs.

Pentru prezentare, un grafic cu puncte pentru mediană și P90 pe fiecare oraș, sortat după P90, arată și nivelul, și dispersia. Dacă managerul vrea să urmărească indicatorul lunar, același calcul se face pe groupby(["oras", luna]).

Ce urmărește intervievatorul: Intervievatorul verifică dacă traduci o cerință de business în statistica potrivită. Răspunsul matur discută interpolarea și volumul pe grup.

94 Mid

Ai rata de retur pe fiecare magazin. Un coleg raportează „rata medie de retur a rețelei” ca df["rata_retur"].mean(). De ce poate fi greșit și cum calculezi corect?

Răspuns scurt: Media ratelor dă aceeași greutate unui magazin cu 20 de comenzi și unuia cu 20.000. Rata rețelei este totalul retururilor împărțit la totalul comenzilor: df["retururi"].sum() / df["comenzi"].sum(), echivalentă cu media ratelor ponderată cu numărul de comenzi.

Media aritmetică a unor rapoarte este corectă doar dacă toate au același numitor. Aici fiecare magazin are alt număr de comenzi, deci media simplă răspunde la altă întrebare: „care e rata de retur a unui magazin tipic?”, nu „ce procent din comenzile rețelei se returnează?”.

Exemplu numeric: un magazin cu 100 de comenzi și 30 de retururi (30%) și unul cu 10.000 de comenzi și 300 de retururi (3%). Media ratelor este 16,5%, dar rata reală a rețelei este 330 / 10.100, adică aproximativ 3,3%.

PYTHON
rata_retea = df["retururi"].sum() / df["comenzi"].sum()

# echivalent, media ponderată
rata_retea = np.average(df["rata_retur"], weights=df["comenzi"])

Dacă ai doar ratele și nu și numărătorii, cere-i. Fără volume, nu poți calcula corect o rată agregată.

Aceeași capcană apare la: media procentelor de conversie pe zile cu trafic diferit, media prețurilor medii pe categorii, media marjelor procentuale pe produse. Și invers, când compari grupe, verifică dacă diferența vine din comportament sau din structură: o rată totală poate crește doar pentru că s-a schimbat mixul de magazine, chiar dacă fiecare magazin s-a îmbunătățit sau a rămas la fel.

Ambele medii pot fi utile, dar trebuie numite clar în raport: „rata rețelei” și „rata mediană pe magazin” sunt metrici diferite, cu interpretări diferite.

Ce urmărește intervievatorul: Se verifică o greșeală de agregare foarte răspândită în rapoarte. Candidatul bun dă un exemplu numeric și numește diferit cele două metrici.

95 Senior

Vrei să arăți relația dintre suprafață și preț pentru 5 milioane de anunțuri imobiliare. plt.scatter durează minute și produce o pată compactă. Ce faci?

Răspuns scurt: Problema e supraplotarea (overplotting): punctele se suprapun și densitatea nu se mai vede. Folosești un eșantion aleator cu transparență, un grafic de densitate pe celule (hexbin sau histogramă 2D) cu scală logaritmică a culorii, eventual pe axe logaritmice, și elimini sau tratezi separat valorile aberante.

Cu milioane de puncte, scatter desenează fiecare marker individual, deci e lent, iar zonele dense devin o pată uniformă în care 10 puncte și 100.000 de puncte arată la fel. Graficul nu mai arată distribuția, doar acoperirea.

Variantele, în funcție de scop:

PYTHON
# 1. eșantion + transparență, pentru o primă impresie
s = df.sample(50_000, random_state=0)
ax.scatter(s["mp"], s["pret"], s=3, alpha=0.1, rasterized=True)

# 2. densitate pe celule hexagonale, pe toate datele
hb = ax.hexbin(df["mp"], df["pret"], gridsize=80, bins="log",
               xscale="log", yscale="log", mincnt=1)
fig.colorbar(hb, ax=ax, label="anunțuri (scară log)")

# 3. tendința pe intervale de suprafață
tend = (df.groupby(pd.cut(df["mp"], bins=np.arange(20, 300, 10)), observed=True)
          ["pret"].quantile([0.25, 0.5, 0.75]).unstack())

Hexbin-ul cu scală logaritmică a culorii arată și zonele foarte dense, și cele rare. Axele logaritmice sunt naturale pentru prețuri și suprafețe, care se întind pe ordine de mărime. Varianta a treia, mediana și quartilele pe intervale, transformă norul de puncte într-o relație citibilă pentru un public nespecializat.

Înainte de grafic, curăță valorile imposibile: 1 m², 0 lei sau prețuri introduse în euro într-o coloană în lei pot întinde axele și pot ascunde tot restul. rasterized=True contează la export în PDF sau SVG, unde altfel fiecare punct devine un obiect vectorial și fișierul ajunge la sute de MB. Pentru explorare interactivă pe asemenea volume există unelte dedicate, ca Datashader.

Ce urmărește intervievatorul: La nivel senior se urmărește cunoașterea limitelor vizualizării pe volume mari și alegerea reprezentării după mesaj. Eșantionarea fără a spune că e eșantion e o greșeală de evitat.

Situații practice

96 Junior

La un interviu primești un CSV necunoscut cu vânzări și 45 de minute ca să răspunzi la trei întrebări de business, cu intervievatorul urmărind ecranul. Cum îți organizezi lucrul?

Răspuns scurt: Clarifici întrebările și definițiile, explorezi rapid structura și calitatea datelor, rezolvi întrebările în ordinea dificultății cu cod simplu, verifici fiecare rezultat cu un total de control și închei cu concluzii formulate pentru business. Vorbești cu voce tare pe tot parcursul.

Un model de răspuns structurat:

  • Clarificare, 2–3 minute. Reformulez întrebările și întreb definițiile: ce înseamnă „client activ”, se includ comenzile anulate, ce perioadă. Notez presupunerile în prima celulă.
  • Explorare, 5–8 minute. Rulez câteva comenzi standard și comentez ce văd:
PYTHON
df = pd.read_csv("vanzari.csv")
df.shape; df.dtypes; df.head()
df.isna().sum(); df.nunique()
df.describe()
df.duplicated().sum()

Caut problemele care ar strica răspunsurile: date ca text, valori negative, duplicate, chei lipsă.

  • Curățare minimă. Repar doar ce afectează întrebările, explicând de ce, fără să încerc perfecțiunea.
  • Răspunsuri, în ordinea dificultății. Încep cu cea mai simplă întrebare, ca să am sigur un rezultat. Prefer cod clar, cu pași numiți, în locul unui lanț ingenios greu de explicat.
  • Verificări. Suma pe grupe egală cu totalul, numărul de rânduri după fiecare merge, o valoare calculată de mână pe un caz.
  • Concluzii, ultimele 5 minute. Pentru fiecare întrebare, un răspuns în limbaj de business, cu cifra, contextul și limitările: „Clujul aduce 31% din venit; excluzând două comenzi B2B atipice, ponderea scade la 24%”.

Dacă mă blochez la o sintaxă, spun ce vreau să obțin și caut în documentație; intervievatorii apreciază mai mult raționamentul clar decât memorarea API-ului. Dacă nu termin, spun ce aș face mai departe.

Ce urmărește intervievatorul: Intervievatorul evaluează procesul: întrebări de clarificare, verificări, comunicare. Greșeala tipică este să sari direct la cod și să ajungi la o cifră neverificată.

97 Mid

Raportul tău lunar, făcut în pandas, arată un venit cu 4% diferit față de cifra din Excel-ul echipei financiare. Cum investighezi diferența?

Răspuns scurt: Pornești de la definiții (perioadă, TVA, anulări, retururi, monedă, data folosită), apoi reconciliezi pas cu pas: același număr de rânduri, aceleași totaluri pe zi sau pe categorie, până izolezi segmentul unde apare diferența. Documentezi cauza și cifra corectă, fără să ajustezi manual.

Un model de răspuns structurat:

Situația. Două cifre pentru același indicator scad încrederea în ambele rapoarte, deci prioritatea este să explici diferența, nu să alegi o cifră.

Pașii.

  • Definiții. Cer formula din Excel: cu sau fără TVA, cu sau fără comenzi anulate și retururi, după data comenzii sau a facturii, în ce fus orar, la ce curs pentru valutele străine. Cele mai multe diferențe de câteva procente vin de aici.
  • Aceeași sursă. Verific dacă ambele pornesc de la același export și aceeași dată de extragere.
  • Reconciliere de sus în jos. Compar totalurile pe niveluri, până când diferența se concentrează:
PYTHON
a = mine.groupby(mine["data"].dt.date)["valoare"].sum()
b = excel.groupby(excel["data"].dt.date)["valoare"].sum()
dif = (a - b).loc[lambda s: s.abs() > 0.01]

Dacă diferența e într-o zi, cobor pe tranzacții: un merge cu indicator=True pe ID-ul tranzacției arată rândurile care există doar într-o parte.

  • Cauze tehnice tipice din partea mea: merge care a dublat rânduri, rânduri eliminate de dropna sau de groupby cu chei lipsă, filtru pe dată care exclude ultima zi, numere citite greșit din format românesc.

Rezultatul. Scriu o notă scurtă cu cauza, cu impactul în lei și cu definiția agreată, apoi pun în cod un test sau o verificare care ar fi prins problema. Dacă greșeala era a mea, o spun direct și corectez raportul trimis.

Ce urmărește intervievatorul: Se evaluează rigoarea în reconciliere și onestitatea. Răspunsul slab ajustează cifra până se potrivește sau presupune din start că Excel-ul e greșit.

98 Mid

Un coleg a plecat și ți-a lăsat un notebook de 300 de celule care produce raportul săptămânal, rulat manual în fiecare luni. Ți se cere să-l faci automat și sigur. Cum procedezi?

Răspuns scurt: Întâi îl faci reproductibil și salvezi un rezultat de referință. Apoi muți logica în funcții testate, parametrizezi perioada și căile, adaugi validări și rulare programată cu alerte, și compari cu referința pe mai multe săptămâni.

Un model de răspuns structurat:

Situația. Raportul funcționează, dar depinde de o persoană, de ordinea celulelor și de pași manuali. Scopul este să rămână corect în timp ce devine automat, deci nu încep prin rescriere.

Pașii.

  • Referința. Rulez notebook-ul cu Restart & Run All pe datele unei săptămâni deja raportate și verific că obțin cifrele trimise. Păstrez rezultatul ca referință. Notez dependențele: fișiere, conexiuni, versiuni de biblioteci.
  • Curățenie. Elimin celulele de explorare care nu contribuie la raport și identific etapele reale: citire, curățare, calcule, export.
  • Funcții și module. Mut fiecare etapă într-o funcție cu intrări și ieșiri clare, într-un fișier .py. Perioada, căile și destinatarii devin parametri sau configurare, nu valori scrise în cod.
  • Teste și validări. Teste pe date mici pentru funcțiile critice și validări la intrare: coloane, volume, perioadă.
  • Echivalență. Rulez varianta nouă pe câteva săptămâni trecute și compar cu referința prin assert_frame_equal, cu toleranțe explicite.
  • Automatizare. Rulare programată cu un planificator (cron, un orchestrator al echipei sau unealta de scheduling existentă), loguri și o alertă când rularea eșuează sau validările nu trec, ca problema să fie văzută înaintea destinatarilor.
  • Documentare. Un README scurt: ce face, de unde vin datele, cum se rulează manual, pe cine anunți.

Rezultatul. Raportul nu mai depinde de o persoană, iar o schimbare în datele sursă se vede ca eroare clară, nu ca cifră greșită.

Ce urmărește intervievatorul: Intervievatorul urmărește dacă protejezi corectitudinea în timpul refactorizării. Greșeala tipică este rescrierea de la zero fără un rezultat de referință.

99 Senior

Un script pandas de prelucrare a tranzacțiilor rula noaptea în 10 minute. De o săptămână durează peste două ore, iar azi-noapte s-a oprit cu MemoryError. Codul nu s-a schimbat. Cum depanezi?

Răspuns scurt: Dacă nu s-a schimbat codul, s-au schimbat datele sau mediul. Compari volumul și tipurile cu rulările bune, cauți un merge care multiplică rânduri, măsori memoria pe etape, repari cauza și adaugi alerte pentru data viitoare.

Un model de răspuns structurat:

Situația. Un job important nu mai livrează. Pe termen scurt trebuie repus în funcțiune, iar pe termen lung trebuie aflată cauza ca să nu se repete.

Ipoteze, de la cea mai probabilă.

  • Volumul a crescut (o campanie, un client nou mare, o sursă suplimentară). Compar numărul de rânduri și dimensiunea fișierelor pe ultimele săptămâni.
  • Un merge multiplică rânduri. O cheie a devenit duplicată în tabelul de referință, iar rezultatul a crescut de zeci de ori. Afișez len() înainte și după fiecare merge.
  • Tipuri schimbate. O coloană numerică primește acum text („N/A”), devine object, iar memoria și timpul cresc mult; sau o coloană categorială are brusc valori unice.
  • Mediul. Altă versiune de pandas după un update, alt server, mai puțină memorie disponibilă.

Diagnostic. Rulez local pe datele din noaptea problemă, cu cronometrare și memorie pe fiecare etapă (memory_usage(deep=True), tracemalloc sau monitorul sistemului). Compar dtypes și nunique() cu o rulare bună.

Remediere. Dacă e o problemă de date, de exemplu duplicate în referință, o raportez echipei sursă și adaug validate= la merge. Dacă e volum real, optimizez: usecols, tipuri potrivite, procesare pe bucăți sau mutarea agregărilor în baza de date.

Prevenție. Loghez la fiecare rulare numărul de rânduri și durata pe etape și pun alerte la abateri mari. Data viitoare afli de problemă când durata se dublează, nu când jobul cade.

Ce urmărește intervievatorul: La nivel senior se urmărește o metodă de diagnostic bazată pe ipoteze și măsurători, nu pe încercări la întâmplare. Răspunsul slab cere imediat un server cu mai multă memorie.

100 Senior

Faci code review la notebook-ul de analiză al unui coleg junior, înainte ca rezultatele să ajungă la management. La ce te uiți și cum dai feedback?

Răspuns scurt: Verifici întâi corectitudinea rezultatelor (definiții, filtre, merge-uri, valori lipsă, agregări), apoi reproductibilitatea și abia la final stilul și performanța. Feedback-ul îl dai concret, prioritizat, cu explicația „de ce” și cu exemple, separând problemele blocante de sugestii.

Un model de răspuns structurat:

Ordinea priorităților. Un notebook frumos cu o cifră greșită face mai mult rău decât unul urât cu cifre corecte, deci încep cu ce poate schimba concluziile.

  • Definiții și întrebare. Răspunde analiza la întrebarea pusă? Sunt definite clar perioada, populația și metricile?
  • Corectitudine. Mă uit la punctele unde apar cele mai multe erori: merge-uri (tip de join, chei duplicate, număr de rânduri înainte și după), filtre pe date (capete de interval, fus orar), tratarea valorilor lipsă și a cheilor lipsă la groupby, medii de rapoarte, conversii de tipuri din formate locale.
  • Verificări de sanitate. Totalurile se potrivesc cu sursa? Rulez și eu câteva calcule independente.
  • Reproductibilitate. Rulează cu Restart & Run All? Căile sunt relative? Seed-uri fixate unde e cazul?
  • Comunicare. Graficele au titluri, unități și axe corecte? Concluziile spun și limitările?
  • Stil și performanță. Bucle care pot fi vectorizate, cod repetat care poate deveni funcție, nume clare.

Feedback-ul. Separ explicit ce e blocant (o eroare care schimbă cifrele) de sugestii. Pentru fiecare observație explic de ce contează și, unde ajută, arăt varianta corectă pe un exemplu mic. Laud concret ce e bine făcut. Pentru teme recurente, propun o sesiune scurtă împreună în loc de zeci de comentarii scrise.

Rezultatul. Raportul pleacă corect, iar colegul învață tiparul de verificare, ca data viitoare să prindă singur aceleași probleme.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi unde se ascund erorile în analiză și dacă poți dezvolta oameni. Răspunsul slab se concentrează pe stilul codului.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Python pentru analiza datelor, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Python pentru analiza datelor scriind cod, nu doar citind

Curs Data Analysis with Python: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.