Construiești o clasă Cont în care soldul se schimbă doar prin depuneri și retrageri verificate. O retragere prea mare e refuzată, iar soldul rămâne corect.
cont.py, în terminal
Refuzat
Ana 70
Încapsularea înseamnă că un obiect își păzește singur datele. Codul din afară nu scrie direct în sold, ci cere: „depune”, „retrage”. Obiectul decide dacă cererea e validă.
să marchezi un atribut ca intern, cu un underscore
să expui o valoare doar pentru citire, cu @property
să validezi o atribuire, cu un setter
să știi ce face, de fapt, un nume cu două underscore-uri
Pasul 2 din 5
Rulează-l linie cu linie
O versiune scurtă a contului: creezi contul Anei, depui 150 și citești soldul. Urmărește cum sare execuția între program și metodele clasei.
Linia 1.class doar descrie cum arată un cont. Python își notează metodele și sare la linia 15, unde începe programul.
Linia 15.Cont("Ana") creează un obiect nou și apelează automat __init__. Parametrul titular primește „Ana”.
Linia 3.self e obiectul care tocmai se construiește. self.titular e un atribut public, al lui.
Linia 4._sold începe cu underscore: e un semnal că atributul e intern și nu se modifică din afara clasei.
Linia 15. Obiectul gata construit ajunge în variabila c.
Linia 16.c.depune(150) intră în metodă: self e c, iar suma e 150.
Linia 7. Metoda verifică întâi cererea. 150 <= 0 e fals, deci nu se aruncă nicio eroare.
Linia 9. Abia după verificare se schimbă soldul: += adună 150 la valoarea veche, 0.
Linia 17.c.sold arată ca un atribut, dar e o proprietate: Python apelează metoda de la linia 12.
Linia 13. Proprietatea întoarce valoarea internă, 150.
Linia 17.print afișează titularul și soldul.
Gata. Codul din afară a citit soldul, dar nu l-a scris niciodată direct.
Prezice ieșirea
Schimbi linia 16 în c.depune(-40). Ce se întâmplă?
Răspuns: ValueError, înainte de afișare.
-40 <= 0 e adevărat, deci linia 8 aruncă eroarea. Linia 9 nu mai rulează, iar print de la linia 17 nu mai e atins.
Pasul 3 din 5
Trei unelte de încapsulare
Python nu are private ca Java sau C++. Are convenții și proprietăți. Le vezi pe rând, apoi două capcane.
1
Un underscore: „nu atinge”
conventie.py
class Cont:def__init__(self):self._sold = 0c = Cont()c._sold = -500print(c._sold)
Ce apare pe ecran
-500
Python nu te oprește. _sold e o înțelegere între programatori: e detaliu intern, iar cine îl scrie din afară își asumă riscul. Editoarele și linterele te avertizează.
2
@property: se citește, nu se scrie
proprietate.py
class Cont:def__init__(self):self._sold = 100 @propertydefsold(self):returnself._soldc = Cont()print(c.sold)c.sold = 1000000
100
Traceback (most recent call last):
File "proprietate.py", line 11, in <module>
c.sold = 1000000
^^^^^^
AttributeError: property 'sold' of 'Cont' object has no setter
@property transformă o metodă într-un atribut care se citește fără paranteze: c.sold, nu c.sold(). Fără setter, orice încercare de scriere se oprește cu AttributeError.
9
Traceback (most recent call last):
File "setter.py", line 19, in <module>
e.nota = 11
^^^^^^
File "setter.py", line 13, in nota
raise ValueError("1-10")
ValueError: 1-10
Setter-ul are același nume ca proprietatea și decoratorul @nota.setter. e.nota = 9 arată ca o atribuire simplă, dar trece prin verificare. Nota 11 e refuzată.
Asta e diferența față de getter-ele și setter-ele din Java: începi cu un atribut simplu și adaugi validarea mai târziu, fără să schimbi codul care îl folosește.
4
Două underscore-uri: numele e schimbat
mangling.py
class Card:def__init__(self):self.__pin = "1234"c = Card()print(c._Card__pin)print(c.__pin)
1234
Traceback (most recent call last):
File "mangling.py", line 7, in <module>
print(c.__pin)
^^^^^^^
AttributeError: 'Card' object has no attribute '__pin'
În clasă, __pin e redenumit automat în _Card__pin. Asta ferește atributul de coliziuni cu o clasă copil, dar nu îl ascunde: cine știe regula îl citește. Pentru date interne, un singur underscore e de ajuns.
Capcană: proprietatea care se citește pe ea însăși
În proprietate scrii self.nota în loc de self._nota. Proprietatea se apelează pe ea, la nesfârșit:
recursiv.py
class Elev: @propertydefnota(self):returnself.notae = Elev()print(e.nota)
Traceback (most recent call last):
File "recursiv.py", line 7, in <module>
print(e.nota)
^^^^^^
File "recursiv.py", line 4, in nota
return self.nota
^^^^^^^^^
File "recursiv.py", line 4, in nota
return self.nota
^^^^^^^^^
File "recursiv.py", line 4, in nota
return self.nota
^^^^^^^^^
[Previous line repeated 1016 more times]
RecursionError: maximum recursion depth exceeded
Repară: în proprietate și în setter lucrezi mereu cu atributul intern, self._nota.
Capcană: validarea ocolită din constructor
Setter-ul refuză note peste 10, dar __init__ scrie direct în _nota. Nota 25 trece fără nicio eroare:
ocolit.py
class Elev:def__init__(self, nota):self._nota = nota @propertydefnota(self):returnself._nota @nota.setterdefnota(self, valoare):ifnot1 <= valoare <= 10:raise ValueError("1-10")self._nota = valoaree = Elev(25)print(e.nota)
Ce apare pe ecran
25
Repară scriind în constructor self.nota = nota, fără underscore. Așa trece și valoarea de start prin setter.
Pasul 4 din 5
Verifică-te
Cinci întrebări noi. După fiecare răspuns vezi imediat de ce e așa.
1 din 5 · Prezice ieșirea
Ce afișează programul?
patrat.py
class Patrat:def__init__(self, l):self._l = l @propertydefaria(self):returnself._l * self._lp = Patrat(3)p._l = 5print(p.aria)
Răspuns: „25”.
Un underscore nu blochează nimic, deci _l devine 5. Proprietatea se calculează la fiecare citire, cu valoarea de acum: 5 · 5.
2 din 5 · Alege varianta
Ce înseamnă pentru Python numele _sold?
Răspuns: e o convenție.
Un singur underscore nu are niciun efect la rulare. E un semnal pentru oameni și pentru unelte precum linterele.
3 din 5 · Prezice ieșirea
Ce afișează programul?
doua.py
class A:def__init__(self):self.__x = 7a = A()a.__x = 1print(a._A__x, a.__x)
Răspuns: „7 1”.
În clasă, __x a devenit _A__x. În afara clasei nu se schimbă niciun nume, așa că a.__x = 1 creează un atribut nou, separat.