Excepții, clase și biblioteca standard

9 / 3 nu produce nicio excepție, deci nu se intră în except. Clauza else se execută doar atunci când nu a apărut nicio excepție, deci, după try, rulează else. Clauza finally rulează întotdeauna, indiferent de existența unei excepții, deci se execută ultima. Prin urmare, rezultă cele 3 linii: try, else, finally. Variantele care includ except corespund ideii greșite că a apărut o excepție, dar la acest apel nu se produce ZeroDivisionError. Varianta din care lipsește finally corespunde interpretării greșite a lui finally ca „operațiune de curățenie doar atunci când apare o excepție”.

Clauza else a unei instrucțiuni try se execută doar atunci când clauza try s-a încheiat până la capăt, fără nicio excepție. Spre deosebire de else al instrucțiunii if, care se leagă de „condiția este falsă”, else al lui try se leagă de „a mers bine” — direcțiile fiind opuse, e util să fie reținut astfel. Ceea ce se execută atunci când apare o excepție este clauza except. Ceea ce se execută întotdeauna, indiferent de excepție, este clauza finally. Dacă nu se potrivește niciun except, execuția nu trece la else, ci excepția respectivă se propagă mai departe, către apelant.

f() pregătește valoarea de returnat, dar înainte de a o returna efectiv execută clauza finally. De aceea, F se afișează primul, iar valoarea returnată rămâne T. g() are un return chiar în clauza finally, iar acesta suprascrie return-ul din clauza try, deci valoarea returnată devine N. print evaluează f() și g() înainte să afișeze pe un singur rând, deci rândul cu F apare primul, iar rândul cu T N urmează. Varianta T T ar corespunde ideii că return-ul din finally este ignorat, iar varianta cu F pe rândul secund ar corespunde ideii că finally rulează după return.

KeyboardInterrupt se află direct sub BaseException și nu moștenește din Exception. issubclass(KeyboardInterrupt, Exception) este False. Fiind provocată atunci când utilizatorul încearcă să oprească programul cu Ctrl-C, ierarhia este separată tocmai pentru a nu fi accidental înghițită de un except Exception scris larg. SystemExit se află în aceeași poziție. Celelalte trei sunt toate descendente ale lui Exception: ZeroDivisionError sub ArithmeticError, FileNotFoundError sub OSError, iar ModuleNotFoundError sub ImportError, deci toate pot fi captate cu except Exception.

Atât IndexError, cât și KeyError, au aceeași natură — o căutare după index sau cheie care nu a găsit nimic — motiv pentru care sunt plasate sub o clasă-părinte comună, LookupError. Scriind except LookupError, se pot prinde deodată atât un acces în afara intervalului unei liste, cât și o cheie inexistentă a unui dicționar. ArithmeticError este părintele lui ZeroDivisionError și altele similare, pentru situații în care calculul în sine nu poate avea loc. AttributeError apare când un atribut nu este găsit, iar ReferenceError atunci când ținta unei referințe slabe a dispărut — ambele se află direct sub Exception și aparțin unei alte familii decât LookupError.

8 / 0 produce ZeroDivisionError, dar ZeroDivisionError este o subclasă a lui ArithmeticError. Clauzele except sunt verificate în ordine, de sus în jos, iar la prima potrivire căutarea se oprește, deci except ArithmeticError, scris primul, prinde excepția, iar se afișează doar A. Clauza except ZeroDivisionError, scrisă mai jos, nu mai apucă să se execute. Doar o singură clauză except se execută la o potrivire, deci nu pot apărea ambele, A și Z. Principiul este ca cele mai specifice (subclasele) să fie scrise primele, iar cele mai generale (clasele-părinte) după — codul din această întrebare are ordinea inversată.

Dacă după except se scrie un tuplu, între paranteze rotunde, clauza se execută dacă se potrivește oricare dintre excepțiile din tuplu. conv("21") returnează 42, deoarece int("21") devine 21. conv("abc") este pasabil ca șir de caractere, dar nu poate fi interpretat ca număr, deci produce ValueError. conv(None) nu este de un tip pasabil lui int(), deci produce TypeError. Distincția — tip corect dar valoare improprie duce la ValueError, iar tip incorect de la bun început duce la TypeError — corespunde exact ordinii din răspuns.

