9.1. O vorbă despre nume și obiecte¶

Obiectele au individualitate și este permis ca nume diferite (din domenii de valabilitate distincte; de la englezescul scope; se folosește și constructul domenii de vizibilitate) să fie legate de același obiect. În alte limbaje de programare, o atare permisiune este cunoscută drept întrebuințare de pseudonime (de la englezescul aliasing; sau atribuire de pseudonime). Pseudonimele se folosesc rar de către cei aflați la primul contact cu Python-ul, utilizarea lor putând fi evitată în mod eficient atunci când avem de a face, în programul nostru, cu tipurile de date elementare care sunt imutabile (numere, șiruri de caractere, tupluri). Pe de altă parte, atribuirea de pseudonime poate avea efecte neașteptate asupra semanticii programelor Python care întrebuințează obiecte mutabile precum listele, dicționarele de date șamd. Pseudonimele îi sunt utile unui program Python deoarece se comportă ca niște pointeri în anumite privințe. De exemplu, transmiterea (ca argument al unei funcții oarecare) unui obiect este ieftină căci implementarea se îngrijește să fie transmis doar un pointer; iar dacă funcția va modifica obiectul transmis ei ca argument, atunci apelantul va observa schimbarea intervenită — ceea ce elimină nevoia de a dispune de două mecanisme de transmitere a argumentelor, ca în Pascal.

9.2. Domenii de valabilitate și spații de nume în Python¶

Înainte de a introduce clasele, trebuie să discutăm puțin despre regulile Python-ului în ceea ce privește domeniile de valabilitate. Definițiile claselor le joacă adesea feste celor care utilizează spațiile de nume (de la englezescul namespace), așa că este important să cunoașteți precis cum funcționează domeniile de valabilitate și spațiile de nume pentru a putea urmări îndeaproape cum evoluează lucrurile. Că tot a venit vorba, cunoașterea acestei problematici îi este utilă oricărui programator matur în Python.

Să începem cu câteva definiții.

Un spațiu de nume este o asociere (sau o corespondență; de la englezescul mapping; se folosește, ca jargon informatic, și termenul de mapare) a unor nume cu niște obiecte. Cele mai multe spații de nume sunt implementate în Python, la momentul de față, ca dicționare de date, însă respectiva implementare nu iese în evidență prin nimic (poate cu excepția performanței) și există posibilitatea ca ea să se schimbe în viitor. Exemple de spații de nume sunt următoarele: setul numelor predefinite (conținând funcții precum abs(), respectiv nume de excepții predefinite); numele globale dintr-un modul; ori numele locale dintr-un apel de funcție. Lucrul important de reținut despre spațiile de nume este că nu există niciun fel de legătură între numele situate în spații de nume diferite; de exemplu, două module distincte pot defini fără pericol de confuzie (câte) o funcție intitulată maximizează – ca să folosească o astfel de funcție, utilizatorii modulelor vor avea de prefixat numele ei cu numele modulului care o conține.

Apropo, folosim cuvântul atribut pentru a ne referi la orice nume care îi urmează unui (operator) punct — cum ar fi faptul că, în expresia z.real, real (partea reală) este un atribut al obiectului z. Într-o exprimare riguroasă, referirea la numele dintr-un modul este o referire la niște atribute: în expresia nume_de_modul.nume_de_funcție, nume_de_modul desemnează numele unui modul pe când nume_de_funcție pe cel al unui atribut al acestui modul. În cazul de față se întâmplă să existe o mapare ușor de sesizat între atributele modulului și numele globale definite în modul: ele împart același spațiu de nume! [1]

Atributele pot fi sau doar-de-citit sau editabile (de la englezescul writable). În cel de-al doilea caz, atributelor li se pot asigna valori. Atributele unui modul sunt editabile: putem scrie nume_de_modul.răspunsul = 42. De asemeni, atributele editabile pot fi șterse, cu ajutorul instrucțiunii del. De exemplu, del nume_de_modul.răspunsul va elimina atributul răspunsul din obiectul numit nume_de_modul.

