...
Pregătire interviuri

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

Întrebările despre Python 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 Python: primele 15 lecții sunt gratuite.

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

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 135 minde citit
Întrebări de interviu Python cu răspunsuri

La un interviu în care se verifică Python, întrebările merg de obicei pe trei planuri: cum funcționează limbajul (mutabilitate, referințe, scope, iteratori, excepții), cât de idiomatic scrii cod (comprehensions, context managers, biblioteca standard) și cât de bine te descurci cu un exercițiu de cod live sau cu o temă de casă. Multe întrebări sunt de tipul „ce afișează codul acesta?”, pentru că scot repede la iveală dacă ai înțeles modelul de obiecte al lui Python sau doar ai memorat sintaxa.

Pentru un post de junior contează să stăpânești tipurile de bază, colecțiile, funcțiile și clasele simple și să explici clar ce face codul tău. La nivel mid se așteaptă să știi decoratori, generatori, context managers, dunder methods, typing, teste cu pytest și să ai o părere argumentată despre GIL, threading și asyncio. Întrebările de senior verifică mecanismele de sub capotă (descriptori, MRO, gestionarea memoriei) și deciziile de proiectare.

Folosește pagina ca pe un set de exerciții: citește întrebarea, încearcă să răspunzi cu voce tare sau să rulezi codul în minte, apoi compară cu răspunsul scurt și cu explicația detaliată. Rulează exemplele într-un interpretor Python 3 recent; acolo unde comportamentul depinde de versiune, versiunea este menționată.

Tipuri, variabile și operatori

1 Junior

Python este un limbaj compilat sau interpretat? Ce face, de fapt, CPython când rulezi python app.py?

Răspuns scurt: Ambele, într-un sens: CPython compilează întâi codul sursă în bytecode, apoi îl execută într-o mașină virtuală. Nu produce cod mașină nativ în avans, ca un compilator C.

CPython este implementarea de referință a limbajului, scrisă în C, și cea pe care o folosești când instalezi Python de pe python.org. Când rulezi un fișier, CPython îl parsează, construiește un arbore sintactic (AST), îl compilează în bytecode (instrucțiuni pentru o mașină virtuală cu stivă) și apoi execută acel bytecode într-o buclă de evaluare.

Pentru modulele importate, bytecode-ul se salvează în fișiere .pyc din folderul __pycache__, ca la următoarea rulare să nu mai fie recompilate. Scriptul principal nu se salvează astfel. Poți vedea bytecode-ul cu modulul dis:

PYTHON
import dis

def aduna(a, b):
    return a + b

dis.dis(aduna)

Vei vedea instrucțiuni precum LOAD_FAST și BINARY_OP (numele exacte diferă între versiuni). Există și alte implementări: PyPy are un compilator JIT, iar CPython 3.13 a introdus un JIT experimental, dezactivat implicit.

Consecința practică: erorile de sintaxă apar înainte să ruleze ceva, dar erorile de tip sau de nume (NameError, TypeError) apar abia când execuția ajunge la linia respectivă. De aceea testele și verificatoarele statice contează mult în Python.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce se întâmplă între sursă și execuție. Greșeala tipică este răspunsul simplist „e interpretat, linie cu linie”, fără să pomenești bytecode-ul.

2 Junior

Python are tipare dinamică și puternică. Ce înseamnă fiecare? Ce se întâmplă la "3" + 3?

Răspuns scurt: Dinamică: tipul aparține obiectului, nu variabilei, și se verifică la rulare. Puternică: Python nu convertește tacit între tipuri incompatibile, deci "3" + 3 aruncă TypeError.

În Python, o variabilă este doar un nume legat de un obiect. Tipul este al obiectului, așa că același nume poate indica pe rând obiecte de tipuri diferite:

PYTHON
x = 5        # x indică un int
x = "text"   # acum indică un str, fără nicio declarație

Asta este tiparea dinamică: verificarea tipurilor se face în momentul execuției, nu la compilare.

Tiparea puternică înseamnă că limbajul nu face conversii implicite surprinzătoare. În JavaScript, "3" + 3 dă "33". În Python primești TypeError: can only concatenate str (not "int") to str. Trebuie să alegi explicit: int("3") + 3 dă 6, iar "3" + str(3) dă "33".

Există câteva excepții care par conversii, dar sunt de fapt operatori definiți pentru acele tipuri: "ab" * 3 dă "ababab", iar 1 + True dă 2, pentru că bool este o subclasă a lui int. De asemenea, int și float se combină fără probleme în operații aritmetice (1 + 2.5 dă 3.5), pentru că amândouă sunt numere.