Un raise scris fără argumente în interiorul unui except relansează, exact așa cum este, excepția aflată în curs de tratare, către apelant. Prin urmare, după afișarea lui inner, LoadError se propagă în afara lui load(), iar except Exception din exterior o preia. Cum LoadError moștenește din Exception, poate fi captată de except Exception, deci execuția nu se oprește. type(e).__name__ returnează numele clasei excepției efectiv lansate, deci se afișează LoadError, nu numele tipului clauzei care a captat-o, Exception. Varianta care conține doar inner ar corespunde cazului în care excepția era înghițită pe loc, fără relansare.

Primul apel folosește indexul 1 al listei, deci returnează 2. Al doilea interoghează o cheie inexistentă într-un dicționar, deci produce KeyError, dar în except este scris doar IndexError. Deși IndexError și KeyError sunt amândouă subclase ale lui LookupError, nu sunt una părinte a celeilalte, deci un except pentru IndexError nu poate prinde KeyError. Excepția necaptată se propagă către apelant, iar cum nu există cine să o prindă, programul se oprește. Dacă se dorește captarea ambelor, se scrie except LookupError, sau se listează ambele într-un tuplu.

assert condiție, mesaj lansează AssertionError atunci când condiția este falsă. Dacă este adevărată, nu se întâmplă nimic. Important este că, pornit în mod de optimizare, ca python3 -O, instrucțiunea assert este eliminată complet, fără să se execute deloc. Prin urmare, assert nu trebuie folosit pentru a verifica intrarea utilizatorului — pentru acest scop se verifică condiția printr-un if și se lansează raise ValueError(...). Este util să se rețină rolul lui assert ca instrument pentru a consemna, în timpul dezvoltării, presupuneri interne.

Scriind d.speak(), Python reinterpretează apelul ca Dog.speak(d). În această poziție, primul argument, ajunge chiar instanța care a făcut apelul. Ortografia self este doar o convenție, nu un nume rezervat de limbaj. Singura specificație este că primul argument primește obiectul însuși, deci și scris explicit Dog.speak(d), funcționează la fel. Crearea și returnarea unei instanțe este rolul lui __new__ și al mecanismului de apelare a clasei; __init__ doar inițializează o instanță deja creată. Pentru a referi clasa-părinte se folosește super().

kind este o variabilă de clasă, scrisă direct sub class, iar toate instanțele create din acea clasă o partajează ca pe una singură. Nici a, nici b nu au kind în propriul __dict__, deci, la citirea atributului, se urcă până la nivelul clasei și se vede aceeași valoare. Atribuirea la Dog.kind modifică exact acea valoare partajată, deci atât a, cât și b, deja create, văd valoarea wolf. Valoarea nu este copiată la crearea instanței, deci nu apare varianta în care rămâne canine.

Atribuirea a.kind nu modifică variabila de clasă, ci creează un element nou, kind, în dicționarul instanței a. De atunci înainte, citirea lui a.kind găsește mai întâi acest element nou, umbrind variabila de clasă. b și Dog.kind rămân la valoarea originală, canine. Prin urmare, în a.__dict__ apare, pe lângă name, pus de __init__, și kind, iar sortat rezultă ['kind', 'name']. Varianta cu husky peste tot ar corespunde ideii greșite că atribuirea pe instanță modifică variabila de clasă, iar varianta cu doar ['name'] ar corespunde ideii că nu se creează nicio umbrire.

self.items.append(x) nu este o atribuire către self.items, ci doar apelează o metodă a obiectului la care ajunge self.items. Nici p, nici q nu au propriul items, deci ambele ajung la aceeași și unica listă, variabila de clasă. Ca urmare, atât 1 adăugat prin p, cât și 2 adăugat prin q, ajung în aceeași listă, iar, indiferent din ce parte se privește, rezultă [1, 2]. Dacă se dorește câte un recipient separat pentru fiecare instanță, acesta trebuie creat explicit în __init__, prin self.items = []. Astfel s-ar obține separat [1] și [2].

__init__ al lui Cat apelează super().__init__(name), deci Animal, clasa-părinte, este cel care stabilește self.name. După aceea se atribuie și self.color valoarea black, deci ambele atribute există. cry este redefinit în clasa-copil, deci implementarea din părinte este suprascrisă, iar cea care se apelează este meow. isinstance(c, Animal) este True, câtă vreme Cat moștenește din Animal. Dacă s-ar uita apelul super(), name nu ar fi setat și ar apărea AttributeError, deci nu se ajunge la o defecțiune tăcută, precum varianta cu None.