Spațiile de nume sunt create la momente de timp diferite și au durate de viață variate. Spațiul de nume care conține numele predefinite este creat la pornirea interpretorului de Python, fără a mai fi șters pe întreaga durată a funcționării acestuia. Spațiul de nume global al unui modul este creat odată cu citirea de către interpretor a definiției modulului în cauză; în mod obișnuit, spațiile de nume ale modulelor rămân în viață până la oprirea interpretorului. Instrucțiunile executate de o invocare de la cel mai înalt nivel a interpretorului, fie că au fost citite dintr-un fișier de script fie că au fost introduse în mod interactiv, sunt considerate că făcând parte dintr-un modul numit __main__, astfel că ele posedă propriul lor spațiu de nume global. (Numele predefinite, la rândul lor, funcționează într-un modul; acesta se numește builtins.)

Spațiul de nume local al unei funcții este creat la apelul funcției și este șters fie la returnarea din execuția codului funcției fie atunci când, în codul funcției, este ridicată o excepție care nu va fi interceptată în cadrul funcției respective. (De fapt, uitare ar fi termenul potrivit pentru a descrie ceea ce se întâmplă cu adevărat într-o atare situație.) Evident, invocările recursive ale unei funcții au fiecare propriul său spațiu de nume.

Un domeniu de valabilitate este o zonă de text dintr-un program Python în care un anumit spațiu de nume este accesibil în mod direct. Prin „accesibil în mod direct” înțelegem faptul că referințele necalificate la nume oarecare reușesc să identifice despre ce nume este vorba în acel spațiu de nume.

Cu toate că domeniile de valabilitate sunt stabilite static, utilizarea lor se face dinamic. La orice moment de timp de pe parcursul execuției unui program Python, există 3 sau 4 domenii de valabilitate imbricate la ale căror spații de nume avem acces în mod direct:

• domeniul de valabilitate poziționat cel mai adânc în interiorul codului, acela din care va începe orice căutare de nume, el conține numele locale

• domeniile de valabilitate ale funcțiilor care înglobează codul (de la englezescul enclosing), în care căutările de nume se realizează pornind de la domeniul de includere (al codului) situat cel mai adânc, acestea deținând atât nume ne-locale cât și nume ne-globale

• penultimul (dinspre interiorul către exteriorul codului) domeniu de valabilitate conține numele globale ale modulului curent

• domeniul de valabilitate cel mai de sus (ultimul în care se va căuta numele respectiv) este spațiul de nume care cuprinde numele predefinite

Atunci când un nume este declarat ca fiind global, toate referirile la el precum și toate atribuirile către el vor fi realizate în domeniul de valabilitate penultim, adică în domeniul care deține toate numele globale ale modulului. Pentru a lega din nou variabilele găsite în exteriorul celui mai adânc situat dintre domeniile de valabilitate poate fi întrebuințată instrucțiunea nonlocal (adică, o declarație de ne-local); dacă nu au fost declarate drept ne-locale, atunci asemenea variabile sunt doar-de-citit (orice tentativă de a edita o atare variabilă va conduce la crearea unei variabile locale noi, conținută în domeniul de valabilitate poziționat cel mai adânc, în timp ce numele omonim din exterior nu-și va modifica valoarea).

Domeniul de valabilitate local se referă, în mod obișnuit, la numele locale ale (chiar) funcției de față. În exteriorul codului de funcții, domeniul de valabilitate local face referire la același spațiu de nume ca și domeniul de valabilitate global: adică la spațiul de nume al modulului. Definițiile claselor, la rândul lor, plasează alte spații de nume în domeniul de valabilitate local.

Este important să realizăm că domeniile de valabilitate se determină textual: domeniul de valabilitate global al unei funcții definite într-un modul este chiar spațiul de nume al modulului respectiv, indiferent de unde ori sub ce pseudonim s-a realizat apelul funcției în cauză. Pe de altă parte, căutarea efectivă a unui anumit nume se realizează dinamic, pe parcursul execuției programului — cu toate acestea, definiția Python-ului ca limbaj de programare evoluează către o rezolvare statică a numelor, adică una la momentul „compilării”, motiv pentru care vă recomandăm să nu vă bazați pe rezolvări dinamice de nume! (În fapt, variabilele locale sunt deja determinate static.)