Opusul tiparii dinamice este tiparea statică (Java, C#), unde tipul variabilei e fixat la compilare. Type hints-urile din Python nu schimbă acest lucru: sunt adnotări citite de unelte precum mypy, nu de interpretor.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că nu confunzi cele două axe (dinamic/static și puternic/slab). Mulți candidați spun greșit că Python e „slab tipat” pentru că nu declari tipuri.

Eroarea, în practică:can only concatenate str (not "int") to strunsupported operand type(s) for +: 'int' and 'str'

3 Junior

Care este diferența dintre == și is? Ce afișează codul de mai jos?

PYTHON
a = [1, 2]
b = [1, 2]
print(a == b, a is b)
c = a
print(c is a)

Răspuns scurt: == compară valorile (apelează __eq__), iar is verifică dacă sunt exact același obiect în memorie. Codul afișează True False, apoi True.

a și b sunt două liste distincte cu același conținut, deci a == b este True, dar a is b este False. c = a nu copiază lista, ci leagă încă un nume de același obiect, deci c is a este True. Poți verifica identitatea și cu id(a) == id(c).

Capcana clasică apare la numere și șiruri:

PYTHON
x = 256
y = 256
print(x is y)   # True în CPython

CPython păstrează în cache obiectele int între -5 și 256, așa că acolo is pare să meargă. Pentru numere mai mari rezultatul depinde de context (în REPL poate fi False, într-un script uneori True, pentru că constantele din același bloc de cod pot fi reutilizate). Este un detaliu de implementare, nu o regulă a limbajului, deci nu te baza pe el.

Regula practică: folosește is doar pentru singleton-uri, mai ales x is None și x is not None, plus santinele proprii create cu object(). Pentru orice comparație de valori folosește ==. Începând cu Python 3.8, x is 5 produce chiar un SyntaxWarning, tocmai pentru că este aproape mereu o greșeală.

Motivul pentru care is None e preferat lui == None: o clasă poate redefini __eq__ și răspunde ciudat, pe când identitatea nu poate fi falsificată.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre identitate și egalitate. Greșeala tipică: candidatul folosește is pentru a compara șiruri sau numere pentru că „a mers în teste”.

4 Junior

Ce tipuri sunt mutabile și ce tipuri sunt imutabile în Python? Ce afișează codul?

PYTHON
a = (1, 2)
b = a
a += (3,)
print(b)

x = [1, 2]
y = x
x += [3]
print(y)

Răspuns scurt: Imutabile: int, float, bool, str, tuple, frozenset, bytes. Mutabile: list, dict, set, bytearray și majoritatea obiectelor proprii. Codul afișează (1, 2), apoi [1, 2, 3].

Un obiect imutabil nu își poate schimba conținutul după creare. Orice „modificare” produce de fapt un obiect nou. Un obiect mutabil poate fi modificat pe loc, iar toate numele care îl referă văd schimbarea.

În primul exemplu, a += (3,) nu poate modifica tuplul, așa că Python creează un tuplu nou (1, 2, 3) și leagă numele a de el. b indică în continuare tuplul vechi, deci se afișează (1, 2).

În al doilea exemplu, += pe o listă apelează __iadd__, care se comportă ca extend și modifică lista existentă. x și y indică același obiect, așa că y afișează [1, 2, 3]. Dacă ai fi scris x = x + [3], s-ar fi creat o listă nouă și y ar fi rămas [1, 2]. Diferența dintre x += ... și x = x + ... este una dintre cele mai frecvente întrebări-capcană.

O nuanță: un tuplu este imutabil, dar elementele lui pot fi mutabile. t = ([1], 2) permite t[0].append(5), pentru că nu schimbi tuplul, ci lista din interior.

De ce contează: obiectele imutabile pot fi chei de dicționar, pot fi partajate fără griji între funcții și fire de execuție, iar cele mutabile trebuie copiate explicit când vrei independență.

Ce urmărește intervievatorul: Întrebarea verifică modelul de referințe al lui Python. Mulți candidați cred că += se comportă la fel pentru toate tipurile.

Eroarea, în practică:'str' object does not support item assignment

5 Junior

Ce afișează print(0.1 + 0.2 == 0.3) și cum compari corect numere zecimale în Python?

Răspuns scurt: Afișează False, pentru că float folosește reprezentarea binară IEEE 754 și 0.1 + 0.2 dă 0.30000000000000004. Compari cu math.isclose, iar pentru bani folosești Decimal sau sume întregi în bani/cenți.

Tipul float din Python este un număr în virgulă mobilă pe 64 de biți (standardul IEEE 754). Multe fracții zecimale simple, precum 0.1, nu au o reprezentare exactă în baza 2, la fel cum 1/3 nu are una exactă în baza 10. Erorile mici de rotunjire se adună:

PYTHON
import math
from decimal import Decimal

print(0.1 + 0.2)                      # 0.30000000000000004
print(math.isclose(0.1 + 0.2, 0.3))   # True
print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3"))  # True
print(Decimal(0.1))  # arată valoarea binară reală, cu multe zecimale

Reguli practice:

  • Pentru comparații între float folosește math.isclose(a, b) sau o toleranță explicită (abs_tol pentru valori apropiate de zero).
  • Pentru bani folosește Decimal, construit din șir (Decimal("19.99")), nu din float, sau ține sumele ca întregi în bani.
  • Pentru fracții exacte există fractions.Fraction.

O capcană înrudită este round(): Python 3 rotunjește la cel mai apropiat număr par în caz de egalitate („banker's rounding”), deci round(2.5) dă 2, iar round(3.5) dă 4. În plus, round(2.675, 2) dă 2.67, pentru că 2.675 este stocat de fapt ca 2.67499999...

Problema nu este specifică lui Python, ci oricărui limbaj care folosește IEEE 754, dar intervievatorii o folosesc des ca să vadă dacă știi de ce.

Ce urmărește intervievatorul: Verifică dacă știi limitele lui float și ai lucrat cu sume de bani. Greșeala tipică este folosirea float pentru prețuri sau compararea directă cu ==.

Eroarea, în practică:decimal.InvalidOperation: ConversionSyntax

6 Junior

Ce valori sunt considerate „false” într-un if în Python? Unde e bug-ul în funcția de mai jos?

PYTHON
def conecteaza(timeout=None):
    if not timeout:
        timeout = 30
    return timeout

print(conecteaza(0))

Răspuns scurt: Sunt false False, None, zero de orice tip numeric, șirul gol și colecțiile goale. Bug-ul: 0 este fals, deci un timeout explicit de 0 este înlocuit cu 30. Verificarea corectă este if timeout is None.

În Python orice obiect are o valoare de adevăr („truthiness”). Sunt considerate false: False, None, 0, 0.0, 0j, Decimal(0), "", [], (), {}, set(), range(0) și orice obiect al cărui __bool__ întoarce False sau al cărui __len__ întoarce 0. Restul sunt adevărate.

Asta permite cod idiomatic și scurt:

PYTHON
if comenzi:          # în loc de if len(comenzi) > 0
    proceseaza(comenzi)

Problema apare când folosești același test pentru „lipsește valoarea”. În funcția din întrebare, apelul conecteaza(0) afișează 30, deși utilizatorul a cerut explicit 0. not timeout nu distinge între None (nu s-a dat nimic) și 0 (s-a dat zero). Varianta corectă:

PYTHON
def conecteaza(timeout=None):
    if timeout is None:
        timeout = 30
    return timeout

Același bug apare cu nume or "Anonim" când șirul gol este o valoare legitimă, sau cu if not pret când prețul 0 este valid (un produs gratuit).

Regula: folosește truthiness când chiar te interesează „gol sau nu”, și is None când te interesează „s-a dat sau nu o valoare”.

Ce urmărește intervievatorul: Intervievatorul caută bug-uri subtile de validare. Mulți candidați scriu if not x din reflex și nu se gândesc la 0 sau la șirul gol ca valori valide.

7 Junior

Ce afișează codul de mai jos? Prin ce diferă de Java sau C?

PYTHON
print(7 / 2, 7 // 2, 7 % 2)
print(-7 // 2, -7 % 2)
print(int(-7 / 2))

Răspuns scurt: Afișează 3.5 3 1, apoi -4 1, apoi -3. În Python // rotunjește în jos (spre minus infinit), iar % are semnul împărțitorului, pe când Java și C trunchiază spre zero.

În Python 3, / este întotdeauna împărțire reală și întoarce float, chiar și pentru 6 / 2 (dă 3.0). Pentru împărțire întreagă folosești //.

Operatorul // face floor division: rezultatul este rotunjit în jos, spre minus infinit. Pentru -3.5, „în jos” înseamnă -4. Java și C trunchiază spre zero și ar da -3.

Operatorul % este definit astfel încât să respecte mereu identitatea:

PYTHON
a == (a // b) * b + (a % b)

Pentru a = -7, b = 2: (-4) * 2 + 1 == -7, deci -7 % 2 dă 1. Rezultatul lui % are semnul împărțitorului, nu al deîmpărțitului. În Java, -7 % 2 dă -1.

int(-7 / 2) calculează întâi -3.5, apoi int() trunchiază spre zero și dă -3. Dacă vrei trunchiere explicită, math.trunc e mai clar.

De ce a ales Python așa: comportamentul lui % este foarte util în practică. zi % 7 dă mereu un rezultat între 0 și 6, chiar pentru valori negative, deci poți calcula zile ale săptămânii sau indecși circulari fără verificări suplimentare.

Ai și divmod(a, b), care întoarce perechea (a // b, a % b) într-un singur apel.

Ce urmărește intervievatorul: Verifică atenția la detalii și dacă ai lucrat cu numere negative. Candidații care vin din alte limbaje greșesc des semnul lui % și rezultatul lui //.

8 Junior

Scrie o funcție care verifică dacă un text este palindrom, ignorând majusculele, spațiile și punctuația. De ce nu e bine să construiești un șir lung prin += într-o buclă?

Răspuns scurt: Normalizezi textul cu "".join(c.lower() for c in text if c.isalnum()) și îl compari cu inversul lui, s[::-1]. Construirea prin += repetat poate fi pătratică, pentru că șirurile sunt imutabile; "".join(...) este liniar.

O soluție idiomatică:

PYTHON
def e_palindrom(text: str) -> bool:
    curat = "".join(c.lower() for c in text if c.isalnum())
    return curat == curat[::-1]

print(e_palindrom("Ele fac cafele"))      # True
print(e_palindrom("Ana are mere"))        # False

isalnum() păstrează literele și cifrele (inclusiv litere cu diacritice), lower() uniformizează majusculele, iar curat[::-1] folosește slicing cu pas -1 ca să inverseze șirul. Pentru comparații fără majuscule în texte internaționale, casefold() este mai robust decât lower().

Șirurile în Python sunt imutabile: s[0] = "x" aruncă TypeError. Fiecare rezultat += bucata creează, în principiu, un șir nou și copiază tot conținutul anterior. Într-o buclă cu n bucăți asta poate ajunge la complexitate O(n²). CPython are o optimizare care uneori face += pe loc, dar ea nu e garantată de limbaj și nu există în alte implementări.

Varianta sigură este să aduni bucățile într-o listă și să le unești la final:

PYTHON
bucati = []
for rand in randuri:
    bucati.append(rand.strip())
raport = "\n".join(bucati)

Dacă intervievatorul cere o soluție fără memorie suplimentară, poți folosi doi indecși care pornesc din capete și sar peste caracterele care nu sunt alfanumerice.

Ce urmărește intervievatorul: Este un exercițiu clasic de cod live. Intervievatorul urmărește slicing-ul, metodele de șiruri și dacă știi de imutabilitate, nu doar dacă funcția merge.

9 Junior

Cum formatezi valori cu f-strings? Ce afișează codul de mai jos?

PYTHON
pret = 1234.5
nume = "Ana"
print(f"{pret:.2f}|{pret:,.1f}|{nume:>6}|{nume!r}|{pret=}")

Răspuns scurt: Afișează 1234.50|1,234.5| Ana|'Ana'|pret=1234.5. După : vine specificatorul de format, !r folosește repr(), iar = (din Python 3.8) afișează și expresia, util la depanare.

F-strings (prefixul f, din Python 3.6) evaluează expresiile dintre acolade în momentul execuției. Sintaxa completă este {expresie!conversie:format}.

Specificatorul de format este același mini-limbaj folosit de format():

  • .2f înseamnă două zecimale, cu rotunjire;
  • , adaugă separator de mii (cu virgulă; _ pune underscore);
  • >6 aliniază la dreapta într-un câmp de 6 caractere, < la stânga, ^ la centru;
  • 08.3f completează cu zerouri până la 8 caractere;
  • % afișează procent: f"{0.256:.1%}" dă 25.6%.

!r aplică repr() în loc de str(), deci șirul apare cu ghilimele. !s și !a sunt celelalte conversii.

Forma {pret=} afișează textul expresiei, semnul egal și valoarea. Este foarte utilă la depanare rapidă: print(f"{len(lista)=}") afișează len(lista)=3.

Câteva detalii legate de versiune: din Python 3.12 (PEP 701) poți folosi aceleași ghilimele în interiorul expresiei (f"{d["cheie"]}") și expresii pe mai multe linii. În versiunile mai vechi trebuie să alternezi ghilimelele.

Pentru loguri nu folosi f-strings direct în apelul de logging; varianta logger.info("Utilizator %s", nume) amână formatarea până când mesajul chiar se afișează.

Ce urmărește intervievatorul: Verifică familiaritatea practică cu limbajul. Un candidat care a scris rapoarte sau loguri știe .2f și aliniere; {x=} arată că lucrează cu versiuni recente.

Eroarea, în practică:Unknown format code 'd' for object of type 'float'f-string: expecting '}'

10 Mid

Ce întorc operatorii and și or în Python? Ce afișează codul și ce face operatorul :=?

PYTHON
print(0 or "implicit")
print([] and 5)
print(3 and 5)
print(None or 0 or "")

Răspuns scurt: and și or întorc unul dintre operanzi, nu neapărat True/False, și se opresc la primul care decide rezultatul. Se afișează implicit, [], 5 și un rând gol. := (walrus, din 3.8) atribuie o valoare în interiorul unei expresii.

x or y evaluează x; dacă e adevărat îl întoarce, altfel întoarce y. x and y evaluează x; dacă e fals îl întoarce, altfel întoarce y. Este evaluare short-circuit: al doilea operand nu se mai evaluează dacă primul decide rezultatul.

În cod: 0 e fals, deci 0 or "implicit" dă "implicit". [] e fals, deci [] and 5 se oprește și întoarce []. 3 e adevărat, deci 3 and 5 întoarce 5. None or 0 or "" ajunge la ultimul operand și întoarce "", iar print afișează un rând gol.

Idiomuri utile și capcanele lor:

PYTHON
nume = nume_introdus or "Anonim"      # atenție: și "" devine "Anonim"
lungime = obiect and len(obiect)      # evită apelul pe None

Operatorul walrus := atribuie și întoarce valoarea în aceeași expresie. E util când altfel ai calcula ceva de două ori:

PYTHON
import re
if (m := re.search(r"\d+", text)):
    print(m.group())

while (bucata := fisier.read(8192)):
    proceseaza(bucata)

valide = [y for x in date if (y := normalizeaza(x)) is not None]

Folosește-l cu măsură: în condiții simple face codul mai scurt, dar în expresii lungi îl face greu de citit.

Ce urmărește intervievatorul: Verifică dacă știi semantica reală a operatorilor logici. Mulți candidați presupun că or întoarce mereu un boolean și nu văd capcana cu valorile false legitime.

Eroarea, în practică:Maybe you meant '==' instead of '='?

11 Mid

Unde e bug-ul? Ce afișează print(False == False in [False])?

PYTHON
def e_culoare_calda(culoare):
    if culoare == "rosu" or "portocaliu":
        return True
    return False

Răspuns scurt: culoare == "rosu" or "portocaliu" se citește ca (culoare == "rosu") or "portocaliu", iar șirul nevid e mereu adevărat, deci funcția întoarce mereu True. A doua expresie este o comparație înlănțuită și afișează True.

Precedența face ca == să se evalueze înainte de or. Pentru orice culoare, "portocaliu" este un șir nevid, deci adevărat. Varianta corectă:

PYTHON
CULORI_CALDE = {"rosu", "portocaliu", "galben"}

def e_culoare_calda(culoare):
    return culoare in CULORI_CALDE

Folosirea unui set face testul clar, ușor de extins și O(1) în medie. Observă și că if conditie: return True / return False se scrie direct return conditie.

A doua parte ține de comparațiile înlănțuite. În Python, a < b < c înseamnă a < b and b < c, cu b evaluat o singură dată. Asta permite cod natural precum if 0 <= index < len(lista).

Regula se aplică însă oricărui operator de comparație, inclusiv ==, in și is. Astfel:

PYTHON
False == False in [False]
# devine: (False == False) and (False in [False])
# adică: True and True -> True

Mulți se așteaptă la (False == False) in [False], adică True in [False], care ar da False. Același efect apare la a == b == c, care verifică dacă toate trei sunt egale, ceea ce e de obicei intenția, dar și la combinații ciudate ca x < y > z.

Concluzia practică: folosește înlănțuirea pentru intervale, iar în rest pune paranteze ca intenția să fie evidentă.

Ce urmărește intervievatorul: Primul bug apare des în codul începătorilor; intervievatorul verifică dacă îl vezi imediat. A doua parte separă candidații care cunosc regulile de precedență de cei care ghicesc.

12 Senior

Cum gestionează CPython memoria? Ce face del și când este eliberat efectiv un obiect?

PYTHON
import gc, weakref

class Nod:
    pass

a = Nod(); b = Nod()
a.vecin = b; b.vecin = a
r = weakref.ref(a)
del a, b
print(r() is None)
gc.collect()
print(r() is None)

Răspuns scurt: CPython folosește în principal numărarea referințelor: obiectul se eliberează imediat când nu mai are nicio referință. Ciclurile sunt curățate de un garbage collector separat. del șterge doar numele, nu obiectul; aici se afișează de obicei False, apoi True.

Fiecare obiect din CPython are un contor de referințe. Când legi un nume de el, îl pui într-o listă sau îl transmiți unei funcții, contorul crește; când referința dispare, scade. La zero, obiectul este distrus imediat. De aceea, în CPython, un fișier deschis fără with se închide de obicei când variabila iese din scope, dar acest comportament nu e garantat de limbaj (PyPy, de exemplu, nu îl are).

del a nu distruge obiectul, ci elimină numele a și scade contorul. Dacă mai există alte referințe, obiectul trăiește mai departe.

Numărarea referințelor nu poate elibera cicluri: în exemplu, cele două noduri se referă reciproc, deci contoarele lor nu ajung la zero nici după del a, b. Pentru asta există un garbage collector ciclic (modulul gc), care rulează periodic, pe generații, și caută grupuri de obiecte accesibile doar între ele. Primul print afișează de obicei False (ciclul încă există), iar după gc.collect() afișează True. Detaliile algoritmului s-au schimbat între versiuni, dar principiul a rămas.

weakref.ref creează o referință care nu crește contorul, așa că poți observa când obiectul dispare. Referințele slabe sunt utile pentru cache-uri și observatori care nu trebuie să țină obiectele în viață (weakref.WeakValueDictionary).

În practică: nu te baza pe __del__ pentru eliberarea resurselor, ci folosește context managers.

Ce urmărește intervievatorul: Întrebare de senior: arată dacă înțelegi de ce memoria crește în anumite situații și de ce apar diferențe între implementări. Greșeala tipică este credința că del eliberează obiectul.

Colecții și comprehensions

13 Junior

Ce afișează codul și cum faci o copie independentă a listei?

PYTHON
a = [1, 2, 3]
b = a
b.append(4)
print(a)

Răspuns scurt: Afișează [1, 2, 3, 4], pentru că b = a nu copiază lista, ci creează încă un nume pentru același obiect. O copie se face cu a.copy(), a[:] sau list(a).

În Python atribuirea nu copiază niciodată date. b = a leagă numele b de același obiect listă de care e legat a. Orice modificare făcută prin b se vede și prin a, pentru că există o singură listă. Fenomenul se numește aliasing. Poți verifica: a is b dă True.

Pentru o copie separată ai mai multe variante echivalente:

PYTHON
b = a.copy()
b = a[:]
b = list(a)

Toate creează o listă nouă cu aceleași elemente. După b.append(4), a rămâne [1, 2, 3].

Același mecanism apare la funcții: dacă transmiți o listă unei funcții și funcția o modifică cu append, sort sau del, apelantul vede schimbarea. Dacă funcția nu ar trebui să modifice argumentul, fie lucrează pe o copie, fie construiește și întoarce o listă nouă.

Atenție că aceste copii sunt superficiale: lista e nouă, dar elementele sunt aceleași obiecte. Pentru liste de numere sau șiruri nu contează, pentru că sunt imutabile. Pentru liste de liste sau de dicționare, modificarea unui element interior se vede în ambele copii și ai nevoie de copy.deepcopy.

Același lucru e valabil pentru dicționare (d.copy(), dict(d)) și seturi (s.copy()).

Ce urmărește intervievatorul: Verifică modelul de referințe, fundamentul multor bug-uri. Candidații care răspund „afișează [1, 2, 3]” nu au înțeles încă diferența dintre nume și obiect.

14 Junior

Vrei o matrice 3x3 plină cu zerouri. Ce afișează codul și cum îl corectezi?

PYTHON
m = [[0] * 3] * 3
m[0][0] = 1
print(m)

Răspuns scurt: Afișează [[1, 0, 0], [1, 0, 0], [1, 0, 0]], pentru că * 3 pe lista exterioară repetă trei referințe la aceeași listă interioară. Corect: m = [[0] * 3 for _ in range(3)].

Operatorul * pe o listă repetă referințele elementelor, nu le copiază. [0] * 3 este în regulă: obține [0, 0, 0], iar zerourile sunt imutabile, deci faptul că e același obiect nu contează. [[0] * 3] * 3 însă creează o listă cu trei referințe către aceeași listă interioară. Modifici m[0][0] și vezi modificarea în toate „rândurile”, pentru că există, de fapt, un singur rând.

Poți confirma:

PYTHON
print(m[0] is m[1])   # True

Varianta corectă construiește un rând nou la fiecare iterație:

PYTHON
m = [[0] * 3 for _ in range(3)]
m[0][0] = 1
print(m)   # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]

Comprehension-ul evaluează expresia [0] * 3 de trei ori, deci obții trei liste distincte.

Aceeași capcană apare și în alte forme: [{}] * 5 (cinci referințe la același dicționar), dict.fromkeys(chei, []) (toate cheile împart aceeași listă) sau o valoare implicită mutabilă într-un parametru. Soluția este mereu aceeași: creezi obiectul mutabil separat pentru fiecare poziție, de exemplu cu un comprehension sau cu collections.defaultdict(list).

Pentru calcule numerice serioase pe matrice se folosesc biblioteci dedicate, dar la interviu întrebarea verifică înțelegerea referințelor.

Ce urmărește intervievatorul: Este una dintre cele mai cunoscute capcane Python. Intervievatorul vrea să vadă dacă poți explica de ce, nu doar dacă știi răspunsul pe de rost.

15 Junior

Cum accesezi în siguranță cheile unui dicționar? Ce afișează codul?

PYTHON
stoc = {"mere": 10, "pere": 0}
print(stoc.get("prune"), stoc.get("prune", 0))
stoc.setdefault("kiwi", 5)
print(list(stoc))
print(stoc["prune"])

Răspuns scurt: Afișează None 0, apoi ['mere', 'pere', 'kiwi'], apoi aruncă KeyError: 'prune'. get întoarce o valoare implicită când cheia lipsește, setdefault inserează cheia doar dacă nu există, iar d[cheie] aruncă excepție.

Ai trei moduri principale de citire:

  • d[cheie] aruncă KeyError dacă cheia lipsește. Folosește-l când lipsa cheii este o eroare reală.
  • d.get(cheie, implicit) întoarce valoarea sau implicit (None dacă nu dai nimic). Nu modifică dicționarul.
  • d.setdefault(cheie, implicit) întoarce valoarea existentă sau inserează implicit și îl întoarce.

Câteva lucruri pe care merită să le spui la interviu:

  • Din Python 3.7, dicționarele păstrează garantat ordinea de inserare. De aceea list(stoc) dă cheile în ordinea în care au fost adăugate. Actualizarea valorii unei chei existente nu îi schimbă poziția.
  • in verifică cheile, nu valorile: "mere" in stoc dă True, 10 in stoc dă False. Pentru valori folosești 10 in stoc.values().
  • Pentru parcurgere folosești for cheie, valoare in stoc.items().
  • Din 3.9 poți uni dicționare cu | și |=; la chei comune câștigă valoarea din dreapta.
PYTHON
implicite = {"tema": "luminoasa", "limba": "ro"}
utilizator = {"tema": "intunecata"}
setari = implicite | utilizator
print(setari)   # {'tema': 'intunecata', 'limba': 'ro'}

Atenție la get cu valoare 0 sau șir gol: if stoc.get("pere"): este fals și pentru o cheie existentă cu valoarea 0. Dacă vrei să știi dacă cheia există, folosește in.

Ce urmărește intervievatorul: Verifică lucrul de zi cu zi cu dicționare. Greșeala tipică: candidatul nu știe că ordinea e garantată sau confundă in pe chei cu in pe valori.

Eroarea, în practică:KeyError: 'cheie''dict' object has no attribute 'has_key'

16 Junior

Ce poate fi cheie într-un dicționar sau element într-un set? Ce afișează codul?

PYTHON
d = {1: "unu", True: "adevarat", 1.0: "float"}
print(d)
print(hash((1, 2)))
print(hash((1, [2])))

Răspuns scurt: Doar obiectele hashable, adică cele care au un hash stabil pe toată durata vieții, de obicei cele imutabile. Codul afișează {1: 'float'}, un număr întreg, apoi aruncă TypeError: unhashable type: 'list'.

Dicționarele și seturile sunt tabele hash: poziția unei chei se calculează din hash(cheie), iar cheile cu hash egal se compară apoi cu ==. Pentru ca asta să funcționeze, hash-ul unei chei nu are voie să se schimbe cât timp ea e în dicționar. De aceea listele, dicționarele și seturile, care sunt mutabile, nu pot fi chei.

Sunt hashable: numerele, șirurile, bytes, None, frozenset și tuplurile, dar un tuplu e hashable doar dacă toate elementele lui sunt hashable. (1, [2]) conține o listă, deci hash aruncă TypeError.

Prima linie e o capcană interesantă. 1, True și 1.0 sunt egale (1 == True == 1.0) și au același hash, deci pentru dicționar sunt aceeași cheie. Prima inserare fixează cheia 1, iar următoarele doar înlocuiesc valoarea. Rezultatul este {1: 'float'}.

Obiectele claselor tale sunt hashable implicit (hash-ul se bazează pe identitate), dar dacă redefinești __eq__ fără __hash__, devin nehashable.

Soluții când ai nevoie de o cheie compusă din date mutabile:

PYTHON
vizitat = set()
coordonate = [3, 4]
vizitat.add(tuple(coordonate))   # convertești lista în tuplu
grupuri = {frozenset({"a", "b"}): 1}

Ce urmărește intervievatorul: Verifică dacă înțelegi cum funcționează dicționarele, nu doar sintaxa. Candidații buni explică legătura dintre mutabilitate și hash.

Eroarea, în practică:unhashable type: 'list'

17 Junior

Scrie o funcție care elimină duplicatele dintr-o listă păstrând ordinea primei apariții. Ce complexitate are?

Răspuns scurt: Cea mai scurtă variantă este list(dict.fromkeys(lista)), care păstrează ordinea pentru că dicționarele rețin ordinea de inserare. Complexitatea este O(n) în medie. list(set(lista)) pierde ordinea.

Varianta idiomatică:

PYTHON
def unice(elemente):
    return list(dict.fromkeys(elemente))

print(unice([3, 1, 3, 2, 1]))   # [3, 1, 2]

dict.fromkeys creează un dicționar cu elementele ca chei (valoarea e None). Cheile duplicate sunt ignorate, iar ordinea primei inserări se păstrează, garantat din Python 3.7.

Varianta explicită, ușor de adaptat:

PYTHON
def unice(elemente, cheie=None):
    vazute = set()
    rezultat = []
    for x in elemente:
        k = cheie(x) if cheie else x
        if k not in vazute:
            vazute.add(k)
            rezultat.append(x)
    return rezultat

print(unice(["Ana", "ana", "Ion"], cheie=str.lower))   # ['Ana', 'Ion']

Complexitatea: fiecare element e verificat și adăugat într-un set, operații O(1) în medie, deci totalul e O(n) timp și O(n) memorie suplimentară.

Greșeli frecvente:

  • list(set(lista)) elimină duplicatele, dar ordinea rezultatului nu e garantată.
  • O verificare de tipul if x not in rezultat pe listă dă O(n²), lent pentru liste mari.
  • Ambele variante cer elemente hashable. Pentru dicționare sau liste, folosește parametrul cheie care produce ceva hashable, de exemplu cheie=lambda d: d["id"].

Bonusul pe care îl apreciază intervievatorii: întrebi dacă e nevoie de păstrarea ordinii și ce tipuri au elementele.

Ce urmărește intervievatorul: Exercițiu scurt de cod live. Intervievatorul urmărește dacă știi de ordinea dicționarelor și dacă alegi o structură cu căutare O(1).

18 Junior

Ce operații oferă set și de ce x in set e mai rapid decât x in list? Ce afișează codul?

PYTHON
a = {1, 2, 3, 4}
b = {3, 4, 5}
print(a | b, a & b, a - b, a ^ b)
print(type({}))

Răspuns scurt: Afișează reuniunea {1, 2, 3, 4, 5}, intersecția {3, 4}, diferența {1, 2}, diferența simetrică {1, 2, 5} și <class 'dict'>. in pe set e O(1) în medie, pe listă e O(n).

Un set este o colecție neordonată de elemente unice și hashable, implementată ca tabel hash. Operațiile de bază:

  • a | b sau a.union(b): elementele din oricare;
  • a & b sau a.intersection(b): elementele comune;
  • a - b sau a.difference(b): ce e în a și nu în b;
  • a ^ b: ce e într-unul singur;
  • a <= b: a este submulțime a lui b.

Metodele cu nume acceptă orice iterabil (a.union([7, 8])), pe când operatorii cer seturi de ambele părți.

{} creează un dicționar gol, nu un set. Setul gol se scrie set(). Este o capcană frecventă.

Diferența de performanță: x in lista parcurge elementele unul câte unul, deci O(n). x in set calculează hash-ul și merge direct la poziție, O(1) în medie. Pe o listă mică diferența e neglijabilă, dar într-o buclă care verifică mii de elemente într-o listă de mii de elemente ajungi la O(n·m).

PYTHON
blocati = set(emailuri_blocate)        # conversie o singură dată, O(m)
valizi = [e for e in emailuri if e not in blocati]   # O(n)

Ordinea elementelor la afișarea unui set nu e garantată, chiar dacă pentru numere mici pare sortată. Dacă ai nevoie de un set imutabil (de exemplu ca cheie de dicționar), folosești frozenset.

Ce urmărește intervievatorul: Verifică dacă alegi structura potrivită pentru căutări. Candidații slabi folosesc liste peste tot și nu știu că {} este dicționar.

19 Junior

Ce afișează codul? Cum elimini corect elementele dintr-o listă sau dintr-un dicționar în timp ce le parcurgi?

PYTHON
numere = [1, 2, 2, 3, 4]
for n in numere:
    if n % 2 == 0:
        numere.remove(n)
print(numere)

Răspuns scurt: Afișează [1, 2, 3]: un 2 rămâne, pentru că după fiecare remove elementele se deplasează și bucla sare peste următorul. Corect este să construiești o listă nouă, de exemplu [n for n in numere if n % 2 != 0].

Bucla for pe o listă folosește intern un index. Pas cu pas:

  • index 0: 1, impar, rămâne;
  • index 1: 2, este eliminat; lista devine [1, 2, 3, 4], iar al doilea 2 ajunge pe indexul 1;
  • index 2: 3, impar; al doilea 2 a fost sărit;
  • index 3: 4, eliminat; lista devine [1, 2, 3], iar bucla se termină.

Nu apare nicio eroare, doar un rezultat greșit, ceea ce face bug-ul periculos.

Soluții corecte:

PYTHON
numere = [n for n in numere if n % 2 != 0]   # listă nouă
numere[:] = [n for n in numere if n % 2 != 0]  # modifici pe loc același obiect
for n in numere[:]:                          # parcurgi o copie
    if n % 2 == 0:
        numere.remove(n)

Varianta cu numere[:] = e utilă când alte părți din program au o referință la aceeași listă.

La dicționare, Python detectează problema: dacă adaugi sau ștergi chei în timpul parcurgerii, primești RuntimeError: dictionary changed size during iteration. Soluțiile sunt similare:

PYTHON
stoc = {k: v for k, v in stoc.items() if v > 0}
for k in list(stoc):       # copie a cheilor
    if stoc[k] == 0:
        del stoc[k]

Modificarea valorilor cheilor existente în timpul parcurgerii este permisă; problema apare doar când se schimbă dimensiunea.

Ce urmărește intervievatorul: Testează dacă poți urmări execuția pas cu pas. Mulți candidați se așteaptă la [1, 3] și nu știu de ce rămâne un 2.

Eroarea, în practică:dictionary changed size during iteration

20 Junior

Explică despachetarea în Python. Ce afișează codul?

PYTHON
prim, *mijloc, ultim = [1, 2, 3, 4, 5]
print(prim, mijloc, ultim)
a, b = 1, 2
a, b = b, a
print(a, b)
for i, (nume, varsta) in enumerate([("Ana", 30), ("Ion", 25)], start=1):
    print(i, nume, varsta)

Răspuns scurt: Afișează 1 [2, 3, 4] 5, apoi 2 1, apoi 1 Ana 30 și 2 Ion 25. Despachetarea atribuie elementele unui iterabil mai multor nume, iar * adună restul într-o listă.

Despachetarea (unpacking) funcționează cu orice iterabil: liste, tupluri, șiruri, generatori. Numărul de nume trebuie să corespundă cu numărul de elemente, altfel primești ValueError: too many values to unpack sau not enough values to unpack.

Cu un nume marcat cu * poți prelua „restul”, care devine mereu o listă (poate fi și goală). Poate exista un singur nume cu stea într-o atribuire.

Interschimbarea a, b = b, a funcționează fără variabilă temporară: partea dreaptă construiește întâi tuplul (2, 1), apoi acesta e despachetat în a și b.

Despachetarea se poate imbrica, ca în bucla cu enumerate: fiecare element este (index, (nume, varsta)). enumerate(..., start=1) evită contoarele manuale.

Alte idiomuri înrudite:

PYTHON
chei = ["nume", "oras"]
valori = ["Ana", "Cluj"]
print(dict(zip(chei, valori)))      # {'nume': 'Ana', 'oras': 'Cluj'}

for x, y in zip([1, 2, 3], ["a", "b"]):
    print(x, y)                      # se oprește la cea mai scurtă: 2 perechi

zip se oprește tăcut la cel mai scurt iterabil, ceea ce poate ascunde date pierdute. Din Python 3.10 poți scrie zip(a, b, strict=True), care aruncă ValueError dacă lungimile diferă. Pentru completare până la cel mai lung există itertools.zip_longest.

Despachetarea apare și la apeluri de funcții: f(*lista, **dictionar).

Ce urmărește intervievatorul: Verifică stilul idiomatic: candidații care scriu for i in range(len(lista)) și variabile temporare la interschimbare arată că încă gândesc în alt limbaj.

Eroarea, în practică:cannot unpack non-iterable NoneType objecttoo many values to unpack (expected 2)

21 Mid

Cum aplatizezi o listă de liste și cum transpui o matrice cu comprehensions? Care este ordinea buclelor într-un comprehension imbricat?

Răspuns scurt: Aplatizare: [x for rand in matrice for x in rand]; buclele se scriu în aceeași ordine ca într-un for imbricat clasic. Transpunere: [list(col) for col in zip(*matrice)] sau un comprehension imbricat.

Într-un comprehension cu mai multe for, ordinea este cea a buclelor scrise normal, de la exterior la interior:

PYTHON
matrice = [[1, 2, 3], [4, 5, 6]]

plat = [x for rand in matrice for x in rand]
# echivalent cu:
# for rand in matrice:
#     for x in rand:
#         plat.append(x)
print(plat)   # [1, 2, 3, 4, 5, 6]

Mulți scriu greșit [x for x in rand for rand in matrice], care dă NameError (sau folosește un rand rămas din alt cod).

Transpunerea are două variante:

PYTHON
t1 = [[rand[i] for rand in matrice] for i in range(len(matrice[0]))]
t2 = [list(col) for col in zip(*matrice)]
print(t1)   # [[1, 4], [2, 5], [3, 6]]

Aici comprehension-ul exterior construiește rândurile rezultatului, iar cel interior parcurge fiecare rând original. zip(*matrice) despachetează rândurile ca argumente separate și le grupează pe coloane.

Există și comprehensions pentru dicționare și seturi:

PYTHON
preturi = {"mere": 5, "pere": 0, "kiwi": 12}
disponibile = {k: v for k, v in preturi.items() if v > 0}
initiale = {k[0] for k in preturi}

În Python 3, variabila de buclă dintr-un comprehension nu „scapă” în exterior, spre deosebire de o buclă for.

Regula de stil: un nivel de imbricare e lizibil; peste două niveluri, sau cu condiții complicate, o buclă obișnuită ori o funcție separată e mai clară.

Ce urmărește intervievatorul: Verifică stăpânirea comprehensions dincolo de cazul simplu. Greșeala frecventă este inversarea ordinii buclelor.

Eroarea, în practică:parentheses around the comprehension target?

22 Mid

Ai o listă de angajați (dicționare cu oras și nume). Cum o sortezi descrescător după oraș și, în cadrul aceluiași oraș, crescător după nume? Ce înseamnă că sortarea e stabilă?

Răspuns scurt: Sortarea în Python este stabilă: elementele egale după cheie își păstrează ordinea relativă. Asta permite sortarea în doi pași: întâi după criteriul secundar, apoi după cel principal, fiecare cu propria direcție.

list.sort() sortează pe loc și întoarce None, iar sorted() primește orice iterabil și întoarce o listă nouă. O greșeală clasică este lista = lista.sort(), după care lista devine None.

Pentru criterii multiple în aceeași direcție, cheia poate fi un tuplu: key=lambda p: (p["oras"], p["nume"]). Pentru numere poți inversa un criteriu cu minus: key=lambda p: (-p["varsta"], p["nume"]). La șiruri nu poți pune minus, așa că folosești stabilitatea:

PYTHON
angajati = [
    {"nume": "Ion", "oras": "Cluj"},
    {"nume": "Ana", "oras": "Iasi"},
    {"nume": "Dan", "oras": "Cluj"},
    {"nume": "Bia", "oras": "Iasi"},
]
angajati.sort(key=lambda p: p["nume"])                # criteriul secundar
angajati.sort(key=lambda p: p["oras"], reverse=True)  # criteriul principal
print([(p["oras"], p["nume"]) for p in angajati])
# [('Iasi', 'Ana'), ('Iasi', 'Bia'), ('Cluj', 'Dan'), ('Cluj', 'Ion')]

Stabilitatea înseamnă că, la al doilea pas, angajații din același oraș rămân în ordinea stabilită la primul pas, adică alfabetic după nume. reverse=True păstrează și el stabilitatea.

Detalii utile: operator.itemgetter("oras", "nume") e o alternativă rapidă la lambda; key se calculează o singură dată pe element, nu la fiecare comparație; complexitatea este O(n log n). Pentru comparatori vechi, de tip cmp, există functools.cmp_to_key.

Pentru sortarea textelor cu diacritice în ordinea alfabetului românesc ai nevoie de locale.strxfrm sau de o bibliotecă precum PyICU, pentru că sortarea implicită compară coduri Unicode.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi key, diferența sort/sorted și proprietatea de stabilitate. Puțini candidați știu trucul cu sortarea în doi pași.

Eroarea, în practică:sort() takes no positional arguments

23 Mid

Ce structuri din modulul collections folosești în practică și pentru ce? De ce nu e bine să folosești o listă ca o coadă?

Răspuns scurt: Cele mai folosite sunt deque (coadă cu operații O(1) la ambele capete), defaultdict (valori implicite automate), Counter (numărare) și namedtuple (tupluri cu câmpuri numite). list.pop(0) e O(n), pe când deque.popleft() e O(1).

O listă Python este un array dinamic. Adăugarea și scoaterea de la final sunt rapide, dar pop(0) sau insert(0, x) mută toate celelalte elemente, deci O(n). Pentru o coadă FIFO folosești deque:

PYTHON
from collections import deque, defaultdict, Counter, namedtuple

coada = deque()
coada.append("sarcina1")
coada.append("sarcina2")
print(coada.popleft())          # sarcina1, O(1)

ultimele = deque(maxlen=3)      # păstrează automat doar ultimele 3
for x in range(10):
    ultimele.append(x)
print(ultimele)                 # deque([7, 8, 9], maxlen=3)

defaultdict creează automat valoarea la prima accesare a unei chei lipsă, ideal pentru grupare:

PYTHON
dupa_initiala = defaultdict(list)
for cuvant in ["ana", "ion", "alin"]:
    dupa_initiala[cuvant[0]].append(cuvant)
print(dict(dupa_initiala))      # {'a': ['ana', 'alin'], 'i': ['ion']}

Atenție: doar accesarea d[cheie] creează intrarea, deci chiar o citire adaugă chei. Pentru verificare folosește in sau get.

Counter este un dicționar specializat pentru numărare, cu operații aritmetice între numărători (c1 + c2, c1 - c2). namedtuple (sau typing.NamedTuple) dă tupluri imutabile cu acces prin nume, p.x în loc de p[0].

OrderedDict a devenit mai puțin necesar de când dict păstrează ordinea, dar are încă move_to_end și o comparație care ține cont de ordine.

ChainMap grupează mai multe dicționare într-o singură vedere, util pentru niveluri de configurare.

Ce urmărește intervievatorul: Verifică cunoașterea bibliotecii standard. Candidații care reimplementează manual numărarea sau gruparea scriu mai mult cod și mai fragil.

Eroarea, în practică:first argument must be callable or None

24 Mid

Ce complexitate au operațiile uzuale pe list și dict? Cum este implementat un dicționar în CPython?

Răspuns scurt: Lista e un array dinamic: acces după index și append O(1) (amortizat), inserare la început și in O(n). Dicționarul e un tabel hash: căutare, inserare și ștergere O(1) în medie, O(n) în cel mai rău caz.

list în CPython este un array de pointeri către obiecte:

  • lista[i], lista[i] = x, len: O(1);
  • append: O(1) amortizat; când capacitatea se umple, array-ul se realocă cu spațiu suplimentar, deci realocările rare se „împart” pe multe operații;
  • pop() de la final: O(1); pop(0), insert(0, x), del lista[0]: O(n);
  • x in lista, lista.index(x), lista.remove(x): O(n);
  • slicing lista[a:b]: O(b - a), pentru că se copiază elementele;
  • sort: O(n log n).

dict este un tabel hash cu adresare deschisă. Din Python 3.6, CPython folosește un format compact: un array de indecși mic și un array separat de intrări (hash, cheie, valoare), adăugate în ordinea inserării. De aici vine păstrarea ordinii, devenită garanție a limbajului în 3.7, și consumul de memorie mai mic.

  • d[k], d[k] = v, del d[k], k in d: O(1) în medie;
  • în cel mai rău caz, dacă multe chei au hash-uri care se ciocnesc, ajungi la O(n);
  • parcurgerea: O(n).

set folosește același principiu, fără valori.

PYTHON
import timeit
lista = list(range(100_000))
multime = set(lista)
print(timeit.timeit(lambda: 99_999 in lista, number=1000))
print(timeit.timeit(lambda: 99_999 in multime, number=1000))

Rulează exemplul: diferența dintre cele două timpi crește odată cu dimensiunea. Pentru hash-ul șirurilor, Python folosește o valoare aleatoare per proces (PYTHONHASHSEED), ca protecție împotriva atacurilor care forțează coliziuni.

Ce urmărește intervievatorul: Verifică dacă poți raționa despre performanță. Candidații de nivel mid trebuie să știe ce operații ascund costuri liniare.

25 Senior

Implementează un cache LRU (Least Recently Used) cu capacitate fixă și operațiile get(cheie) și put(cheie, valoare) în O(1).

Răspuns scurt: Folosești collections.OrderedDict: la fiecare acces muți cheia la final cu move_to_end, iar când depășești capacitatea elimini primul element cu popitem(last=False). Toate operațiile sunt O(1).

Un cache LRU păstrează cele mai recent folosite elemente și, când se umple, elimină elementul nefolosit de cel mai mult timp. Ai nevoie de căutare O(1) (un tabel hash) și de o ordine a accesărilor actualizabilă în O(1) (o listă dublu înlănțuită). OrderedDict combină exact aceste două structuri:

PYTHON
from collections import OrderedDict

class CacheLRU:
    def __init__(self, capacitate: int):
        self.capacitate = capacitate
        self.date = OrderedDict()

    def get(self, cheie, implicit=None):
        if cheie not in self.date:
            return implicit
        self.date.move_to_end(cheie)          # devine cea mai recentă
        return self.date[cheie]

    def put(self, cheie, valoare):
        if cheie in self.date:
            self.date.move_to_end(cheie)
        self.date[cheie] = valoare
        if len(self.date) > self.capacitate:
            self.date.popitem(last=False)     # elimină cea mai veche

c = CacheLRU(2)
c.put("a", 1); c.put("b", 2)
c.get("a")
c.put("c", 3)
print(list(c.date))   # ['a', 'c']

Dacă intervievatorul cere implementarea fără OrderedDict, construiești un dict cheie → nod și o listă dublu înlănțuită cu noduri santinelă la capete; mutarea unui nod la final înseamnă câteva atribuiri de pointeri.

Discuția de senior merge mai departe: clasa nu e thread-safe, deci în cod concurent ai nevoie de un threading.Lock în jurul operațiilor. Pentru memoizarea funcțiilor există deja functools.lru_cache(maxsize=...), care e implementat în C și thread-safe pentru structura internă. Poți discuta și expirarea după timp (TTL) și măsurarea ratei de reușită prin cache_info().

Ce urmărește intervievatorul: Este o problemă clasică de proiectare a structurilor de date. Intervievatorul urmărește alegerea structurilor pentru O(1) și discuția despre concurență.

Funcții, closures și decoratori

Exersează capitolul cu exerciții reale: Curs Python →
26 Junior

Ce tipuri de parametri poate avea o funcție Python și în ce ordine se scriu? Ce afișează apelul?

PYTHON
def comanda(produs, cantitate=1, *extra, livrare="standard", **detalii):
    print(produs, cantitate, extra, livrare, detalii)

comanda("carte", 2, "cadou", "urgent", livrare="curier", culoare="rosu")

Răspuns scurt: Ordinea este: poziționali, cu valori implicite, *args, keyword-only, **kwargs. Apelul afișează carte 2 ('cadou', 'urgent') curier {'culoare': 'rosu'}.

Python leagă argumentele de parametri în câțiva pași. Argumentele poziționale se distribuie de la stânga la dreapta: "carte" merge în produs, 2 în cantitate. Ce rămâne poziționale („cadou”, „urgent”) intră în *extra, care este un tuplu. Orice parametru scris după *extra poate fi dat doar prin nume, deci livrare este keyword-only. Argumentele cu nume care nu corespund niciunui parametru ajung în detalii, un dicționar**.

Numele args și kwargs sunt doar convenții; contează stelele.

Reguli de reținut:

  • Parametrii cu valoare implicită trebuie să vină după cei fără (între cei poziționali).
  • Nu poți da aceeași valoare de două ori: comanda("carte", produs="x") aruncă TypeError: got multiple values for argument 'produs'.
  • Lipsa unui parametru obligatoriu aruncă TypeError: missing 1 required positional argument.

Stelele funcționează și invers, la apel, pentru a despacheta o colecție în argumente:

PYTHON
args = ("carte", 3)
optiuni = {"livrare": "curier", "ambalaj": "cadou"}
comanda(*args, **optiuni)
# carte 3 () curier {'ambalaj': 'cadou'}

Acest mecanism este baza decoratorilor și a funcțiilor care transmit mai departe argumentele (wrappers), unde scrii func(*args, **kwargs) ca să nu depinzi de semnătura exactă.

Ce urmărește intervievatorul: Verifică dacă înțelegi legarea argumentelor, nu doar sintaxa *args. Greșeala tipică este să nu știi că parametrii de după *args devin keyword-only.

Eroarea, în practică:missing 1 required positional argumenttakes 1 positional argument but 2 were given

27 Junior

Ce se întâmplă la rularea codului de mai jos și de ce? Explică regula LEGB.

PYTHON
x = 10

def f():
    print(x)
    x = 5

f()

Răspuns scurt: Codul aruncă UnboundLocalError. Pentru că x este atribuit în funcție, compilatorul îl consideră variabilă locală în tot corpul funcției, iar la print(x) variabila locală încă nu are valoare.

Python caută un nume în patru niveluri, în ordinea LEGB: Local (funcția curentă), Enclosing (funcțiile care o conțin), Global (modulul) și Built-in (len, print etc.).

Decizia dacă un nume este local se ia la compilarea funcției, nu linie cu linie. Dacă există o atribuire către x oriunde în corpul lui f (inclusiv x += 1, un for x in ... sau un import x), atunci x este local în toată funcția. Linia print(x) caută variabila locală, care nu a primit încă o valoare. Mesajul în Python 3.11+ este cannot access local variable 'x' where it is not associated with a value; în versiunile mai vechi este local variable 'x' referenced before assignment.

Dacă elimini linia x = 5, funcția afișează 10, pentru că x nu mai e local și se găsește la nivel global.

Variantele corecte, în funcție de intenție:

PYTHON
def f():
    y = x + 1        # doar citești globalul, folosești alt nume local
    return y

def g(x):            # primești valoarea ca parametru, cea mai bună variantă
    return x + 1

Dacă chiar vrei să modifici variabila globală, ai nevoie de global x, dar asta face codul mai greu de testat.

O capcană înrudită: dacă denumești o variabilă list sau sum, ascunzi funcția built-in în acel scope, iar mai târziu list(...) dă TypeError: 'list' object is not callable.

Ce urmărește intervievatorul: Testează înțelegerea modului în care Python decide scope-ul. Mulți candidați cred că până la atribuire se folosește variabila globală.

Eroarea, în practică:NameError: name 'x' is not definedUnboundLocalError: local variable

28 Junior

Ce fac global și nonlocal? Scrie o funcție care întoarce un contor care crește la fiecare apel.

Răspuns scurt: global x face ca atribuirile din funcție să modifice variabila din modul, iar nonlocal x pe cea din funcția care o conține. Un contor se face cu o funcție interioară care folosește nonlocal.

În mod implicit, o atribuire într-o funcție creează o variabilă locală. Cele două cuvinte-cheie schimbă această regulă pentru un nume anume.

global leagă numele de variabila din modul:

PYTHON
apeluri = 0

def inregistreaza():
    global apeluri
    apeluri += 1

nonlocal leagă numele de o variabilă dintr-o funcție exterioară (nu din modul):

PYTHON
def creeaza_contor(start=0):
    valoare = start
    def urmatorul():
        nonlocal valoare
        valoare += 1
        return valoare
    return urmatorul

c = creeaza_contor()
print(c(), c(), c())        # 1 2 3
alt = creeaza_contor(10)
print(alt())                # 11, contor independent

Fără nonlocal, linia valoare += 1 ar arunca UnboundLocalError, pentru că atribuirea ar face valoare locală în urmatorul. Funcția interioară, împreună cu variabila „capturată”, formează o closure.

Observă că doar atribuirea are nevoie de aceste cuvinte-cheie. Modificarea unui obiect mutabil, de exemplu lista.append(x) pe o listă globală, funcționează fără global, pentru că nu legi numele de alt obiect.

În cod real, global este un semnal de alarmă: starea globală modificată din funcții face testarea și concurența dificile. De obicei e mai clar să întorci valori, să folosești o clasă sau o closure cu nonlocal.

Ce urmărește intervievatorul: Verifică înțelegerea scope-urilor și a closures. Un candidat bun spune și de ce global e de evitat, nu doar cum se folosește.

Eroarea, în practică:UnboundLocalError: local variablename is used prior to global declaration

29 Junior

Ce înseamnă că în Python funcțiile sunt „obiecte de primă clasă”? Când folosești lambda, map și filter și când preferi comprehensions?

Răspuns scurt: Funcțiile sunt obiecte ca oricare altele: le poți atribui unor variabile, le poți pune în colecții, le poți transmite ca argumente și întoarce din alte funcții. lambda e utilă pentru funcții scurte de o expresie, dar pentru transformări simple comprehensions sunt de obicei mai lizibile.

Un nume de funcție este doar o variabilă care indică un obiect de tip function. De aceea poți scrie:

PYTHON
def dublu(x):
    return x * 2

operatii = {"dublu": dublu, "patrat": lambda x: x ** 2}
print(operatii["patrat"](4))        # 16

def aplica(func, valori):
    return [func(v) for v in valori]

print(aplica(dublu, [1, 2, 3]))     # [2, 4, 6]

Un dicționar de funcții, ca mai sus, înlocuiește des un lanț lung de if/elif.

lambda creează o funcție anonimă dintr-o singură expresie, fără instrucțiuni (return, atribuiri obișnuite, try). Locul ei natural este ca argument scurt: sorted(cuvinte, key=len) sau key=lambda p: p["pret"]. PEP 8 recomandă să nu atribui un lambda unei variabile; dacă ai nevoie de un nume, folosește def, care dă și mesaje de eroare mai clare.

map și filter întorc în Python 3 iteratori leneși, nu liste:

PYTHON
numere = [1, 2, 3, 4]
print(list(map(str, numere)))                  # ['1', '2', '3', '4']
print([n * n for n in numere if n % 2 == 0])  # [4, 16]

Când ai deja o funcție cu nume (map(str, ...)), map e concis. Când ai nevoie de lambda și de o condiție, comprehension-ul e mai clar și nu adaugă apeluri de funcții suplimentare.

Ce urmărește intervievatorul: Verifică stilul de programare funcțională în Python. Candidații care pun lambda peste tot sau atribuie lambda unor variabile arată că nu cunosc idiomurile.

30 Junior

Ce afișează codul de mai jos? Unde e bug-ul și cum îl corectezi?

PYTHON
class Cos:
    def __init__(self, produse=[]):
        self.produse = produse

a = Cos()
b = Cos()
a.produse.append("mere")
print(b.produse)

Răspuns scurt: Afișează ['mere']. Valoarea implicită [] se creează o singură dată, la definirea funcției, deci toate coșurile create fără argument împart aceeași listă. Corect: produse=None, apoi self.produse = [] if produse is None else list(produse).

Valorile implicite ale parametrilor se evaluează o singură dată, când se execută instrucțiunea def, și se păstrează pe obiectul funcției (Cos.__init__.__defaults__). Orice apel care nu dă argumentul primește exact același obiect. La o listă, care e mutabilă, modificarea făcută prin a se vede prin b. Bug-ul e greu de observat pentru că apare doar când creezi mai multe obiecte fără argument.

Varianta corectă folosește None ca santinelă:

PYTHON
class Cos:
    def __init__(self, produse=None):
        self.produse = [] if produse is None else list(produse)

list(produse) face și o copie, ca un apelant care transmite propria listă să nu fie afectat dacă coșul o modifică ulterior. Dacă vrei ca lista să fie partajată intenționat, documentezi asta.

Dacă folosești @dataclass, modulul te protejează: o valoare implicită list, dict sau set aruncă ValueError: mutable default <class 'list'> for field produse is not allowed: use default_factory. Varianta corectă este:

PYTHON
from dataclasses import dataclass, field

@dataclass
class Cos:
    produse: list[str] = field(default_factory=list)

Unelte de linting precum Ruff sau Pylint semnalează automat valorile implicite mutabile, deci merită activate în proiect.

Ce urmărește intervievatorul: Este una dintre cele mai cunoscute capcane Python, aici într-o clasă. Intervievatorul verifică dacă înțelegi momentul în care se evaluează valorile implicite și dacă știi soluția idiomatică.

31 Junior

Ce întoarce o funcție fără return? Unde e bug-ul?

PYTHON
def total(preturi):
    s = 0
    for p in preturi:
        s += p
    print(s)

cu_tva = total([10, 20]) * 1.19

Răspuns scurt: O funcție fără return întoarce None. Bug-ul: total afișează suma, dar nu o întoarce, deci înmulțirea devine None * 1.19 și aruncă TypeError.

Orice funcție Python întoarce ceva. Dacă execuția ajunge la final fără return, sau la un return gol, valoarea este None. În exemplu se afișează 30, apoi apare TypeError: unsupported operand type(s) for *: 'NoneType' and 'float'.

Diferența dintre print și return este fundamentală:

  • print scrie un text la ieșire, pentru om; programul nu poate folosi rezultatul.
  • return dă valoarea înapoi apelantului, care o poate stoca, combina sau testa.

Versiunea corectă:

PYTHON
def total(preturi):
    return sum(preturi)

cu_tva = total([10, 20]) * 1.19
print(round(cu_tva, 2))   # 35.7

Funcțiile pot întoarce mai multe valori, sub forma unui tuplu care se despachetează:

PYTHON
def min_max(valori):
    return min(valori), max(valori)

mic, mare = min_max([4, 1, 9])

Același tip de bug apare cu metodele care modifică pe loc și întorc None: lista.sort(), lista.append(x), random.shuffle(lista), dict.update(...). Scrierea lista = lista.sort() pierde lista.

O regulă bună de proiectare: funcțiile care calculează ceva întorc rezultatul, iar afișarea se face separat, la marginea programului. Așa le poți testa ușor cu assert.

Ce urmărește intervievatorul: Pare banală, dar mulți începători confundă afișarea cu întoarcerea unei valori. Intervievatorul vrea să vadă că recunoști imediat NoneType în mesajul de eroare.

Eroarea, în practică:'NoneType' object is not subscriptablecannot unpack non-iterable NoneType object

32 Junior

Python transmite argumentele prin valoare sau prin referință? Ce afișează codul?

PYTHON
def modifica(lista):
    lista.append(4)
    lista = [0]
    lista.append(5)

x = [1, 2, 3]
modifica(x)
print(x)

Răspuns scurt: Niciuna dintre variante, în sens clasic: Python transmite referințe către obiecte („call by sharing”). Funcția poate modifica obiectul primit, dar reatribuirea parametrului nu afectează apelantul. Se afișează [1, 2, 3, 4].

La apel, parametrul lista devine un nume nou legat de același obiect ca x. Nu se copiază nimic.

  • lista.append(4) modifică obiectul comun, deci schimbarea se vede și prin x.
  • lista = [0] leagă numele local lista de o listă nouă. x nu este afectat; legătura dintre cele două nume s-a rupt.
  • lista.append(5) modifică lista nouă, care dispare la ieșirea din funcție.

De aceea rezultatul este [1, 2, 3, 4].

Modelul se numește call by sharing sau „pass by object reference”. Diferența față de transmiterea prin referință din C++ este că o funcție nu poate face ca variabila apelantului să indice alt obiect. Diferența față de transmiterea prin valoare este că obiectele mutabile nu sunt copiate.

Pentru obiectele imutabile (numere, șiruri, tupluri), efectul pare a fi transmitere prin valoare, pentru că nu există operații care să le modifice:

PYTHON
def incrementeaza(n):
    n += 1          # creează un int nou, local
    return n

a = 5
incrementeaza(a)
print(a)            # 5

Consecința practică: dacă o funcție trebuie să „schimbe” o valoare imutabilă, o întoarce. Dacă primește o colecție mutabilă și nu ar trebui să o modifice, lucrează pe o copie. Documentează clar când o funcție modifică argumentele (efecte secundare).

Ce urmărește intervievatorul: Verifică modelul de date al lui Python. Răspunsurile „prin referință” sau „prin valoare” fără nuanțe arată că modelul nu e înțeles.

33 Mid

Ce este o closure? Ce afișează codul de mai jos și cum îl corectezi?

PYTHON
functii = [lambda: i for i in range(3)]
print([f() for f in functii])

Răspuns scurt: O closure este o funcție care ține minte variabilele din scope-ul în care a fost definită. Codul afișează [2, 2, 2], pentru că lambda-urile citesc i la apel, nu la creare. Corect: lambda i=i: i.

Când o funcție interioară folosește o variabilă din funcția exterioară, Python nu copiază valoarea, ci păstrează o legătură către variabilă (o „celulă”). Funcția împreună cu aceste celule este o closure:

PYTHON
def multiplicator(factor):
    def inmulteste(x):
        return x * factor
    return inmulteste

triplu = multiplicator(3)
print(triplu(5))                             # 15
print(triplu.__closure__[0].cell_contents)  # 3

Problema din întrebare se numește late binding: toate cele trei lambda-uri se referă la aceeași variabilă i, iar valoarea ei este citită abia când lambda este apelată. La acel moment comprehension-ul s-a terminat și i este 2. Același efect apare cu bucle for normale și cu funcții definite cu def.

Soluții:

PYTHON
functii = [lambda i=i: i for i in range(3)]          # valoare implicită evaluată acum
print([f() for f in functii])                         # [0, 1, 2]

from functools import partial
functii = [partial(lambda i: i, i) for i in range(3)] # leagă valoarea la creare

Varianta cu valoare implicită are un dezavantaj: apelantul poate suprascrie accidental i. partial sau o funcție-fabrică (multiplicator de mai sus) sunt mai explicite.

Bug-ul apare des în practică la callback-uri create în buclă, de exemplu în interfețe grafice sau la programarea unor sarcini, când toate callback-urile ajung să folosească ultimul element.

Ce urmărește intervievatorul: Testează înțelegerea profundă a closures. Mulți candidați se așteaptă la [0, 1, 2] și nu pot explica rezultatul real.

34 Mid

Scrie un decorator cu parametri, @retry(incercari=3), care reîncearcă o funcție când aruncă o excepție. De ce folosești functools.wraps?

Răspuns scurt: Un decorator cu parametri are trei niveluri: funcția care primește parametrii, decoratorul propriu-zis și wrapper-ul. functools.wraps copiază pe wrapper numele, documentația și alte metadate ale funcției originale.

@retry(incercari=5) înseamnă: apelează retry(incercari=5), iar rezultatul (decoratorul) se aplică funcției. De aici cele trei niveluri:

PYTHON
import functools
import time

def retry(incercari=3, pauza=0.5, exceptii=(Exception,)):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(1, incercari + 1):
                try:
                    return func(*args, **kwargs)
                except exceptii:
                    if i == incercari:
                        raise
                    time.sleep(pauza * 2 ** (i - 1))   # backoff exponențial
        return wrapper
    return decorator

@retry(incercari=4, exceptii=(ConnectionError, TimeoutError))
def descarca(url):
    '''Descarcă o resursă.'''
    ...

print(descarca.__name__, descarca.__doc__)   # descarca Descarcă o resursă.

Detalii care contează:

  • raise fără argument, la ultima încercare, re-aruncă excepția originală cu traceback-ul ei.
  • Parametrul exceptii evită reîncercarea pentru erori care nu sunt temporare (de exemplu ValueError); reîncercarea oarbă a oricărei excepții ascunde bug-uri.
  • *args, **kwargs fac wrapper-ul compatibil cu orice semnătură.

Fără functools.wraps, descarca.__name__ ar fi "wrapper", documentația s-ar pierde, iar logurile, stack trace-urile și unelte precum pytest sau generatoarele de documentație ar arăta numele greșit. wraps setează și __wrapped__, prin care poți ajunge la funcția originală, de exemplu în teste.

În producție există biblioteci dedicate, precum tenacity, dar la interviu se cere de obicei implementarea manuală.

Ce urmărește intervievatorul: Verifică stăpânirea decoratorilor dincolo de exemplul simplu. Candidații greșesc des numărul de niveluri sau uită wraps.

35 Mid

Ce înseamnă / și * în semnătura unei funcții? Când sunt utile?

PYTHON
def cauta(text, model, /, sensibil=False, *, maxim=10):
    ...

Răspuns scurt: Parametrii dinaintea lui / sunt doar poziționali (din Python 3.8), iar cei de după * sunt doar keyword-only. Te ajută să controlezi cum e apelată funcția și să poți redenumi parametri fără să strici codul apelanților.

În semnătura din exemplu:

  • text și model sunt positional-only: cauta("abc", "b") merge, cauta(text="abc", model="b") aruncă TypeError.
  • sensibil poate fi dat în ambele moduri.
  • maxim este keyword-only: trebuie scris maxim=5; cauta("abc", "b", True, 5) aruncă TypeError.
PYTHON
cauta("abc", "b", True, maxim=5)       # corect
cauta("abc", "b", sensibil=True)       # corect

De ce keyword-only: argumentele booleene sau numerice fără nume sunt greu de citit la apel. trimite(mesaj, True, False) nu spune nimic, pe când trimite(mesaj, urgent=True, arhivare=False) e clar. Biblioteca standard folosește des acest model, de exemplu sorted(lista, key=..., reverse=True).

De ce positional-only:

  • Poți redenumi parametrul mai târziu fără să strici codul nimănui, pentru că niciun apelant nu folosește numele.
  • Numele nu intră în conflict cu kwargs: într-o funcție def f(nume, /, kwargs) poți primi și f("x", nume="y").
  • Imită funcțiile built-in scrise în C: len(obj, /), divmod(a, b, /).

Un * simplu, fără nume, se poate folosi și fără *args: def conecteaza(host, *, port=443, timeout=5). Pentru o bibliotecă publică, aceste marcaje fac parte din contractul API-ului și merită gândite de la început, pentru că schimbarea lor ulterioară e o modificare incompatibilă.

Ce urmărește intervievatorul: Verifică dacă scrii API-uri gândite pentru cei care le folosesc. Mulți candidați nu au întâlnit / și confundă * cu *args.

Eroarea, în practică:takes 1 positional argument but 2 were givengot an unexpected keyword argument

36 Mid

Ce oferă modulul functools? Arată partial, reduce și memoizarea cu cache pe un exemplu.

Răspuns scurt: partial fixează o parte din argumentele unei funcții, reduce combină elementele unei colecții într-o singură valoare, iar cache și lru_cache memorează rezultatele apelurilor pentru argumente deja văzute.

Câteva unelte din functools care apar des:

PYTHON
from functools import cache, lru_cache, partial, reduce
import operator

din_binar = partial(int, base=2)
print(din_binar("1010"))                        # 10

print(reduce(operator.mul, [1, 2, 3, 4], 1))    # 24, adică ((1*1)*2)*3*4

@cache
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)

print(fib(80))
print(fib.cache_info())

partial creează un obiect apelabil cu unele argumente deja completate. E util pentru callback-uri sau când o funcție cere o funcție cu un singur argument.

reduce aplică o funcție binară cumulativ. A treia valoare (1) este punctul de pornire și evită eroarea pe o listă goală. Pentru cazurile comune există funcții mai clare: sum, math.prod, max, "".join, așa că reduce se folosește rar.

@cache (din Python 3.9) este echivalent cu @lru_cache(maxsize=None): memorează nelimitat. @lru_cache(maxsize=128) păstrează doar cele mai recente rezultate. Fără memoizare, fib(80) recursiv ar face un număr exponențial de apeluri; cu ea, fiecare valoare se calculează o singură dată.

Limitări de reținut:

  • argumentele trebuie să fie hashable; o listă ca argument aruncă TypeError;
  • funcția trebuie să fie pură (același rezultat pentru aceleași argumente, fără efecte secundare);
  • recursivitatea are o limită (implicit în jur de 1000 de niveluri), deci fib(5000) apelat direct dă RecursionError;
  • pe metode, cache-ul ține referințe la self și poate împiedica eliberarea obiectelor.

Mai există cached_property, total_ordering și singledispatch.

Ce urmărește intervievatorul: Verifică familiaritatea cu biblioteca standard și cu memoizarea. Candidații buni menționează condiția ca argumentele să fie hashable și funcția pură.

Eroarea, în practică:reduce() of empty iterable with no initial value

37 Senior

Scrie un decorator implementat ca o clasă, care numără de câte ori e apelată funcția decorată. Ce problemă apare când îl aplici pe o metodă și cum o rezolvi?

Răspuns scurt: Clasa primește funcția în __init__ și o apelează în __call__. Pe o metodă, self nu mai e transmis, pentru că instanța decoratorului nu e descriptor; rezolvi implementând __get__, care leagă obiectul de apel.

Un decorator poate fi orice obiect apelabil. O clasă e utilă când vrei să păstrezi stare și să o expui:

PYTHON
import functools

class Numara:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.apeluri = 0

    def __call__(self, *args, **kwargs):
        self.apeluri += 1
        return self.func(*args, **kwargs)

    def __get__(self, obj, tip=None):
        if obj is None:
            return self
        return functools.partial(self.__call__, obj)

@Numara
def salut(nume):
    return f"Salut, {nume}"

salut("Ana"); salut("Ion")
print(salut.apeluri)          # 2

De ce e nevoie de __get__: funcțiile obișnuite sunt descriptori. Când scrii obj.metoda, Python apelează function.__get__, care produce o metodă legată ce adaugă automat obj ca prim argument. Instanța lui Numara nu are acest comportament în mod implicit, așa că obj.metoda(5) ar apela __call__(5) fără self și ar da TypeError sau un rezultat greșit. Metoda __get__ din exemplu imită legarea: întoarce un apelabil care pune obj în față.

Observații de senior:

  • Contorul este pe funcție, deci partajat între toate instanțele clasei; dacă vrei numărare per obiect, o stochezi pe obj.
  • self.apeluri += 1 nu este atomic între fire de execuție; ai nevoie de un Lock în cod concurent.
  • Un decorator-funcție cu un atribut (wrapper.apeluri = 0) e adesea mai simplu și funcționează direct pe metode.

Întrebarea leagă decoratorii de protocolul descriptorilor, mecanismul prin care funcționează metodele.

Ce urmărește intervievatorul: Întrebare de senior: verifică dacă știi cum devine o funcție metodă legată. Puțini candidați pot explica de ce decoratorul-clasă strică self.

OOP și metode speciale

38 Junior

Ce este self în Python? Ce eroare apare dacă îl uiți și ce face de fapt __init__?

Răspuns scurt: self este instanța pe care se apelează metoda, transmisă automat ca prim argument: obj.metoda() este echivalent cu Clasa.metoda(obj). Dacă îl uiți, primești TypeError: ... takes 0 positional arguments but 1 was given. __init__ inițializează un obiect deja creat.

O clasă este un șablon, iar un obiect este o instanță concretă cu propriile date. Metodele sunt funcții definite în clasă; când le apelezi printr-un obiect, Python transmite obiectul ca prim argument. Numele self e doar o convenție, dar una respectată universal.

PYTHON
class Cont:
    def __init__(self, titular, sold=0):
        self.titular = titular
        self.sold = sold

    def depune(self, suma):
        if suma <= 0:
            raise ValueError("Suma trebuie să fie pozitivă")
        self.sold += suma
        return self.sold

c = Cont("Ana")
c.depune(100)
Cont.depune(c, 50)    # exact același lucru
print(c.sold)         # 150

Dacă scrii def depune(suma):, apelul c.depune(100) transmite de fapt două argumente (c și 100), iar eroarea spune că metoda primește un argument, dar au fost date două. Mesajul pare ciudat până înțelegi că instanța se adaugă automat.

__init__ nu este constructorul în sensul strict. Obiectul este creat de __new__, apoi __init__ primește obiectul gol și îi setează atributele. __init__ trebuie să întoarcă None; dacă întoarce altceva, apare TypeError.

Atributele se creează prin atribuire pe self, oriunde în clasă, dar e bine să le definești pe toate în __init__, ca obiectul să aibă mereu aceeași formă și să fie ușor de citit.

Ce urmărește intervievatorul: Verifică bazele OOP în Python. Intervievatorul vrea să vadă că înțelegi mecanismul, nu doar că scrii self din obișnuință.

Eroarea, în practică:takes 0 positional arguments but 1 was given'Produs' object has no attribute 'pret'

39 Junior

Care este diferența dintre un atribut de clasă și unul de instanță? Ce afișează codul?

PYTHON
class Echipa:
    membri = []
    def adauga(self, nume):
        self.membri.append(nume)

a = Echipa()
b = Echipa()
a.adauga("Ana")
print(b.membri)

Răspuns scurt: Un atribut de clasă este definit în corpul clasei și e partajat de toate instanțele; unul de instanță e setat pe self și aparține fiecărui obiect. Codul afișează ['Ana'], pentru că ambele echipe folosesc aceeași listă.

Când citești self.membri, Python caută întâi în dicționarul instanței (a.__dict__), apoi în clasă și în clasele părinte. Instanțele nu au propriul membri, deci găsesc lista clasei, una singură. append o modifică, iar modificarea se vede prin orice instanță.

Varianta corectă creează lista în __init__:

PYTHON
class Echipa:
    def __init__(self):
        self.membri = []

    def adauga(self, nume):
        self.membri.append(nume)

O nuanță importantă: atribuirea se comportă diferit de modificare.

PYTHON
class Setari:
    tema = "luminoasa"

s1, s2 = Setari(), Setari()
s1.tema = "intunecata"     # creează atribut pe instanță, umbrește clasa
print(s2.tema)             # luminoasa
Setari.tema = "auto"
print(s1.tema, s2.tema)    # intunecata auto

s1.tema = ... nu schimbă clasa, ci adaugă un atribut în s1.__dict__. s2 vede în continuare valoarea clasei, care poate fi schimbată ulterior pentru toate instanțele care nu au propria valoare.

Atributele de clasă sunt potrivite pentru constante și valori comune (TVA = 0.19, limita_maxima = 100) sau pentru un contor intenționat partajat, modificat prin Clasa.contor += 1. Pentru date mutabile per obiect, folosește atribute de instanță.

Ce urmărește intervievatorul: Testează modelul de căutare a atributelor. Bug-ul cu lista partajată apare des în cod real, iar mulți candidați nu știu că atribuirea creează un atribut nou pe instanță.

Eroarea, în practică:'Produs' object has no attribute 'pret'

40 Junior

Care este diferența dintre o metodă de instanță, @classmethod și @staticmethod? Dă un exemplu realist pentru @classmethod.

Răspuns scurt: Metoda de instanță primește obiectul (self), @classmethod primește clasa (cls), iar @staticmethod nu primește nimic implicit. @classmethod se folosește des pentru constructori alternativi, care funcționează corect și în subclase.

PYTHON
from datetime import date

class Persoana:
    def __init__(self, nume, an_nastere):
        self.nume = nume
        self.an_nastere = an_nastere

    def varsta(self):                       # metodă de instanță
        return date.today().year - self.an_nastere

    @classmethod
    def din_text(cls, text):                # constructor alternativ
        nume, an = text.split(",")
        return cls(nume.strip(), int(an))

    @staticmethod
    def an_valid(an):                       # funcție utilitară
        return 1900 <= an <= date.today().year

class Student(Persoana):
    pass

s = Student.din_text("Ana, 2003")
print(type(s).__name__, s.nume)            # Student Ana
print(Persoana.an_valid(1850))              # False
  • Metoda de instanță are nevoie de datele unui obiect concret.
  • @classmethod primește clasa pe care a fost apelată. Pentru că folosește cls(...) și nu Persoana(...), apelul Student.din_text creează un Student. Biblioteca standard folosește același model: dict.fromkeys, datetime.fromisoformat, int.from_bytes.
  • @staticmethod este o funcție obișnuită plasată în clasă din motive de organizare. Nu are acces la instanță sau la clasă. Dacă nu ține logic de clasă, o funcție la nivel de modul este adesea mai potrivită.

Ambele decoratoare pot fi apelate atât pe clasă, cât și pe instanță. O greșeală frecventă este folosirea @staticmethod pentru un constructor alternativ cu numele clasei scris explicit, ceea ce strică moștenirea.

Ce urmărește intervievatorul: Verifică dacă știi când alegi fiecare tip de metodă. Răspunsul bun include argumentul cu subclasele, nu doar diferența de parametri.

41 Junior

Cum funcționează moștenirea și super() în Python? Care e diferența dintre isinstance(obj, Clasa) și type(obj) == Clasa?

Răspuns scurt: O subclasă preia atributele și metodele părintelui și le poate suprascrie; super() apelează implementarea următoare din ierarhie. isinstance acceptă și subclasele, pe când type(obj) == Clasa verifică doar tipul exact.

PYTHON
class Angajat:
    def __init__(self, nume, salariu):
        self.nume = nume
        self.salariu = salariu

    def bonus(self):
        return self.salariu * 0.1

class Manager(Angajat):
    def __init__(self, nume, salariu, echipa):
        super().__init__(nume, salariu)      # inițializează partea comună
        self.echipa = echipa

    def bonus(self):                         # suprascriere (override)
        return super().bonus() + 100 * len(self.echipa)

m = Manager("Ana", 10000, ["Ion", "Dan"])
print(m.bonus())                        # 1200.0
print(isinstance(m, Angajat))           # True
print(type(m) == Angajat)               # False

Dacă uiți super().__init__(...) în subclasă, __init__-ul părintelui nu rulează, iar atributele lui (nume, salariu) lipsesc; primești AttributeError mai târziu, într-un loc greu de legat de cauză.

super() fără argumente funcționează în Python 3 în orice metodă definită în clasă. Nu înseamnă neapărat „părintele direct”, ci clasa următoare în ordinea de rezolvare a metodelor (MRO), ceea ce contează la moștenirea multiplă.

isinstance respectă principiul substituției: un Manager este și un Angajat, deci orice cod care acceptă angajați trebuie să-l accepte. type(x) == Clasa rupe acest principiu și e corect doar în rarele situații în care chiar vrei tipul exact. isinstance acceptă și un tuplu de tipuri: isinstance(x, (int, float)).

În multe cazuri e mai bine să nu verifici deloc tipul și să te bazezi pe duck typing. Pentru ierarhii adânci, compoziția este adesea o alternativă mai flexibilă decât moștenirea.

Ce urmărește intervievatorul: Verifică bazele moștenirii și folosirea corectă a verificărilor de tip. Greșeala tipică este uitarea lui super().__init__.

Eroarea, în practică:isinstance() arg 2 must be a type'super' object has no attribute

42 Junior

Care este diferența dintre __str__ și __repr__? Ce afișează codul?

PYTHON
class Produs:
    def __init__(self, nume, pret):
        self.nume, self.pret = nume, pret
    def __repr__(self):
        return f"Produs({self.nume!r}, {self.pret!r})"
    def __str__(self):
        return f"{self.nume} - {self.pret} lei"

p = Produs("Carte", 45)
print(p)
print([p])
print(f"{p!r}")

Răspuns scurt: __str__ dă o reprezentare prietenoasă pentru utilizator, __repr__ una exactă pentru programator, ideal cod valid care recreează obiectul. Se afișează Carte - 45 lei, [Produs('Carte', 45)] și Produs('Carte', 45).

print(obj) și str(obj) folosesc __str__. repr(obj), REPL-ul, debuggerele și !r în f-strings folosesc __repr__. Dacă o clasă definește doar __repr__, str() îl folosește și pe acela. Invers nu: fără __repr__ primești forma implicită, ceva de tipul <__main__.Produs object at 0x...>.

Rezultatul din mijloc surprinde des: când afișezi o listă, str(lista) construiește textul folosind repr pentru fiecare element. De aceea vezi [Produs('Carte', 45)], nu „Carte - 45 lei”. Același lucru e valabil pentru dicționare, tupluri și seturi.

De ce contează __repr__:

  • în loguri și la depanare vezi imediat ce conține obiectul;
  • !r în implementare pune ghilimele în jurul șirurilor, deci distingi Produs('45', 45) de Produs(45, 45), diferență invizibilă cu str;
  • convenția „poate fi copiat în cod ca să recreeze obiectul” face depanarea mai rapidă.

Practica recomandată: definește mereu __repr__ pentru clasele tale. @dataclass îl generează automat. Adaugă __str__ doar când există o reprezentare clară pentru utilizator, diferită de cea tehnică.

Nu pune date sensibile (parole, tokenuri) în __repr__, pentru că ajunge ușor în loguri și rapoarte de erori.

Ce urmărește intervievatorul: Verifică metodele speciale de bază. Partea cu lista arată dacă știi cum folosesc containerele aceste metode.

Eroarea, în practică:__str__ returned non-string

43 Junior

Cum faci încapsulare în Python? Ce înseamnă _atribut, __atribut și cum folosești @property pentru validare?

Răspuns scurt: Python nu are atribute private reale. _atribut este o convenție („intern, nu atinge”), __atribut declanșează name mangling (devine _Clasa__atribut), iar @property îți permite să validezi sau să calculezi un atribut păstrând sintaxa simplă obj.atribut.

Python se bazează pe convenții, nu pe restricții:

  • _sold: semnalează că atributul e detaliu de implementare. Nu e protejat, dar uneltele și colegii îl tratează ca intern; from modul import * nu importă numele care încep cu _.
  • __sold: Python îl redenumește intern în _Cont__sold. Scopul nu este securitatea, ci evitarea coliziunilor de nume cu subclasele. Accesul obj.__sold din afară dă AttributeError, dar obj._Cont__sold funcționează.

@property transformă o metodă într-un atribut calculat și îți permite să adaugi validare fără să schimbi codul care folosește clasa:

PYTHON
class Termometru:
    def __init__(self, celsius):
        self.celsius = celsius            # trece prin setter

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, valoare):
        if valoare < -273.15:
            raise ValueError("Sub zero absolut")
        self._celsius = valoare

    @property
    def fahrenheit(self):                 # doar citire, calculat
        return self._celsius * 9 / 5 + 32

t = Termometru(20)
print(t.fahrenheit)       # 68.0
t.celsius = -300          # ValueError

Avantajul față de Java: nu scrii getteri și setteri „preventiv”. Începi cu un atribut public simplu, iar dacă mai târziu ai nevoie de validare, îl transformi în property fără să modifici niciun apelant. t.fahrenheit = 5 dă AttributeError, pentru că nu există setter.

Ce urmărește intervievatorul: Verifică dacă știi abordarea Python față de încapsulare. Candidații care vin din Java scriu des get_x()/set_x() sau cred că __x e privat cu adevărat.

Eroarea, în practică:property of object has no setter

44 Mid

De ce clasa de mai jos nu mai poate fi pusă într-un set după ce ai definit __eq__? Cum o corectezi?

PYTHON
class Punct:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

puncte = {Punct(1, 2), Punct(1, 2)}

Răspuns scurt: Când definești __eq__ fără __hash__, Python setează __hash__ = None, deci obiectele devin nehashable și apare TypeError. Corect: definești și __hash__ pe baza acelorași câmpuri, ideal imutabile, și întorci NotImplemented pentru tipuri străine.

Contractul dintre egalitate și hash este: dacă a == b, atunci hash(a) == hash(b). Hash-ul implicit se bazează pe identitate, deci două puncte egale ar avea hash-uri diferite și un set le-ar păstra pe amândouă. Ca să nu încalce contractul în tăcere, Python dezactivează hash-ul când redefinești __eq__.

Versiunea corectă:

PYTHON
class Punct:
    __slots__ = ("_x", "_y")

    def __init__(self, x, y):
        self._x, self._y = x, y

    @property
    def x(self): return self._x

    @property
    def y(self): return self._y

    def __eq__(self, other):
        if not isinstance(other, Punct):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):
        return hash((self.x, self.y))

print(len({Punct(1, 2), Punct(1, 2)}))   # 1
print(Punct(1, 2) == "abc")              # False, fără AttributeError

Puncte importante:

  • Hash-ul trebuie calculat din câmpuri care nu se schimbă. Dacă modifici un obiect după ce l-ai pus într-un set, el rămâne în „compartimentul” vechi și nu mai poate fi găsit.
  • NotImplemented îi spune lui Python să încerce comparația inversă și, în final, să întoarcă False, în loc să arunce excepție la comparația cu alt tip.
  • Cea mai simplă soluție practică este @dataclass(frozen=True), care generează __eq__ și __hash__ corecte și interzice modificarea câmpurilor.

Ce urmărește intervievatorul: Verifică înțelegerea contractului __eq__/__hash__. Candidații de nivel mid trebuie să știe de ce obiectele mutabile nu ar trebui să fie hashable.

Eroarea, în practică:unhashable type: 'list'

45 Mid

Ce generează automat @dataclass? Explică field(default_factory=...), frozen=True și __post_init__.

Răspuns scurt: @dataclass generează din adnotările câmpurilor __init__, __repr__ și __eq__, iar opțional ordonare, hash și __slots__. default_factory creează o valoare implicită nouă pentru fiecare obiect, frozen=True face instanțele imutabile, iar __post_init__ rulează după __init__, pentru validări.

PYTHON
from dataclasses import dataclass, field, asdict

@dataclass(frozen=True, order=True)
class Versiune:
    major: int
    minor: int = 0

@dataclass
class Comanda:
    client: str
    produse: list[str] = field(default_factory=list)
    total: float = 0.0
    nota_interna: str = field(default="", repr=False)

    def __post_init__(self):
        if self.total < 0:
            raise ValueError("Totalul nu poate fi negativ")

c = Comanda("Ana", ["carte"], 45.0)
print(c)                 # Comanda(client='Ana', produse=['carte'], total=45.0)
print(asdict(c))
print(Versiune(1, 2) < Versiune(1, 10))   # True, comparație pe câmpuri, în ordine

Ce se generează: __init__ cu parametrii în ordinea câmpurilor, __repr__ lizibil și __eq__ care compară câmpurile ca tuplu. Cu order=True apar și <, <= etc.

  • default_factory este obligatoriu pentru valori implicite mutabile; altfel primești ValueError, tocmai ca să eviți lista partajată între instanțe.
  • frozen=True face ca atribuirea după creare să arunce FrozenInstanceError și generează __hash__, deci obiectele pot fi chei de dicționar. Imutabilitatea e superficială: o listă din interior tot poate fi modificată.
  • __post_init__ e locul pentru validări și câmpuri derivate. Într-o clasă frozen, câmpurile derivate se setează cu object.__setattr__(self, "camp", valoare).

Din Python 3.10 există slots=True (memorie mai mică) și kw_only=True (parametri doar cu nume). Dataclasses nu validează tipurile la rulare: Comanda(client=123) merge. Pentru validare la rulare a datelor externe se folosesc biblioteci precum pydantic.

Ce urmărește intervievatorul: Verifică dacă scrii clase de date moderne. Intervievatorul urmărește mai ales default_factory și înțelegerea faptului că adnotările nu sunt verificate la rulare.

Eroarea, în practică:non-default argument follows default argumentmutable default for field: use default_factory

46 Mid

Ce afișează codul? Explică ordinea de rezolvare a metodelor (MRO) și rolul lui super() la moștenirea multiplă.

PYTHON
class A:
    def salut(self): print("A")
class B(A):
    def salut(self): print("B"); super().salut()
class C(A):
    def salut(self): print("C"); super().salut()
class D(B, C):
    def salut(self): print("D"); super().salut()

D().salut()
print([k.__name__ for k in D.__mro__])

Răspuns scurt: Afișează D, B, C, A, apoi ['D', 'B', 'C', 'A', 'object']. super() nu înseamnă „părintele meu”, ci următoarea clasă din MRO-ul obiectului, calculat cu algoritmul C3.

Când o clasă moștenește din mai multe clase, Python calculează o listă liniară de clase, MRO (method resolution order), disponibilă în D.__mro__ sau D.mro(). Algoritmul folosit este linearizarea C3, care garantează că:

  • o clasă apare înaintea părinților ei;
  • ordinea părinților din definiție (B înainte de C) e respectată;
  • fiecare clasă apare o singură dată, deci A nu se repetă în problema diamantului.

Pentru D(B, C) rezultă D, B, C, A, object.

super() caută metoda în clasa care urmează după clasa curentă în MRO-ul instanței, nu al clasei în care e scris codul. De aceea super().salut() din B apelează C.salut, deși B nu știe nimic despre C. Abia C ajunge la A. Astfel, fiecare metodă rulează exact o dată.

Acest model se numește moștenire cooperativă și are o cerință: toate clasele din lanț trebuie să apeleze super() și să aibă semnături compatibile. De obicei, în __init__ se acceptă **kwargs și se transmit mai departe:

PYTHON
class Baza:
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

Dacă B ar fi apelat direct A.salut(self), C.salut ar fi fost sărit. Dacă ordinea părinților face linearizarea imposibilă, Python aruncă TypeError la definirea clasei.

În practică, moștenirea multiplă se folosește mai ales pentru mixin-uri, clase mici care adaugă un comportament (JsonMixin, LoggingMixin).

Ce urmărește intervievatorul: Verifică înțelegerea reală a lui super(). Majoritatea candidaților cred că super() din B apelează A.

Eroarea, în practică:Cannot create a consistent MRO'super' object has no attribute

47 Mid

Implementează o clasă Vector 2D care suportă v1 + v2, v * 3, 3 * v și abs(v). Ce rol are NotImplemented?

Răspuns scurt: Definești __add__, __mul__, __rmul__ și __abs__. Când operația nu e suportată pentru tipul celuilalt operand, întorci NotImplemented, ca Python să încerce metoda reflectată a celuilalt operand sau să arunce un TypeError clar.

PYTHON
import math

class Vector:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __eq__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return self.x == other.x and self.y == other.y

    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, scalar):
        if not isinstance(scalar, (int, float)):
            return NotImplemented
        return Vector(self.x * scalar, self.y * scalar)

    __rmul__ = __mul__

    def __abs__(self):
        return math.hypot(self.x, self.y)

v = Vector(3, 4)
print(v + Vector(1, 1), v * 2, 2 * v, abs(v))
# Vector(4, 5) Vector(6, 8) Vector(6, 8) 5.0

La 2 * v, Python încearcă întâi int.__mul__(2, v). int nu știe de Vector și întoarce NotImplemented, așa că Python încearcă metoda reflectată v.__rmul__(2). Fără __rmul__, 2 * v ar arunca TypeError.

NotImplemented (o constantă, nu excepția NotImplementedError) înseamnă „nu știu să fac asta, întreabă-l pe celălalt”. Dacă ai arunca direct o excepție, ai bloca acest mecanism. Dacă ambele părți întorc NotImplemented, Python aruncă un TypeError cu mesaj clar.

Dacă nu definești __iadd__, v += w folosește __add__ și leagă v de un obiect nou, ceea ce e corect pentru un tip imutabil. Supraîncărcarea operatorilor e potrivită când semnificația e evidentă (vectori, bani, matrice); altfel, o metodă cu nume e mai clară.

Ce urmărește intervievatorul: Verifică stăpânirea modelului de date. Diferența dintre NotImplemented și NotImplementedError și necesitatea lui __rmul__ separă candidații care au implementat așa ceva de cei care au doar citit.

48 Mid

Cum faci ca o clasă proprie să funcționeze cu len(), for, in și indexare? Ce înseamnă duck typing?

Răspuns scurt: Implementezi metodele speciale corespunzătoare: __len__, __iter__ (sau __getitem__), __contains__ și __getitem__. Duck typing înseamnă că Python se uită la comportamentul obiectului, adică la metodele pe care le are, nu la tipul sau la clasa din care moștenește.

Funcțiile și instrucțiunile din Python apelează metode speciale: len(x) apelează x.__len__(), x[i] apelează x.__getitem__(i), item in x apelează x.__contains__(item), iar for apelează iter(x), adică x.__iter__().

PYTHON
class Playlist:
    def __init__(self, nume, piese):
        self.nume = nume
        self._piese = list(piese)

    def __len__(self):
        return len(self._piese)

    def __getitem__(self, index):
        rezultat = self._piese[index]
        if isinstance(index, slice):
            return Playlist(self.nume, rezultat)
        return rezultat

    def __iter__(self):
        return iter(self._piese)

    def __contains__(self, piesa):
        return piesa in self._piese

p = Playlist("Drum", ["A", "B", "C"])
print(len(p), p[0], "B" in p, list(p[1:]))   # 3 A True ['B', 'C']
if p:                                        # folosește __len__
    print("nevid")

Câteva reguli de rezervă: dacă lipsește __iter__, for folosește __getitem__ cu indecși 0, 1, 2 până la IndexError; dacă lipsește __contains__, in parcurge obiectul; dacă lipsește __bool__, valoarea de adevăr folosește __len__.

Duck typing („dacă merge ca o rață și măcăne ca o rață, e o rață”): o funcție care primește un iterabil acceptă orice obiect care se poate parcurge, fără să ceară o anumită clasă. json.load acceptă orice obiect cu metoda read, nu doar fișiere.

Pentru a declara explicit intenția poți moșteni din collections.abc.Sequence, care îți cere __getitem__ și __len__ și îți oferă gratuit index, count, __reversed__ și __contains__.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de date și a filozofiei Python. Candidații buni știu că for, in și len sunt doar apeluri de metode speciale.

Eroarea, în practică:object of type 'int' has no len()

49 Mid

Ce face __slots__? Când merită folosit și ce limitări are?

Răspuns scurt: __slots__ declară lista fixă de atribute ale clasei, iar instanțele nu mai au un __dict__. Obții memorie mai mică per obiect și acces ceva mai rapid, dar nu mai poți adăuga atribute noi dinamic, iar moștenirea cere atenție.

În mod normal, fiecare instanță are un dicționar __dict__ în care stochează atributele. Dicționarul este flexibil, dar ocupă memorie. Cu __slots__, atributele sunt stocate în poziții fixe, definite de clasă:

PYTHON
class PunctSimplu:
    def __init__(self, x, y):
        self.x, self.y = x, y

class PunctSlots:
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x, self.y = x, y

p = PunctSlots(1, 2)
p.z = 3            # AttributeError: 'PunctSlots' object has no attribute 'z'

Când merită: când creezi foarte multe instanțe mici (milioane de puncte, noduri de graf, înregistrări citite din fișiere). Măsoară diferența în aplicația ta cu tracemalloc, nu te baza pe estimări. Un efect secundar util: o greșeală de scriere precum p.yy = 5 aruncă eroare în loc să creeze tăcut un atribut nou.

Limitări:

  • nu poți adăuga atribute care nu sunt în listă;
  • referințele slabe (weakref) funcționează doar dacă adaugi "__weakref__" în __slots__;
  • dacă o subclasă nu își definește propriul __slots__, instanțele ei primesc din nou __dict__, iar beneficiul se pierde; subclasa declară doar atributele noi;
  • valorile implicite nu se pot pune ca atribute de clasă cu același nume ca un slot;
  • moștenirea multiplă din două clase cu sloturi nevide dă TypeError.

Din Python 3.10, @dataclass(slots=True) generează automat __slots__ din câmpuri, varianta cea mai comodă în cod modern.

Ce urmărește intervievatorul: Verifică înțelegerea modului în care sunt stocate atributele și preocuparea pentru memorie. Răspunsul bun include limitările, nu doar beneficiul.

Eroarea, în practică:no __dict__ for setting new attributes

50 Senior

Ce este un descriptor? Cum funcționează @property pe dedesubt? Scrie un descriptor reutilizabil care validează că un atribut e pozitiv.

Răspuns scurt: Un descriptor este un obiect, atribut al unei clase, care definește __get__, __set__ sau __delete__ și controlează astfel accesul la atribut. property, metodele legate, classmethod și staticmethod sunt toate implementate ca descriptori.

Când accesezi obj.atribut, Python verifică dacă în clasă există un obiect cu acel nume care are __get__. Dacă da, apelează descriptor.__get__(obj, type(obj)) în loc să întoarcă direct valoarea.

PYTHON
class Pozitiv:
    def __set_name__(self, owner, name):
        self.nume_privat = "_" + name

    def __get__(self, obj, tip=None):
        if obj is None:
            return self                      # acces prin clasă
        return getattr(obj, self.nume_privat)

    def __set__(self, obj, valoare):
        if valoare <= 0:
            raise ValueError(f"{self.nume_privat[1:]} trebuie să fie pozitiv")
        setattr(obj, self.nume_privat, valoare)

class Produs:
    pret = Pozitiv()
    stoc = Pozitiv()

    def __init__(self, pret, stoc):
        self.pret = pret
        self.stoc = stoc

p = Produs(10, 5)
p.stoc = 0          # ValueError: stoc trebuie să fie pozitiv

__set_name__ (din Python 3.6) primește numele atributului, deci același descriptor se refolosește fără să repeți numele.

Ordinea de prioritate contează:

  • Descriptorii de date (cu __set__ sau __delete__) au prioritate față de obj.__dict__. Așa funcționează property: atribuirea trece mereu prin setter.
  • Descriptorii non-date (doar __get__) pot fi umbriți de un atribut din instanță. Funcțiile sunt astfel de descriptori: function.__get__ produce metoda legată care primește self.

property e practic un descriptor de date scris în C, care apelează funcțiile date ca getter și setter. Descriptorii stau la baza ORM-urilor (câmpurile unui model Django sau SQLAlchemy) și a câmpurilor validate.

Ce urmărește intervievatorul: Întrebare de senior despre mecanismele interne ale limbajului. Intervievatorul vrea să audă diferența dintre descriptorii de date și cei non-date și legătura cu metodele.

Eroarea, în practică:property of object has no setter

51 Senior

Care este diferența dintre __new__ și __init__? Ce este o metaclasă și cum poți evita una folosind __init_subclass__?

Răspuns scurt: __new__ creează și întoarce obiectul, iar __init__ îl inițializează după creare. O metaclasă este „clasa unei clase” (implicit type) și controlează cum se construiesc clasele. Pentru cazuri comune, precum înregistrarea automată a subclaselor, __init_subclass__ e mai simplu.

La Clasa(args), Python apelează întâi Clasa.__new__(Clasa, args), care întoarce instanța, apoi instanta.__init__(args). Rar ai nevoie de __new__; cazul clasic este subclasarea unui tip imutabil, unde valoarea trebuie fixată la creare:

PYTHON
class Procent(float):
    def __new__(cls, valoare):
        if not 0 <= valoare <= 100:
            raise ValueError("Procentul trebuie să fie între 0 și 100")
        return super().__new__(cls, valoare)

print(Procent(19.5) / 100)   # 0.195

În __init__ ar fi prea târziu: valoarea unui float nu mai poate fi schimbată.

Clasele sunt și ele obiecte, create de o metaclasă. Implicit aceasta este type: type(int) dă <class 'type'>. O metaclasă proprie poate modifica sau verifica fiecare clasă definită. Așa funcționează ABCMeta și EnumType. Metaclasele sunt însă greu de citit și se combină greu între ele.

Din Python 3.6, __init_subclass__ acoperă cel mai frecvent caz, „fă ceva când cineva moștenește din mine”:

PYTHON
class Exportator:
    registru = {}

    def __init_subclass__(cls, format, **kwargs):
        super().__init_subclass__(**kwargs)
        Exportator.registru[format] = cls

class ExportCSV(Exportator, format="csv"):
    pass

class ExportJSON(Exportator, format="json"):
    pass

print(Exportator.registru)
# {'csv': <class '__main__.ExportCSV'>, 'json': <class '__main__.ExportJSON'>}

Așa obții un sistem simplu de pluginuri fără metaclasă. Regula de senior: decoratori de clasă și __init_subclass__ întâi; metaclasă doar când chiar trebuie să controlezi crearea clasei.

Ce urmărește intervievatorul: Verifică cunoașterea mecanismelor de construire a obiectelor și judecata de a nu folosi unelte complicate fără motiv.

Eroarea, în practică:__init__() should return None

Excepții și context managers

52 Junior

Explică blocurile try, except, else și finally. Ce afișează codul?

PYTHON
def f():
    try:
        return "din try"
    finally:
        print("finally")

print(f())

Răspuns scurt: except rulează la excepție, else doar dacă nu a apărut excepție, iar finally rulează întotdeauna, chiar și la return. Codul afișează finally, apoi din try.

Structura completă:

PYTHON
try:
    fisier = open("date.txt", encoding="utf-8")
except FileNotFoundError:
    print("Fișierul lipsește")
else:
    with fisier:
        print(fisier.read())       # rulează doar dacă open a reușit
finally:
    print("Gata")                  # rulează mereu

De ce există else: vrei ca în try să fie doar codul care poate arunca excepția pe care o tratezi. Dacă ai pune și citirea în try, un FileNotFoundError apărut din alt motiv ar fi prins de același except, ascunzând problema.

finally rulează indiferent cum se iese din try: normal, prin excepție, prin return, break sau continue. În exemplul din întrebare, return "din try" calculează valoarea de întors, apoi rulează finally, care afișează textul, iar abia după aceea funcția întoarce efectiv. De aceea vezi întâi finally.

Capcana periculoasă este un return în finally:

PYTHON
def g():
    try:
        raise ValueError("problemă")
    finally:
        return "ok"

print(g())   # ok, excepția a dispărut

return din finally înlocuiește orice valoare și înghite excepțiile. Din Python 3.14 (PEP 765), un return, break sau continue care iese dintr-un finally produce SyntaxWarning. Folosește finally doar pentru curățenie (închidere de resurse, eliberarea unui lock), iar de cele mai multe ori un with este o alegere mai bună.

Ce urmărește intervievatorul: Verifică ordinea de execuție și înțelegerea rolului fiecărui bloc. Puțini candidați știu că return în finally înghite excepțiile.

Eroarea, în practică:expected 'except' or 'finally' block

53 Junior

De ce este o problemă codul de mai jos? Care este ierarhia excepțiilor în Python?

PYTHON
try:
    proceseaza_comanda(comanda)
except:
    pass

Răspuns scurt: Un except: gol prinde absolut tot, inclusiv KeyboardInterrupt, SystemExit și bug-uri precum NameError, iar pass le ascunde complet. Prinde doar excepțiile pe care știi să le tratezi și loghează-le.

Toate excepțiile moștenesc din BaseException. Sub ea sunt câteva excepții speciale, care nu reprezintă erori de program: KeyboardInterrupt (Ctrl+C), SystemExit (aruncată de sys.exit()) și GeneratorExit. Restul moștenesc din Exception: ValueError, TypeError, KeyError și IndexError (ambele sub LookupError), OSError cu subclasele ei, precum FileNotFoundError și PermissionError, și așa mai departe.

except: fără tip este echivalent cu except BaseException:. Consecințe:

  • programul nu mai poate fi oprit cu Ctrl+C în acea zonă;
  • sys.exit() dintr-o funcție apelată nu mai oprește programul;
  • greșeli de programare (NameError dintr-o variabilă scrisă greșit, AttributeError) sunt ascunse, iar funcția pare că „nu face nimic”.

Varianta corectă tratează doar ce poți trata și lasă restul să se propage:

PYTHON
import logging
logger = logging.getLogger(__name__)

try:
    proceseaza_comanda(comanda)
except StocInsuficient as e:
    notifica_client(comanda, str(e))
except (ConnectionError, TimeoutError):
    logger.warning("Serviciu indisponibil, reîncercăm", exc_info=True)
    pune_in_coada(comanda)

Ordinea blocurilor except contează: Python îl alege pe primul care se potrivește, deci excepțiile specifice se pun înaintea celor generale.

Un except Exception larg este acceptabil la granițele aplicației (bucla principală a unui worker, un handler HTTP), unde vrei să loghezi orice eroare și să continui, dar întotdeauna cu logger.exception(...), nu cu pass.

Ce urmărește intervievatorul: Verifică disciplina în tratarea erorilor. except: pass este unul dintre cele mai criticate tipare în code review și un semnal negativ la interviu.

Eroarea, în practică:catching classes not inheriting BaseException

54 Junior

Cum creezi o excepție proprie? Care este diferența dintre raise, raise e și raise ExceptieNoua(...) from e?

Răspuns scurt: Creezi o clasă care moștenește din Exception. raise gol re-aruncă excepția curentă cu traceback-ul ei original, raise e o re-aruncă din punctul curent, iar raise Noua(...) from e aruncă o excepție nouă și o leagă explicit de cauza originală.

Excepțiile proprii fac erorile din domeniul aplicației explicite și ușor de prins separat:

PYTHON
class ConfigInvalida(Exception):
    '''Configurația aplicației este greșită sau incompletă.'''

def citeste_port(config: dict) -> int:
    try:
        return int(config["port"])
    except KeyError as e:
        raise ConfigInvalida("Lipsește cheia 'port'") from e
    except ValueError as e:
        raise ConfigInvalida(f"Port invalid: {config['port']!r}") from e

Cu from e, traceback-ul afișează ambele excepții, legate de mesajul „The above exception was the direct cause of the following exception”. Cel care citește logul vede atât problema de domeniu, cât și cauza tehnică. Cauza este disponibilă și în atributul __cause__.

raise fără argument, într-un bloc except, re-aruncă exact excepția prinsă, cu traceback-ul complet. Este varianta potrivită când vrei doar să loghezi și să lași eroarea să meargă mai departe:

PYTHON
try:
    salveaza(date)
except OSError:
    logger.exception("Salvare eșuată")
    raise

raise e funcționează și el, dar adaugă linia curentă în traceback, ceea ce îl face puțin mai greu de citit. Nu există motiv să-l preferi.

Recomandări: moștenește din Exception, nu din BaseException; dă nume care se termină în Error sau descriu clar problema; creează o ierarhie mică doar când apelanții chiar trebuie să distingă între cazuri.

Ce urmărește intervievatorul: Verifică dacă știi să păstrezi informația de depanare. Candidații care pierd cauza originală sau aruncă Exception("ceva") generic produc loguri greu de folosit.

Eroarea, în practică:exceptions must derive from BaseExceptionNo active exception to reraise

55 Junior

Ce înseamnă EAFP și LBYL? Care stil e considerat idiomatic în Python și de ce?

Răspuns scurt: EAFP („mai ușor să ceri iertare decât permisiune”) înseamnă să încerci operația și să tratezi excepția. LBYL („privește înainte să sari”) înseamnă să verifici condițiile înainte. În Python, EAFP este considerat idiomatic.

Cele două stiluri pe același exemplu:

PYTHON
# LBYL
if "email" in utilizator and utilizator["email"]:
    trimite(utilizator["email"])

# EAFP
try:
    trimite(utilizator["email"])
except KeyError:
    logger.info("Utilizator fără email")

Argumentele pentru EAFP în Python:

  • Evită condițiile de cursă (TOCTOU, „time of check to time of use”). Codul if os.path.exists(cale): open(cale) poate eșua oricum, dacă fișierul e șters între verificare și deschidere de alt proces. try: open(cale) except FileNotFoundError: tratează corect toate cazurile.
  • Funcționează cu duck typing: încerci să folosești obiectul ca pe un iterabil sau ca pe un fișier, în loc să verifici tipul.
  • În cazul fericit, un try nu costă aproape nimic în CPython; excepțiile costă când chiar apar.

LBYL rămâne mai potrivit când:

  • cazul „negativ” e frecvent; dacă jumătate din chei lipsesc, dict.get sau in e mai clar și mai rapid decât multe excepții;
  • verificarea e ieftină și fără risc de cursă, de exemplu validarea argumentelor unei funcții;
  • operația are efecte secundare parțiale pe care nu le poți anula după ce a eșuat.

Regula importantă la EAFP: blocul try trebuie să fie cât mai mic. Dacă pui zece linii în try și prinzi KeyError, poți ascunde o cheie lipsă dintr-un loc complet diferit.

Ce urmărește intervievatorul: Verifică dacă înțelegi filozofia Python și compromisurile, nu doar dacă știi acronimele. Argumentul cu condiția de cursă arată experiență practică.

Eroarea, în practică:invalid literal for int() with base 10KeyError: 'cheie'

56 Junior

De ce se recomandă with open(...) pentru lucrul cu fișiere? Ce garantează și de ce e bine să specifici encoding?

Răspuns scurt: with garantează închiderea fișierului la ieșirea din bloc, chiar dacă apare o excepție. encoding="utf-8" explicit evită diferențele între sisteme, pentru că encoding-ul implicit depinde de platformă.

Instrucțiunea with folosește protocolul context manager: la intrare se apelează __enter__, iar la ieșire, indiferent de motiv (final normal, return, excepție), se apelează __exit__, care la fișiere închide descriptorul.

PYTHON
with open("comenzi.csv", encoding="utf-8") as f:
    for linie in f:                  # citire linie cu linie, memorie constantă
        proceseaza(linie.rstrip("\n"))
# aici f este închis, chiar dacă proceseaza a aruncat excepție

Fără with, ai nevoie de try/finally ca să închizi fișierul corect. Un fișier rămas deschis poate bloca ștergerea lui pe Windows, poate pierde date scrise în buffer care nu au fost încă salvate pe disc și consumă descriptori, o resursă limitată a sistemului de operare.

Despre encoding: open() fără encoding folosește encoding-ul implicit al sistemului. Pe Linux și macOS este de obicei UTF-8, dar pe Windows poate fi o pagină de cod regională (de exemplu cp1252), iar un fișier cu diacritice citit acolo produce UnicodeDecodeError sau caractere stricate. PEP 686 prevede ca UTF-8 să devină implicit începând cu Python 3.15; până atunci, specifică explicit encoding-ul.

Alte detalii utile:

  • modurile: "r", "w" (suprascrie), "a" (adaugă), "x" (eroare dacă fișierul există), plus "b" pentru binar;
  • newline="" este recomandat când folosești modulul csv;
  • poți deschide mai multe fișiere în același with: with open(a) as sursa, open(b, "w") as dest:;
  • pathlib.Path("f.txt").read_text(encoding="utf-8") e comod pentru fișiere mici.

Ce urmărește intervievatorul: Verifică practici de bază pentru cod robust. Întrebarea despre encoding arată dacă ai rulat cod pe mai multe sisteme de operare.

Eroarea, în practică:No such file or directory'utf-8' codec can't decode byte

57 Mid

Scrie un context manager care măsoară durata unui bloc de cod, în două variante: ca o clasă și cu contextlib.contextmanager. Ce înseamnă dacă __exit__ întoarce True?

Răspuns scurt: Clasa implementează __enter__ și __exit__; varianta cu decorator e o funcție generator cu un singur yield într-un try/finally. Dacă __exit__ întoarce o valoare adevărată, excepția din bloc este suprimată.

Varianta cu clasă:

PYTHON
import time

class Cronometru:
    def __init__(self, eticheta):
        self.eticheta = eticheta

    def __enter__(self):
        self.start = time.perf_counter()
        return self                      # valoarea legată de "as"

    def __exit__(self, exc_type, exc, tb):
        self.durata = time.perf_counter() - self.start
        print(f"{self.eticheta}: {self.durata:.3f}s")
        return False                     # nu suprimăm excepțiile

with Cronometru("import") as c:
    sum(range(1_000_000))
print(c.durata)

Varianta cu contextlib:

PYTHON
from contextlib import contextmanager

@contextmanager
def cronometru(eticheta):
    start = time.perf_counter()
    try:
        yield
    finally:
        print(f"{eticheta}: {time.perf_counter() - start:.3f}s")

Codul dinaintea lui yield ține loc de __enter__, valoarea dată lui yield se leagă de as, iar codul de după ține loc de __exit__. try/finally e esențial: dacă blocul aruncă o excepție, ea apare în generator exact la yield; fără finally, curățenia nu s-ar face.

__exit__ primește tipul, obiectul și traceback-ul excepției (sau None de trei ori). Dacă întoarce True, Python consideră excepția tratată și continuă după bloc. Folosește acest lucru doar intenționat, de exemplu într-un manager care ignoră o anumită eroare (cum face contextlib.suppress). Întoarcerea accidentală a unei valori adevărate ascunde erori.

Clasa e potrivită când managerul are stare sau metode; varianta cu decorator e mai scurtă pentru cazurile simple.

Ce urmărește intervievatorul: Verifică dacă știi să construiești propriile abstracții de gestionare a resurselor. Greșeala frecventă la varianta cu decorator este lipsa lui try/finally.

Eroarea, în practică:does not support the context manager protocol

58 Mid

Cum proiectezi tratarea erorilor într-o aplicație Python cu mai multe straturi (de exemplu API, logică de business, acces la date)? Unde prinzi excepțiile și ce loghezi?

Răspuns scurt: Definești o ierarhie mică de excepții de domeniu, convertești erorile tehnice în excepții de domeniu la granița stratului de date și prinzi excepțiile cât mai sus, la marginea aplicației, unde le transformi în răspunsuri și le loghezi o singură dată, cu traceback.

Un model care funcționează bine:

PYTHON
class AplicatieError(Exception):
    '''Baza tuturor erorilor de domeniu.'''

class ResursaNegasita(AplicatieError):
    pass

class OperatieInterzisa(AplicatieError):
    pass

# stratul de date
def gaseste_comanda(id_comanda):
    rand = db.fetch_one("SELECT ... WHERE id = %s", (id_comanda,))
    if rand is None:
        raise ResursaNegasita(f"Comanda {id_comanda} nu există")
    return rand

# marginea aplicației (handler HTTP, CLI, worker)
def handler(cerere):
    try:
        return raspuns_ok(anuleaza_comanda(cerere.id))
    except ResursaNegasita as e:
        return raspuns(404, str(e))
    except OperatieInterzisa as e:
        return raspuns(403, str(e))
    except Exception:
        logger.exception("Eroare neașteptată la anulare, id=%s", cerere.id)
        return raspuns(500, "Eroare internă")

Principii:

  • Nu prinde ce nu poți trata. Straturile din mijloc lasă excepțiile să treacă; prind doar ca să adauge context (raise ... from e) sau ca să facă o curățenie.
  • Loghează o singură dată, acolo unde decizi ce faci cu eroarea. Logarea la fiecare strat produce același traceback de cinci ori.
  • logger.exception include automat traceback-ul; adaugă identificatorii relevanți (ID comandă, utilizator), dar nu date sensibile.
  • Distinge erorile așteptate de cele neașteptate: o comandă inexistentă e un rezultat normal (loghezi la nivel info sau deloc), o eroare de conexiune la baza de date e o problemă de operare.
  • Nu folosi excepțiile pentru controlul fluxului normal când un rezultat simplu (None, un obiect rezultat) e mai clar.

Ce urmărește intervievatorul: Verifică experiența cu aplicații reale, nu doar sintaxa. Intervievatorul caută principiul „prinde aproape de margine, loghează o dată”.

59 Mid

Ce sunt ExceptionGroup și except* din Python 3.11? Ce afișează codul?

PYTHON
try:
    raise ExceptionGroup("validare", [ValueError("vârstă"), TypeError("nume")])
except* ValueError as eg:
    print("valori:", eg.exceptions)
except* TypeError as eg:
    print("tipuri:", eg.exceptions)

Răspuns scurt: ExceptionGroup grupează mai multe excepții independente apărute simultan, iar except* tratează fiecare tip din grup separat; pot rula mai multe blocuri. Se afișează valori: (ValueError('vârstă'),) și tipuri: (TypeError('nume'),).

Până la Python 3.11, o funcție putea arunca o singură excepție. În cod concurent sau la validări, poți avea însă mai multe erori independente: trei sarcini paralele care eșuează din motive diferite sau mai multe câmpuri invalide într-un formular. ExceptionGroup (PEP 654) le împachetează pe toate.

Sintaxa except* diferă de except normal:

  • fiecare bloc except* extrage din grup excepțiile de tipul lui și primește un sub-grup (eg.exceptions este un tuplu);
  • pot rula mai multe blocuri pentru același grup, câte unul pentru fiecare tip potrivit, de aceea în exemplu se afișează ambele linii;
  • excepțiile care nu se potrivesc cu niciun bloc sunt re-aruncate automat, tot ca grup;
  • nu poți combina except și except* în același try.

Unde le întâlnești în practică: asyncio.TaskGroup (tot din 3.11) aruncă un ExceptionGroup dacă una sau mai multe sarcini eșuează:

PYTHON
import asyncio

async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            tg.create_task(descarca("a"))
            tg.create_task(descarca("b"))
    except* ConnectionError as eg:
        for e in eg.exceptions:
            print("conexiune:", e)

Tot în 3.11 a apărut add_note(), care adaugă context unei excepții fără să o înlocuiești; nota apare în traceback:

PYTHON
try:
    importa_rand(rand)
except ValueError as e:
    e.add_note(f"La rândul {nr} din fișier")
    raise

Ce urmărește intervievatorul: Verifică dacă ești la curent cu Python modern și cu concurența structurată din asyncio. Candidații care lucrează pe versiuni recente le-au întâlnit deja.

60 Mid

Ce unelte din contextlib folosești în practică? Cum deschizi un număr variabil de fișiere, toate închise corect?

Răspuns scurt: Cele mai utile sunt suppress (ignoră explicit o excepție), ExitStack (un număr variabil de context managers, stabilit la rulare), closing (apelează close() la final) și chdir (din 3.11). Pentru un număr variabil de fișiere folosești ExitStack.

ExitStack rezolvă problema în care nu știi dinainte câte resurse vei deschide:

PYTHON
from contextlib import ExitStack

def uneste_fisiere(cai, destinatie):
    with ExitStack() as stiva:
        fisiere = [stiva.enter_context(open(c, encoding="utf-8")) for c in cai]
        with open(destinatie, "w", encoding="utf-8") as out:
            for f in fisiere:
                out.write(f.read())
    # toate fișierele sunt închise aici, în ordine inversă

Dacă deschiderea celui de-al cincilea fișier eșuează, primele patru sunt închise automat. Cu un try/finally manual ar fi trebuit să ții evidența a ce s-a deschis. Poți adăuga și funcții de curățenie oarecare cu stiva.callback(functie, argumente).

Alte unelte:

PYTHON
from contextlib import suppress, closing
import os

with suppress(FileNotFoundError):     # intenția e explicită
    os.remove("temp.lock")

from urllib.request import urlopen
with closing(urlopen("https://example.com")) as r:   # pentru obiecte cu close()
    continut = r.read()

suppress e mai clar decât try/except/pass, dar se aplică doar excepției numite și oprește execuția blocului la prima eroare.

  • contextlib.chdir(cale) (3.11) schimbă temporar directorul curent;
  • redirect_stdout capturează ce se afișează cu print;
  • nullcontext() este un manager care nu face nimic, util când un with este opțional;
  • AsyncExitStack și asynccontextmanager sunt variantele pentru cod asincron.

Aceste unelte reduc mult codul de tip try/finally și fac curățenia resurselor greu de greșit.

Ce urmărește intervievatorul: Verifică cunoașterea bibliotecii standard pentru gestionarea resurselor. ExitStack este răspunsul pe care îl așteaptă un intervievator de nivel mid.

61 Senior

Ce afișează traceback-ul în cazul de mai jos? Care este diferența dintre __context__ și __cause__ și ce face raise ... from None?

PYTHON
def converteste(valoare):
    try:
        return int(valoare)
    except ValueError:
        return int(valoare.replace(",", "."))

converteste("3,5")

Răspuns scurt: Apar două excepții: ValueError pentru "3,5" și apoi o a doua ValueError pentru "3.5", legate de mesajul „During handling of the above exception, another exception occurred”. Aceasta este înlănțuirea implicită (__context__); from e setează __cause__, iar from None ascunde contextul.

Când în timpul tratării unei excepții apare alta, Python nu o pierde pe prima: o atașează automat celei noi în atributul __context__. Traceback-ul afișează ambele, cu fraza „During handling of the above exception, another exception occurred”. În exemplu, int("3.5") aruncă și el ValueError, pentru că int() nu acceptă zecimale; corect ar fi fost float(...).

Există trei variante:

  • implicit (__context__): excepția nouă apare din greșeală în timpul tratării; mesajul sugerează un bug în handler;
  • explicit cu raise Noua() from e (__cause__): spui că excepția nouă e cauzată intenționat de cea veche; mesajul devine „The above exception was the direct cause of the following exception”;
  • raise Noua() from None: setează __suppress_context__ și ascunde excepția originală din traceback.
PYTHON
def citeste_varsta(text):
    try:
        return int(text)
    except ValueError:
        raise ValueError(f"Vârsta trebuie să fie un număr întreg, nu {text!r}") from None

from None e potrivit când excepția originală e un detaliu de implementare care doar ar încurca utilizatorul unei biblioteci. Nu îl folosi în cod intern, unde cauza tehnică ajută la depanare.

Un caz înrudit: dacă o excepție apare în finally sau într-un __exit__, ea o înlocuiește pe cea originală, care rămâne doar în __context__. De aceea codul de curățenie trebuie să fie simplu și să nu arunce excepții; unde e riscant, îl pui în propriul try și loghezi.

Ce urmărește intervievatorul: Întrebare de senior: arată dacă poți citi traceback-uri complexe și dacă proiectezi API-uri cu mesaje de eroare curate.

Eroarea, în practică:could not convert string to float

Iteratori și generatori

Exersează capitolul cu exerciții reale: Curs Python →
62 Junior

Care este diferența dintre un iterabil și un iterator? Ce face, de fapt, o buclă for?

Răspuns scurt: Un iterabil poate produce un iterator prin iter() (are __iter__); un iterator dă elementele pe rând prin next() (are __next__) și aruncă StopIteration la final. for apelează iter() o dată, apoi next() repetat până la StopIteration.

O buclă for x in colectie: este echivalentă cu:

PYTHON
it = iter(colectie)
while True:
    try:
        x = next(it)
    except StopIteration:
        break
    # corpul buclei

Listele, tuplurile, șirurile, dicționarele, seturile și fișierele sunt iterabile. Un iterabil poate fi parcurs de mai multe ori, pentru că fiecare apel iter() creează un iterator nou. Un iterator păstrează poziția curentă și se consumă: după ce a ajuns la final, rămâne epuizat. Iteratorii sunt și ei iterabili (iter(it) întoarce chiar it), de aceea îi poți folosi direct în for.

Un iterator propriu, implementat ca o clasă:

PYTHON
class Numaratoare:
    def __init__(self, start):
        self.curent = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.curent <= 0:
            raise StopIteration
        self.curent -= 1
        return self.curent + 1

print(list(Numaratoare(3)))     # [3, 2, 1]

it = iter([10, 20])
print(next(it), next(it))       # 10 20
print(next(it, "gata"))         # gata, valoare implicită în loc de excepție

În practică rar scrii clase de iteratori, pentru că o funcție generator face același lucru în mai puține linii. Protocolul contează totuși: explică de ce un fișier se parcurge linie cu linie fără să fie încărcat în memorie și de ce un iterator nu poate fi parcurs de două ori.

Ce urmărește intervievatorul: Verifică înțelegerea protocolului de iterare, fundamentul generatorilor. Mulți candidați folosesc termenii ca sinonime.

Eroarea, în practică:'int' object is not iterable'list' object is not an iterator

63 Junior

Ce afișează codul de mai jos? Ce face yield?

PYTHON
def gen():
    print("start")
    yield 1
    print("mijloc")
    yield 2
    print("final")

g = gen()
print("creat")
print(next(g))
print(next(g))

Răspuns scurt: Afișează creat, start, 1, mijloc, 2. Apelul gen() nu rulează corpul funcției, ci creează un generator; fiecare next() rulează codul până la următorul yield, unde execuția se suspendă.

O funcție care conține yield devine o funcție generator. Apelul ei nu execută nimic din corp, ci întoarce un obiect generator, care este un iterator. De aceea primul mesaj afișat este creat, nu start.

La fiecare next(g):

  • execuția continuă de unde a rămas;
  • rulează până la următorul yield;
  • valoarea de după yield este întoarsă apelantului;
  • funcția se oprește acolo, păstrând toate variabilele locale.

Primul next afișează start și întoarce 1. Al doilea afișează mijloc și întoarce 2. Un al treilea next ar afișa final, iar apoi, pentru că funcția se termină, ar arunca StopIteration. Într-un for, această excepție doar oprește bucla.

Diferența față de return: return încheie funcția definitiv și întoarce o singură valoare. yield poate produce o secvență de valori, una câte una, la cerere. Un return valoare într-un generator încheie iterarea, iar valoarea ajunge în StopIteration.value.

Un exemplu practic:

PYTHON
def linii_valide(cale):
    with open(cale, encoding="utf-8") as f:
        for linie in f:
            linie = linie.strip()
            if linie and not linie.startswith("#"):
                yield linie

for l in linii_valide("config.txt"):
    print(l)

Avantajul este evaluarea leneșă: valorile se calculează abia când sunt cerute, deci poți procesa fișiere sau secvențe foarte mari fără să le ții în memorie, iar consumatorul se poate opri oricând.

Ce urmărește intervievatorul: Verifică dacă înțelegi execuția suspendată a generatorilor. Răspunsul greșit tipic pune start înaintea lui creat.

Eroarea, în practică:generator raised StopIteration'generator' object is not subscriptable

64 Junior

Este range un generator? Ce afișează codul?

PYTHON
r = range(0, 10**12, 2)
print(len(r), r[5], 999_999_999_998 in r)
print(r[1:4])
next(r)

Răspuns scurt: Nu: range este o secvență leneșă și imutabilă, nu un iterator. Afișează 500000000000 10 True și range(2, 8, 2), apoi next(r) aruncă TypeError: 'range' object is not an iterator.

Un obiect range stochează doar start, stop și step, deci ocupă aceeași memorie indiferent de dimensiune. Elementele se calculează la cerere. Spre deosebire de un generator, range este o secvență completă:

  • are len(), calculat prin formulă;
  • poate fi indexat (r[5] dă 0 + 5 * 2 = 10) și tăiat (r[1:4] dă un alt range);
  • poate fi parcurs de câte ori vrei, pentru că fiecare iter(r) creează un iterator nou;
  • testul in pentru numere întregi este O(1): Python verifică matematic dacă valoarea e în interval și respectă pasul, fără să parcurgă elementele. Pentru valori de alt tip, de exemplu un float, se face parcurgere.

Pentru că nu e iterator, next(r) aruncă TypeError. Ai nevoie de it = iter(r), apoi next(it).

În Python 2, range construia o listă, iar xrange era varianta leneșă. În Python 3, range a preluat comportamentul lui xrange. De aceea list(range(1012)) ar încerca să creeze o listă enormă, pe când for i in range(1012) începe imediat.

Câteva idiomuri:

PYTHON
for i in range(len(lista) - 1, -1, -1):   # parcurgere inversă după index
    ...
for i in reversed(range(len(lista))):    # varianta mai lizibilă
    ...

Dacă ai nevoie de elemente, nu de indecși, preferă for x in lista sau enumerate(lista) în loc de range(len(lista)).

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre secvențe leneșe și iteratori. Mulți candidați spun că range este generator.

65 Junior

Ce afișează codul și de ce? Cum eviți bug-ul?

PYTHON
patrate = map(lambda x: x * x, [1, 2, 3])
print(list(patrate))
print(list(patrate))
print(4 in patrate)

Răspuns scurt: Afișează [1, 4, 9], apoi [], apoi False. map întoarce un iterator, care se consumă la prima parcurgere. Dacă ai nevoie de valori de mai multe ori, le salvezi într-o listă.

În Python 3, map, filter, zip, reversed, enumerate, expresiile generator, obiectele fișier și majoritatea funcțiilor din itertools întorc iteratori. Un iterator poate fi parcurs o singură dată. Primul list(patrate) îl epuizează; al doilea primește imediat StopIteration și construiește o listă goală. Nu apare nicio eroare, ceea ce face bug-ul greu de observat.

Testul in pe un iterator îl parcurge până găsește elementul, consumând valorile în acest proces. Aici iteratorul e deja gol, deci rezultatul este False.

Un bug real arată de obicei așa:

PYTHON
randuri = (linie.split(",") for linie in fisier)
total = sum(1 for _ in randuri)            # consumă tot
valori = [r[2] for r in randuri]           # listă goală

Soluții:

  • Dacă ai nevoie de date de mai multe ori și încap în memorie, materializează-le o dată: patrate = list(map(...)) sau, mai idiomatic, [x * x for x in valori].
  • Dacă datele sunt mari, fă toate calculele într-o singură parcurgere sau recreează iteratorul (de exemplu o funcție care întoarce un generator nou la fiecare apel).
  • itertools.tee(it, 2) creează doi iteratori independenți, dar ține în memorie elementele consumate de unul și neconsumate de celălalt, deci nu e o soluție pentru date mari parcurse complet.

Când scrii o funcție care primește un parametru „iterabil” și îl parcurge de două ori, documentează că ai nevoie de o colecție sau fă tu list(...) la început.

Ce urmărește intervievatorul: Verifică înțelegerea evaluării leneșe în Python 3. Este un bug frecvent în cod de procesare a datelor, mai ales la cei care au învățat Python 2.

Eroarea, în practică:'generator' object is not subscriptable

66 Mid

Ce face yield from? Scrie un generator care aplatizează recursiv liste imbricate oricât de adânc.

Răspuns scurt: yield from iterabil delegă iterarea către alt iterabil sau generator: produce pe rând toate valorile lui și transmite mai departe send() și throw(). Pentru aplatizare, generatorul se apelează recursiv pe sublistele întâlnite.

Cea mai simplă utilizare înlocuiește o buclă:

PYTHON
def concateneaza(*iterabile):
    for it in iterabile:
        yield from it          # echivalent cu: for x in it: yield x

print(list(concateneaza([1, 2], "ab")))   # [1, 2, 'a', 'b']

Aplatizarea recursivă:

PYTHON
def aplatizeaza(element):
    if isinstance(element, (list, tuple)):
        for sub in element:
            yield from aplatizeaza(sub)
    else:
        yield element

date = [1, [2, [3, [4, 5]]], (6,), 7]
print(list(aplatizeaza(date)))   # [1, 2, 3, 4, 5, 6, 7]

Verificarea folosește tipuri concrete intenționat. Dacă ai verifica „orice iterabil”, un șir ar fi aplatizat în caractere, iar fiecare caracter este tot un șir de lungime 1, deci recursia nu s-ar opri.

Ce face în plus yield from față de bucla simplă:

  • transmite valorile trimise cu send() și excepțiile aruncate cu throw() direct către sub-generator;
  • valoarea dată de return în sub-generator devine valoarea expresiei yield from:
PYTHON
def sub():
    yield 1
    return "rezultat"

def principal():
    r = yield from sub()
    print("sub a întors:", r)

list(principal())    # afișează: sub a întors: rezultat

Mecanismul a stat la baza primelor corutine din asyncio, înainte de async/await (Python 3.5). Pentru structuri foarte adânci, recursivitatea poate atinge limita de recursie; o variantă iterativă cu o stivă explicită o evită.

Ce urmărește intervievatorul: Verifică stăpânirea generatorilor și a recursivității. Detaliul cu șirurile care produc recursie infinită arată atenție la cazuri limită.

67 Mid

Ce funcții din itertools folosești des? De ce codul de mai jos nu grupează corect?

PYTHON
from itertools import groupby
vanzari = [("Cluj", 10), ("Iasi", 5), ("Cluj", 7)]
for oras, grup in groupby(vanzari, key=lambda v: v[0]):
    print(oras, sum(v[1] for v in grup))

Răspuns scurt: groupby grupează doar elementele consecutive cu aceeași cheie, deci afișează Cluj de două ori. Trebuie să sortezi întâi după aceeași cheie. Alte funcții utile: chain, islice, product, combinations, accumulate, pairwise și batched.

Codul afișează Cluj 10, Iasi 5, Cluj 7. groupby funcționează ca uniq din Unix: începe un grup nou de fiecare dată când cheia se schimbă. Varianta corectă:

PYTHON
from itertools import groupby
from operator import itemgetter

vanzari.sort(key=itemgetter(0))
for oras, grup in groupby(vanzari, key=itemgetter(0)):
    print(oras, sum(v[1] for v in grup))     # Cluj 17, Iasi 5

Atenție și la faptul că fiecare grup este un iterator care devine invalid când treci la grupul următor. Dacă vrei să-l păstrezi, îl transformi în listă imediat. Pentru agregări simple, fără sortare, un defaultdict sau un Counter e adesea mai simplu.

Alte funcții folosite des:

PYTHON
from itertools import chain, islice, product, combinations, accumulate, pairwise, batched

list(chain([1, 2], [3]))               # [1, 2, 3]
list(islice(range(100), 2, 10, 3))     # [2, 5, 8], slicing pe orice iterator
list(product("ab", [0, 1]))            # [('a', 0), ('a', 1), ('b', 0), ('b', 1)]
list(combinations([1, 2, 3], 2))       # [(1, 2), (1, 3), (2, 3)]
list(accumulate([1, 2, 3, 4]))         # [1, 3, 6, 10], sume parțiale
list(pairwise([1, 4, 9]))              # [(1, 4), (4, 9)], din 3.10
list(batched(range(5), 2))             # [(0, 1), (2, 3), (4,)], din 3.12

Toate întorc iteratori leneși. count, cycle și repeat produc secvențe infinite, deci le combini cu islice sau zip. batched este foarte util la trimiterea datelor în loturi către un API sau o bază de date. Pe versiuni mai vechi de 3.12 îl implementezi cu islice într-o buclă.

Ce urmărește intervievatorul: Verifică dacă folosești biblioteca standard în loc să reinventezi bucle. Capcana cu groupby nesortat e o întrebare clasică.

68 Mid

Scrie un generator infinit pentru șirul lui Fibonacci și ia primele 10 valori fără să construiești o listă mare. Prin ce diferă o expresie generator de un list comprehension din punct de vedere al memoriei?

Răspuns scurt: Un generator cu while True și yield produce valori la nesfârșit, iar itertools.islice(gen, 10) ia doar primele 10. O expresie generator ocupă memorie mică și constantă, pe când un list comprehension construiește toată lista dintr-odată.

PYTHON
from itertools import islice, takewhile

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print(list(islice(fibonacci(), 10)))
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

print(list(takewhile(lambda x: x < 100, fibonacci())))
# toate valorile sub 100

Bucla infinită nu e o problemă, pentru că generatorul calculează următoarea valoare doar când i se cere. islice se oprește după numărul cerut, iar takewhile la prima valoare care nu respectă condiția. Atenție: list(fibonacci()) sau len() pe un generator infinit nu se termină niciodată (len nici nu e definit pe generatori).

Diferența de memorie:

PYTHON
import sys
lista = [x * x for x in range(1_000_000)]
gen = (x * x for x in range(1_000_000))
print(sys.getsizeof(lista))   # crește proporțional cu numărul de elemente
print(sys.getsizeof(gen))     # mic și constant, indiferent de interval

sys.getsizeof măsoară doar obiectul container, nu și numerele din el, deci diferența reală e și mai mare. Expresia generator nu stochează rezultatele, ci doar starea curentă.

Când folosești fiecare:

  • expresie generator: când consumi valorile o singură dată, mai ales în funcții de agregare: sum(x * x for x in valori), any(...), max(...). Parantezele suplimentare nu sunt necesare când e singurul argument;
  • listă: când ai nevoie de len, indexare, parcurgeri multiple sau sortare.

Generatorii nu sunt automat mai rapizi; pentru colecții mici, o listă e adesea la fel de bună sau chiar mai rapidă.

Ce urmărește intervievatorul: Verifică înțelegerea evaluării leneșe și a costului de memorie. Exercițiul Fibonacci cu generator e frecvent la interviurile de nivel junior-mid.

69 Senior

Ce fac metodele send(), throw() și close() ale unui generator? Scrie un generator care primește valori și întoarce media curentă.

Răspuns scurt: send(valoare) reia generatorul și face ca expresia yield să primească acea valoare, throw() aruncă o excepție în generator în punctul unde e suspendat, iar close() îl oprește aruncând GeneratorExit. Astfel, un generator poate fi o corutină care consumă date.

Un yield poate fi și expresie: valoare = yield rezultat întoarce rezultat apelantului și primește înapoi ce trimite acesta cu send.

PYTHON
def medie_curenta():
    total = 0
    n = 0
    medie = None
    while True:
        valoare = yield medie
        total += valoare
        n += 1
        medie = total / n

m = medie_curenta()
next(m)               # „priming”: rulează până la primul yield
print(m.send(10))     # 10.0
print(m.send(20))     # 15.0
print(m.send(30))     # 20.0
m.close()

Primul next(m) (sau m.send(None)) este obligatoriu: un generator abia creat nu e suspendat la niciun yield, deci nu are unde primi valoarea. m.send(10) direct ar arunca TypeError: can't send non-None value to a just-started generator.

close() aruncă GeneratorExit în generator. Dacă generatorul are try/finally sau un with, curățenia rulează. Un generator nu trebuie să prindă GeneratorExit și să mai facă yield după aceea; în acest caz Python aruncă RuntimeError.

throw(Exceptie) aruncă o excepție în punctul de suspendare. Generatorul o poate trata și continua, sau o lasă să se propage la apelant.

Istoric, acest mecanism (generator-based coroutines, completat cu yield from) a stat la baza programării asincrone în Python. Din 3.5, async def și await creează corutine native, un tip separat, care nu se mai amestecă cu generatorii. Vechiul decorator asyncio.coroutine a fost eliminat în 3.11.

Generatorii cu send apar azi mai rar în cod de aplicație, dar sunt utili pentru pipeline-uri de procesare de tip „push” și pentru a înțelege cum funcționează await.

Ce urmărește intervievatorul: Întrebare de senior despre mecanismele generatorilor. Detaliul cu „priming” și legătura cu async arată înțelegere profundă.

Eroarea, în practică:can't send non-None value to just-started generator

70 Senior

Unde e problema în codul de mai jos? Ce se întâmplă cu fișierul dacă apelantul nu consumă tot generatorul?

PYTHON
def citeste_erori(cale):
    with open(cale, encoding="utf-8") as f:
        for linie in f:
            if "ERROR" in linie:
                yield linie

prima = next(citeste_erori("app.log"))

Răspuns scurt: Fișierul rămâne deschis cât timp generatorul e suspendat, adică până când generatorul este închis sau eliberat din memorie. Momentul exact depinde de implementare, deci consumul parțial poate lăsa resurse deschise. Soluția: închizi explicit generatorul (closing) sau muți gestionarea fișierului la apelant.

După next(...), generatorul este suspendat în interiorul blocului with. Fișierul se închide doar când execuția iese din with, ceea ce se întâmplă în trei situații: generatorul e consumat complet, se apelează close() pe el, sau obiectul generator e distrus.

În CPython, generatorul din exemplu nu mai are nicio referință după linia cu next, deci este distrus imediat prin numărarea referințelor, iar close() se apelează implicit. În PyPy sau în cazul în care generatorul face parte dintr-un ciclu de referințe, momentul poate fi mult mai târziu. Dacă generatorul e păstrat într-o variabilă sau într-un obiect cu durată lungă de viață, fișierul rămâne deschis. Într-un server care face asta la fiecare cerere poți ajunge la eroarea „Too many open files”.

Variante corecte:

PYTHON
from contextlib import closing

with closing(citeste_erori("app.log")) as erori:
    prima = next(erori, None)
# generatorul e închis, deci și fișierul

def filtreaza_erori(linii):          # generatorul nu mai deține resursa
    for linie in linii:
        if "ERROR" in linie:
            yield linie

with open("app.log", encoding="utf-8") as f:
    prima = next(filtreaza_erori(f), None)

A doua variantă este, de obicei, designul mai bun: resursa e deschisă și închisă de cel care îi cunoaște durata de viață, iar generatorul rămâne o transformare pură, ușor de testat cu o listă de șiruri.

Aceeași problemă apare cu conexiuni la baze de date, cursoare și lock-uri ținute în generatori. Într-un generator asincron, folosește contextlib.aclosing (din 3.10).

Ce urmărește intervievatorul: Întrebare de senior: combină generatorii cu gestionarea resurselor. Intervievatorul caută înțelegerea duratei de viață a obiectelor și preferința pentru un design care separă resursa de transformare.

Module, pachete și mediu

71 Junior

Ce face if __name__ == "__main__": și de ce e folosit?

Răspuns scurt: Fiecare modul are variabila __name__, care este "__main__" când fișierul e rulat direct și numele modulului când e importat. Blocul permite ca un fișier să fie atât script executabil, cât și modul importabil, fără să ruleze codul principal la import.

Când rulezi python raport.py, Python setează __name__ = "__main__" pentru acel fișier. Când alt fișier scrie import raport, codul din raport.py se execută integral, de sus până jos, iar __name__ devine "raport".

PYTHON
# raport.py
def genereaza(luna):
    return f"Raport pentru {luna}"

def main():
    import sys
    luna = sys.argv[1] if len(sys.argv) > 1 else "ianuarie"
    print(genereaza(luna))

if __name__ == "__main__":
    main()

Fără această condiție, un import raport (de exemplu dintr-un test) ar rula imediat main(), ar citi argumente din linia de comandă care nu au legătură cu testul și ar afișa text sau, mai rău, ar trimite emailuri ori ar modifica baza de date.

De ce e bine să pui logica într-o funcție main() în loc să scrii codul direct sub if:

  • variabilele rămân locale, nu devin globale ale modulului;
  • poți apela main() din teste sau din alt cod;
  • poți folosi sys.exit(main()) pentru a întoarce un cod de ieșire.

Același mecanism e necesar pe Windows și macOS când folosești multiprocessing: procesele copil importă modulul principal, iar codul care pornește procese trebuie protejat de if __name__ == "__main__":, altfel apare o eroare sau o pornire recursivă de procese.

Pentru pachete, echivalentul este fișierul __main__.py, rulat cu python -m pachet.

Ce urmărește intervievatorul: Este o întrebare de bază, dar intervievatorul vrea să audă motivul (codul de la nivel de modul rulează la import), nu doar „așa se face”.

72 Junior

Care este diferența dintre un modul și un pachet? Ce rol are __init__.py și când apare eroarea „attempted relative import with no known parent package”?

Răspuns scurt: Un modul este un fișier .py; un pachet este un folder de module, de obicei cu un __init__.py. Eroarea apare când rulezi direct un fișier care folosește importuri relative; soluția este să-l rulezi ca modul, cu python -m pachet.modul.

O structură tipică:

magazin/
    __init__.py
    produse.py
    comenzi/
        __init__.py
        servicii.py
main.py

__init__.py se execută la primul import al pachetului. Poate fi gol sau poate expune API-ul public al pachetului:

PYTHON
# magazin/__init__.py
from .produse import Produs
__all__ = ["Produs"]

Așa, utilizatorii scriu from magazin import Produs fără să cunoască structura internă. Din Python 3.3 există și namespace packages, foldere fără __init__.py, dar pentru propriul cod un __init__.py explicit evită surprize.

Importuri absolute și relative, în magazin/comenzi/servicii.py:

PYTHON
from magazin.produse import Produs     # absolut, recomandat de PEP 8
from ..produse import Produs           # relativ, față de pachetul curent
from . import alt_modul                # din același pachet

Importurile relative funcționează doar dacă Python știe în ce pachet se află modulul. Dacă rulezi python magazin/comenzi/servicii.py, fișierul devine __main__, fără pachet părinte, și apare ImportError: attempted relative import with no known parent package. Soluția corectă este să rulezi din folderul rădăcină:

BASH
python -m magazin.comenzi.servicii

Așa, Python încarcă întâi pachetele părinte, iar importurile relative se rezolvă corect. Adăugarea manuală de căi în sys.path din cod pare să rezolve problema, dar o mută în altă parte și face proiectul fragil.

Ce urmărește intervievatorul: Verifică organizarea codului în proiecte reale. Eroarea cu importul relativ e una dintre cele mai frecvente frustrări ale juniorilor.

Eroarea, în practică:attempted relative import with no known parent

73 Junior

Cum gestionezi dependențele unui proiect Python? Care e diferența dintre requirements.txt, pyproject.toml și un fișier lock?

Răspuns scurt: pyproject.toml descrie proiectul și dependențele lui directe, de obicei cu intervale de versiuni. Un fișier lock (sau un requirements.txt generat cu pip freeze) fixează versiunile exacte ale tuturor pachetelor, inclusiv ale celor indirecte, ca instalarea să fie reproductibilă.

Pașii de bază:

BASH
python -m venv .venv
source .venv/bin/activate        # pe Windows: .venv\Scripts\activate
python -m pip install requests
python -m pip freeze > requirements.txt

python -m pip garantează că folosești pip-ul interpretorului activ, nu altul găsit în PATH.

Rolurile fișierelor:

  • pyproject.toml (PEP 518, PEP 621) este standardul modern. Conține numele, versiunea, versiunea minimă de Python și dependențele directe, plus configurarea uneltelor (pytest, ruff, mypy):
TOML
[project]
name = "magazin"
version = "0.1.0"
requires-python = ">=3.11"
dependencies = ["requests>=2.31,<3", "pydantic>=2"]

[project.optional-dependencies]
dev = ["pytest", "ruff"]
  • requirements.txt este o listă simplă pentru pip. Poate fi scrisă manual, cu intervale, sau generată cu pip freeze, caz în care conține versiunile exacte ale tot ce e instalat.
  • Fișierele lock (uv.lock, poetry.lock, sau requirements.txt compilat cu pip-tools) fixează tot arborele de dependențe, adesea cu hash-uri. Garantează că serverul de producție, CI-ul și colegii instalează exact aceleași versiuni.

Regula practică: o bibliotecă declară intervale largi, ca să poată coexista cu alte pachete; o aplicație folosește un lock, ca să fie reproductibilă. Actualizezi lock-ul intenționat, rulezi testele, apoi faci commit.

Folderul .venv nu se pune în Git; se pun pyproject.toml și fișierul lock. Unelte precum uv sau Poetry automatizează tot fluxul.

Ce urmărește intervievatorul: Verifică experiența cu proiecte reale și cu instalări reproductibile. Candidații care instalează pachete global sau nu fixează versiunile au probleme în producție.

Eroarea, în practică:ModuleNotFoundError: No module named

74 Junior

Care este diferența dintre import config și from config import DEBUG? Ce afișează codul și de ce e descurajat from modul import *?

PYTHON
# config.py
DEBUG = False

# main.py
from config import DEBUG
import config
config.DEBUG = True
print(DEBUG, config.DEBUG)

Răspuns scurt: import config leagă numele modulului, iar from config import DEBUG copiază în modulul curent legătura către valoarea de la momentul importului. Codul afișează False True. import * aduce nume necontrolate și face greu de știut de unde vine fiecare nume.

from config import DEBUG creează în main.py un nume nou, DEBUG, legat de același obiect ca config.DEBUG în acel moment, adică False. Atribuirea config.DEBUG = True leagă atributul modulului de alt obiect, dar numele local DEBUG din main.py rămâne legat de False. E aceeași regulă ca la variabilele obișnuite: atribuirea nu modifică alte nume.

Consecințe practice:

  • Dacă un modul are o stare globală care se poate schimba (configurare, un flag), accesează-o prin config.DEBUG, ca să vezi mereu valoarea curentă.
  • La testare cu unittest.mock.patch, trebuie să înlocuiești numele în modulul care îl folosește, nu doar în cel care îl definește, tocmai din acest motiv.

Stiluri de import:

PYTHON
import os.path                     # clar de unde vine fiecare funcție
from datetime import datetime      # comod pentru nume folosite des
import numpy as np                 # alias convențional

from modul import * este descurajat de PEP 8 pentru că:

  • nu știi ce nume au fost aduse și poți suprascrie, fără să-ți dai seama, nume existente (de exemplu un open sau un filter propriu);
  • uneltele de analiză statică și cititorii codului nu mai pot spune de unde vine un nume;
  • o actualizare a modulului poate introduce nume noi care intră în conflict.

Dacă un modul definește __all__, import * aduce doar numele din listă; fără __all__, aduce toate numele care nu încep cu _. Este acceptabil doar în REPL sau în __init__.py, pentru a reexporta un API controlat.

Ce urmărește intervievatorul: Testează dacă înțelegi că importul leagă nume, la fel ca atribuirea. Capcana apare des la configurații globale și la mock-uri în teste.

Eroarea, în practică:'module' object is not callableDid you mean to use 'from ... import ...'?

75 Mid

Cum găsește Python un modul la import? Ce se întâmplă dacă îți denumești fișierul random.py sau email.py?

Răspuns scurt: Python verifică întâi cache-ul sys.modules, apoi caută în ordinea din sys.path, unde primul este folderul scriptului rulat. Un fișier propriu random.py ascunde modulul standard, iar importurile care se bazează pe el eșuează cu erori ciudate.

La import x, pașii sunt:

  • Python verifică sys.modules, un dicționar cu modulele deja încărcate. Dacă x e acolo, întoarce direct obiectul; de aceea codul de la nivelul unui modul rulează o singură dată, indiferent de câte ori e importat.
  • Altfel, caută în ordine în locațiile din sys.path: folderul scriptului rulat (sau folderul curent în REPL și la python -m), apoi căile din variabila PYTHONPATH, biblioteca standard și site-packages al mediului activ.
  • Găsește fișierul, îl execută într-un obiect modul nou și îl pune în sys.modules.
PYTHON
import sys
print(sys.path[0])
import random
print(random.__file__)   # arată ce fișier a fost încărcat de fapt

Dacă ai în proiect un fișier random.py, el apare înaintea bibliotecii standard. Codul tău care face random.randint(...) dă AttributeError: module 'random' has no attribute 'randint'. Mai grav, un modul standard sau o bibliotecă instalată care importă intern random poate primi fișierul tău. Numele periculoase includ random, email, json, logging, test, types, string, queue, calendar și numele bibliotecilor pe care le folosești (requests.py, pandas.py). Din Python 3.13, mesajul de eroare sugerează explicit că un fișier local ascunde modulul standard.

Diagnosticul rapid este print(modul.__file__). După redenumire, șterge și __pycache__.

importlib.reload(modul) re-execută un modul deja încărcat, util în REPL, dar obiectele create anterior rămân legate de vechile clase, deci nu îl folosi ca mecanism în aplicații.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de import și experiența de depanare. Umbrirea unui modul standard este o eroare pe care aproape toți au făcut-o cel puțin o dată.

Eroarea, în practică:ModuleNotFoundError: No module namedmodule 'math' has no attribute

76 Mid

Ce este un import circular? De ce apare eroarea de mai jos și cum o rezolvi?

ImportError: cannot import name 'Client' from partially initialized module 'clienti'
(most likely due to a circular import)

Răspuns scurt: Un import circular apare când modulul A importă B, iar B importă A. Unul e încă pe jumătate executat când celălalt îi cere un nume. Se rezolvă prin restructurare, prin importul modulului în loc de nume sau prin import amânat.

Să presupunem:

PYTHON
# clienti.py
from comenzi import Comanda
class Client:
    def comanda_noua(self):
        return Comanda(self)

# comenzi.py
from clienti import Client
class Comanda:
    def __init__(self, client: Client):
        self.client = client

La import clienti, Python creează modulul în sys.modules și începe să-l execute. Prima linie importă comenzi, care la rândul lui încearcă from clienti import Client. clienti există deja în sys.modules, dar execuția lui s-a oprit la prima linie, deci Client nu e încă definit. De aici mesajul „partially initialized module”.

Soluții, în ordinea preferinței:

  • Restructurează dependențele. Un ciclu indică adesea că două module sunt prea legate. Mută codul comun într-un modul separat (modele.py) sau decide o direcție clară a dependenței.
  • Importă modulul, nu numele: import clienti și folosește clienti.Client în interiorul funcțiilor. Numele se caută abia la apel, când ambele module sunt complet încărcate.
  • Import amânat, în interiorul funcției care are nevoie de el. Funcționează, dar ascunde dependența.
  • Doar pentru type hints, folosește TYPE_CHECKING:
PYTHON
from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from clienti import Client     # importat doar de mypy, nu la rulare

class Comanda:
    def __init__(self, client: Client):
        self.client = client

Cu from __future__ import annotations, adnotările nu sunt evaluate la rulare, deci numele Client nu trebuie să existe atunci. Din Python 3.14, evaluarea amânată a adnotărilor este comportamentul implicit (PEP 649).

Ce urmărește intervievatorul: Verifică experiența cu proiecte mai mari decât un script. Intervievatorul vrea să audă că ciclul e o problemă de design, nu doar un truc de import.

77 Mid

Care este diferența dintre un datetime „naive” și unul „aware”? Cum lucrezi corect cu fusuri orare în Python?

Răspuns scurt: Un datetime naive nu are fus orar atașat, iar unul aware are tzinfo. Stochează și compară momentele în UTC cu obiecte aware, convertește în ora locală doar la afișare și folosește zoneinfo (din Python 3.9) pentru fusuri precum Europe/Bucharest.

Un datetime naive, precum datetime(2026, 3, 29, 3, 30), nu spune în ce fus orar e exprimat. Nu poate fi comparat sau scăzut dintr-unul aware: primești TypeError: can't compare offset-naive and offset-aware datetimes.

PYTHON
from datetime import datetime, timedelta, timezone
from zoneinfo import ZoneInfo

acum_utc = datetime.now(timezone.utc)                # aware, în UTC
bucuresti = ZoneInfo("Europe/Bucharest")
local = acum_utc.astimezone(bucuresti)              # aceeași clipă, altă afișare
print(local.isoformat())

intalnire = datetime(2026, 7, 1, 10, 0, tzinfo=bucuresti)
print(intalnire.utcoffset())                        # 3:00:00, ora de vară

Reguli practice:

  • Stochează în UTC, în baza de date și în loguri. Convertește la ora locală doar când afișezi utilizatorului.
  • Nu folosi datetime.utcnow(): întoarce un obiect naive care doar „arată” ca UTC și este marcat ca depreciat din Python 3.12. Folosește datetime.now(timezone.utc).
  • Folosește zoneinfo.ZoneInfo (bibliotecă standard din 3.9, cu baza de date IANA a sistemului; pe Windows ai nevoie de pachetul tzdata) în loc de offset-uri fixe. +02:00 nu știe de trecerea la ora de vară.
  • Aritmetica pe ore locale are capcane la schimbarea orei: în România, în ultima duminică din martie, ora 3:30 nu există, iar în ultima duminică din octombrie ora 3:30 apare de două ori. Atributul fold distinge cele două apariții.
  • Pentru durate, scade obiecte aware sau lucrează în UTC; timedelta(days=1) adăugat unei ore locale nu înseamnă mereu 24 de ore reale.
  • Pentru schimbul de date, folosește ISO 8601 cu offset (isoformat() și datetime.fromisoformat()).

Ce urmărește intervievatorul: Verifică experiența cu bug-uri reale de dată și oră, care apar în aproape orice aplicație. Mulți candidați nu știu de diferența naive/aware până nu au un bug în producție.

Eroarea, în practică:can't compare offset-naive and offset-aware

78 Senior

Cum structurezi și publici un pachet Python reutilizabil? Ce sunt src layout, wheel-urile și entry points?

Răspuns scurt: Pui codul în src/numele_pachetului, descrii proiectul în pyproject.toml cu un build backend, construiești cu python -m build un wheel și o arhivă sursă, apoi le publici cu twine. Entry points declarate în [project.scripts] creează comenzi în terminal la instalare.

O structură recomandată:

facturare/
    pyproject.toml
    README.md
    src/facturare/__init__.py
    src/facturare/cli.py
    tests/test_calcul.py

src layout înseamnă că pachetul nu stă direct în rădăcina proiectului. Testele nu mai pot importa accidental codul din folderul curent; trebuie să instalezi pachetul (pip install -e .), deci testezi exact ce vor primi utilizatorii și prinzi fișierele uitate din pachet.

pyproject.toml:

TOML
[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "facturare"
version = "1.2.0"
requires-python = ">=3.10"
dependencies = ["httpx>=0.27"]

[project.scripts]
facturare = "facturare.cli:main"

Build backend-ul (hatchling, setuptools, flit, poetry-core etc.) transformă proiectul în distribuții. python -m build produce:

  • un wheel (.whl), un pachet gata construit, instalat rapid prin simpla copiere a fișierelor; pentru cod pur Python este universal;
  • un sdist (.tar.gz), codul sursă, din care se poate construi wheel-ul pe orice platformă.

Entry points: la instalare, pip creează comanda facturare în mediu, care apelează facturare.cli:main. Utilizatorul nu mai rulează python -m ....

Publicarea: twine upload dist/*, mai întâi pe TestPyPI. În CI e recomandat „trusted publishing” cu identitate OIDC în loc de tokenuri salvate.

Aspecte de senior: versionare semantică (o schimbare incompatibilă înseamnă versiune majoră nouă), intervale de dependențe largi pentru biblioteci, un CHANGELOG, marcajul py.typed dacă oferi type hints și testarea pe toate versiunile de Python declarate.

Ce urmărește intervievatorul: Verifică experiența cu distribuirea codului, nu doar cu scrierea lui. Un senior trebuie să poată explica de ce src layout previne o clasă întreagă de erori.

Typing și testare cu pytest

79 Junior

Ce sunt type hints? Ce se întâmplă la rularea codului de mai jos?

PYTHON
def total(preturi: list[float]) -> float:
    return sum(preturi)

print(total(["a", "b"]))

Răspuns scurt: Type hints sunt adnotări citite de unelte precum mypy sau pyright, dar ignorate de interpretor la rulare. Codul pornește și aruncă TypeError abia în sum; un verificator static ar fi semnalat greșeala înainte.

Adnotările sunt stocate pe funcție (total.__annotations__), dar Python nu le verifică. total(["a", "b"]) ajunge în sum, care pornește de la 0 și încearcă 0 + "a", deci apare TypeError: unsupported operand type(s) for +: 'int' and 'str'. Dacă funcția ar fi făcut doar return preturi[0], ar fi întors "a" fără nicio eroare.

De aceea type hints se folosesc împreună cu un verificator static:

BASH
mypy app/
# error: List item 0 has incompatible type "str"; expected "float"

Beneficii reale: erori prinse înainte de rulare, completare automată mai bună în editor, documentație care nu se învechește și refactorizări mai sigure.

Sintaxa modernă depinde de versiune:

PYTHON
def cauta(utilizatori: dict[str, int], nume: str) -> int | None:   # 3.10+
    return utilizatori.get(nume)

from typing import Optional                                          # variantă veche
def cauta_vechi(utilizatori: "dict[str, int]", nume: str) -> Optional[int]:
    return utilizatori.get(nume)
  • list[int], dict[str, int] direct pe tipurile built-in: din 3.9 (înainte: typing.List, typing.Dict);
  • int | None: din 3.10 (înainte: Optional[int] sau Union[int, None]);
  • variabilele se pot adnota și ele: cache: dict[str, bytes] = {}.

Adnotările sunt opționale și se pot adăuga treptat. Codul de la granițe (API-ul public al unui modul, funcțiile care primesc date externe) câștigă cel mai mult. Pentru validare la rulare, de exemplu a datelor JSON primite, folosești biblioteci care citesc adnotările, precum pydantic.

Ce urmărește intervievatorul: Verifică dacă știi că Python nu impune tipurile la rulare. Mulți candidați cred că o adnotare greșită aruncă eroare imediat.

Eroarea, în practică:unsupported operand type(s) for +: 'int' and 'str'

80 Junior

Scrie teste cu pytest pentru o funcție care calculează reducerea dintr-un preț, inclusiv cazul în care procentul este invalid. Cum le rulezi?

Răspuns scurt: Scrii funcții care încep cu test_ într-un fișier test_*.py, folosești assert simplu și pytest.raises pentru excepții, apoi rulezi pytest din rădăcina proiectului.

Codul testat:

PYTHON
# reduceri.py
def aplica_reducere(pret: float, procent: float) -> float:
    if not 0 <= procent <= 100:
        raise ValueError("Procentul trebuie să fie între 0 și 100")
    return round(pret * (1 - procent / 100), 2)

Testele:

PYTHON
# test_reduceri.py
import pytest
from reduceri import aplica_reducere

def test_reducere_normala():
    assert aplica_reducere(200, 25) == 150

def test_fara_reducere():
    assert aplica_reducere(99.99, 0) == 99.99

def test_procent_invalid():
    with pytest.raises(ValueError, match="între 0 și 100"):
        aplica_reducere(100, 120)

Rulare:

BASH
pytest                  # descoperă automat testele
pytest -v               # afișează fiecare test
pytest -k invalid       # doar testele care conțin „invalid” în nume
pytest -x               # se oprește la primul eșec

De ce assert simplu: pytest rescrie instrucțiunile assert din teste și, la eșec, afișează valorile ambelor părți ale comparației, inclusiv diferențele dintre liste sau dicționare. Nu ai nevoie de assertEqual ca în unittest.

pytest.raises verifică atât tipul excepției, cât și, prin match, mesajul (o expresie regulată). Un test fără pytest.raises care așteaptă o excepție ar trece fals dacă excepția nu apare.

Pentru valori float calculate, folosește pytest.approx: assert calcul() == pytest.approx(0.3).

Un test bun verifică un singur comportament, are un nume care descrie scenariul și acoperă cazurile limită: 0, 100, valori negative, șiruri goale. pytest rulează și teste scrise cu unittest, deci poate fi adoptat treptat.

Ce urmărește intervievatorul: Verifică dacă scrii teste din reflex. La nivel junior contează să știi structura de bază, pytest.raises și cazurile limită.

81 Junior

Ce sunt fixtures în pytest? Scrie un fixture care pregătește date de test și face curățenie după test. Ce rol are conftest.py?

Răspuns scurt: Un fixture este o funcție marcată cu @pytest.fixture care pregătește ceva pentru teste; testele îl primesc cerându-l ca parametru. Cu yield, codul de după rulează ca teardown. conftest.py face fixtures disponibile pentru toate testele din folder, fără import.

Fixtures înlocuiesc metodele setUp/tearDown cu un mecanism de injectare a dependențelor:

PYTHON
# conftest.py
import sqlite3
import pytest

@pytest.fixture
def db():
    conn = sqlite3.connect(":memory:")
    conn.execute("CREATE TABLE produse (nume TEXT, pret REAL)")
    conn.execute("INSERT INTO produse VALUES ('carte', 45)")
    yield conn                 # testul rulează aici
    conn.close()               # teardown, chiar dacă testul a eșuat

# test_produse.py
def test_numar_produse(db):
    (n,) = db.execute("SELECT COUNT(*) FROM produse").fetchone()
    assert n == 1

def test_fisier_export(tmp_path):
    cale = tmp_path / "export.csv"
    cale.write_text("nume,pret\n", encoding="utf-8")
    assert cale.read_text(encoding="utf-8").startswith("nume")

Cum funcționează: pytest vede parametrul db, caută un fixture cu acest nume, îl execută și transmite valoarea dată lui yield. Fiecare test primește o bază de date nouă, deci testele nu se influențează între ele.

Scope-ul controlează cât de des se creează fixture-ul: function (implicit, pentru fiecare test), class, module, package, session. O conexiune la un server de test costisitor poate fi scope="session", dar atunci testele trebuie să nu lase date în urmă, de exemplu folosind tranzacții anulate la final.

Fixtures pot depinde de alte fixtures. pytest are și fixtures încorporate utile: tmp_path (folder temporar unic), monkeypatch (înlocuiește temporar atribute și variabile de mediu), capsys (capturează ce se afișează) și caplog (capturează logurile).

conftest.py se încarcă automat; un fișier de la rădăcina folderului tests partajează fixtures în toată suita. pytest --fixtures listează ce e disponibil.

Ce urmărește intervievatorul: Verifică familiaritatea practică cu pytest. Un candidat care a scris teste reale știe de yield pentru teardown și de tmp_path.

82 Junior

Cum rulezi același test pentru mai multe seturi de date în pytest? Scrie un exemplu pentru o funcție care validează coduri poștale.

Răspuns scurt: Folosești @pytest.mark.parametrize cu numele parametrilor și o listă de valori; pytest generează câte un test separat pentru fiecare set. Cu pytest.param(..., id=...) dai nume clare cazurilor.

PYTHON
import re
import pytest

def cod_postal_valid(cod: str) -> bool:
    return re.fullmatch(r"\d{6}", cod) is not None

@pytest.mark.parametrize(
    "cod, asteptat",
    [
        ("400001", True),
        ("010011", True),
        ("40000", False),
        ("4000011", False),
        ("40a001", False),
        pytest.param("", False, id="sir-gol"),
        pytest.param(" 400001", False, id="spatiu-in-fata"),
    ],
)
def test_cod_postal(cod, asteptat):
    assert cod_postal_valid(cod) is asteptat

Rezultatul pytest -v arată fiecare caz ca test separat, de exemplu test_cod_postal[400001-True] sau test_cod_postal[sir-gol]. Dacă un caz eșuează, celelalte rulează în continuare și vezi exact care date au produs problema. Cu o buclă for în interiorul unui singur test, primul eșec ar opri verificarea și n-ai ști câte cazuri sunt afectate.

Detalii utile:

  • re.fullmatch cere ca tot șirul să se potrivească; re.match ar accepta "4000011", pentru că verifică doar începutul. Testele parametrizate prind exact acest tip de bug.
  • Poți pune mai mulți decoratori parametrize pe același test; pytest generează produsul cartezian al combinațiilor.
  • pytest.param(..., marks=pytest.mark.xfail) marchează un caz cunoscut ca eșuând, de exemplu un bug încă nerezolvat.
  • Fixtures pot fi și ele parametrizate (@pytest.fixture(params=[...])), util când vrei să rulezi toate testele pe mai multe configurații, de exemplu pe două baze de date.

Parametrizarea te încurajează să gândești în cazuri limită: valori minime, maxime, goale, cu spații, cu caractere neașteptate.

Ce urmărește intervievatorul: Verifică dacă scrii teste concise și ușor de diagnosticat. Bonus pentru candidații care observă diferența match/fullmatch în exemplu.

83 Mid

Funcția genereaza_raport din app/raport.py folosește from app.api import descarca_date. Cum o testezi fără să faci cereri reale în rețea? Unde aplici patch?

Răspuns scurt: Înlocuiești funcția cu un mock prin unittest.mock.patch sau monkeypatch, dar în locul unde e folosită, adică app.raport.descarca_date, nu app.api.descarca_date. from ... import creează o referință separată în modulul care importă.

Codul testat:

PYTHON
# app/raport.py
from app.api import descarca_date

def genereaza_raport(luna):
    date = descarca_date(luna)
    return {"luna": luna, "total": sum(d["suma"] for d in date)}

Testul:

PYTHON
from unittest.mock import patch
from app.raport import genereaza_raport

def test_raport_aduna_sumele():
    fals = [{"suma": 10}, {"suma": 5}]
    with patch("app.raport.descarca_date", return_value=fals) as mock_desc:
        rezultat = genereaza_raport("mai")
    assert rezultat == {"luna": "mai", "total": 15}
    mock_desc.assert_called_once_with("mai")

De ce app.raport și nu app.api: la import, app/raport.py și-a creat propriul nume descarca_date, legat de funcția originală. patch("app.api.descarca_date") ar înlocui numele din app.api, dar app.raport ar folosi în continuare referința veche și testul ar face cereri reale. Regula din documentație: aplici patch acolo unde numele este căutat, nu unde este definit. Dacă modulul ar fi folosit import app.api și app.api.descarca_date(...), patch-ul pe app.api ar fi funcționat.

Alternativa cu pytest:

PYTHON
def test_raport(monkeypatch):
    monkeypatch.setattr("app.raport.descarca_date", lambda luna: [{"suma": 3}])
    assert genereaza_raport("iunie")["total"] == 3

Pentru excepții folosești side_effect=ConnectionError("timeout"). autospec=True face mock-ul să respecte semnătura funcției reale și prinde apeluri greșite.

Avertisment: prea multe mock-uri fac testele să verifice implementarea în loc de comportament. O alternativă mai curată este injectarea dependenței: funcția primește clientul API ca parametru, iar în test îi dai un obiect fals simplu.

Ce urmărește intervievatorul: Aceasta este cea mai frecventă greșeală la mocking. Intervievatorul verifică dacă știi regula „patch unde e folosit” și dacă poți explica de ce.

84 Mid

Cum scrii o funcție generică cu type hints, de exemplu primul(elemente) care întoarce primul element cu tipul corect? Explică TypeVar, sintaxa din Python 3.12, Callable și diferența dintre Any și object.

Răspuns scurt: Un TypeVar leagă tipul de intrare de cel de ieșire, deci verificatorul știe că primul(list[int]) întoarce int. Din 3.12 poți scrie direct def primul[T](...). Callable[[int], str] descrie o funcție, iar Any dezactivează verificarea, pe când object acceptă orice dar nu permite operații specifice.

Fără generice, ai pierde informația de tip:

PYTHON
from typing import Any

def primul_slab(elemente: list[Any]) -> Any:
    return elemente[0]       # verificatorul nu mai știe ce întoarce

Cu TypeVar, varianta compatibilă cu versiuni mai vechi:

PYTHON
from typing import TypeVar
from collections.abc import Callable, Sequence

T = TypeVar("T")

def primul(elemente: Sequence[T], implicit: T | None = None) -> T | None:
    return elemente[0] if elemente else implicit

x = primul([1, 2, 3])        # verificatorul deduce: int | None

Sintaxa din Python 3.12 (PEP 695), fără declarație separată:

PYTHON
def primul[T](elemente: Sequence[T]) -> T:
    return elemente[0]

class Stiva[T]:
    def __init__(self) -> None:
        self._date: list[T] = []
    def push(self, x: T) -> None:
        self._date.append(x)
    def pop(self) -> T:
        return self._date.pop()

type Transformare = Callable[[str], str]     # alias de tip, tot din 3.12

Callable[[int, str], bool] înseamnă o funcție care primește un int și un str și întoarce bool. Callable[..., bool] acceptă orice argumente.

Any vs object: ambele acceptă orice valoare, dar cu Any verificatorul permite orice operație (x.metoda_inexistenta() trece), iar cu object nu permite nimic specific până nu verifici tipul cu isinstance. object este varianta sigură când chiar accepți orice.

Pentru parametri, preferă tipuri abstracte din collections.abc (Sequence, Iterable, Mapping): funcția devine utilizabilă cu liste, tupluri sau alte colecții, nu doar cu list.

Ce urmărește intervievatorul: Verifică nivelul de stăpânire a sistemului de tipuri. Candidații de nivel mid trebuie să poată scrie o funcție generică și să explice de ce Any e o scăpare.

85 Mid

Ce este typing.Protocol și prin ce diferă de o clasă abstractă (abc.ABC)? Când alegi fiecare variantă?

Răspuns scurt: Protocol descrie o interfață structurală: orice clasă care are metodele cerute e compatibilă, fără să moștenească nimic. ABC e nominal: clasa trebuie să moștenească explicit, iar instanțierea fără metodele abstracte implementate eșuează la rulare.

Clasă abstractă (verificare la rulare, prin moștenire):

PYTHON
from abc import ABC, abstractmethod

class Notificator(ABC):
    @abstractmethod
    def trimite(self, mesaj: str) -> None: ...

class Email(Notificator):
    def trimite(self, mesaj: str) -> None:
        print("email:", mesaj)

Notificator()   # TypeError: Can't instantiate abstract class Notificator ...

Protocol (verificare statică, prin structură, din Python 3.8):

PYTHON
from typing import Protocol, runtime_checkable

@runtime_checkable
class PoateTrimite(Protocol):
    def trimite(self, mesaj: str) -> None: ...

class SMS:                               # nu moștenește nimic
    def trimite(self, mesaj: str) -> None:
        print("sms:", mesaj)

def anunta(canal: PoateTrimite, text: str) -> None:
    canal.trimite(text)

anunta(SMS(), "Comanda a fost livrată")  # valid pentru mypy
print(isinstance(SMS(), PoateTrimite))  # True, datorită @runtime_checkable

Protocol este duck typing formalizat pentru verificatoarele statice.

Când alegi:

  • Protocol când vrei să accepți obiecte din cod pe care nu îl controlezi (clase din biblioteci externe), când vrei interfețe mici și decuplate sau când scrii teste cu obiecte false simple. Interfața o definește consumatorul, nu producătorul.
  • ABC când vrei o ierarhie explicită, să oferi implementări comune (metode concrete în clasa de bază) și să forțezi la rulare implementarea metodelor obligatorii.

Limitare: isinstance cu un protocol runtime_checkable verifică doar existența metodelor, nu și semnăturile sau tipurile. Biblioteca standard folosește ambele: collections.abc.Iterable e un ABC care recunoaște și clasele care doar au __iter__, iar typing definește protocoale precum SupportsInt.

Ce urmărește intervievatorul: Verifică înțelegerea tipării structurale față de cea nominală. Răspunsul bun include criterii de alegere, nu doar definiții.

Eroarea, în practică:Can't instantiate abstract classNotImplementedError

86 Mid

Ai de reprezentat o înregistrare simplă, de exemplu un utilizator citit dintr-un API. Compară dict simplu, TypedDict, NamedTuple și @dataclass. Ce rol au Literal și Final?

Răspuns scurt: TypedDict dă tipuri unui dicționar care rămâne dicționar la rulare, NamedTuple e un tuplu imutabil cu câmpuri numite, iar @dataclass e o clasă completă, cu metode. Literal restrânge valorile la câteva constante, iar Final marchează o valoare care nu trebuie reatribuită.

PYTHON
from dataclasses import dataclass
from typing import Final, Literal, NamedTuple, NotRequired, TypedDict

Rol = Literal["admin", "editor", "cititor"]
LIMITA_PAGINA: Final = 50

class UtilizatorDict(TypedDict):
    id: int
    email: str
    rol: Rol
    telefon: NotRequired[str]        # cheie opțională, din 3.11

class UtilizatorTuplu(NamedTuple):
    id: int
    email: str

@dataclass
class Utilizator:
    id: int
    email: str
    rol: Rol = "cititor"

    def e_admin(self) -> bool:
        return self.rol == "admin"

raw: UtilizatorDict = {"id": 1, "email": "ana@exemplu.ro", "rol": "admin"}
u = Utilizator(**raw)

Cum alegi:

  • TypedDict când datele rămân dicționare: JSON primit sau trimis, argumente **kwargs. Nu are cost la rulare și nu schimbă codul existent, doar îl face verificabil.
  • NamedTuple pentru valori mici, imutabile, care se pot despacheta (id, email = u) și compara ca tupluri; sunt ușoare și hashable.
  • @dataclass pentru obiecte de domeniu care au comportament (metode), valori implicite, validare în __post_init__ sau stare mutabilă.

Literal["admin", "editor", "cititor"] face ca un verificator static să semnaleze rol="superadmin" ca eroare. Pentru seturi de valori folosite în multe locuri, un enum.Enum (sau StrEnum din 3.11) oferă și verificare la rulare.

Final spune verificatorului că valoarea nu trebuie reatribuită; la rulare nu e impus nimic.

Niciuna dintre aceste structuri nu validează datele la rulare. Pentru date externe nesigure ai nevoie de validare explicită sau de o bibliotecă dedicată.

Ce urmărește intervievatorul: Verifică dacă alegi structura potrivită pentru date, nu doar pe cea cunoscută. Candidații de nivel mid trebuie să știe că niciuna nu validează la rulare.

87 Senior

Ce este property-based testing? Scrie un test cu biblioteca Hypothesis. Ce îți spune, și ce nu îți spune, procentul de coverage?

Răspuns scurt: În loc de exemple alese manual, descrii proprietăți care trebuie să fie adevărate pentru orice intrare, iar Hypothesis generează automat intrări, inclusiv cazuri limită, și reduce un eșec la cel mai mic exemplu. Coverage arată ce linii au rulat, nu dacă au fost verificate corect.

PYTHON
from hypothesis import given, strategies as st

def elimina_duplicate(xs):
    return list(dict.fromkeys(xs))

@given(st.lists(st.integers()))
def test_elimina_duplicate(xs):
    rez = elimina_duplicate(xs)
    assert len(rez) == len(set(rez))          # nu mai există duplicate
    assert set(rez) == set(xs)                # nu s-a pierdut nimic
    assert rez == sorted(rez, key=xs.index)   # ordinea primei apariții

@given(st.text())
def test_codificare_dus_intors(s):
    assert s.encode("utf-8").decode("utf-8") == s

Hypothesis generează liste goale, numere foarte mari, negative, șiruri cu caractere Unicode rare. Când un test eșuează, face shrinking: caută cel mai simplu exemplu care încă produce eșecul, de exemplu [0, 0] în loc de o listă cu 40 de elemente aleatoare. Exemplele care au eșuat sunt salvate și rejucate la rulările următoare.

Proprietăți tipice: dus-întors (serializare și deserializare dau originalul), invarianți (sortarea păstrează lungimea și elementele), echivalența cu o implementare simplă și lentă, idempotență (f(f(x)) == f(x)).

Despre coverage (pytest --cov, cu pluginul pytest-cov):

  • spune ce linii, iar cu --cov-branch și ce ramuri, au fost executate;
  • nu spune dacă testele verifică rezultatul; un test fără assert poate da coverage complet;
  • e util pentru a găsi cod netestat deloc, nu ca țintă în sine; o țintă impusă încurajează teste superficiale.

Pentru a măsura calitatea testelor există mutation testing (de exemplu mutmut): unealta introduce modificări mici în cod și verifică dacă testele le detectează.

Ce urmărește intervievatorul: Întrebare de senior despre calitatea testelor. Intervievatorul vrea să vadă că nu confunzi coverage-ul mare cu teste bune.

88 Senior

Cum adnotezi corect un decorator, astfel încât verificatorul de tipuri să păstreze semnătura funcției decorate? Ce sunt ParamSpec, @overload și Self?

Răspuns scurt: Folosești ParamSpec pentru parametri și un TypeVar pentru valoarea întoarsă, ca wrapper-ul să aibă aceeași semnătură ca funcția originală. @overload descrie mai multe semnături pentru aceeași funcție, iar Self (din 3.11) desemnează tipul clasei curente, inclusiv în subclase.

Un decorator adnotat naiv cu Callable[..., Any] șterge toată informația: după decorare, verificatorul nu mai știe ce argumente primește funcția. Cu ParamSpec (din 3.10):

PYTHON
import functools
import logging
from collections.abc import Callable
from typing import ParamSpec, TypeVar

P = ParamSpec("P")
R = TypeVar("R")

def logheaza(func: Callable[P, R]) -> Callable[P, R]:
    @functools.wraps(func)
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
        logging.info("Apel %s", func.__name__)
        return func(*args, **kwargs)
    return wrapper

@logheaza
def aduna(a: int, b: int) -> int:
    return a + b

aduna(1, "2")    # mypy: Argument 2 to "aduna" has incompatible type "str"; expected "int"

În 3.12 poți scrie def logheaza[**P, R](func: Callable[P, R]) -> Callable[P, R]:. Concatenate permite descrierea decoratorilor care adaugă sau elimină un parametru.

@overload se folosește când tipul rezultatului depinde de tipul argumentelor:

PYTHON
from typing import overload

@overload
def citeste(cheie: str, implicit: None = None) -> str | None: ...
@overload
def citeste(cheie: str, implicit: str) -> str: ...
def citeste(cheie, implicit=None):
    return SETARI.get(cheie, implicit)

Variantele cu ... sunt doar pentru verificator; ultima este implementarea reală.

Self rezolvă metodele care întorc instanța curentă, de exemplu în interfețele fluente:

PYTHON
from typing import Self

class Interogare:
    def unde(self, conditie: str) -> Self:
        ...
        return self

Astfel, o subclasă InterogareProduse care apelează unde() primește tot tipul InterogareProduse, nu clasa de bază.

Ce urmărește intervievatorul: Întrebare de senior pentru cei care scriu biblioteci sau cod partajat. Arată dacă poți face typing-ul util în locurile dificile, nu doar pe funcții simple.

GIL, concurență și performanță

Exersează capitolul cu exerciții reale: Curs Python →
89 Junior

Care este diferența dintre concurență și paralelism? Ce variante ai în Python și pe care o alegi pentru descărcarea a 100 de pagini web?

Răspuns scurt: Concurența înseamnă a progresa pe mai multe sarcini alternativ; paralelismul înseamnă a le executa efectiv în același timp, pe mai multe nuclee. Pentru descărcări, care așteaptă mai ales rețeaua, potrivite sunt firele de execuție sau asyncio.

Concurența înseamnă structurarea programului ca să gestioneze mai multe sarcini care se suprapun în timp: în timp ce o sarcină așteaptă un răspuns din rețea, alta continuă. Poate funcționa și pe un singur nucleu. Paralelismul înseamnă execuția simultană, pe mai multe nuclee de procesor.

Distincția importantă este tipul de sarcină:

  • I/O-bound: timpul se pierde așteptând rețeaua, discul sau baza de date. Descărcarea paginilor web intră aici.
  • CPU-bound: timpul se consumă în calcule (procesare de imagini, compresie, algoritmi).

Opțiunile din Python:

  • threading: mai multe fire în același proces. În CPython standard, GIL-ul (Global Interpreter Lock) permite unui singur fir să execute bytecode Python la un moment dat, dar firul eliberează GIL-ul când așteaptă I/O. Deci firele ajută la I/O, nu la calcule.
  • asyncio: un singur fir, o buclă de evenimente care comută între corutine la fiecare await. Eficient pentru foarte multe conexiuni simultane, dar cere biblioteci asincrone (de exemplu httpx sau aiohttp în loc de requests).
  • multiprocessing sau ProcessPoolExecutor: procese separate, fiecare cu propriul interpretor și propriul GIL, deci paralelism real pentru calcule; datele trebuie însă serializate între procese.

Pentru 100 de pagini, cel mai simplu este ThreadPoolExecutor cu un număr limitat de fire și biblioteca obișnuită de HTTP. Dacă aplicația e deja asincronă sau numărul de conexiuni e foarte mare, asyncio e alegerea naturală. Procesele ar adăuga costuri fără beneficiu, pentru că procesorul stă aproape tot timpul.

Indiferent de variantă, limitează numărul de cereri simultane, ca să nu supraîncarci serverul destinație.

Ce urmărește intervievatorul: Verifică dacă înțelegi tipurile de sarcini și alegi unealta potrivită. Greșeala tipică este „folosesc multiprocessing pentru orice e lent”.

90 Mid

Scrie cod care descarcă în paralel o listă de URL-uri folosind concurrent.futures, procesează rezultatele în ordinea terminării și tratează erorile per URL.

Răspuns scurt: Creezi un ThreadPoolExecutor cu un număr limitat de fire, trimiți câte o sarcină pe URL cu submit, apoi parcurgi as_completed; future.result() întoarce rezultatul sau re-aruncă excepția apărută în firul respectiv.

PYTHON
from concurrent.futures import ThreadPoolExecutor, as_completed
from urllib.request import urlopen

def descarca(url: str, timeout: float = 10) -> int:
    with urlopen(url, timeout=timeout) as r:
        return len(r.read())

def descarca_toate(urls: list[str], fire: int = 8) -> dict[str, int]:
    rezultate, erori = {}, {}
    with ThreadPoolExecutor(max_workers=fire) as executor:
        viitoare = {executor.submit(descarca, u): u for u in urls}
        for f in as_completed(viitoare):
            url = viitoare[f]
            try:
                rezultate[url] = f.result()
            except Exception as e:          # eroarea din firul respectiv
                erori[url] = repr(e)
    if erori:
        print(f"{len(erori)} URL-uri au eșuat: {erori}")
    return rezultate

Puncte de discutat:

  • submit întoarce imediat un Future, un obiect care va conține rezultatul. Dicționarul viitoare leagă fiecare future de URL-ul lui.
  • as_completed produce future-urile pe măsură ce se termină, deci poți procesa primele rezultate înainte ca cele lente să fie gata. Dacă vrei ordinea originală, executor.map(descarca, urls) e mai simplu, dar prima excepție apare abia când ajungi la acel rezultat și oprește parcurgerea.
  • Excepțiile dintr-un fir nu dispar, dar nici nu apar singure: sunt stocate în future și re-aruncate la result(). Dacă nu apelezi result(), erorile se pierd tăcut.
  • max_workers limitează paralelismul. Un număr nelimitat de cereri poate fi blocat de server sau poate epuiza conexiunile locale.
  • Timeout-ul pe fiecare cerere e esențial; fără el, un server care nu răspunde blochează un fir pentru mult timp.
  • Blocul with așteaptă terminarea tuturor sarcinilor la ieșire.

Pentru calcule CPU-bound înlocuiești ThreadPoolExecutor cu ProcessPoolExecutor, cu același API; funcția și argumentele trebuie să poată fi serializate.

Ce urmărește intervievatorul: Verifică dacă ai scris cod concurent real. Intervievatorul urmărește tratarea erorilor per sarcină, limitarea paralelismului și timeout-urile.

91 Mid

Ce afișează programul de mai jos și cât durează? Ce se schimbă dacă înlocuiești await asyncio.sleep(1) cu time.sleep(1)?

PYTHON
import asyncio, time

async def sarcina(nume, secunde):
    await asyncio.sleep(secunde)
    return nume

async def main():
    start = time.perf_counter()
    rez = await asyncio.gather(sarcina("a", 1), sarcina("b", 1))
    print(rez, round(time.perf_counter() - start))

asyncio.run(main())

Răspuns scurt: Afișează ['a', 'b'] 1: cele două corutine așteaptă simultan, deci durata totală e de aproximativ o secundă. Cu time.sleep(1) bucla de evenimente este blocată, sarcinile rulează una după alta și durata devine aproximativ două secunde.

async def definește o corutină. Apelul sarcina("a", 1) nu execută nimic, ci creează un obiect corutină. asyncio.run pornește bucla de evenimente, iar asyncio.gather programează corutinele ca sarcini concurente și așteaptă rezultatele, întoarse în ordinea argumentelor.

La await asyncio.sleep(1), corutina îi spune buclei „mă poți suspenda; trezește-mă peste o secundă”. Bucla trece la cealaltă sarcină, care face la fel. Ambele așteptări se suprapun, deci totalul e de o secundă.

time.sleep(1) este o funcție sincronă: blochează întregul fir de execuție, inclusiv bucla de evenimente. Nicio altă corutină nu poate rula în acea secundă. Același efect îl au cererile HTTP cu biblioteci sincrone (requests), drivere de baze de date sincrone sau calcule lungi. Este cea mai frecventă greșeală în cod asincron: totul pare corect, dar nu există concurență.

Soluții când trebuie să apelezi cod blocant:

PYTHON
async def handler():
    return await asyncio.to_thread(functie_blocanta, argument)   # din 3.9

Pentru calcule grele, folosești un ProcessPoolExecutor cu loop.run_in_executor.

Alte reguli:

  • await se poate folosi doar în funcții async;
  • o corutină creată și neașteptată nu rulează deloc, iar Python afișează „coroutine was never awaited”;
  • din 3.11, asyncio.TaskGroup este alternativa recomandată la gather, pentru că anulează celelalte sarcini dacă una eșuează;
  • asyncio.timeout(5) (3.11) pune o limită de timp unui bloc.

Asyncio e potrivit pentru multe operații I/O simultane, cu condiția ca tot lanțul de biblioteci să fie asincron.

Ce urmărește intervievatorul: Verifică înțelegerea modelului cooperativ din asyncio. Blocarea buclei cu cod sincron este greșeala numărul unu la candidații care au doar citit despre async.

92 Mid

Codul de mai jos ar trebui să afișeze 400000. De ce poate afișa mai puțin, deși există GIL? Cum îl corectezi?

PYTHON
import threading

contor = 0

def incrementeaza():
    global contor
    for _ in range(100_000):
        contor += 1

fire = [threading.Thread(target=incrementeaza) for _ in range(4)]
for f in fire: f.start()
for f in fire: f.join()
print(contor)

Răspuns scurt: contor += 1 nu este o operație atomică: înseamnă citire, adunare și scriere, iar un fir poate fi întrerupt între pași, deci unele incrementări se pierd. GIL-ul protejează structurile interne ale interpretorului, nu logica ta. Corectezi cu un threading.Lock.

La nivel de bytecode, contor += 1 se descompune în mai multe instrucțiuni: încarcă valoarea globală, încarcă constanta 1, adună, salvează rezultatul. GIL-ul garantează că un singur fir execută bytecode la un moment dat, dar interpretorul poate comuta între fire între oricare două instrucțiuni. Scenariul problematic:

  • firul A citește contor = 10;
  • interpretorul comută la firul B, care citește tot 10, adună și scrie 11;
  • firul A își reia lucrul, adună 1 la valoarea citită anterior și scrie tot 11.

O incrementare s-a pierdut. Aceasta este o condiție de cursă (race condition). În funcție de versiunea de Python și de momentul în care se face comutarea, codul poate afișa 400000 de multe ori și doar uneori mai puțin, ceea ce face bug-ul și mai periculos. Pe un build free-threaded (fără GIL), pierderile sunt și mai probabile.

Corectarea cu un lock:

PYTHON
lock = threading.Lock()

def incrementeaza():
    global contor
    for _ in range(100_000):
        with lock:
            contor += 1

with lock garantează că un singur fir execută secțiunea critică. Lock-ul are un cost, așa că o variantă mai eficientă este ca fiecare fir să numere local și să adune o singură dată la final, sub lock.

Alternative care evită starea partajată:

  • queue.Queue, thread-safe, pentru comunicarea între fire (model producător-consumator);
  • ThreadPoolExecutor cu funcții care întorc rezultate, adunate apoi de firul principal.

Câteva operații pe obiecte built-in, precum list.append, sunt în practică atomice în CPython, dar nu te baza pe asta pentru operații compuse de tipul citește-modifică-scrie.

Ce urmărește intervievatorul: Verifică înțelegerea corectă a GIL-ului. Mulți candidați cred că GIL-ul face codul cu fire automat sigur.

93 Senior

Un endpoint sau un script Python e lent. Cum găsești cauza și cum îl optimizezi? Ce unelte folosești?

Răspuns scurt: Măsori înainte să optimizezi: cProfile pentru a vedea unde se duce timpul, timeit pentru a compara variante mici, py-spy pentru procese care rulează deja în producție. Apoi atacă întâi algoritmul și I/O-ul, nu micro-optimizările.

Pașii pe care îi urmez:

  • Reproduc și măsor. Stabilesc un caz reprezentativ și un timp de referință, ca să știu dacă o schimbare ajută.
  • Profilez.
BASH
python -m cProfile -s cumulative script.py | head -30
python -m cProfile -o profil.out script.py     # pentru analiză ulterioară

cumulative arată timpul total petrecut într-o funcție, inclusiv în funcțiile apelate de ea; tottime arată doar timpul propriu. Rezultatul salvat poate fi vizualizat cu unelte precum snakeviz. Pentru un proces care rulează deja, py-spy top --pid ... sau py-spy record arată unde stă procesul fără să-l oprești sau să-i modifici codul, util în producție.

  • Identific tipul problemei. De multe ori timpul nu e în Python, ci în I/O: interogări SQL repetate în buclă (problema N+1), apeluri HTTP secvențiale, citiri de fișiere multiple.
  • Optimizez în ordinea câștigului:
  • algoritm și structuri de date: căutări în listă înlocuite cu set sau dict, sortări repetate eliminate;
  • I/O: interogări grupate, cache, concurență pentru apeluri de rețea;
  • funcții built-in și biblioteci scrise în C (sum, sorted, str.join, collections) în loc de bucle manuale;
  • abia la final micro-optimizări, verificate cu timeit:
PYTHON
import timeit
print(timeit.timeit("x in s", setup="s = set(range(10_000)); x = 9_999", number=100_000))
  • Verific că rezultatul e identic (teste) și că timpul s-a îmbunătățit pe cazul de referință.

Dacă rămâne CPU-bound după toate acestea, opțiunile sunt multiprocessing, biblioteci numerice vectorizate, extensii în C/Rust sau Cython ori o altă implementare, precum PyPy.

Ce urmărește intervievatorul: Întrebare de senior despre metodă: intervievatorul vrea să audă „măsor întâi”. Candidații care încep cu micro-optimizări ghicite pierd timp pe lucruri care nu contează.

94 Senior

Ce este build-ul „free-threaded” de Python (PEP 703)? Ce s-a schimbat în 3.13 și 3.14 și ce implicații are pentru codul tău?

Răspuns scurt: Este o variantă a CPython fără GIL, în care firele de execuție pot rula bytecode Python cu adevărat în paralel. A apărut experimental în 3.13 și a devenit variantă oficial suportată, dar opțională, în 3.14. Build-ul standard are în continuare GIL.

GIL-ul simplifică implementarea CPython și a extensiilor în C, dar împiedică firele să folosească mai multe nuclee pentru cod Python. PEP 703 a propus un CPython în care GIL-ul poate fi eliminat.

Starea pe versiuni:

  • 3.13: build experimental separat, de obicei instalat ca python3.13t. Nu e implicit. Poți verifica din cod cu sys._is_gil_enabled().
  • 3.14: build-ul free-threaded devine oficial suportat (PEP 779), dar rămâne opțional, alături de build-ul cu GIL, care este cel implicit.

Implicații practice:

  • Codul cu fire pentru sarcini CPU-bound poate obține paralelism real, fără costul proceselor separate.
  • Condițiile de cursă devin mai vizibile. Cod care „mergea” datorită GIL-ului (incrementări neprotejate, verificări urmate de acțiuni) se strică mai des. Sincronizarea corectă cu Lock, Queue sau structuri imutabile devine obligatorie.
  • Extensiile în C trebuie să declare explicit că suportă modul fără GIL; dacă importi o extensie care nu declară asta, interpretorul reactivează GIL-ul și afișează un avertisment. Ecosistemul se adaptează treptat, deci verifici dependențele.
  • Performanța pe un singur fir e ceva mai slabă decât pe build-ul standard; măsoară pe aplicația ta înainte să decizi.

O direcție paralelă sunt subinterpretoarele: din 3.14, modulul concurrent.interpreters (PEP 734) și InterpreterPoolExecutor permit mai multe interpretoare izolate în același proces, fiecare cu propriul GIL.

Pentru majoritatea aplicațiilor, recomandarea rămâne: asyncio sau fire pentru I/O, procese pentru calcule, iar free-threading de testat acolo unde paralelismul pe fire aduce un câștig măsurabil.

Ce urmărește intervievatorul: Verifică dacă ești la curent cu evoluția limbajului. Un senior ar trebui să știe ce înseamnă pentru siguranța codului existent, nu doar că „GIL-ul dispare”.

95 Senior

Memoria unui serviciu Python crește continuu până când procesul este repornit. Cum investighezi o scurgere de memorie și care sunt cauzele tipice?

Răspuns scurt: Compari instantanee de memorie cu tracemalloc ca să vezi ce linii de cod alocă tot mai mult și cauți obiecte care se acumulează. Cauze tipice: cache-uri sau liste globale fără limită, lru_cache pe metode, referințe păstrate în closures sau handlere și extensii native.

În Python, „scurgerea” înseamnă de obicei că obiectele rămân accesibile din greșeală, nu că memoria nu se eliberează. Pași:

  • Confirm tiparul. Urmăresc memoria procesului în timp (metrici de monitorizare). O creștere care se stabilizează poate fi normală; una liniară, proporțională cu numărul de cereri, indică o acumulare.
  • Folosesc tracemalloc, din biblioteca standard:
PYTHON
import tracemalloc

tracemalloc.start(25)                  # păstrează 25 de cadre de stivă
inainte = tracemalloc.take_snapshot()
# ... rulează de multe ori operația suspectă ...
dupa = tracemalloc.take_snapshot()
for stat in dupa.compare_to(inainte, "lineno")[:10]:
    print(stat)

Rezultatul arată ce linii de cod au alocat cel mai mult între cele două momente.

  • Caut obiectele acumulate: gc.get_objects() numărate pe tip, sau unelte precum objgraph, care arată lanțul de referințe ce ține un obiect în viață.

Cauze frecvente:

  • dicționare sau liste la nivel de modul folosite drept cache, fără limită sau expirare;
  • @lru_cache sau @cache pe metode: cache-ul ține referințe la self, deci obiectele nu sunt eliberate niciodată, iar maxsize=None crește la nesfârșit;
  • handlere, callback-uri sau observatori înregistrați și niciodată dezabonați;
  • excepții sau traceback-uri păstrate în variabile, care țin în viață toate cadrele de stivă și variabilele lor locale;
  • thread-uri sau sarcini asyncio create și niciodată terminate;
  • extensii în C sau biblioteci native, unde memoria nu apare în tracemalloc; acolo ajută uneltele de sistem.

Fragmentarea alocatorului poate face ca memoria procesului să nu scadă chiar după eliberarea obiectelor. Soluția pe termen scurt este repornirea periodică a worker-ilor (de exemplu opțiunea max_requests din Gunicorn), dar cauza trebuie găsită.

Ce urmărește intervievatorul: Întrebare de senior cu caracter operațional. Intervievatorul caută o metodă de investigație și cunoașterea cauzelor reale, nu ghicitul.

Situații practice

96 Junior

Primești la interviu o problemă de cod live în Python. Cum o abordezi de la citirea enunțului până la soluția finală?

Răspuns scurt: Clarific enunțul și cazurile limită, spun cu voce tare o soluție simplă și complexitatea ei, scriu cod curat și idiomatic, îl testez manual pe câteva exemple și abia apoi optimizez, explicând compromisurile.

Un model de răspuns structurat, pe care îl poți aplica la orice exercițiu:

  • Clarific. Repet problema cu cuvintele mele și întreb despre intrări: pot fi goale? pot conține duplicate sau valori negative? cât de mari sunt? ce întorc dacă nu există soluție? Intervievatorii apreciază întrebările, pentru că așa lucrezi și în echipă.
  • Dau un exemplu mic. Scriu un caz de intrare și rezultatul așteptat, ca să verific că am înțeles corect.
  • Propun întâi o soluție simplă. Chiar dacă e O(n²), o spun și îi precizez complexitatea. Apoi caut îmbunătățirea, de obicei cu un dict sau un set, sortare ori doi indecși.
  • Scriu cod idiomatic. Nume clare, funcții mici, enumerate, zip, comprehensions, biblioteca standard (collections.Counter, heapq, bisect, itertools). Folosirea uneltelor potrivite din Python arată experiență. Pot adăuga type hints ca să fie clar contractul funcției.
  • Gândesc cu voce tare. Explic de ce aleg o structură de date. Dacă mă blochez, spun ce încerc; intervievatorul poate da un indiciu doar dacă știe unde sunt.
  • Testez. Parcurg codul manual pe exemplul inițial și pe cazurile limită (listă goală, un singur element, valori egale). Dacă am un editor, scriu câteva assert-uri.
  • Închei cu analiza. Complexitatea de timp și memorie, ce aș schimba pentru date foarte mari, ce teste aș adăuga în cod real.

Greșeli de evitat: să scriu cod imediat, fără să clarific problema; să tac minute întregi; să optimizez prematur o soluție pe care încă nu o am; să ignor un indiciu dat de intervievator.

Ce urmărește intervievatorul: Intervievatorul evaluează procesul la fel de mult ca rezultatul: comunicarea, clarificarea cerințelor și testarea. Mulți candidați buni tehnic pierd puncte pentru că lucrează în tăcere.

97 Junior

Un coleg care a lucrat ani de zile în Java începe un proiect în Python și scrie cod corect, dar neidiomatic. Cum i-ai explica principalele diferențe?

Răspuns scurt: Aș porni de la exemple concrete din codul lui, nu de la teorie: parcurgerea fără indecși, comprehensions, with, excepții în loc de verificări, atribute publice cu @property la nevoie, dataclass în loc de clase cu getteri.

Abordarea mea:

  • Încep cu respect pentru experiența lui. Conceptele de proiectare, testare și arhitectură se transferă; se schimbă stilul. Îi spun ce face bine, nu doar ce să schimbe.
  • Lucrez pe codul lui real, într-un review sau într-o sesiune de pair programming, cu câteva perechi „înainte și după”:
PYTHON
# stil Java
for i in range(len(produse)):
    if produse[i].pret > 100:
        scumpe.append(produse[i].nume)

# stil Python
scumpe = [p.nume for p in produse if p.pret > 100]
  • Diferențele principale pe care le explic:
  • nu e nevoie de getteri și setteri; atributele sunt publice, iar @property se adaugă doar când apare o regulă;
  • nu orice trebuie să fie clasă; funcțiile la nivel de modul și modulele țin loc de clase statice utilitare;
  • @dataclass înlocuiește clasele care doar stochează date;
  • EAFP: try/except e normal, iar excepțiile se folosesc și pentru cazuri așteptate;
  • with pentru resurse, în loc de try/finally;
  • duck typing și Protocol în loc de interfețe declarate peste tot;
  • convențiile PEP 8: snake_case, fără prefixe de tip în nume.
  • Automatizez ce se poate. Configurăm Ruff (linting și formatare) și mypy în proiect, ca regulile simple să fie semnalate de unelte, nu de mine. Discuțiile rămân pentru designul codului.
  • Îi dau resurse scurte: PEP 8, „The Zen of Python” (import this) și exemple din codul nostru pe care le consider bune.

Rezultatul pe care îl urmăresc este un coleg care înțelege de ce stilul Python e așa, nu unul care aplică reguli pe de rost.

Ce urmărește intervievatorul: Întrebare de comunicare și mentorat. Intervievatorul verifică dacă știi idiomurile Python suficient de bine încât să le explici și dacă dai feedback constructiv.

98 Mid

Un script Python funcționează perfect pe laptopul tău, dar pe serverul de producție cade cu o eroare. Cum procedezi?

Răspuns scurt: Citesc complet traceback-ul, apoi compar sistematic cele două medii: versiunea de Python, versiunile pachetelor, variabilele de mediu, căile și permisiunile, encoding-ul și fusul orar. Reproduc problema într-un mediu identic cu producția și repar cauza.

Un răspuns structurat:

  • Citesc eroarea completă. Traceback-ul de jos în sus: tipul excepției, mesajul, linia din codul nostru unde a apărut. Dacă logurile nu au traceback-ul, primul pas e să-l obțin.
  • Compar mediile, pe categorii de cauze frecvente:
  • versiunea de Python (python --version); o sintaxă precum match (3.10) sau X | None evaluat la rulare (3.10) cade pe versiuni mai vechi;
  • versiunile pachetelor (pip freeze pe ambele mașini, comparate); lipsa unui fișier lock duce des la versiuni diferite;
  • variabile de mediu și configurare (chei lipsă, alte valori);
  • căi relative: scriptul presupune un director curent anume; soluția este Path(__file__).parent;
  • permisiuni pentru fișiere, porturi, foldere;
  • encoding: open() fără encoding="utf-8" se comportă diferit pe alt sistem;
  • fusul orar și setările regionale;
  • resurse: memorie, timeout-uri de rețea, firewall.
  • Reproduc. Cel mai bine într-un container cu aceeași imagine ca producția sau pe un mediu de staging. O eroare reprodusă local e pe jumătate rezolvată.
  • Repar cauza, nu simptomul. Dacă problema a fost o dependență nefixată, adaug un fișier lock; dacă a fost o cale relativă, o fac absolută față de fișierul sursă.
  • Previn repetarea. Rulez testele în CI pe aceeași versiune de Python ca producția, folosesc aceeași imagine Docker în toate mediile și adaug loguri utile la pornire (versiunea aplicației, configurarea încărcată, fără secrete).

La final, aș documenta pe scurt ce s-a întâmplat, ca echipa să recunoască tiparul data viitoare.

Ce urmărește intervievatorul: Verifică metoda de depanare și experiența cu medii diferite. Intervievatorul caută o abordare sistematică, nu „reinstalez totul și sper”.

99 Mid

Faci code review la un pull request în Python care funcționează, dar e greu de citit: funcții lungi, nume vagi, cod duplicat și un except: pass. Cum dai feedback?

Răspuns scurt: Separ ce blochează îmbinarea (precum except: pass) de sugestiile de stil, dau comentarii concrete cu exemple și motivul lor, las formatarea pe seama uneltelor automate și comentez codul, nu persoana.

Cum structurez review-ul:

  • Înțeleg întâi scopul. Citesc descrierea și rulez local dacă e nevoie. Un review bun verifică întâi dacă soluția e corectă și potrivită, abia apoi stilul.
  • Prioritizez comentariile, marcate clar:
  • blocante: except: pass ascunde orice eroare, inclusiv bug-uri; propun prinderea excepției specifice și logarea ei;
  • importante: funcțiile de 100 de linii și codul duplicat, care îngreunează testarea și modificările viitoare;
  • minore („nit”): nume și mici idiomuri.
  • Comentarii concrete, cu motiv și exemplu:
PYTHON
# în loc de
try:
    trimite_factura(c)
except:
    pass

# propun
try:
    trimite_factura(c)
except SmtpIndisponibil:
    logger.warning("Factura %s nu a fost trimisă, reîncercăm", c.id)
    programeaza_reincercare(c)

Explic de ce: „dacă trimite_factura are un bug, nu vom afla niciodată, iar clientul nu primește factura”.

  • Formularea contează. Comentez codul, nu persoana: „funcția aceasta ar fi mai ușor de testat dacă...” în loc de „ai scris prost”. Pun întrebări acolo unde nu sunt sigur: „ce se întâmplă dacă lista e goală?”.
  • Automatizez stilul. Dacă discuțiile sunt despre spații sau ordinea importurilor, propun Ruff și un hook de pre-commit, ca review-urile să rămână despre logică.
  • Recunosc ce e bun în PR, nu doar problemele.
  • Pentru restructurări mari, propun o discuție scurtă sau pair programming în loc de 40 de comentarii scrise, și pot accepta ca o parte să fie făcută într-un PR separat.

Scopul este cod mai bun și un coleg care învață, nu câștigarea unei dispute.

Ce urmărește intervievatorul: Verifică maturitatea profesională și standardele de calitate. Intervievatorul vrea să vadă că știi ce e grav și ce e doar preferință și că poți da feedback fără conflicte.

100 Senior

Echipa ta trebuie să migreze o aplicație Python mare de la 3.8 la 3.12. Cum planifici și execuți migrarea?

Răspuns scurt: Fac un inventar al dependențelor și al compatibilității lor, ridic acoperirea cu teste pe zonele critice, rulez CI-ul pe ambele versiuni, rezolv avertismentele de depreciere, migrez treptat mediile (dezvoltare, staging, producție) cu plan de revenire și abia la final adopt sintaxa nouă.

Plan structurat:

  • Motivul și obiectivul. 3.8 nu mai primește actualizări de securitate (sfârșit de suport în octombrie 2024), deci migrarea este o nevoie de securitate și de întreținere, nu doar de funcționalități noi. Stabilesc versiunea țintă și un calendar.
  • Inventarul dependențelor. Pentru fiecare pachet verific dacă versiunea curentă suportă 3.12; multe trebuie actualizate, iar unele actualizări majore au propriile schimbări incompatibile. Pachetele abandonate trebuie înlocuite. Aceasta e de obicei partea cea mai lungă.
  • Schimbările din limbaj și din biblioteca standard. Citesc secțiunile „Porting” din documentația „What's New” pentru 3.9, 3.10, 3.11 și 3.12. Exemple relevante: modulul distutils a fost eliminat în 3.12, asyncio.coroutine în 3.11, iar datetime.utcnow() e depreciat din 3.12.
  • Plasa de siguranță. Verific acoperirea cu teste a fluxurilor critice și adaug teste unde lipsesc, înainte de orice schimbare.
  • Avertismentele. Rulez testele cu python -W error::DeprecationWarning pe versiunea curentă și le rezolv; ele anunță exact ce va dispărea.
  • CI pe două versiuni. Matricea de CI rulează pe 3.8 și 3.12 până când totul trece pe ambele; apoi codul poate fi lansat pe oricare.
  • Lansare treptată. Întâi mediile de dezvoltare și staging, apoi o parte din producție (de exemplu un worker sau un procent din trafic), cu monitorizarea erorilor, a latenței și a memoriei, plus un plan clar de revenire la imaginea anterioară.
  • După stabilizare, renunț la 3.8, actualizez requires-python și adopt treptat sintaxa nouă (X | None, match), eventual automat cu pyupgrade sau Ruff.

Comunic progresul și riscurile echipei de produs.

Ce urmărește intervievatorul: Întrebare de senior despre planificare tehnică și gestionarea riscului. Intervievatorul caută o abordare incrementală, cu teste și plan de revenire, nu „schimbăm versiunea și reparăm ce se strică”.

Î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, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Algoritmi și structuri de date, explicați gratuit

Fiecare subiect are o animație pas cu pas, codul în Python, C++ și Java și întrebările care apar la interviuri și la BAC.

  1. Recursivitate
  2. Backtracking
  3. Metoda bulelor
  4. Căutarea binară
  5. Stiva și coada
  6. Arbori binari
  7. BFS și DFS
  8. Algoritmul lui Dijkstra
  9. Programare dinamică

Pe scurt, toate într-un loc: algoritmi explicați și structuri de date.

Învață Python scriind cod, nu doar citind

Curs Python: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.