Ordinea de rezolvare a metodelor este stabilită printr-o regulă numită liniarizare C3, nu prin simplă căutare în adâncime. Părintele comun A este plasat după toți copiii care moștenesc din A, deci ordinea devine D, B, C, A, object. Dacă s-ar face o căutare în adâncime, coborând mai întâi în B și ajungând direct la A, ar rezulta D, B, A, C, object, dar nu așa se întâmplă — acesta este punctul de atenție. who() caută de la începutul MRO și folosește prima apariție găsită, deci se returnează cea din B. Dacă s-ar scrie class E(C, B), ar rezulta E, C, B, A, object — clasa scrisă prima are prioritate.

Liniarizarea C3 impune două reguli: să se păstreze ordinea în care au fost enumerate clasele de bază și ca un părinte să fie plasat după copiii săi. F(A, B) cere ca A să fie plasat înaintea lui B, dar cum B este copilul lui A, părintele A trebuie să vină după copilul B. Aceste două cerințe nu pot fi satisfăcute simultan, deci, neputându-se construi un MRO consistent, se produce TypeError chiar la evaluarea definiției clasei. Eșecul nu apare abia la rulare, ci în chiar momentul în care se trece de instrucțiunea class. Forma corectă este class F(B, A), scriind copilul primul.

_one, cu un singur underscore, indică prin convenție doar uz intern, fără să-și schimbe numele; poate fi citit normal din exterior. __two, cu doi underscore, este supus deformării numelui: numele efectiv al atributului devine _P__two, adică _NumeleClasei__nume. De aceea, scriind p.__two, apare AttributeError, dar scriind p._P__two, se poate citi. Și în __dict__ apare numele deja deformat, deci sortat rezultă ['_P__two', '_one']. Doar cele care încep cu doi underscore sunt deformate; _one nu este afectat.

print(v) și str(v) folosesc __str__, deci rezultă V(1, 2). Pe de altă parte, afișarea în interiorul unui container, precum o listă sau un dicționar, folosește __repr__ pentru fiecare element, deci rezultă [Vec(x=1, y=2)]. Această distincție este esența întrebării. len(v) returnează valoarea dată de __len__, adică 2, iar v + Vec(3, 4) returnează un Vec nou, dat de __add__, care, pasat lui print, folosește din nou __str__, deci apare V(4, 6). Într-o clasă fără __str__ definit, se folosește în locul lui __repr__, dar niciodată invers, __str__ nu preia locul lui __repr__.

Fiind definit __eq__, p == q compară atributul x și devine True, dar cum p și q sunt obiecte create separat, p is q rămâne False. Aici este esențial faptul că o clasă care definește __eq__ primește automat __hash__ setat la None, deci Point.__hash__ is None este True. Un obiect fără hash nu poate fi folosit ca element de mulțime sau ca cheie de dicționar, deci încercarea de a crea {p, q} produce TypeError. Dacă se dorește includerea și în mulțimi, trebuie definit manual un __hash__ care returnează aceeași valoare pentru obiecte egale.

math.sqrt returnează float chiar și atunci când rezultatul este exact, deci rădăcina lui 16 se afișează ca 4.0, nu ca 4. math.floor rotunjește spre coada axei numerelor, deci -1.5 devine -2, iar math.ceil rotunjește spre capătul opus, deci -1.5 devine -1. Pentru numere negative, trebuie observat contrastul cu int(-1.5), care rotunjește spre 0 și dă -1, diferit de rezultatul lui floor. Dacă floor și ceil se confundă, rezultă ordinea -1 -2, iar dacă se crede că sqrt returnează int, rezultă 4.

os.path.splitext desparte doar extensia, păstrând punctul de partea extensiei, și returnează un tuplu cu 2 elemente. Prin urmare, rezultă ('/tmp/z', '.txt'). Punctul nu dispare, deci nu rezultă 'txt'. os.path.basename returnează numele de la sfârșitul căii, deci 'z.txt'. Cel care returnează partea de director, '/tmp', este os.path.dirname, iar dacă se dorește un tuplu cu ambele deodată, se folosește os.path.split. Este util să se rețină distincția: splitext taie după extensie, nu după separatorul de director.

re.match potrivește doar de la începutul șirului, iar începutul lui 'abc' este 'a', care nu se potrivește cu 'b', deci returnează None. re.search caută și în interior, deci se potrivește cu 'b', iar .group() extrage șirul potrivit, b. Această diferență este cel mai adesea testată la modulul re. re.findall returnează o listă cu toate porțiunile care se potrivesc cu tiparul, iar \d+ înseamnă cifre consecutive, deci rezultă ['1', '22', '333']. Caracterele de separare nu sunt incluse. Dacă nu există nicio potrivire, se returnează o listă vidă.