O caracteristică aparte a Python-ului – atunci când nu ne găsim sub efectul vreuneia din instrucțiunile global ori nonlocal – este aceea că atribuirile către nume se fac întotdeauna în domeniul de valabilitate poziționat cel mai adânc în interiorul codului. Atribuirile nu copiază date — ele doar leagă nume de obiecte. Același lucru este valabil și pentru ștergeri: instrucțiunea del x elimină legătura lui x din spațiul de nume la care se referă domeniul de valabilitate local. În fapt, orice operație care introduce nume noi întrebuințează domeniul de valabilitate local: în particular, instrucțiunile import precum și definițiile de funcții leagă fie numele modulului fie numele funcției de domeniul de valabilitate local.

Instrucțiunea global poate fi utilizată la a arăta că o anume variabilă trăiește în domeniul de valabilitate global, astfel că trebuie re-legată (tot) în el; instrucțiunea nonlocal indică faptul că variabila respectivă trăiește într-un domeniu de valabilitate care înglobează codul de față, deci că va trebui re-legată în acela.

def testează_domeniul_de_vizibilitate():
    def construiește_ceva_local():
        șuncă = "șuncă produsă local"

    def construiește_ceva_nelocal():
        nonlocal șuncă
        șuncă = "șuncă produsă ne-local"

    def construiește_ceva_global():
        global șuncă
        șuncă = "șuncă produsă global"

    șuncă = "testez șunca"
    construiește_ceva_local()
    print("După asignarea locală:", șuncă)
    construiește_ceva_nelocal()
    print("După asignarea ne-locală:", șuncă)
    construiește_ceva_global()
    print("După asignarea globală:", șuncă)

testează_domeniul_de_vizibilitate()
print("În domeniul de valabilitate global:", șuncă)

După asignarea locală: testez șunca
După asignarea ne-locală: șuncă produsă ne-local
După asignarea globală: șuncă produsă ne-local
În domeniul de valabilitate global: șuncă produsă global

9.3. Prima privire aruncată asupra claselor¶

Clasele aduc un strop de nou în conținutul sintaxei, alte trei tipuri de obiecte, precum și ceva noutăți la semantică.

class NumeleClasei:
    <instrucțiunea-1>
    .
    .
    .
    <instrucțiunea-N>

class ClasaMea:
    """Un exemplu simplist de clasă"""
    i = 12345

    def f(self):
        return 'salutare, lume'

x = ClasaMea()

def __init__(self):
    self.datele_clasei = []

x = ClasaMea()

>>> class NumărComplex:
...     def __init__(self, partea_reală, partea_imaginară):
...         self.real = partea_reală
...         self.imaginar = partea_imaginară
...
>>> x = NumărComplex(3.0, -4.5)
>>> x.real, x.imaginar
(3.0, -4.5)

x.contor = 1
while x.contor < 10:
    x.contor = x.contor * 2
print(x.contor)
del x.contor

x.f()

xf = x.f
while True:
    print(xf())

class Câine:

    genul = 'canis'             # variabilă de clasă comună tuturor
                                # instanțelor

    def __init__(self, numele):
        self.numele = numele    # variabilă de instanță, unică fiecărei
                                # instanțe

>>> d = Câine('Fido')
>>> e = Câine('Amicu\'')
>>> d.genul                     # comun tuturor câinilor
'canis'
>>> e.genul                     # comun tuturor câinilor
'canis'
>>> d.numele                    # doar al lui d
'Fido'
>>> e.numele                    # doar al lui e
"Amicu'"

class Câine:

    trucuri = []            # folosită din greșeală ca variabilă de clasă

    def __init__(self, numele):
        self.numele = numele

    def adauga_trucul(self, trucul):
        self.trucuri.append(trucul)

>>> d = Câine('Fido')
>>> e = Câine('Amicu\'')
>>> d.adaugă_trucul('rostogol')
>>> e.adaugă_trucul('mort')
>>> d.trucuri               # folosință la comun neașteptată
['rostogol', 'mort']

class Câine:

    def __init__(self, numele):
        self.numele = numele
        self.trucuri = []    # creează câte o listă goală
                             # pentru fiecare câine

    def adaugă_trucul(self, trucul):
        self.trucuri.append(trucul)

>>> d = Câine('Fido')
>>> e = Câine('Amicu\'')
>>> d.adaugă_trucul('rostogol')
>>> e.adaugă_trucul('mort')
>>> d.trucuri
['rostogol']
>>> e.trucuri
['mort']

9.4. Observații diverse¶

Dacă același nume de atribut va apărea și într-o instanță și într-o clasă, la găsirea atributului i se va da prioritate instanței:

>>> class Depozitul:
...    scopul = 'înmagazinare'
...    regiunea = 'vestică'
...
>>> d1 = Depozitul()
>>> print(d1.scopul, d1.regiunea)
înmagazinare vestică
>>> d2 = Depozitul()
>>> d2.regiunea = 'estică'
>>> print(d2.scopul, d2.regiunea)
înmagazinare estică

Atributele de date pot fi referențiate atât de metode cât și de utilizatorii obișnuiți („clienții”) ai obiectului (având respectivele atribute). Cu alte cuvinte, clasele sunt inutilizabile la implementarea unor tipuri de date abstracte pure. Practic, nimic din Python nu ne poate ajuta să asigurăm ascunderea datelor — totul se bazează pe o simplă convenție. (Pe de altă parte, implementarea de față a Python-ului, scrisă în C, poate să mascheze în totalitate detaliile de implementare, respectiv să controleze accesul la un anumit obiect, atunci când este nevoie de așa ceva; o asemenea capacitate poate fi întrebuințată de diversele extensii ale Python-ului scrise în C.)

Clienții trebuie să folosească atributele de date cu grijă — căci ei pot strica invarianții păstrați de metode dacă își vor pune amprenta pe atributele de date ale acestora. Nu uitați că clienții îi pot adăuga atribute după bunul lor plac unui obiect instanță fără ca prin aceasta să le afecteze validitatea metodelor, atâta timp cât se evită conflictele de nume — și aici, întrebuințarea unei convenții de nume ne poate scăpa de o grămadă de bătăi de cap.

Nu ni se pune la dispoziție nicio scurtătură (și nici alte tehnici!) atunci când referențiem atribute de date din interiorul unei metode. Trebuie spus că o astfel de caracteristică a Python-ului crește lizibilitatea codului oricărei metode: deoarece nu avem nicio șansă să confundăm variabilele locale cu variabilele de instanță atunci când ne aruncăm privirea peste instrucțiunile dintr-o metodă.

Adeseori, primul argument al unei metode este numit self. Aceasta nu este decât o convenție: numele self nu posedă nicio semnificație aparte pentru Python. Remarcați, însă, că dacă nu vă veți face obiceiul de a-l folosi, atunci s-ar putea întâmpla ca programul dumneavoastră să le provoace dificultăți la lectură altor programatori în Python, după cum s-ar putea și să aveți greutăți cu vreo aplicație cititor de clase care se bazează tocmai pe această convenție de nume.

Orice obiect funcție care este (și) atribut de clasă definește o metodă pentru instanțele clasei în cauză. Nu este obligatoriu ca definiția funcției respective să fie literalmente parte din definiția clasei: este suficient să îi asignăm unei variabile locale din clasă un obiect funcție. De exemplu:

# Funcție definită în afara clasei
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1

    def g(self):
        return 'salutare, lume'

    h = g

Aici, f, g și h îi sunt cu toatele atribute clasei C și se referă la obiecte funcție, din care motiv ele le vor fi metode tuturor instanțelor lui C — h nefiind nimic altceva decât g. Atenție la faptul că o astfel de abordare va reuși doar să-i provoace confuzii vreunui cititor al programului dumneavoastră.