Afișând direct un obiect date cu print, apare în formatul ISO, cu cratimă ca separator, 2026-08-22. Pentru a schimba formatul se folosește strftime, iar pasându-i '%Y/%m/%d' se obține șirul cu separator bară oblică, 2026/08/22. Adăugând timedelta(days=10) la un date, ceea ce se returnează nu este un timedelta, ci un nou date, indicând data cu 10 zile mai târziu, deci la print apare 2026-09-01. Calculul care trece peste sfârșitul lunii este gestionat automat de datetime, deci nu apare o dată inexistentă, precum 2026-08-32, obținută prin simpla adăugare a lui 10 la ziua curentă. Dacă s-ar crede că print(d) folosește același format ca strftime, ar rezulta separatorul cu bară oblică peste tot, dar afișarea implicită folosește cratimă. Scăzând între ele două date, se returnează un timedelta, nu un date, iar afișarea acestuia are o formă precum 10 days, 0:00:00.

'abracadabra' conține 5 litere a, câte 2 litere b și r, și câte 1 literă c și d. most_common(2) returnează doar primele 2, în ordine descrescătoare, sub formă de listă de tupluri (element, număr), deci rezultă [('a', 5), ('b', 2)]. Dintre b și r, care au același număr, se preferă cel apărut mai devreme, deci este ales b. Counter este un fel de dicționar, dar, spre deosebire de un dicționar obișnuit, interogarea unui element inexistent nu produce KeyError, ci returnează 0. Această proiectare permite să se numere fără a mai fi nevoie să se verifice în prealabil existența.

Tipul creat cu namedtuple, afișat, ia forma Pt(x=1, y=2), cu numele tipului și al câmpurilor. Valoarea poate fi citită atât după nume, cât și după index, deci p.x și p[0] sunt amândouă 1. Fiind un tip derivat din tuplu, isinstance(p, tuple) este True. Cu alte cuvinte, este un fel de tuplu, deci elementele nu pot fi rescrise ulterior. Dacă se dorește o valoare modificabilă, se folosește _replace, care creează o instanță nouă cu valoarea înlocuită, sau se definește o clasă obișnuită.

map returnează nu o listă, ci un iterator, care oferă câte o valoare la fiecare next(), iar odată epuizat, rămâne așa. La primul list() se extrag toate cele 3 valori, deci al doilea list() nu mai are ce rămas, rezultând o listă vidă. Nu apare nici eroare, nici None; devine gol în tăcere, ceea ce e ușor de trecut cu vederea. map(str, ...) transformă fiecare element în șir de caractere, deci conținutul primei liste nu este numeric, ci ['1', '2', '3']. Același lucru se întâmplă cu filter, zip, enumerate și cu generatoarele, deci, dacă se dorește parcurgere de mai multe ori, se fixează imediat conținutul cu list().

Pasând None ca prim argument lui filter, filtrarea se face după valoarea de adevăr a elementului însuși. 0, șirul vid și None sunt evaluate ca false, deci sunt eliminate, iar rezultă [1, 2, 'a']. Nu rămân cele eliminate. all este specificat să returneze True atunci când nu există niciun element fals, deci pentru o listă complet vidă returnează True. any returnează True atunci când există cel puțin un element adevărat, deci pentru o listă vidă returnează False. Faptul că aceste două dau răspunsuri opuse pentru o secvență vidă este exact ce se testează aici.

Chiar și apelând o funcție ce conține yield, corpul nu se execută nici măcar o linie. Ceea ce se returnează este doar un obiect generator, deci created apare afișat primul. Abia la primul next(g), execuția pornește efectiv de la început, afișează start, apoi se oprește la yield 1, care returnează 1. Următorul next(g) reia exact de unde s-a oprit, afișează mid, apoi se oprește la yield 2, care returnează 2. Această execuție amânată este diferența decisivă față de o funcție obișnuită; dacă se mai apelează încă o dată next(g), funcția se termină și apare StopIteration.

== este operatorul care întreabă dacă valorile sunt egale, deci pentru a și b, care au același conținut, rezultă True. is este operatorul care întreabă dacă este vorba de același obiect, iar a și b sunt două liste create separat, deci rezultă False. Pe de altă parte, c = a nu creează o listă nouă, ci doar atașează un alt nume aceluiași obiect, deci a is c este True. Cu alte cuvinte, dacă se modifică lista prin c, schimbarea se vede și prin a. None este un obiect special, existent într-o singură instanță, deci scrierea x is None este convenția corectă, dar pentru a compara valori se folosește întotdeauna ==.