Metodele pot apela alte metode folosind atributele de metodă ale argumentului self:

class Punga:
    def __init__(self):
        self.datele = []

    def adaugă(self, x):
        self.datele.append(x)

    def adaugă_dublu(self, x):
        self.adaugă(x)
        self.adaugă(x)

Metodele se pot referi la numele globale în același fel ca funcțiile obișnuite. Domeniul de valabilitate global care i se asociază unei metode este chiar modulul care conține definiția metodei. (O clasă, ca atare, nu se folosește niciodată pe post de domeniu de valabilitate global.) Chiar dacă nu vom avea decât arareori motive serioase să întrebuințăm date globale în vreo metodă, există numeroase utilizări legitime ale domeniului de valabilitate global: cum ar fi, funcțiile și modulele importate în domeniul de valabilitate global pot fi folosite atât de către metode cât și de către funcțiile ori clasele care au fost definite în el. În mod obișnuit, clasa care conține o anumită metodă este ea însăși definită în acest domeniu de valabilitate global, iar noi vom face cunoștință în secțiunea următoare cu mai multe motive întemeiate ca o metodă oarecare să dorească să se refere la propria sa clasă.

Orice valoare este, în sine, un obiect și dispune, ca atare, de o clasă (aceasta mai numindu-se și tipul valorii). Clasa respectivă este stocată drept obiectul_nostru.__class__.

9.5. Moștenirea¶

Așa cum se înțelege de la sine, o caracteristică a indiferent cărui limbaj de programare n-ar putea fi socotită „de clasă” dacă nu le-ar face față cum se cuvine moștenirilor (dificultăților…). În cazul Python-ului, sintaxa pentru definirea unei clase derivate (dintr-o clasă de bază) arată după cum urmează:

class NumeleClaseiDerivate(NumeleClaseiDeBază):
    <instrucțiunea-1>
    .
    .
    .
    <instrucțiunea-N>

Numele NumeleClaseiDeBază trebuie să fie definit într-un spațiu de nume ce poate fi accesat din domeniul de valabilitate în care a fost introdusă definiția clasei derivate despre care discutăm. Sunt permise, în locul unui nume de clasă cu rolul de clasă de bază, (și) expresii oarecare. O astfel de flexibilitate în definiții se va dovedi folositoare atunci când, de exemplu, clasa de bază este situată în alt modul:

class NumeleClaseiDerivate(nume_de_modul.NumeleClaseiDeBază):

Execuția (codului) unei definiții de clasă derivată se realizează în același fel cu execuția (codului) unei clase de bază. Atunci când este construit obiectul clasă (derivată), interpretorul își amintește (și) de clasa de bază. Această proprietate se întrebuințează la rezolvarea referințelor de atribute: dacă vreun atribut căutat nu se găsește în codul clasei (derivate), căutarea sa va trece la codul clasei de bază. O atare regulă va fi aplicată recursiv dacă clasa de bază se dovedește a fi, la rândul său, derivată din altă clasă.

Nimic deosebit nu se va întâmpla la instanțierea claselor derivate: ca și până acum, NumeleClaseiDerivate() va crea o instanță (nouă) a clasei respective. Referințele la metode sunt rezolvate astfel: se caută atributul de clasă corespunzător, coborând, la nevoie, pe lanțul (dependențelor) care duce până la clasele de bază, apoi, odată găsit numele, referința metodei este considerată validă dacă ea întoarce un obiect funcție.

Clasele derivate au dreptul să-și suprascrie metodele (moștenite) de la clasele de bază. Deoarece metodele nu beneficiază de privilegii anume atunci când apelează metode ale aceluiași obiect, o metodă aparținând unei clase de bază care apelează altă metodă definită în aceeași clasă de bază poate avea surpriza că a apelat, de fapt, metoda unei clase derivate care a suprascris metoda (teoretic) apelată. (Pentru programatorii în C++: toate metodele din Python sunt efectiv virtuale.)

O metodă suprascrisă într-o clasă derivată dorește, cel mai adesea, să extindă și nu să înlocuiască pur și simplu metoda omonimă din clasa de bază. Dispunem de un procedeu necomplicat pentru a apela în mod direct metoda unei clase de bază: apelați, de-a dreptul, NumeleClaseiDeBază.numele_metodei(self, restul_argumentelor). O atare proprietate le folosește și clienților. (Țineți seama de faptul că ea funcționează doar atunci când clasa de bază este accesibilă sub denumirea de NumeleClaseiDeBază în domeniul de valabilitate global.)

Python-ul are două funcții predefinite care conlucrează cu moștenirea:

• Utilizați isinstance() pentru a verifica tipul unei instanțe: isinstance(obiectul_în_cauză, int) va întoarce True dacă și numai dacă obiectul_în_cauză.__class__ este fie int fie altă clasă derivată din int.

• Întrebuințați issubclass() pentru a testa moștenirea unei clase: issubclass(bool, int) va returna True pentru că bool este o subclasă (adică, o moștenitoare; sau o urmașă) a lui int. În schimb, issubclass(float, int) va întoarce False dat fiind că float nu îi este subclasă lui int.

class NumeleClaseiDerivate(ClasaDeBază1, ClasaDeBază2, ClasaDeBază3):
    <instrucțiunea-1>
    .
    .
    .
    <instrucțiunea-N>

9.6. Variabile private¶

În Python nu există variabile de instanță „private”, adică variabile care să nu poată fi accesate decât din interiorul instanței respective. Cu toate acestea, dispunem de o convenție respectată de aproape întreg codul Python: orice nume prefixat de o bară jos (adică, de o liniuță de subliniere; precum în _șuncă) trebuie socotit drept parte non-publică a API-ului (indiferent dacă este vorba de o funcție, de o metodă ori de o dată membru). Numele respectiv trebuie, așadar, tratat cu grija pe care o avem pentru un detaliu de implementare, despre care știm că s-ar putea schimba oricând, fără să fim anunțați.

Deoarece există, în practica POO, un caz de întrebuințare valid pentru membrii privați ai unei clase (mai precis, procedeul prin care să evităm conflictele de nume cu numele definite de clasele urmaș), avem la îndemână în Python un suport restrâns pentru un atare mecanism, denumit transformare de nume (de la englezescul name mangling). Astfel, orice identificator de forma __șuncă (cel puțin două bare jos pe post de prefixe și cel mult o bară jos pe post de sufix) va fi înlocuit în textul programului cu _numeleclasei__șuncă, unde numeleclasei desemnează numele de clasă curent, cu prefixul ori prefixele eliminat(e). Această transformare de nume se va realiza indiferent de poziția sintactică a identificatorului, atâta timp când aceasta se găsește în interiorul unei definiții de clasă.

Transformarea de nume este utilă la a le permite subclaselor să suprascrie diverse metode fără să strice apelurile de metode intra-clasă. Ca exemplu:

class Mapare:
    def __init__(self, iterabilul):
        self.lista_de_itemi = []
        self.__actualizează(iterabilul)

    def actualizează(self, iterabilul):
        for itemul in iterabilul:
            self.lista_de_itemi.append(itemul)

    __actualizează = actualizează   # copie privată a metodei
                                    # actualizează() originale

class SubclasaLuiMapare(Mapare):

    def actualizează(self, cheile, valorile):
        # îi oferă o nouă signatură lui actualizează()
        # fără să-l strice pe __init__()
        for itemul in zip(cheile, valorile):
            self.lista_de_itemi.append(itemul)

Exemplul de deasupra va funcționa chiar și în cazul când în SubclasaLuiMapare am introduce un identificator __actualizează și aceasta pentru că identificatorul în cauză va fi înlocuit cu _Mapare__actualizează în clasa Mapare, respectiv cu _SubclasaLuiMapare__actualizează în clasa SubclasaLuiMapare.

Nu uitați că regulile de transformare ale numelor au fost proiectate mai ales pentru a ne feri de accidente; este posibil, în pofida lor, să accesați, respectiv să modificați orice variabilă socotită drept privată. O asemenea libertate ne poate fi de folos în circumstanțe deosebite, precum cele ale întrebuințării unui depanator de programe (de la englezescul debugger).

Țineți seama (și) de faptul că, indiferent de cod îi transmiteți fie lui exec() fie lui eval(), acesta nu va considera numele de clasă al clasei care a făcut invocarea (uneia din cele două funcții) drept numele clasei curente; o atare situație seamănă cu efectul produs de execuția instrucțiunii global, efect care este restrâns doar la codul compilat într-un singur fragment de cod-de-octeți. Aceeași restricție le privește și pe getattr(), setattr() și delattr(), precum și pe orice referențiere directă a lui __dict__.

9.7. Șurubărie¶

Ne servește uneori să avem la îndemână un tip de date asemănător celui numit „record” în Pascal, respectiv lui „struct” din C, tip care să pună laolaltă mai mulți itemi de date cu denumiri (individuale). Procedeul idiomatic pentru așa ceva (în Python) este dat de dataclasses:

from dataclasses import dataclass

@dataclass
class Angajatul:
    numele: str
    departamentul: str
    salariul: int

>>> popescu = Angajatul('popescu', 'sala de calculatoare', 1000)
>>> popescu.departamentul
'sala de calculatoare'
>>> popescu.salariul
1000

Unui fragment de program Python care se așteaptă să primească un anumit tip de date abstracte îi putem transmite, de cele mai multe ori, pe post de înlocuitor o clasă care emulează metodele tipului de date respectiv. De exemplu, admițând că dispunem de o funcție care formatează diverse date preluate dintr-un obiect fișier, putem defini mai întâi o clasă căreia să-i aparțină metodele read() și readline(), metode capabile să extragă datele dintr-o memorie-tampon (de la englezescul buffer) dedicată stocării (temporare a) șirurilor de caractere, după care îi putem transmite funcției de formatare această clasă în calitate de argument.

Obiectele metodă de instanță posedă, și ele, atribute: metoda.__self__ este obiectul instanță căruia îi aparține metoda metoda(), respectiv metoda.__func__ este obiectul funcție care îi corespunde metodei în cauză (adică, lui metoda()).

9.8. Iteratori¶

Deja ați remarcat, probabil, că majoritatea obiectelor container pot fi inspectate în mod iterativ (de la englezescul, în jargon informatic, loop over; vom întrebuința și constructele iterate de-a lungul, respectiv iterate în lung) folosind o instrucțiune de ciclare for:

for elementul in [1, 2, 3]:
    print(elementul)
for elementul in (1, 2, 3):
    print(elementul)
for cheia in {'unu':1, 'doi':2}:
    print(cheia)
for cheia in "123":
    print(cheia)
for rândul in open("fișierul_meu_text.txt"):
    print(rândul, end='')

Acest stil de acces la itemi este clar, concis și convenabil. Utilizarea iteratorilor constituie o practică sistematică, cu caracter unificator, în Python. În culise, instrucțiunea for face apel la iter() având drept argument obiectul container. Funcția va întoarce un obiect iterator, care definește metoda __next__(), metodă ce accesează în mod secvențial elementele containerului respectiv. Atunci când nu mai întâlnește niciun item (al containerului), __next__() va lansa o excepție StopIteration pentru a-i spune buclei for să se încheie. Puteți apela metoda __next__() cu ajutorul funcției prestabilite next(); exemplul următor vă dezvăluie cum trebuie procedat:

>>> șirul = 'abc'
>>> iteratorul = iter(șirul)
>>> iteratorul
<str_iterator object at 0x10c90e650>
>>> next(iteratorul)
'a'
>>> next(iteratorul)
'b'
>>> next(iteratorul)
'c'
>>> next(iteratorul)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    next(iteratorul)
StopIteration

Le putem acum, dat fiind că tocmai am văzut mecanismul prin care se pune în practică protocolul iteratorilor, adăuga un comportament de iterator claselor noastre. Este suficient să definim o metodă __iter__(), care să întoarcă un obiect ce posedă o metodă __next__(). În caz că clasa noastră îl definește ea însăși pe __next__(), metoda __iter__() nu mai are de făcut decât să-l returneze pe self (apelantului):

class ÎntorsulPeDos:
    """Un iterator pentru a itera de-a lungul unei secvențe,
       în sens invers."""
    def __init__(self, datele):
        self.datele = datele
        self.indexul = len(datele)

    def __iter__(self):
        return self

    def __next__(self):
        if self.indexul == 0:
            raise StopIteration
        self.indexul = self.indexul - 1
        return self.datele[self.indexul]

>>> reversul = ÎntorsulPeDos('arca')
>>> iter(reversul)
<__main__.ÎntorsulPeDos object at 0x00A1DB50>
>>> for caracterul in reversul:
...     print(caracterul)
...
a
c
r
a

9.9. Generatori¶

Generatorii sunt o unealtă puternică, ușor de folosit la construcția de iteratori. Codul Python al generatorilor este asemeni celui al unei funcții obișnuite cu excepția faptului că întrebuințează instrucțiunea yield (în loc de return) ori de câte ori trebuie întoarse date (apelantului). De fiecare dată când un generator va fi (re)folosit drept argument al lui next(), el își va continua activitatea (dat fiind că un generator își amintește toate valorile datelor precum și ultima instrucție executată de la apelul precedent al lui next). Exemplul dat în continuare vă arată că generatorii sunt banal de creat:

def întoarce_pe_dos(datele):
    for indexul in range(len(datele)-1, -1, -1):
        yield datele[indexul]

>>> for caracterul in intoarce_pe_dos('trop'):
...     print(caracterul)
...
p
o
r
t

Orice poate fi realizat folosind iteratorii bazați (explicit) pe clase, vezi cele prezentate în secțiunea anterioară, poate fi obținut și cu generatori. Ceea ce face codul acestora din urmă atât de compact este faptul că metodele __iter__() și __next__() sunt create automat.

Altă trăsătură cheie a generatorilor este aceea că atât variabilele locale cât și starea de la momentul execuției sunt salvate automate între apeluri. Din acest motiv, codul funcției (generator) este mai ușor de scris și mult mai clar în exprimarea ideilor decât ceea ce putem realiza cu o abordare (complicată) în care avem de folosit variabile de instanță precum self.indexul și self.datele.

În afară de creatul automat de metode și de salvatul stării programului, generatorii au proprietatea că, atunci când își termină iterarea, vor lansa automat o StopIteration. Luate împreună, aceste caracteristici ne permit să construim iteratori cu același efort ca la scrierea codului unei funcții oarecare.

9.10. Expresii generator¶

Generatorii simpli pot fi introduși succint în codul Python ca expresii (generator) a căror sintaxă seamănă cu cea de la comprehensiunea listelor, excepție făcând faptul că acolo erau folosite paranteze drepte pe când aici vom întrebuința paranteze rotunde. Astfel de expresii sunt proiectate pentru situații când este nevoie de un generator (simplu) care să fie utilizat de îndată (ce a fost citit de interpretor) de către funcția în codul căreia a fost inserat. Expresiile generator sunt (încă și) mai compacte deși mai puțin versatile decât definițiile complete de generatori, respectiv tind să fie mai prietenoase în privința consumului de memorie decât comprehensiunile de liste corespondente.

Exemple:

>>> sum(i*i for i in range(10))      # sumă de pătrate perfecte
285

>>> vectorul_x = [10, 20, 30]
>>> vectorul_y = [7, 5, 3]
>>> sum(x*y for x,y in
...     zip(vectorul_x, vectorul_y)) # produs scalar
260

>>> cuvinte_unice = set(cuvântul for rândul in pagina
...                     for cuvântul in rândul.split())

>>> șef_de_promoție = max((studentul.media_generală, studentul.numele)
...                       for studentul in absolvenți)

>>> datele = 'trop'
>>> list(datele[i] for i in range(len(datele)-1, -1, -1))
['p', 'o', 'r', 't']

Note de subsol