# Funcții predefinite

Interpretorul de Python dispune de un număr de funcții și de tipuri (de date) predefinite care vă stau în permanență la dispoziție. Ele sunt listate aici în ordine alfabetică.

Funcții predefinite

A
`abs()`
`aiter()`
`all()`
`anext()`
`any()`
`ascii()`
B
`bin()`
`bool()`
`breakpoint()`
`bytearray()`
`bytes()`
C
`callable()`
`chr()`
`classmethod()`
`compile()`
`complex()`
D
`delattr()`
`dict()`
`dir()`
`divmod()`

E
`enumerate()`
`eval()`
`exec()`
F
`filter()`
`float()`
`format()`
`frozenset()`
G
`getattr()`
`globals()`
H
`hasattr()`
`hash()`
`help()`
`hex()`
I
`id()`
`input()`
`int()`
`isinstance()`
`issubclass()`
`iter()`

L
`len()`
`list()`
`locals()`
M
`map()`
`max()`
`memoryview()`
`min()`
N
`next()`
O
`object()`
`oct()`
`open()`
`ord()`
P
`pow()`
`print()`
`property()`

R
`range()`
`repr()`
`reversed()`
`round()`
S
`set()`
`setattr()`
`slice()`
`sorted()`
`staticmethod()`
`str()`
`sum()`
`super()`
T
`tuple()`
`type()`
V
`vars()`
Z
`zip()`
_
`__import__()`

abs(number, /)

  Returnează valoarea absolută a unui număr. Argumentul poate fi orice număr întreg, număr în virgulă mobilă, ori obiect care implementează metoda `__abs__()`. Dacă argumentul este număr complex, atunci va fi returnat modulul său (magnitudinea sa).

aiter(async_iterable, /)

  Returnează un iterator asincron pentru iterabilul asincron dat. Este echivalentă cu apelarea lui `x.__aiter__()`.

  Atenție: spre deosebire de `iter()`, `aiter()` nu dispune și de o versiune cu două argumente.

  Added in version 3.10.

all(iterable, /)

  Returnează `True` dacă fie toate elementele iterabilului (de la englezescul, ca jargon informatic, iterable) au valoarea logică adevărat fie iterabilul este vid (gol). Echivalentă cu:

      def toate(iterabilul):
          for elementul in iterabilul:
              if not elementul:
                  return False
          return True

awaitable anext(async_iterator, /)
awaitable anext(async_iterator, default, /)

  Când acesta e așteptat, returnează fie itemul care urmează după (valoarea argumentului) iteratorul asincron dat fie default (adică, valoarea predefinită) dacă valoarea respectivă a fost setată iar iteratorul a ajuns la final.

  Prezenta este varianta asincronă a funcției predefinite `next()` și are un comportament asemănător celei din urmă.

  Ea apelează metoda `__anext__()` a lui async_iterator, fiind returnat un de așteptat. Ca urmare a așteptării se va întoarce valoarea următoare a iteratorului. Dacă default este precizat, atunci această valoare predefinită va fi returnată în cazul când iteratorul a ajuns la final iar în caz contrar va fi lansată o excepție `StopAsyncIteration`.

  Added in version 3.10.

any(iterable, /)

  Returnează `True` dacă măcar unul din elementele argumentului iterable (adică, iterabilul; din englezește, ca jargon informatic) are valoarea logică adevărat. Dacă iterabilul este vid, se va returna `False`. Echivalentă lui:

      def măcar_unul(iterabilul):
          for elementul in iterabilul:
              if elementul:
                  return True
          return False

ascii(object, /)

  Aidoma lui `repr()`, returnează un șir de caractere care constituie o reprezentare afișabilă a unui obiect (adică, argumentul object), însă cu escaparea tuturor caracterelor non-ASCII din șirul pe care l-ar fi înapoiat `repr()`, escapare realizată folosind constructele `\x`, `\u` ori `\U`. În acest fel, se va genera un șir de caractere asemănător celui returnat de funcția `repr()` din Python 2.

bin(integer, /)

  Convertește un număr întreg la un șir de caractere binare prefixat cu „0b”. Rezultatul este o expresie validă în Python. Dacă integer (adică, un întreg) nu este un obiect Python din clasa `int`, atunci el trebuie să fie un obiect care definește o metodă `__index__()` ce returnează numere întregi. Câteva exemple:

      >>> bin(3)
      '0b11'
      >>> bin(-10)
      '-0b1010'

  Fără legătură cu faptul că poate nu vă place respectivul prefix „0b”, întrebuințați-o pe cea (mai) convenabilă dintre modalitățile de mai jos.

      >>> format(14, '#b'), format(14, 'b')
      ('0b1110', '1110')
      >>> f'{14:#b}', f'{14:b}'
      ('0b1110', '1110')

  See also `enum.bin()` to represent negative values as twos-complement.

  Vedeți și `format()` pentru mai multe informații.

class bool(object=False, /)

  Returnează o valoare booleană, adică pe unul din itemii `True` (Adevărat) și `False` (Fals). Argumentul va fi convertit pe baza procedurii de testare a valorii de adevăr. Dacă argumentul fie are valoarea logică fals fie lipsește, se va returna `False`; în caz contrar, se returnează `True`. Clasa `bool` îi este subclasă lui `int` (a se vedea Tipuri numerice – int, float, complex). Nu poate fi moștenită. Singurele sale instanțe sunt `False` și `True` (consultați Tipul boolean – bool).

  Schimbat în versiunea 3.7: Parametrul este acum numai pozițional.

breakpoint(*args, **kws)

  Această funcție vă va transporta chiar în locul din care depanatorul programului a apelat-o. Mai precis, ea apelază funcția `sys.breakpointhook()`, transmițându-i direct argumentele (poziționale) `args` și (cuvinte-cheie) `kws`. De obicei, `sys.breakpointhook()` o apelează pe `pdb.set_trace()`, fără să fie nevoie de argumente. În această situație, funcția de față este doar o funcție de conveniență, construită pentru a ne scuti atât de importul explicit al modulului `pdb` cât și de tastatul de (prea mult) cod pentru a ajunge la depanator. Însă, `sys.breakpointhook()` poate fi setată cu altă funcție, ceea ce înseamnă că `breakpoint()` o va apela automat pe aceasta din urmă (în locul lui set_trace), fapt care vă va permite să lansați (și să utilizați) un depanator pe gustul dumneavoastră. Atunci când `sys.breakpointhook()` nu este disponibilă, funcția de față va lansa o excepție `RuntimeError`.

  În mod predefinit, comportamentul lui `breakpoint()` poate fi schimbat cu ajutorul variabilei de mediu `PYTHONBREAKPOINT`. Vedeți `sys.breakpointhook()` pentru detalii de întrebuințare.

  Aveți în vedere că mecanismul descris mai sus nu mai este garantat dacă o înlocuiți pe `sys.breakpointhook()`.

  Lansează un eveniment de auditare `builtins.breakpoint` cu argumentul `breakpointhook`.

  Added in version 3.7.

class bytearray(source=b'')
class bytearray(source, encoding, errors='strict')

  Întoarce un (nou) tablou de octeți. Clasa `bytearray` îi corespunde unei secvențe mutabile de numere întregi situate în plaja de valori 0 <= x < 256. Posedă majoritatea metodelor tipice ale secvențelor mutabile, care sunt prezentate în Tipuri de secvențe mutabile, precum și mare parte din metodele tipului (de date) `bytes`, după cum se poate vedea în Operații cu octeți și cu tablouri de octeți.

  Parametrul opțional source (adică, sursa) poate fi folosit la inițializarea tabloului în câteva feluri (diferite):

  - Dacă este șir de caractere, atunci trebuie setat și parametrul encoding (adică, codificarea șirului), respectiv (opțional) parametrul errors (adică, cum controlăm erorile, eventuale, de codificare); după care, `bytearray()` va converti șirul de caractere în octeți pe baza metodei `str.encode()`.

  - Dacă este număr întreg, atunci tabloul va avea dimensiunea dată de el și va fi inițializat cu octeți null.

  - Dacă este un obiect care respectă interfața de memorie-tampon, atunci un buffer (adică, o memorie-tampon) doar-de-citit al obiectului respectiv va fi folosit la inițializarea tabloului de octeți.

  - Dacă este un iterabil (de la englezescul, ca jargon informatic, iterable), atunci trebuie să aibă drept elemente doar numere întregi din plaja de valori `0 <= x < 256`, aceste numere alcătuind conținutul inițial al tabloului.

  Dacă nu introducem niciun argument, atunci va fi creat un tablou de dimensiune 0 (gol).

  Vedeți, de asemeni, Tipuri de secvențe binare – octeți, tablouri de octeți, vederi de memorie și Obiecte tablou de octeți.

class bytes(source=b'')
class bytes(source, encoding, errors='strict')

  Returnează un obiect „bytes” (așadar, octeți) nou, adică o secvență imutabilă de numere întregi din plaja de valori `0 <= x < 256`. Clasa `bytes` este varianta imutabilă a clasei `bytearray` – astfel, ea posedă aceleași metode non-mutabile și are același comportament la indexare și la tranșare precum cea din urmă.

  Ca atare, argumentele constructorului se interpretează la fel ca la `bytearray()`.

  Obiecte octeți pot fi create și cu valori literale, a se vedea Valori literale din șiruri de caractere și din octeți.

  A se vedea, de asemeni, Tipuri de secvențe binare – octeți, tablouri de octeți, vederi de memorie, Obiecte octeți, precum și Operații cu octeți și cu tablouri de octeți.

callable(object, /)

  Returnează `True` dacă argumentul object (adică, obiectul) pare apelabil, respectiv `False` în caz contrar. Chiar dacă a fost returnat `True`, tot este posibil ca apelul să eșueze, însă dacă valoarea de adevăr returnată a fost `False`, atunci, cu siguranță, apelarea lui object nu va reuși. Nu uitați că clasele sunt apelabile (apelul unei clase întoarce o instanță a acesteia); la rândul lor, instanțele sunt apelabile dacă provin dintr-o clasă care posedă o metodă `__call__()`.

  Added in version 3.2: Această funcție a fost mai întâi eliminată din Python 3.0 și apoi reintrodusă în Python 3.2.

chr(codepoint, /)

  Întoarce șirul de caractere prin care este desemnat caracterul având valoarea (sau codul de caracter ori punctul de cod din planul multilingvistic) Unicode dată de numărul întreg specificat. De exemplu, `chr(97)` va returna șirul de caractere `'a'`, în timp ce `chr(8364)` va întoarce șirul de caractere `'€'`. Este inversa funcției `ord()`.

  Domeniul de valori al argumentului ține de la 0 și până la, inclusiv, 1,114,111 (adică, 0x10FFFF în baza de numerație 16). Pentru valori ale lui din afara acestui domeniu va fi lansată o excepție `ValueError`.

@classmethod

  Transformă o metodă într-o metodă de clasă.

  Unei metode de clasă i se transmite clasa însăși drept prim argument implicit, tot așa cum unei metode de instanță îi va fi transmisă instanța. Pentru a declara o metodă de clasă, întrebuințați idiomul care urmează:

      class ClasaMea:
          @classmethod
          def f(cls, argumentul1, argumentul2): ...

  Formula `@classmethod` este un decorator de funcție – vedeți Definiții de funcții pentru detalii.

  O metodă de clasă poate fi apelată pornind fie de la clasă (ca în `C.f()`) fie de la o instanță a acesteia (ca în `C().f()`). Instanța, luată ca atare, va fi ignorată, tot ceea ce va conta fiind clasa din care provine. Atunci când o metodă de clasă se apelează pornind de la vreo clasă derivată (din clasa în care a fost definită metoda), obiectul clasă derivată îi va fi transmis metodei pe post de prim argument implicit.

  Metodele de clasă diferă de ceea ce se înțelege atât în C++ cât și în Java prin metode statice. Dacă sunteți interesat de amănunte privind astfel de metode, consultați rubrica `staticmethod()` din secțiunea de față. Mai multe informații relative la metodele de clasă pot fi citite în Ierarhia standard a tipurilor.

  Schimbat în versiunea 3.9: Metodele de clasă pot cuprinde, de acum, și alți descriptori, precum `property()`.

  Schimbat în versiunea 3.10: Metodele de clasă moștenesc, de acum, atributele de metodă (`__module__`, `__name__`, `__qualname__`, `__doc__` și `__annotations__`), respectiv posedă un atribut `__wrapped__` nou.

  Deprecated since version 3.11, removed in version 3.13: Metodele de clasă nu mai pot cuprinde alți descriptori, cum ar fi `property()`.

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

  Îl compilează pe source (adică, sursa) fie într-un obiect cod fie într-un obiect AST. Obiectele cod pot fi executate cu `exec()` ori cu `eval()`. Sursa poate fi un șir de caractere obișnuit, un șir de octeți, respectiv un obiect AST. Vizitați documentația modulului `ast` pentru informații referitoare la cum trebuie procedat cu obiectele AST.

  Argumentul filename (adică, nume_de_fișier) trebuie să furnizeze fișierul din care a fost citit codul (de compilat); transmiteți orice valoare recognoscibilă în caz că acest cod nu a fost citit din vreun fișier (`'<string>'` este folosit frecvent).

  Argumentul mode (adică, felul) precizează tipul de cod care trebuie compilat; acesta poate fi `'exec'` dacă sursa constă dintr-o secvență de instrucțiuni, `'eval'` dacă avem doar o singură expresie (ca sursă), respectiv `'single'` atunci când avem (de compilat) numai o instrucțiune iterativă (în acest ultim caz, formulele expresiilor care se evaluează drept ceva diferit de `None` vor fi afișate ca atare).

  Argumentele opționale flags (adică, fanioane ori indicatoare) și dont_inherit (adică, nu_se_moștenește) controlează care din setările de compilator trebuie activate și care din caracteristicile viitoare (adică, instrucțiunile future ori setările din viitor) trebuie permise. Dacă niciunul din argumente nu este precizat (ori dacă amândouă sunt egale cu zero), atunci codul va fi compilat ținând seama de exact aceleași indicatoare care erau active pentru codul care a apelat funcția `compile()`. Dacă se dă argumentul flags dar nu și argumentul dont_inherit (sau dacă acesta din urmă este zero), atunci setările de compilator și setările din viitor specificate de argumentul flags vor fi întrebuințate împreună cu toate setările de care s-ar fi ținut seama în orice caz. În schimb, dacă dont_inherit este un număr întreg nenul, atunci se consideră că argumentul flags conține toate setările în vigoare – adică, indicatoarele (caracteristici viitoare și setări de compilator) din codul exterior (cel din care s-a făcut apelul) vor fi ignorate.

  Setările de compilator și setările future sunt precizate de biți (individuali) iar aceștia pot fi supuși unei operații SAU pe biți (adică, multiplexați) atunci când este nevoie să specificăm un cumul de opțiuni. Câmpul de biți (de la englezescul, ca jargon informatic, bitfield) folosit pentru precizarea unei caracteristici future se găsește în atributul `compiler_flag` al instanței `_Feature` din modulul `__future__`. Setările de compilator se află în modulul `ast`, unde au primit prefixul `PyCF_`.

  Argumentul optimize (adică, optimizarea) specifică nivelul de optimizare al compilatorului; valoarea implicită `-1` face să fie selectat nivelul de optimizare al interpretorului care le corespunde setărilor `-O`. Nivelurile explicite sunt `0` (fără optimizare; `__debug__` are valoarea logică adevărat), `1` (aserțiunile sunt eliminate, `__debug__` are valoarea logică fals) sau `2` (sunt eliminate inclusiv docstring-urile).

  This function raises `SyntaxError` or `ValueError` if the compiled source is invalid.

  Dacă doriți să parsați codul Python sub forma unei reprezentări AST, consultați `ast.parse()`.

  Lansează un eveniment de auditare `compile` cu argumentele `source` și `filename`. Un astfel de eveniment poate fi lansat și de o compilare implicită.

  Notă

  Atunci când compilăm un șir de caractere care constă din mai multe rânduri de cod Python în modul `'single'` sau `'eval'`, acest șir trebuie să se încheie cu cel puțin un caracter rând-nou. O asemenea restricție servește la deosebirea dintre instrucțiunile incomplete și cele complete în modulul `code`.

  Atenționare

  Este posibil să defectați funcționarea interpretorului de Python dacă îi cereți să compileze un șir de caractere prea mare/sofisticat într-un obiect AST și aceasta din cauza restricțiilor privitoare la stiva de apeluri ale compilatorului AST al Python-ului.

  Schimbat în versiunea 3.2: Permite utilizarea caracterelor rând-nou din Windows și Mac. De asemeni, datele de intrare în modul `'exec'` nu mai trebuie să se termine cu un caracter rând-nou. A fost adăugat parametrul optimize.

  Schimbat în versiunea 3.5: Până acum, o excepție `TypeError` era lansată atunci când se întâlneau octeți null în source.

  Added in version 3.8: De acum, `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT` poate fi transmis în flags ca să se activeze suportul pentru `await`, `async for` și `async with` la nivel global.

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

  Transformă fie un (singur) șir de caractere fie un număr (real) într-un număr complex, respectiv creează un număr complex din părțile sale reală și imaginară.

  Exemple:

      >>> complex('+1.23')
      (1.23+0j)
      >>> complex('-4.5j')
      -4.5j
      >>> complex('-1.23+4.5j')
      (-1.23+4.5j)
      >>> complex('\t( -1.23+4.5J )\n')
      (-1.23+4.5j)
      >>> complex('-Infinity+NaNj')
      (-inf+nanj)
      >>> complex(1.23)
      (1.23+0j)
      >>> complex(imag=-4.5)
      -4.5j
      >>> complex(-1.23, 4.5)
      (-1.23+4.5j)

  Dacă argumentul este șir de caractere, atunci el trebuie să includă fie partea reală (în același format cu cel de la `float()`) fie partea imaginară (păstrând formatul pomenit anterior, dar adăugând unul din sufixele `'j'` și `'J'`), ori atât partea reală cât și partea imaginară (în această situație, semnul părții imaginare este obligatoriu) ale numărului complex pe care intenționăm să-l construim. Este permis ca șirul de caractere să fie încadrat de spații goale (opționale), respectiv de parantezele rotunde `'('` și `')'`, elemente tipografice care vor fi ignorate cu toatele. Pe de altă parte, șirul de caractere nu poate include spații goale poziționate între vreunul din semnele tipografice `'+'`, `'-'` ori sufixele `'j'`, `'J'` și numărul zecimal în cauză. Ca exemplu, se admite formula `complex('1+2j')` în timp ce formula `complex('1 + 2j')` va lansa excepția `ValueError`. Mai precis, datele de intrare trebuie să se conformeze regulii de producție `complexvalue`, din gramatica limbajului, dată mai jos, iar aceasta după ce atât parantezele cât și prefixele ori sufixele date de spații goale vor fi fost eliminate:

      complexvalue ::= floatvalue |
                       floatvalue ("j" | "J") |
                       floatvalue sign absfloatvalue ("j" | "J")

  Dacă argumentul este număr, atunci constructorul va fi utilizat la întreprinderea unei conversii numerice, aidoma constructorului clasei `int` și a celui al clasei `float`. Fiind dat un obiect Python oarecare `x`, `complex(x)` îi va fi delegat lui `x.__complex__()`. În caz că metoda `__complex__()` nu este definită, se va regresa la metoda `__float__()`. Dacă nici `__float__()` nu este definită, atunci se va regresa până la `__index__()`.

  Dacă se dau două argumente ori dacă sunt întrebuințate argumente cuvânt-cheie, atunci fiecare din argumente poate fi de orice tip (de date) numeric (inclusiv număr complex). În caz că ambele argumente sunt numere reale, va fi returnat un număr complex având partea reală real și partea imaginară imag. Atunci când ambele argumente sunt numere complexe, deci dispunem de mărimile `real1.real`, `real1.imag` pentru primul argument (`real1`) și de `imag1.real`, `imag1.imag` pentru cel de-al doilea argument (`imag1`), se va returna un număr complex cu partea reală `real1.real-imag1.imag` și cu partea imaginară `real1.imag+imag1.real`. Iar când (numai) unul din argumente este număr real, doar partea sa reală (adică, numărul însuși) va fi folosită la calcularea expresiilor anterioare.

  Dacă nu se dă niciun argument, atunci va fi întors `0j`.

  Tipul (de date număr) complex este prezentat în Tipuri numerice – int, float, complex.

  Schimbat în versiunea 3.6: Este permisă scrierea numerelor grupând cifrele acestora în seturi separate de caractere bară-jos, la fel ca în cazul valorilor literale folosite în cod.

  Schimbat în versiunea 3.8: Regresează până la `__index__()` atunci când metodele `__complex__()` și `__float__()` nu sunt definite.

delattr(object, name, /)

  Este înrudită cu `setattr()`. Argumentele sale sunt un obiect Python oarecare și un șir de caractere. Șirul de caractere trebuie să fie numele unuia dintre atributele obiectului. Dacă obiectul permite o atare acțiune, funcția va șterge atributul care are drept nume șirul de caractere dat. De exemplu, `delattr(x, 'nu_știu_ce')` este echivalent cu `del x.nu_știu_ce`. name nu trebuie să fie neapărat un identificator Python (a se vedea `setattr()`).

class dict(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)

  Creează un dicționar (de date) nou. Obiectul `dict` este clasa dicționar. Vedeți `dict` și Tipuri de asociere – dict pentru documentații referitoare la această clasă.

  În ceea ce privește (celel)alte containere, a se vedea atât clasele predefinite `list`, `set`, respectiv `tuple` cât și modulul `collections`.

dir()
dir(object, /)

  Când nu se dă argumentul, va fi returnată lista tuturor numelor din domeniul de valabilitate local aflat în vigoare. Atunci când se dă argumentul, se va încerca întoarcerea unei liste cuprinzând atributele valide ale obiectului precizat de respectivul argument.

  Dacă obiectul dispune de o metodă numită `__dir__()`, atunci va fi apelată această metodă și ea va trebui să returneze lista atributelor (obiectului). O atare particularitate le permite obiectelor care implementează variante (personalizate) ale funcției `__getattr__()` ori ale funcției `__getattribute__()` să personalizeze felul în care `dir()` dă raportul în privința atributelor.

  Dacă obiectul nu dispune de nicio metodă numită `__dir__()`, atunci funcția va încerca să obțină informații de la atributul `__dict__`, când acesta a fost definit, respectiv din tipul (de date al) obiectului. Lista care va rezulta nu va fi, obligatoriu, completă și ar putea avea și greșeli în caz că obiectul dat ca argument posedă o funcție `__getattr__()` personalizată.

  Mecanismul aflat implicit în spatele lui `dir()` se comportă diferit de la tip de obiecte la tip de obiecte, căci el se străduie să procure informații definitorii mai degrabă decât informații complete:

  - Când obiectul (dat ca argument) este un obiect modul, lista va conține numele atributelor modulului respectiv.

  - Când obiectul este fie un tip (de date) fie un obiect clasă, lista va cuprinde numele atributelor acestuia/acesteia, împreună cu atributele strămoșilor lui/ei, obținute în mod recursiv.

  - În restul situațiilor, lista (returnată) va conține numele atributelor obiectului, numele atributelor clasei din care provine acest obiect, precum și, în mod recursiv, numele atributelor pe care le posedă strămoșii clasei obiectului.

  Lista rezultată va fi ordonată în mod alfabetic. De exemplu:

      >>> import struct
      >>> dir()   # show the names in the module namespace
      ['__builtins__', '__name__', 'struct']
      >>> dir(struct)   # show the names in the struct module
      ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
       '__initializing__', '__loader__', '__name__', '__package__',
       '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
       'unpack', 'unpack_from']
      >>> class Shape:
      ...     def __dir__(self):
      ...         return ['area', 'perimeter', 'location']
      ...
      >>> s = Shape()
      >>> dir(s)
      ['area', 'location', 'perimeter']

  Notă

  Dat fiind că funcția `dir()` este pusă la dispoziție mai ales ca bun de folosință imediată, de întrebuințat de la promptul aflat în modul interactiv, ea va căuta să ne procure un set de nume interesante mai degrabă decât vreo listă de nume copioasă și plină de rigoare în alcătuire (a se citi plicticoasă), putând, inclusiv, să-și schimbe comportamentul în privința amănuntelor între versiuni succesive ale Python-ului. Ca exemplu, atributele de meta-clasă vor lipsi din lista de rezultate atunci când argumentul este o clasă.

divmod(a, b, /)

  Acceptă ca argumente două numere (reale, fără a fi instanțe ale clasei complex) și întoarce o pereche de numere care, în particular, dacă argumentele sunt numere întregi, vor constitui (chiar) câtul și restul așa cum sunt ele obținute la împărțirea cu rest a două numere întregi. Dacă avem operanzi de tipuri diferite, atunci vor opera regulile operatorilor aritmetici în baza de numerație doi. Astfel, pentru operanzi întregi, rezultatul va coincide cu `(a // b, a % b)`. Pentru operanzi în virgulă mobilă, rezultatul va fi `(q, a % b)`, unde q înseamnă, de obicei, `math.floor(a / b)`, deși vom ajunge și în circumstanțe când va fi cu 1 mai mic decât valoarea exprimată prin formula anterioară. Indiferent de situație, valoarea expresiei `q * b + a % b` va fi extrem de aproape de a, iar atunci când `a % b` va fi diferit de zero expresia va avea același semn cu b, respectiv va fi îndeplinită restricția restului unei împărțiri: `0 <= abs(a % b) < abs(b)`.

enumerate(iterable, start=0)

  Returnează un obiect enumerat. iterable (adică, iterabilul) trebuie să fie o secvență, un iterator ori alt obiect care permite iterații. Metoda `__next__()` a iteratorului pe care îl va întoarce `enumerate()` va returna un tuplu conținând un contor (care începe să numere de la start, argument cu valoarea predefinită 0) împreună cu câte una din valorile ce se obțin iterând de-a lungul lui iterable.

      >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
      >>> list(enumerate(seasons))
      [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
      >>> list(enumerate(seasons, start=1))
      [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

  Rezultatul este echivalent cu:

      def enumerate(iterable, start=0):
          n = start
          for elem in iterable:
              yield n, elem
              n += 1

eval(source, /, globals=None, locals=None)
  Argumentele:

    - source (`str` | code object) – O expresie Python.

    - globals (`dict` | `None`) – Spațiul de nume global (predefinit: `None`).

    - locals (mapping | `None`) – Spațiul de nume local (predefinit: `None`).

  Returnează:

    Valoarea rezultată din evaluarea expresiei.

  lansează:

    Erorile de sintaxă se raportează drept excepții.

  Atenționare

  Această funcție va executa orice cod primit. Apelarea ei cu date de intrare oferite de către un utilizator oarecare poate conduce la vulnerabilități de securitate.

  The source argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals mappings as global and local namespace. If the globals dictionary is present and does not contain a value for the key `__builtins__`, a reference to the dictionary of the built-in module `builtins` is inserted under that key before source is parsed. That way you can control what builtins are available to the executed code by inserting your own `__builtins__` dictionary into globals before passing it to `eval()`. If the locals mapping is omitted it defaults to the globals dictionary. If both mappings are omitted, the source is executed with the globals and locals in the environment where `eval()` is called. Note, eval() will only have access to the nested scopes (non-locals) in the enclosing environment if they are already referenced in the scope that is calling `eval()` (e.g. via a `nonlocal` statement).

  Exemplu:

      >>> x = 1
      >>> eval('x+1')
      2

  Această funcție poate fi întrebuințată și pentru a se executa obiecte cod (precum cele create de `compile()`) oarecare. Dacă doriți aceasta, atunci transmiteți-i funcției, în locul unui șir de caractere, un obiect cod. În caz că respectivul obiect cod a fost compilat cu valoarea `'exec'` dată argumentului mode, valoarea returnată de `eval()` va fi `None`.

  Indicații: funcția `exec()` suportă execuția dinamică a instrucțiunilor. Funcțiile `globals()` și `locals()` returnează dicționarul (de nume) global și, respectiv, pe cel local, aflate în vigoare, ceea ce poate fi de folos atunci când respectivele dicționare vor trebui utilizate de către oricare din funcțiile `eval()` și `exec()`.

  În caz că argumentul source este șir de caractere, eventualele spații goale, respectiv tabulatoare, care ar încadra șirul, vor fi eliminate.

  A se vedea `ast.literal_eval()` dacă suntem în căutarea unei funcții capabile să evalueze în siguranță șirurile de caractere prin folosirea doar a unor valori literale.

  Lansează un eveniment de auditare `exec` cu obiectul cod în cauză drept argument. Evenimente provocate de compilarea codului pot fi, de asemenea, lansate.

  Schimbat în versiunea 3.13: Argumentele globals și locals pot fi transmise, de acum, sub formă de (argumente) cuvinte-cheie.

  Schimbat în versiunea 3.13: Semantica spațiului de nume locals predefinit a fost ajustată conform descrierii din documentația builtin-ului `locals()`.

exec(source, /, globals=None, locals=None, *, closure=None)

  Atenționare

  Această funcție va executa orice cod primit. Apelarea ei cu date de intrare oferite de către un utilizator oarecare poate conduce la vulnerabilități de securitate.

  Această funcție suportă execuția dinamică a codului Python. (Argumentul) source trebuie să fie ori un șir de caractere ori un obiect cod. Dacă este șir de caractere, atunci șirul în cauză va fi mai întâi parsat aidoma unei suite de instrucțiuni Python, apoi instrucțiunile respective vor fi executate (cu excepția situației în care intervin erori de sintaxă). [1] Dacă (argumentul) este un obiect cod, el va fi executat pur și simplu. În toate cazurile, codul care va fi executat este presupus drept valid ca fișier de date de intrare (vedeți secțiunea Date de intrare din fișiere din Manualul de referință al limbajului). Atenție la faptul că instrucțiunile `nonlocal`, `yield` și `return` nu pot fi executate în afara unor definiții de funcții iar aceasta inclusiv în situația includerii lor în codul transmis funcției `exec()`. Valoarea returnată este `None`.

  În toate cazurile, dacă părțile opționale sunt omise, codul se execută în domeniul de valabilitate curent. În cazul când doar (maparea) globals se dă, aceasta trebuie să fie un dicționar de date (și nu vreo subclasă a tipului dicționar), dicționar care va fi utilizat atât pentru variabilele globale cât și pentru cele locale. Dacă sunt date atât globals cât și locals, atunci ele vor fi întrebuințate pentru variabilele globale, respectiv pentru cele locale. Atunci când este dat, locals trebuie să fie (orice) obiect mapare. Amintiți-vă că, la nivel de modul, mărimile globale și cele locale se găsesc în același dicționar.

  Notă

  Atunci când `exec` primește două obiecte diferite în calitate de globals și locals, codul va fi executat ca și cum ar fi scufundat în codul definiției unei clase. Aceasta înseamnă că funcțiile și clasele definite în codul care urmează a fi executat nu vor putea accesa variabilele introduse la nivelul cel mai de sus al ierarhiei (căci variabilele „de top” sunt tratate întotdeauna ca variabile de clasă în codul unei definiții de clasă).

  Dacă dicționarul globals nu dispune de nicio valoare pentru cheia `__builtins__`, cheii acesteia i se va da drept valoare o referință la dicționarul modulului predefinit `builtins`. În acest fel, veți putea controla ce mărimi predefinite (adică, builtins-uri) îi sunt accesibile codul care urmează a fi executat introducând pur și simplu propriul dumneavoastră dicționar `__builtins__` în (maparea) globals înainte de a transmiterea acesteia către funcția `exec()`.

  Argumentul closure (adică, închidere) specifică o închidere – un tuplu de cellvar-uri (așa-numitele variabile celulă, referențiate din domenii de valabilitate imbricate celui al unei funcții). Este valid numai atunci când (argumentul) object desemnează un obiect cod care include variabile libere (din închidere). Lungimea tuplului trebuie să îi corespundă precis lungimii atributului `co_freevars` al obiectului cod.

  Lansează un eveniment de auditare `exec` cu obiectul cod în cauză drept argument. Evenimente provocate de compilarea codului pot fi, de asemenea, lansate.

  Notă

  Funcțiile predefinite `globals()` și `locals()` returnează spațiile de nume aflate în vigoare, cel global și respectiv cel local, ceea ce poate fi de folos atunci când respectivele spații de nume vor trebui transmise drept cel de-al doilea și cel de-al treilea din argumentele lui `exec()`.

  Notă

  (Mărimile) locals implicite acționează aidoma descrierii făcute mai jos pentru `locals()`. Dați-i un dicționar locals explicit (argumentului omonim) ca să vedeți efectul codului asupra lui locals după ce interpretorul va reveni de la execuția (codului) funcției `exec()`.

  Schimbat în versiunea 3.11: Adăugat parametrul closure.

  Schimbat în versiunea 3.13: Argumentele globals și locals pot fi transmise, de acum, sub formă de (argumente) cuvinte-cheie.

  Schimbat în versiunea 3.13: Semantica spațiului de nume locals predefinit a fost ajustată conform descrierii din documentația builtin-ului `locals()`.

filter(function, iterable, /)

  Construiește un iterator din acele elemente ale lui iterable (adică, un iterabil) pentru care function (adică, funcția) are valoarea logică adevărat. (Argumentul) iterable poate fi ori o secvență, un container care permite iterații, ori un iterator. Dacă (argumentul) function este `None`, vom socoti că el desemnează funcția identitate, așadar, toate elementele lui iterable care au valoarea logică fals vor fi eliminate.

  Observați că `filter(function, iterable)` îi este echivalent expresiei generatoare `(itemul for itemul in iterable if function(itemul))` în caz că argumentul function nu este `None`, respectiv lui `(itemul for itemul in iterable if itemul)` dacă function este `None`.

  A se vedea `itertools.filterfalse()` pentru funcția complementară, cea care va returna acele elemente ale lui iterable pentru care function va avea valoarea logică fals.

class float(number=0.0, /)
class float(string, /)

  Returnează un număr în virgulă mobilă construit fie dintr-un șir de caractere fie dintr-un număr.

  Exemple:

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

  Dacă argumentul este șir de caractere, acesta trebuie să includă un număr zecimal, precedat eventual de semn și încadrat, opțional, de spații goale. Semnul poate fi `'+'` ori `'-'`; un `'+'` nu produce efecte asupra valorii numărului pe care îl precede. Argumentul poate fi inclusiv un șir de caractere reprezentând un NaN (adică, o cantitate nu-sunt-număr), respectiv plus sau minus infinit. Mai precis, datele de intrare trebuie să se conformeze regulii de producție gramaticale `floatvalue`, de mai jos, iar aceasta după ce prefixele și sufixele (eventuale) formate cu spații goale vor fi fost eliminate:

      sign          ::= "+" | "-"
      infinity      ::= "Infinity" | "inf"
      nan           ::= "nan"
      digit         ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
      digitpart     ::= digit (["_"] digit)*
      number        ::= [digitpart] "." digitpart | digitpart ["."]
      exponent      ::= ("e" | "E") [sign] digitpart
      floatnumber   ::= number [exponent]
      absfloatvalue ::= floatnumber | infinity | nan
      floatvalue    ::= [sign] absfloatvalue

  Scrierea cu litere mari ori mici nu are nicio relevanță aici, astfel că, de exemplu, „inf”, „Inf”, „INFINITY”, respectiv „iNfINity” sunt cu toatele formulări acceptabile pentru plus infinit.

  În schimb, dacă argumentul este fie un număr întreg fie un număr în virgulă mobilă, va fi returnat un număr în virgulă mobilă de aceeași valoare (relativ la precizia reprezentării în virgulă mobilă aflată în vigoare în Python). În situația în care valoarea argumentului se găsește în afara plajei de valori valide ale float-urilor din Python, va fi lansată o excepție `OverflowError`.

  Fiind dat un obiect Python oarecare `x`, `float(x)` îi este delegat lui `x.__float__()`. Dacă `__float__()` nu este definită, atunci se va regresa până la `__index__()`.

  Dacă nu se dau argumente, va fi returnată valoarea `0.0`.

  Tipul float (adică, numere în virgulă mobilă) este prezentat în Tipuri numerice – int, float, complex.

  Schimbat în versiunea 3.6: Este permisă scrierea numerelor grupând cifrele acestora în seturi separate de caractere bară-jos, la fel ca în cazul valorilor literale folosite în cod.

  Schimbat în versiunea 3.7: Parametrul este acum numai pozițional.

  Schimbat în versiunea 3.8: Regresează până la `__index__()` în caz că nu este definită `__float__()`.

format(value, format_spec='', /)

  Îi construiește lui value (adică, lui o valoare) o reprezentare „formatată” (pusă într-un format specificat), conform indicațiilor date de format_spec (adică, de specificația formatului). Interpretarea lui format_spec va depinde de tipul (de date al) argumentului value; există, însă, o sintaxă de formatare standard, pe care o respectă majoritatea tipurilor de date predefinite: Mini-limbajul specificației de format.

  (Argumentul) format_spec implicit este un șir de caractere vid, ceea ce va produce un efect (al apelului funcției de față) similar celui al apelării lui `str(value)`.

  Apelul lui `format(value, format_spec)` se traduce în `type(value).__format__(value, format_spec)`, ceea ce permite ocolirea dicționarului de instanță atunci când va fi căutată metoda `__format__()` a (obiectu)lui value. Va fi lansată o excepție `TypeError` atunci când (argumentul) format_spec este (un șir de caractere) nevid și acțiunea de căutare a metodei ajunge până la `object` , respectiv atunci când cel puțin unul dintre (argumentul) format_spec și valoarea de returnat nu este șir de caractere.

  Schimbat în versiunea 3.4: `object().__format__(format_spec)` lansează o excepție `TypeError` atunci când format_spec nu este un șir de caractere vid.

class frozenset(iterable=(), /)

  Returnează un obiect `frozenset`, ce poate conține, eventual, elemente ale lui iterable (adică, iterabilul). `frozenset` este o clasă predefinită. A se vedea `frozenset` și Tipuri mulțime – setul și setul înghețat pentru documentații referitoare la această clasă.

  Pentru (celel)alte containere, vedeți clasele predefinite `set`, `list`, `tuple` și `dict`, respectiv modulul `collections`.

getattr(object, name, /)
getattr(object, name, default, /)

  Returnează valoarea atributului denumit name al lui object (adică, obiectul). (Argumentul) name (adică, numele) trebuie să fie un șir de caractere. Dacă șirul de caractere exprimat de name este chiar numele unui atribut al lui object, atunci rezultatul (acțiunii funcției de față) este chiar valoarea respectivului atribut. Ca exemplu, `getattr(x, 'nu_știu_ce')` este echivalentă cu `x.nu_știu_ce`. Dacă atributul denumit nu există, se va returna default, în caz că acesta din urmă a fost dat, iar în caz contrar va fi lansată o excepție `AttributeError`. (Șirul de caractere) name nu trebuie să fie neapărat un identificator Python (a se vedea `setattr()`).

  Notă

  Dat fiind că transformarea numelor private are loc la momentul compilării, utilizatorul trebuie să modifice manual numele unui atribut privat (este vorba despre acele atribute cu numele prefixate de două caractere bară-jos) pentru a-l putea găsi cu `getattr()`.

globals()

  Returnează dicționarul (de date) care implementează spațiul de numele al modulului în care ne găsim. Atunci când este vorba de cod poziționat în interiorul (codului) unei funcții, dicționarul va fi setat la momentul definirii funcției și va rămâne neschimbat indiferent de unde va fi apelată funcția în cauză.

hasattr(object, name, /)

  Argumentele sunt un obiect (denumit object) și un șir de caractere (cu numele name). Rezultatul (valoarea întoarsă în urma apelului funcției de față) este `True` dacă șirul de caractere este chiar numele unui atribut al obiectului, respectiv `False` în caz contrar. (A fost implementată sub forma apelului `getattr(object, name)` urmat de observarea eventualei lansări a unei excepții `AttributeError`.)

hash(object, /)

  Returnează valoarea hash a obiectului (dacă acesta posedă o astfel de valoare). Valorile hash sunt numere întregi. Ele se folosesc la comparații rapide ale cheilor de dicționar în timpul unei căutări într-un dicționar (de date). Valorile numerice care sunt găsite egale, în urma efectuării comparației, dispun de aceeași valoare hash (chiar dacă sunt de tipuri diferite, precum numerele 1 și 1.0).

  Notă

  Pentru obiectele care posedă metode `__hash__()` personalizate, țineți seama de faptul că funcția `hash()` trunchiază valoarea returnată relativ la lungimea în biți (a unui număr întreg fără semn) de pe mașina (de calcul) gazdă.

help()
help(request)

  Invocă sistemul de asistență predefinit. (Această funcție a fost gândită pentru o utilizare interactivă.) Dacă nu se dă niciun argument, sistemul de asistență interactiv se va declanșa în consola (terminalul) interpretorului. Când argumentul este un șir de caractere, acest șir va fi căutat ca nume de modul ori de funcție, de clasă, de metodă, respectiv drept cuvânt-cheie sau subiect al documentației, după care (odată ce a fost găsit) o pagină de asistență relevantă va fi afișată în consolă. În caz că argumentul este orice alt obiect, o pagină de asistență relativă la el va fi generată (și afișată).

  Nu uitați că, atunci când o bară oblică directă (/) intervine în lista parametrilor unei funcții, afișată ca urmare a apelării lui `help()`, aceasta presupune că parametrii poziționați la stânga barei oblice directe sunt parametri numai-poziționali. Pentru mai multe informații, a se vedea itemul privitor la parametrii numai-poziționali din lista FAQ/IFF (Întrebări frecvent formulate).

  Această funcție i-a fost adăugată spațiului de nume predefinit de către modulul `site`.

  Schimbat în versiunea 3.4: Modificările aduse lui `pydoc` și lui `inspect` presupun, în particular, că raportările (oferite de sistemul de asistență) despre prototipurile (sau signaturile) unor apelabili sunt, de acum, mai detaliate și cu un plus de consistență.

hex(integer, /)

  Convertește un număr întreg într-un șir de caractere hexazecimale, scris cu litere mici și având prefixul „0x”. În caz că integer (adică, un întreg) nu este obiect al clasei Python `int`, atunci el trebuie să posede măcar o metodă `__index__()` care să returneze numere întregi. Câteva exemple:

      >>> hex(255)
      '0xff'
      >>> hex(-42)
      '-0x2a'

  Dacă doriți să transformați un număr întreg într-un șir de caractere hexazecimale, scris fie cu litere mici fie cu majuscule, respectiv fie prefixat fie fără prefix, atunci vă sunt la îndemână modalitățile de mai jos:

      >>> '%#x' % 255, '%x' % 255, '%X' % 255
      ('0xff', 'ff', 'FF')
      >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
      ('0xff', 'ff', 'FF')
      >>> f'{255:#x}', f'{255:x}', f'{255:X}'
      ('0xff', 'ff', 'FF')

  Vedeți și `format()` pentru mai multe informații.

  Consultați, de asemenea, `int()` în legătură cu convertirea unui șir de caractere hexazecimale într-un număr întreg (care a fost) scris (ca șir) în baza de numerație 16.

  Notă

  Pentru a obține reprezentarea ca șir de caractere hexazecimale a unui număr în virgulă mobilă, utilizați metoda `float.hex()`.

id(object, /)

  Returnează „identitatea” lui object (adică, a lui obiect). Aceasta este un număr întreg căruia îi este garantată unicitatea și constanța (în sistemul Python) relativă la obiectul în cauză pe întreaga durată a existenței acestuia din urmă. Două obiecte cu existențe care nu se suprapun pot deține aceeași valoare a lui `id()`.

  Aceasta (adică, „identitatea”; detaliu de implementare a CPython-ului) este (momentan) adresa obiectului în memorie.

  Lansează un eveniment de auditare `builtins.id` cu argumentul `id`.

input()
input(prompt, /)

  Atunci când se dă argumentul prompt (adică, promptul), acesta va fi înscris în fluxul de ieșire standard (adică, în standard output) fără a i se adăuga niciun caracter rând-nou drept sufix. Funcția va citi apoi un rând (nou) din datele de intrare, îl va converti într-un șir de caractere (eliminând însă eventualul sufix dat de vreun caracter rând-nou), după care va returna rezultatul convertirii. Când se ajunge la EOF (caracterul final-de-fișier), va fi lansată o excepție `EOFError`. De exemplu:

      >>> s = input('--> ')
      --> Monty Python's Flying Circus
      >>> s
      "Monty Python's Flying Circus"

  În caz că a fost încărcat (în prelabil) modulul `readline`, funcția `input()` îl va întrebuința pentru a ne pune la dispoziție capabilități sofisticate de editare a liniei de comandă precum și a istoricului.

  Lansează un eveniment de auditare `builtins.input` cu argumentul `prompt` înainte de citirea datelor de intrare.

  Lansează un eveniment de auditare `builtins.input/result` cu rezultatul (drept argument) după ce datele de intrare au fost citite cu succes.

class int(number=0, /)
class int(string, /, base=10)

  Întoarce un obiect (număr) întreg construit fie dintr-un număr (argumentul number) fie dintr-un șir de caractere (argumentul string), respectiv returnează `0` atunci când nu se dau argumente.

  Exemple:

      >>> int(123.45)
      123
      >>> int('123')
      123
      >>> int('   -12_345\n')
      -12345
      >>> int('FACE', 16)
      64206
      >>> int('0xface', 0)
      64206
      >>> int('01110011', base=2)
      115

  Dacă argumentul (dat) `x` dispune de o metodă `__int__()`, atunci `int(x)` va întoarce (valoarea returnată de) `x.__int__()`. Dacă argumentul posedă metoda `__index__()`, atunci va fi întoarsă (valoarea returnată de) `x.__index__()`. În sfârșit, dacă argumentul a implementat metoda `__trunc__()`, se va întoarce (valoarea returnată de) `x.__trunc__()`. Pentru numere (argumente) în virgulă mobilă, trunchierea se face prin lipsă când numerele sunt pozitive, respectiv prin adaos când sunt negative.

  În situația când sau argumentul (întâi) nu este număr sau i se dă o valoare explicită lui base (adică, bazei de numerație), argumentul (întâi) trebuie să fie sau un șir de caractere sau o instanță a uneia din clasele `bytes` și `bytearray`, care instanță să reprezinte un număr întreg exprimat în baza de numerație base. În mod opțional, șirul de caractere poate fi precedat fie de `+` fie de `-` (fără să existe spații goale între prefix și acesta), poate fi prefixat cu zerouri, poate fi încadrat de spații goale, în fine, poate avea (caracterele) cifrele grupate în seturi separate prin caractere bară-jos.

  Un șir de caractere care desemnează un număr întreg exprimat în baza de numerație n conține (doar) „cifre”, fiecare „cifră” corespunzându-i unei valori întregi situate între 0 și n-1 (inclusiv). Valorile 0–9 se reprezintă prin caracterele Unicode corespunzând cifrelor zecimale. Valorile 10–35 pot fi reprezentate de caracterele (de literă, ASCII) de la `a` la `z` (ori de la `A` la `Z`). Valoarea implicită a argumentului base este 10. Bazele de numerație acceptate sunt 0 și (numerele din plaja) 2–36. Șirurile date în baza 2, în baza 8 și în baza 16 pot fi prefixate, opțional, cu `0b`/`0B`, `0o`/`0O` și respectiv `0x`/`0X`, aidoma valorilor literale care exprimă numere întregi întâlnite în codul Python. Relativ la baza (de numerație) 0, șirul de caractere va fi interpretat în același fel cu orice literal întreg din codul Python, adică folosindu-i-se prefixul la determinarea bazei de numerație, 2, 8, 10 ori 16. În plus, în baza 0 nu sunt permise prefixele date de zerouri: astfel, `int('010', 0)` nu va fi acceptat, în timp ce atât `int('010')` cât și `int('010', 8)` vor fi acceptate.

  Tipul (de date număr) întreg este prezentat în Tipuri numerice – int, float, complex.

  Schimbat în versiunea 3.4: Dacă base nu este instanță a lui `int` însă obiectul base are o metodă `base.__index__`, această metodă va fi apelată pentru a determina o valoare întreagă a (argumentu)lui base (adică, a bazei de numerație). Versiunile anterioare (ale funcției) întrebuințau metoda `base.__int__` în locul metodei `base.__index__`.

  Schimbat în versiunea 3.6: Este permisă scrierea numerelor grupând cifrele acestora în seturi separate de caractere bară-jos, la fel ca în cazul valorilor literale folosite în cod.

  Schimbat în versiunea 3.7: Primul parametru (ori argument) este, de acum, numai-pozițional.

  Schimbat în versiunea 3.8: Regresează până la `__index__()` atunci când nu este definită `__int__()`.

  Schimbat în versiunea 3.11: Delegarea lui `__trunc__()` este scoasă din uz.

  Schimbat în versiunea 3.11: Datele de intrare sub formă de șiruri de caractere `int` cât și reprezentările șirurilor de caractere pot fi limitate pentru a se evita atacurile (informatice de tip) denial of service (adică, interzicerea serviciului). Va fi lansată o excepție `ValueError` atunci când se depășește limita atât la convertirea unui șir de caractere într-un (obiect) `int` cât și la conversia unui (obiect) `int` într-un șir de caractere. Consultați documentația privitoare la restricții de lungime la conversia dintre șiruri și întregi.

isinstance(object, classinfo, /)

  Returnează `True` dacă argumentul object (adică, obiectul) este o instanță fie a argumentului (clasă) classinfo fie a vreunui moștenitor (direct, indirect ori virtual) al acestuia din urmă. Dacă object nu este obiect al niciunuia din tipurile anterioare, atunci funcția va întoarce întotdeauna `False`. Dacă classinfo este un tuplu de obiecte tip (de date) (ori, în mod recursiv, de tupluri de acest fel) sau un (obiect) tip uniune de tipuri (de date) diverse, (funcția) va întoarce `True` în caz că object este instanță a vreunuia din aceste tipuri (de date). Atunci când classinfo nu este tip (de date) și nici tuplu format din tipuri (de date) și alte asemenea tupluri, va fi lansată o excepție `TypeError`. Nicio atare excepție `TypeError` nu va putea fi lansată relativ la vreun tip (de date) invalid dacă (acesta) a trecut cu succes de vreo filtrare (precedentă).

  Schimbat în versiunea 3.10: classinfo poate fi un (obiect) tip uniune.

issubclass(class, classinfo, /)

  Returnează `True` dacă (argumentul) class (adică, o clasă) îi este subclasă (directă, indirectă, virtuală) (argumentu)lui (clasă) classinfo. Orice clasă este socotită subclasă a ei însăși. (Argumentul) classinfo poate fi un tuplu de obiecte clasă (ori, în mod recursiv, de tupluri de acest fel) precum și un (obiect) tip uniune, situație în care (funcția de față) va returna `True` când class îi este subclasă oricăruia din elementele care îl alcătuiesc pe classinfo. În restul cazurilor, va fi lansată o excepție `TypeError`.

  Schimbat în versiunea 3.10: classinfo poate fi un (obiect) tip uniune.

iter(iterable, /)
iter(callable, sentinel, /)

  Întoarce un obiect iterator. Primul argument va fi interpretat diferit în funcție de prezența celui de-al doilea argument. Fără cel de-al doilea argument, primul argument trebuie să fie un obiect colecție, care să suporte fie protocolul de iterabil (cu alte cuvinte, metoda `__iter__()`) fie pe cel de secvență (adică, metoda `__getitem__()`, cu argumente numere întregi începând de la `0`). În caz că niciunul din protocoale nu este suportat, se va lansa o excepție `TypeError`. Dacă argumentul al doilea, sentinel (adică, santinela), este dat, atunci primul argument trebuie să fie un obiect apelabil. Iteratorul creat în această situație îl va apela pe callable (adică, apelabilul) fără argumente ori de câte ori va exista un apel al metodei sale `__next__()`; dacă valoarea de returnat va fi egală cu cea a lui sentinel, se va lansa o excepție `StopIteration`, în caz contrar valoarea urmând a fi returnată.

  A se vedea și Tipuri de iterator.

  O aplicație folositoare a celei de-a doua forme a lui `iter()` este la construcția unui cititor pe-blocuri(-de-date). Ca exemplu, iată citirea unor blocuri (de date) de lungime fixă din fișierul binar al unei baze de date, citire efectuată până la întâlnirea finalului de fișier:

      from functools import partial
      with open('datele_mele.db', 'rb') as fișierul:
          for blocul in iter(partial(fișierul.read, 64), b''):
              procesează_blocul_de_date(blocul)

len(object, /)

  Returnează lungimea (adică, numărul de elemente ale) unui obiect. Argumentul poate fi o secvență (precum un șir de caractere, un obiect octeți, un tuplu, o listă ori o plajă de valori) sau o colecție (cum ar fi un dicționar de date, un set, respectiv un set înghețat).

  (Pentru moment, detaliu de implementare al CPython-ului) `len` va lansa excepții `OverflowError` dacă va întâlni lungimi mai mari decât `sys.maxsize`; ca, de exemplu, `range(2 ** 100)`.

class list(iterable=(), /)

  În loc să fie o funcție (ori o comandă), (clasa) `list` este, de fapt, un tip de secvență mutabilă (de date), după cum puteți afla din documentațiile din Liste și din Tipuri secvență – lista, tuplul, plaja de valori.

locals()

  Returnează un obiect mapare (adică, o asociere) reprezentând tab(e)la de simboluri locale aflate în vigoare, cu numele variabilelor drept chei și cu referințele curente ale acestor variabile drept valori.

  Relativ la domeniul de valabilitate al modulului (curent), la fel ca atunci când o utilizăm fie pe `exec()` fie pe `eval()` cu un singur spațiu de nume, funcția de față va returna același spațiu de nume ca și `globals()`.

  Relativ la domeniul de valabilitate al clasei (curente), funcția de față va returna spațiul de nume care urmează a fi transmis constructorului meta-clasei.

  Dacă o utilizăm fie pe `exec()` fie pe `eval()` cu argumente locals și globals diferite, funcția de față va returna spațiul de nume local aflat în vigoare la apelul ei.

  În oricare din cazurile anterioare, fiecare apel al lui `locals()` efectuat într-un cadru de execuție dat va întoarce același obiect mapare. Modificările întreprinse prin intermediul obiectului mapare returnat de `locals()` vor fi vizibile drept variabile locale asignate, reasignate sau șterse, în timp ce asignarea, reasignarea și ștergerea relative la variabile locale vor afecta de îndată conținutul obiectului mapare întors (de funcția de față).

  Pe de altă parte, într-un domeniu de valabilitate optimizat (precum cel de funcții, de generatori și de corutine), fiecare apel al lui `locals()` va returna un dicționar (de date) nou, conținând legăturile curente ale variabilelor locale de funcție precum și referințele la (obiecte) celulă non-locale, în timp ce asignarea, reasignarea, respectiv ștergerea variabilelor locale și a referințelor la (obiecte) celulă non-locale nu vor afecta conținutul niciunuia din dicționarele (de date) returnate anterior.

  Apelarea lui `locals()` ca parte a unei comprehensiuni realizate în codul unei funcții, în cel al unui generator ori în cel al unei corutine este echivalentă apelării acesteia din domeniul de valabilitate ambient, cu particularitatea că variabilele iterative inițializate ale comprehensiunii vor fi incluse (acestui ansamblu locals). În alte domenii de valabilitate, (funcția de față) se comportă ca și cum comprehensiunea ar funcționa ca o funcție imbricată.

  Apelarea lui `locals()` ca parte a unei expresii generatoare este la fel cu apelarea ei din codul unei funcții generatoare imbricate.

  Schimbat în versiunea 3.12: Comportamentul lui `locals()` într-o comprehensiune a fost actualizat în conformitate cu descrierea făcută în PEP 709.

  Schimbat în versiunea 3.13: Parte din PEP 667, semantica mutării acelor obiecte mapare pe care le returnează funcția de față este, de acum, (bine) definită. La fel și comportamentul (funcției de față) într-un domeniu de valabilitate optimizat, descris mai sus. În afară de a fi (bine) definit, comportamentul în alte domenii de valabilitate rămâne neschimbat relativ la versiunile precedente (ale Python-ului).

map(function, iterable, *iterables)

  Întoarce un iterator care aplică (argumentul) function (adică, funcția) fiecăruia din itemii (argumentu)lui iterable (adică, iterabilul), producând rezultatele. În caz că sunt transmise și argumentele iterables, (argumentul) function va trebui să accepte tot atâtea argumente (câți iterabili au fost transmiși) și să fie aplicat asincron (în paralel) tuturor itemilor din toți acești iterabili. Când intervin mai mulți iterabili, iteratorul se va opri la încheierea celui mai scurt dintre aceștia. Pentru situațiile în care datele de intrare funcții sunt aranjate dinainte sub formă de tupluri de argumente, a se consulta `itertools.starmap()`.

max(iterable, /, *, key=None)
max(iterable, /, *, default, key=None)
max(arg1, arg2, /, *args, key=None)

  Îl returnează pe cel mai mare din itemii (argumentu)lui iterable (adică, iterabilul) sau pe cel mai mare dintre două sau mai multe argumente (ne referim la arg1, arg2, args).

  Când este transmis un singur argument (numai) pozițional, el trebuie să fie un iterabil. Va fi înapoiat cel mai mare element al său. Când se transmit două sau mai multe argumente (numai) poziționale, cel mai mare dintre aceste argumente poziționale va fi returnat.

  Dispunem de două argumente numai cuvânt-cheie opționale. Argumentul key (adică, cheia) precizează o funcție de ordonare cu un singur argument aidoma celei întrebuințate la `list.sort()`. Argumentul default (adică, de obicei sau implicit) specifică obiectul de returnat în caz că iterabilul transmis este vid. În situația când iterabilul transmis este vid însă (valoarea lui) de obicei nu este transmisă, va fi lansată o excepție `ValueError`.

  Dacă survin mai mulți itemi de valoare maximă, funcția de față îl va returna pe cel întâlnit primul. Un atare comportament este în linia celor întreprinse de (celel)alte unelte dedicate sortării într-un mod uniform precum `sorted(iterable, key=keyfunc, reverse=True)[0]` și `heapq.nlargest(1, iterable, key=keyfunc)`.

  Schimbat în versiunea 3.4: Adăugat argumentul numai cuvânt-cheie default.

  Schimbat în versiunea 3.8: (Argumentul) key poate fi `None`.

class memoryview(object)

  Întoarce un obiect „vedere de memorie” construit din argumentul transmis. Consultați Vederi de memorie pentru mai multe informații.

min(iterable, /, *, key=None)
min(iterable, /, *, default, key=None)
min(arg1, arg2, /, *args, key=None)

  Îl returnează pe cel mai mic din itemii (argumentu)lui iterable (adică, iterabilul) sau pe cel mai mic dintre două sau mai multe argumente (ne referim la arg1, arg2, args).

  Când este transmis un singur argument (numai) pozițional, el trebuie să fie un iterabil. Va fi înapoiat cel mai mic element al său. Când se transmit două sau mai multe argumente (numai) poziționale, cel mai mic dintre aceste argumente poziționale va fi returnat.

  Dispunem de două argumente numai cuvânt-cheie opționale. Argumentul key (adică, cheia) precizează o funcție de ordonare cu un singur argument aidoma celei întrebuințate la `list.sort()`. Argumentul default (adică, de obicei sau implicit) specifică obiectul de returnat în caz că iterabilul transmis este vid. În situația când iterabilul transmis este vid însă (valoarea lui) de obicei nu este transmisă, va fi lansată o excepție `ValueError`.

  Dacă survin mai mulți itemi de valoare minimă, funcția de față îl va returna pe cel întâlnit primul. Un atare comportament este în linia celor întreprinse de (celel)alte unelte dedicate sortării într-un mod uniform precum `sorted(iterable, key=keyfunc)[0]` și `heapq.nsmallest(1, iterable, key=keyfunc)`.

  Schimbat în versiunea 3.4: Adăugat argumentul numai cuvânt-cheie default.

  Schimbat în versiunea 3.8: (Argumentul) key poate fi `None`.

next(iterator, /)
next(iterator, default, /)

  Captează itemul următor dintr-un iterator apelând metoda `__next__()` a acestuia. Dacă se dă (argumentul) default (adică, implicit), atunci valoarea lui va fi returnată când se încheie iteratorul, în caz contrar fiind lansată o excepție `StopIteration`.

class object

  Aceasta este clasa de bază originară a tuturor celorlalte clase. Ea dispune de metode care le sunt comune tuturor instanțelor de clase Python. Atunci când constructorul (ei) este apelat, el va returna un obiect nou, fără niciun fel de particularitate. Constructorul (ei) nu acceptă argumente.

  Notă

  Instanțele (clasei) `object` nu posedă atribute `__dict__`, motiv pentru care nu-i veți putea atribui niciun atribut oarecare vreunei instanțe a lui `object`.

oct(integer, /)

  Convertește un număr întreg la un șir de caractere octale prefixat cu „0o”. Rezultatul este o expresie Python validă. În caz că (argumentul) integer (adică, un întreg) nu este obiect al clasei Python `int`, el trebuie să dețină o metodă `__index__()` care returnează numere întregi. De exemplu:

      >>> oct(8)
      '0o10'
      >>> oct(-56)
      '-0o70'

  Când doriți să transformați un număr întreg într-un șir de caractere octale, cu sau fără prefixul „0o”, puteți întrebuința una dintre modalitățile care urmează.

      >>> '%#o' % 10, '%o' % 10
      ('0o12', '12')
      >>> format(10, '#o'), format(10, 'o')
      ('0o12', '12')
      >>> f'{10:#o}', f'{10:o}'
      ('0o12', '12')

  Vedeți și `format()` pentru mai multe informații.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

  Îl deschide pe file (adică, fișierul) și returnează un obiect fișier corespunzător. În caz că fișierul nu poate fi deschis, se va lansa o excepție `OSError`. Consultați Citirea și scrierea fișierelor pentru mai multe exemple privitoare la cum se folosește funcția de față.

  (Argumentul) file este un obiect ca-o-cale-de-acces care ne pune la dispoziție sau denumirea căii de acces (fie absolută fie relativă la directorul în care ne aflăm) la fișierul care urmează să fie deschis sau descriptorul de fișier, exprimat printr-un număr întreg, al fișierului de încorporat. (În caz că se dă un descriptor de fișier, acesta va fi închis atunci când se va închide obiectul I/E returnat, cu excepția situației când (argumentul) closefd este setat la `False`.)

  (Argumentul) mode (adică, modul) este un șir de caractere opțional care precizează felul în care file va fi deschis. Are valoarea implicită `'r'`, ceea ce înseamnă deschidere pentru citirea (lui file) în modul text. Alte valori tipice sunt `'w'`, adică (deschidere pentru) scriere (dacă fișierul există, atunci conținutul său va fi șters), `'x'` pentru creare(a fișierului) în caz că nu există deja, respectiv `'a'` pentru adăugare (ceea ce înseamnă că, în unele sisteme Unix, toate acțiunile de scriere vor adăuga conținut la finalul fișierului indiferent de poziția curentă a cursorului). În modul text, dacă (argumentul) encoding (adică, codificarea) nu este precizat, atunci codificarea folosită va depinde de platforma (de calcul): `locale.getencoding()` este apelată pentru a se obține codificarea locală aflată în vigoare. (Când întreprindeți citiri și scrieri de biți în formă brută, utilizați modul binar și lăsați-l pe encoding nespecificat.) Modurile disponibile sunt:

  Caracterul | Semnificația
  --- | ---
  `'r'` | deschidere pentru citire (implicită)
  `'w'` | deschidere pentru scriere, ștergând întâi ceea ce s-a scris deja
  `'x'` | deschidere cu crearea fișierului (nou), nu va reuși dacă fișierul există deja
  `'a'` | deschidere pentru scriere, va adăuga conținutul la sfârșit dacă fișierul există
  `'b'` | modul binar
  `'t'` | modul text (implicit)
  `'+'` | deschidere pentru actualizare (citire și scriere)

  Modul implicit este `'r'` (deschidere pentru citirea de text, mod sinonim cu `'rt'`). Modurile `'w+'` și `'w+b'` deschid fișierul însă îi trunchiază conținutul.

  Conform celor prezentate în Vedere de ansamblu, Python-ul face deosebirea între (operațiunile) I/E binare și cele (de) text. Fișierele deschise în modul binar (adică, atunci când îl găsim pe `'b'` în argumentul mode) își returnează conținutul sub formă de obiecte `bytes`, în absența oricărei codificări. În modul text (mod implicit, respectiv cel în care ne aflăm atunci când îl găsim pe `'t'` în argumentul mode), conținutul fișierului va fi returnat sub formă de `str`, octeții (conținutului) fiind decodificați mai întâi fie conform unei codificări (implicite) care depinde de platforma (de calcul) pe care lucrăm fie conform unei codificări anumite dacă aceasta din urmă este specificată în encoding.

  Notă

  Python-ul nu depinde de înțelesul pe care îl acordă sistemul de operare noțiunii de fișier text; întreaga procesare (cerută de funcția de față) se efectuează de către Python, fiind, așadar, independentă de platforma (de calcul).

  (Argumentul) buffering (adică, o memorare-tampon) este un număr întreg opțional folosit la implementarea policiticii de memorare tampon (provizorie). Transmiteți-i (valoarea) 0 pentru a opri această memorare temporară (se permite doar în modul binar), 1 pentru opțiunea de a memora temporar rândul curent (se acceptă doar în modul text), respectiv un număr întreg > 1 pentru a indica mărimea în octeți a unei memorii-tampon de mărime constantă. Nu uitați că această modalitate de a specifica mărimea memoriei-tampon se aplică doar la (operațiile) I/E binare cu memorie-tampon, în timp ce `TextIOWrapper` (adică, fișierele deschise cu `mode='r+'`) vor întrebuința o altfel de memorare temporară. Pentru a dezafecta memorarea temporară la `TextIOWrapper`, luați în considerare folosirea fanionului `write_through` la `io.TextIOWrapper.reconfigure()`. Atunci când nu se dă niciun argument buffering, politica implicită de memorare temporară va funcționa după cum urmează:

  - Fișierele binare sunt memorate temporar în calupuri (blocuri) de mărime constantă; mărimea memoriei-tampon se alege folosind o (tehnică) euristică la determinarea „mărimii blocului” (standard de memorie) al dispozitivului pe care lucrăm, respectivând regresând, dacă este cazul, către `io.DEFAULT_BUFFER_SIZE`. Pe multe sisteme (de calcul), memoria-tampon are o lungime cuprinsă, de obicei, între 4096 și 8192 de octeți.

  - Fișierele text „interactive” (adică, fișierele pentru care metoda `isatty()` va returna `True`) întrebuințează memorarea temporară a rândului (de text). Alte fișier text utilizează politica prezentată mai sus în cazul fișierelor binare.

  (Argumentul) encoding desemnează numele codificării utilizate fie la decodificarea fie la codificarea lui file. El trebuie folosit numai în modul text. Codificarea implicită (prestabilită) este dependentă de platforma (de calcul) (adică, este ceea ce va returna `locale.getencoding()`), însă poate fi întrebuințată oricare din codificările de text suportate de Python. Consultați modulul `codecs` pentru lista codificărilor acceptate.

  (Argumentul) errors (adică, erorile) este un șir de caractere opțional care precizează cum se vor aborda erorile (excepțiile) de codificare și de decodificare – nu trebuie folosit în modul binar. O varietate de rutine de tratare a erorilor tipice ne stau la dispoziție (listate în Rutine de tratare a erorilor), nemaivorbind de faptul că orice nume (asociat unei proceduri) legat de tratarea erorilor, care a fost deja înregistrat cu `codecs.register_error()`, este acceptat. Printre numele standard avem:

  - `'strict'` (utilizat) ca să se lanseze o excepție `ValueError` când survine o eroare de codificare. Valoarea implicită de `None` (a lui errors) va produce același efect.

  - `'ignore'` (utilizat când se) ignoră erorile. Atenție la faptul că ignorarea erorilor de codificare (a datelor) poate conduce la pierderi de date.

  - `'replace'` (utilizat deoarece) cauzează inserarea unui marcaj înlocuitor (cum ar fi `'?'`) acolo unde datele sunt malformate.

  - `'surrogateescape'` (utilizat pentru că) va transforma orice octeți incorecți (care nu pot fi decodificați) în componente inferioare de unități surogat de cod (valori Unicode), din plaja de valori pornind de la U+DC80 și până la U+DCFF, inclusiv. Aceste unități surogat de cod vor fi înlocuite cu octeții inițiali atunci când se va folosi rutina de tratare a erorii (înregistrată ca) `surrogateescape` în acțiunea de scriere a datelor. O atare capacitate este utilă la procesarea fișierelor cărora nu le cunoaștem codificarea.

  - `'xmlcharrefreplace'` trebuie folosit doar la scrierea în file. Caracterele care nu pot fi procesate de codificarea în vigoare vor fi înlocuite cu referințe de caractere XML corespunzătoare `&#nnn;`.

  - `'backslashreplace'` (utilizat pentru că) va înlocui datele malformate cu secvențe escape, realizate în Python cu caractere bară-oblică-inversă.

  - `'namereplace'` (de asemeni, de folosit doar la scrierea în file) (utilizat pentru că) va înlocui caracterele care nu pot fi procesate cu secvențe escape (de eludare) `\N{...}`.

  (Argumentul) newline (adică, rând-nou) determină cum se parsează caracterele rând-nou provenite din fluxul de caractere. El poate fi `None`, `''`, `'\n'`, `'\r'` și `'\r\n'`. (Parsarea) funcționează după cum urmează:

  - Atunci când datele de intrare sunt citite din flux iar newline este setat ca `None`, va fi activat modul universal al caracterelor rând-nou. Rândurile (de caractere) din datele de intrare se pot termina în `'\n'`, `'\r'`, respectiv în `'\r\n'` și toate aceste caractere vor fi înlocuite cu `'\n'` înainte de returnarea lor la apelant. Dacă newline este setat ca `''`, modul universal al caracterelor rând-nou se activează, însă finalurile de rând îi sunt întoarse apelantului fără să fi fost modificate. Pentru orice altă valoare permisă (ca setare a lui newline), rândurile de date de intrare se pot termina numai cu șirul de caractere dat (adică, cel al setării) iar finalurile de rând i se vor returna apelantului (tot) fără să fi fost modificate.

  - Atunci când se scriu date de ieșire în flux iar newline este setat ca `None`, orice caracter `'\n'` care este scris va fi înlocuit cu caracterul separator de rânduri (rând-nou) prestabilit (implicit) al sistemului de operare (în care lucrăm), `os.linesep`. Dacă newline este setat ca `''` ori ca `'\n'`, nu se va realiza nicio înlocuire (a caracterelor rând-nou). Dacă newline are oricare altă valoare permisă, atunci fiecare caracter `'\n'` care este scris va fi înlocuit cu valoarea respectivă (a setării lui newline).

  Dacă (argumentul) closefd este `False` și (pentru file) a fost dat un descriptor de fișier în locul unui nume de fișier (a unei denumiri de cale de acces), atunci descriptorul de fișier în cauză va fi menținut deschis (și) după închiderea fișierului. În schimb, atunci când se dă un nume de fișier (pentru file), (argumentul) closed trebuie să fie neapărat `True` (valoarea sa implicită); în caz contrar, va fi lansată o eroare (excepție).

  Un mecanism personalizat de deschidere (a lui file) va putea fi întrebuințat la funcția de față dacă (argumentu)lui opener (adică, deschizătorul) îi va fi transmis un asemenea apelabil. Descriptorul de fișier al obiectului fișier în cauză va fi obținut prin apelarea acestui opener, căruia îi vor fi setate argumentele file și flags. (Apelabilul) opener va trebui să întoarcă un descriptor de fișier deschis (folosirea lui `os.open` pe post de opener ne va pune la dispoziție aceeași funcționalitate precum cea a setării (lui opener) la `None`).

  Fișierul nou creat este de nemoștenit (de către alte procese; non-succesoral).

  Exemplul următor utilizează parametrul dir_fd al funcției `os.open()` pentru a deschide un fișier situat într-un director dat:

      >>> import os
      >>> descriptorul_directorului = os.open('un_director_oarecare', os.O_RDONLY)
      >>> def deschizător(path, flags):
      ...     return os.open(path, flags, dir_fd=descriptorul_directorului)
      ...
      >>> with open('sâcsâc.txt', 'w', opener=deschizător) as f:
      ...     print('Acest mesaj va fi scris în: un_director_oarecare/sâcsâc.txt', file=f)
      ...
      >>> os.close(descriptorul_directorului)  # evitați pierderea resursei

  Tipul (de date al) acelui obiect fișier pe care îl returnează funcția `open()` depinde de argumentul mode (folosit). Atunci când o utilizăm pe `open()` pentru a deschide un fișier în modul text (`'w'`, `'r'`, `'wt'`, `'rt'` șamd.), ea va returna o subclasă a lui `io.TextIOBase` (mai precis, pe `io.TextIOWrapper`). Atunci o întrebuințăm (pe funcția de față) pentru a deschide un fișier în modul binar, cu folosirea unei memorii-tampon, clasa returnată va fi o subclasă a lui `io.BufferedIOBase`. Clasa anume nu rămâne aceeași: la citiri în modul binar, se returnează (un obiect clasă) `io.BufferedReader`; la scrieri și la adăugări de realizat în modul binar, se întoarce `io.BufferedWriter` și, în sfârșit, în modul citit/scris se va returna `io.BufferedRandom`. Când memoria-tampon este dezafectată, va fi întors însăși fluxul brut de date, o subclasă a lui `io.RawIOBase`, adică `io.FileIO`.

  Vedeți, de asemenea, modulele privitoare la manipularea fișierelor, precum `fileinput`, `io` (în care este declarată `open()`), `os`, `os.path`, `tempfile` și `shutil`.

  Lansează un eveniment de auditare `open` cu argumentele `path`, `mode`, `flags`.

  Argumentele `mode` și `flags` pot sau să sufere modificări sau să parvină din apelul original.

  Schimbat în versiunea 3.3:

  - A fost adăugat parametrul opener.

  - A fost adăugat modul `'x'`

  - Până acum era lansată excepția `IOError`, excepție care este, de acum, un pseudonim al lui `OSError`.

  - Se lansează, de acum, excepția `FileExistsError` în caz că fișierul pe care dorim să-l deschidem în modul deschidere-cu-creare (`'x'`) există deja.

  Schimbat în versiunea 3.4:

  - Fișierul este, de acum, de nemoștenit.

  Schimbat în versiunea 3.5:

  - Dacă apelul (de) sistem este întrerupt iar rutina de tratare a semnalului (răspunzător de întrerupere) nu lansează nicio excepție, funcția va încerca din nou, de acum, să realizeze apelul (de) sistem în loc să lanseze o excepție `InterruptedError` (consultați PEP 475 pentru motivație).

  - A fost adăugată rutina de tratare a erorii (înregistrată ca) `'namereplace'`.

  Schimbat în versiunea 3.6:

  - Suport adăugat pentru acceptarea de obiecte care implementează clasa (abstractă) `os.PathLike`.

  - În Windows, dechiderea unei memorii-tampon a consolei (terminalului) poate returna o subclasă a lui `io.RawIOBase` diferită de `io.FileIO`.

  Schimbat în versiunea 3.11: A fost eliminat modul `'U'`.

ord(character, /)

  Returnează valoarea ordinală a unui caracter (Unicode).

  Atunci când (valoarea) argumentul(ui) este un șir de caractere (care desemnează un caracter Unicode) cu un singur element, se va returna un număr întreg reprezentând valoarea (punctul de cod) Unicode a(l) caracterului respectiv. De exemplu, `ord('a')` întoarce numărul întreg `97` iar `ord('€')` (simbolul Euro) returnează `8364`. Este inversa funcției `chr()`.

  Dacă (valoarea) argumentul(ui) este fie un obiect `bytes` fie un obiect `bytearray` de lungime 1, se va returna valoarea octetului său. Ca exemplu, `ord(b'a')` întoarce numărul întreg `97`.

pow(base, exp, mod=None)

  Returnează (argumentul) base (adică, baza) ridicat la puterea (dată de valoarea transmisă argumentului) exp (adică, exponentul); în caz că se dă (argumentul) mod (adică, modulo), va fi returnată valoarea obținută după calculul lui modulo mod din valoarea lui base ridicat la puterea exp (calcul realizat mai eficient decât cel presupus de folosirea expresiei `pow(base, exp) % mod`). Forma cu două argumente a funcției de față, adică `pow(base, exp)`, este echivalentă cu utilizarea operatorului putere: `base**exp`.

  Atunci când argumentele iau valori care aparțin unor tipuri (de date) numerice predefinite diferite, vor fi aplicate regulile de conversie cerute de aritmetica operatorilor în baza de numerație 2. Pentru operanzi `int`, rezultatul va fi de același tip cu operanzii (după conversie), excepție făcând cazul când cel de-al doilea operand este negativ; într-o asemenea situație, toate argumentele vor fi convertite mai întâi în float-uri, apoi rezultatul va fi returnat sub formă de float. De exemplu, `pow(10, 2)` va întoarce `100` pe când `pow(10, -2)` va returna `0.01`. Când avem o bază negativă, de tip `int` ori `float`, și un exponent care nu este număr întreg, rezultatul ne va fi dat sub formă de număr complex (adică, de instanță a clasei `complex`). De exemplu, `pow(-9, 0.5)` va întoarce o valoare apropiată de `3j`. Pe de altă parte, pentru o bază negativă, de tip `int` ori `float`, și un exponent număr întreg, rezultatul ne va fi dat sub formă de număr în virgulă mobilă (adică, de float). Astfel, `pow(-9, 2.0)` returnează `81.0`.

  Pentru operanzi base și exp de tip `int`, atunci când se dă (argumentul) mod, acest mod trebuie să fie și el de tip întreg și, în plus, de valoare nenulă. Când se dă mod iar exp este negativ, valorile (întregi) ale lui base și mod trebuie să fie numere prime între ele. Într-o atare situație, se va returna `pow(inv_base, -exp, mod)`, unde inv_base reprezintă simetricul lui base la operația de înmulțire modulo mod.

  Iată un exemplu de calcul al lui inv_base, și anume inversul (simetricul) lui `38` (la înmulțirea) modulo `97`:

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

  Schimbat în versiunea 3.8: În cazul unor operanzi `int`, forma cu trei argumente a lui `pow` acceptă, de acum, valori negative ale celui de-al doilea argument, permițând astfel calculul elementelor simetrice la înmulțirea modulară.

  Schimbat în versiunea 3.8: Permite argumente (numai) cuvânt-cheie. Până acum, erau admise doar argumente (numai) poziționale.

print(*objects, sep=' ', end='\n', file=None, flush=False)

  Scrie (argumentele) objects (adică, obiectele) în fluxul de text file (adică, fișierul deschis), separându-le prin (valoarea argumentului) sep (adică, separatorul) și adăugând la final (valoarea argumentului) end. (Argumentele) sep, end, file și flush, dacă dorim să le transmitem, trebuie date sub formă de argumente (numai) cuvânt-cheie.

  Argumentele care nu sunt date sub formă de cuvânt-cheie vor fi convertite, cu toatele, în șiruri de caractere, așa cum procedează `str()`, vor fi separate prin sep și urmate, la final, de end. Atât sep cât și end trebuie să fie (ca valoare) șiruri de caractere; dacă sunt date ca `None`, atunci înseamnă că (funcției de față) i se cere să le întrebuințeze valorile implicite (prestabilite). Dacă nu sunt furnizate objects, `print()` va scrie doar end (în flux).

  Argumentul file trebuie să fie un obiect care dispune de o metodă `write(string)`; în caz că file nu este dat ori este `None`, se va utiliza `sys.stdout`. Dat fiind că argumentele care urmează a fi scrise sunt convertite mai întâi în șiruri de caractere tipografice, `print()` nu trebuie folosită cu obiecte fișier (deschise) în modul binar. Pentru astfel de situații, întrebuințați-o pe `file.write(...)`.

  Utilizarea memoriei-tampon la scrierea în fluxul de ieșire este, de obicei, decisă de către (setările lui) file. Cu toate acestea, atunci când (argumentul) flush (adică, fără temporizare sau de îndată) a primit valoarea logică adevărat, în fluxul de ieșire se va scrie fără temporizare (adică, fără folosirea unei memorii-tampon).

  Schimbat în versiunea 3.3: Adăugat argumentul (numai) cuvânt-cheie flush.

class property(fget=None, fset=None, fdel=None, doc=None)

  Returnează atributul (unei clase) dat de (un obiect) proprietate.

  (Argumentul) fget desemnează o funcție de folosit la obținerea (citirea) valorii atributului (adică, un getter). (Argumentul) fset desemnează o funcție de folosit la setarea (scrierea) valorii atributului (adică, un setter). (Argumentul) fdel desemnează o funcție de folosit la ștergerea valorii atributului (adică, un deleter). Iar (argumentul) doc se ocupă de crearea unui docstring (adică, a unui șir de documentație) privitor la atribut.

  O întrebuințare tipică este la definirea atributului manageriat (de la englezescul, ca jargon informatic, managed) `x`:

      class C:
          def __init__(self):
              self._x = None

          def citește_l_pe_x(self):        # un "getter"
              return self._x

          def setează_l_pe_x(self, value): # un "setter"
              self._x = value

          def șterge_l_pe_x(self):         # un "deleter"
              del self._x

          x = property(citește_l_pe_x, setează_l_pe_x, șterge_l_pe_x, \
                      "Eu sunt proprietatea 'x'.")

  Dacă c este o instanță a lui C, atunci `c.x` îl va invoca pe getter, `c.x = valoarea_cutare` îl va invoca pe setter, respectiv `del c.x` îl va invoca pe deleter.

  Dacă este setat, (argumentul) doc va desemna docstring-ul atributului dat de proprietate. În caz contrar, proprietatea va prelua docstring-ul lui fget (în ipoteza că acesta există). O atare capacitate face posibilă crearea facilă de proprietăți doar-de-citit utilizând-o pe `property()` drept decorator:

      class Papagal:
          def __init__(self):
              self._voltaj = 100000

          @property
          def voltajul(self):
              """Citirea valorii actuale a voltajului."""
              return self._voltaj

  Decoratorul `@property` transformă metoda `voltajul()` într-un „getter” al atributului doar-de-citit voltajul (al clasei `Papagal`), respectiv setează docstring-ul lui voltajul la (valoarea) „Citirea valorii actuale a voltajului.”.

  @getter
  @setter
  @deleter

    Un obiect proprietate dispune de metode `getter`, `setter` și `deleter` utilizabile pe post de decorator, iar acești decoratori vor crea o copie a proprietății având funcția accesor (adică, getter) corespunzătoare setată la funcția decorată. Cea mai bună explicație (a acestui mecanism) este oferită de exemplul care urmează:

        class C:
            def __init__(self):
                self._x = None

            @property
            def x(self):
                """Eu sunt proprietatea 'x'."""
                return self._x

            @x.setter
            def x(self, valoare):
                self._x = valoare

            @x.deleter
            def x(self):
                del self._x

    Codul (Python) anterior este absolut echivalent cu cel din primul exemplu. Asigurați-vă că le-ați dat funcțiilor adiționale exact numele proprietății originale (în cazul nostru, `x`).

    Obiectul proprietate returnat va avea drept valori ale atributelor `fget`, `fset` și `fdel` chiar valorile transmise argumentelor corespunzătoare ale constructorului clasei sale (funcția de față).

  Schimbat în versiunea 3.5: Șirurile de documentație (docstring-urile) obiectelor proprietate pot fi, de acum, modificate (ulterior creării obiectelor respective).

  __name__

    Atribut a cărui valoare este numele proprietății. Această valoare poate fi schimbată chiar în timpul execuției (programului).

    Added in version 3.13.

class range(stop, /)
class range(start, stop, step=1, /)

  În loc să fie o funcție (ori o comandă), (clasa) `range` este, de fapt, un tip de secvență imutabilă (de date), după cum puteți afla din documentațiile din Plaje de valori și din Tipuri secvență – lista, tuplul, plaja de valori.

repr(object, /)

  Returnează un șir de caractere care constituie o reprezentare afișabilă a (argumentu)lui object (adică, obiectul). Pentru multe tipuri (de date; având obiectul respectiv drept instanță), funcția de față caută să returneze un șir de caractere care, dacă i-ar fi transmis lui `eval()`, ar avea drept efect obținerea unui obiect de acceași valoare; în caz de nereușită, reprezentarea (oferită de funcția de față unui obiect) este un șir de caractere încadrat de paranteze unghiulare, șir ce include numele tipului (de date al) obiectului și varii informații suplimentare, cum ar fi, adesea, numele și adresa (de memorie ale) obiectului. O clasă poate controla ceea ce returnează funcția de față atunci când este aplicată instanțelor clasei în cauză prin (re)definirea metodei `__repr__()`. Dacă `sys.displayhook()` este inaccesibilă, atunci funcția de față va lansa o excepție `RuntimeError`.

  Clasa de față posedă o reprezentare personalizată, care poate fi evaluată (prin aplicarea lui `eval()`):

      class Persoana:
         def __init__(self, nume, etate):
            self.numele = nume
            self.vârsta = etate

         def __repr__(self):
            return f"Persoana('{self.numele}', {self.vârsta})"

reversed(object, /)

  Returnează un iterator în sens invers. Argumentul trebuie să fie un obiect care sau dispune de o metodă `__reversed__()` sau suportă protocolul de secvență (adică, metodele `__len__()` și `__getitem__()` cu argumente (numere) întregi care încep de la `0`).

round(number, ndigits=None)

  Returnează (argumentul) number (adică, numărul), reconstruit cu precizia dată de rotunjirea sa la (un număr de) ndigits (adică, n-cifre) cifre zecimale situate la dreapta punctului (virgulei). În caz că (argumentul) ndigits lipsește ori este `None`, va fi returnat numărul întreg cel mai apropiat de data de intrare.

  Pentru tipurile (de date) care o suportă pe `round()`, valorile se rotunjesc la cel mai apropiat multiplu de 10 la puterea minus ndigits; atunci când doi astfel de multipli sunt situați la aceeași distanță (o diferență numerică) de valoarea pe care o aproximează, rotunjirea se va realiza prin optarea pentru aceea dintre valorile lor (numere întregi) care este număr par (de exemplu, atât `round(0.5)` cât și `round(-0.5)` returnează numărul `0`, respectiv `round(1.5)` întoarce numărul `2`). Orice număr întreg este acceptat ca valoare a (argumentu)lui ndigits (pozitiv, nul ori negativ). Dacă ndigits fie lipsește fie este `None`, atunci valoarea returnată va fi număr întreg. În restul cazurilor, valoarea întoarsă va fi de același tip (de date) cu number.

  Pentru un obiect Python oarecare, intitulat `number`, `round` i se va delega lui `number.__round__`.

  Notă

  Comportamentul lui `round()` în cazul numerelor în virgulă mobilă (adică, float-uri) poate fi surprinzător: de exemplu, `round(2.675, 2)` ne va da `2.67` în loc de valoarea așteptată, `2.68`. Aceasta nu este greșeală de implementare: este doar rezultatul faptului că cele mai multe din fracțiile zecimale nu pot fi reprezentate exact în virgulă mobilă. Consultați Aritmetică în virgulă mobilă: probleme și limitări pentru mai multe informații.

class set(iterable=(), /)

  Returnează un obiect `set` nou, construit eventual cu itemi preluați din (argumentul) iterable (adică, iterabilul). `set` (adică, tipul mulțime) este o clasă predefinită. Vedeți `set` și Tipuri mulțime – setul, setul înghețat pentru documentații referitoare la această clasă.

  Pentru (celel)alte containere (de date), a se vedea clasele predefinite `frozenset`, `list`, `tuple` și `dict`, cât și modulul `collections`.

setattr(object, name, value, /)

  Aceasta este perechea lui `getattr()`. Argumentele sale sunt object (un obiect Python oarecare), name (un șir de caractere) și value (o valoare arbitrară). Șirul de caractere poate desemna numele vreunui atribut al obiectului (deja existent) ori pe cel al unui atribut nou. Funcția de față îi va atribui valoarea arbitrară acestui atribut, cu condiția ca obiectul să permită aceasta. De exemplu, expresia `setattr(x, 'nu_știu_ce', 123)` este echivalentă cu `x.nu_știu_ce = 123`.

  (Argumentul) name nu trebuie să fie neapărat un identificator Python, așa cum sunt aceștia definiți în Identificatori și cuvinte-cheie, cu excepția situațiilor în care se dorește așa ceva pentru obiectul respectiv, cum ar fi cazul unei `__getattribute__()` personalizate ori cel dat de `__slots__`. Un atribut al cărui nume nu verifică cerințele impuse identificatorilor Python nu va fi accesibil prin intermediul operatorului punct (`.`), însă va putea fi accesat utilizând `getattr()` șamd.

  Notă

  Dat fiind că transformarea numelor private are loc la momentul compilării, utilizatorul trebuie să modifice manual numele unui atribut privat (este vorba despre acele atribute cu numele prefixate de două caractere bară-jos) pentru a-l putea seta cu `setattr()`.

class slice(stop, /)
class slice(start, stop, step=None, /)

  Returnează un obiect tranșă reprezentând un set de indecși precizați de `range(start, stop, step)`. Argumentele start și step (adică, pasul) îl au pe `None` drept valoare implicită.

  Obiectele tranșă dispun de atributele doar-de-citit `start`, `stop` și `step` care nu fac decât să returneze valorile corespunzătoare ale argumentelor (ori valorile implicite ale acestora). Ele nu îndeplinesc nicio altă funcție în mod explicit; cu toate acestea, ele sunt întrebuințate de NumPy precum și de alte pachete ale unor terțe părți.

  start
  stop
  step

  Obiecte tranșă vor fi, de asemeni, generate atunci când facem uz de sintaxa de indexare extinsă. Ca exemplu: `a[start:stop:step]` ori `a[start:stop, i]`. A se vedea `itertools.islice()` pentru o variantă (alternativă) a funcției de față, variantă care returnează un iterator.

  Schimbat în versiunea 3.12: Obiectele tranșă sunt, de acum, identificabile prin hash (cu condiția ca atributele `start`, `stop` și `step` să fie ele însele identificabile prin funcții hash).

sorted(iterable, /, *, key=None, reverse=False)

  Returnează o listă sortată nouă plecând de la itemii (argumentu)lui iterable (adică, iterabilul).

  Posedă două argumente opționale care trebuie utilizate doar sub formă de argumente cuvânt-cheie.

  (Argumentul) key (adică, cheie) specifică o funcție cu un singur argument care va fi folosită pentru a extrage câte o cheie de comparație de la fiecare element al (argumentu)lui iterable (cum ar fi, `key=str.lower`). Valoarea sa prestabilită este `None` (situație în care elementele vor fi comparate în mod direct).

  (Argumentul) reverse (adică, în sens invers) desemnează o valoare de adevăr. Dacă este setat la `True`, atunci elementele listei (care urmează a fi returnată) vor fi sortate inversându-se fiecare comparație (a lor).

  Faceți uz de `functools.cmp_to_key()` dacă doriți să convertiți o funcție cmp (adică, de comparație) din vechiul stil la o funcție key.

  Funcția predefinită `sorted()` este garantat a fi stabilă. Astfel, o sortare este stabilă dacă se certifică faptul că ordinea relativă a elementelor socotite egale în urma comparației nu se va schimba — o atare capacitate este de folos la sortările în mai multe treceri (cum ar fi, sortarea (angajaților) întâi pe departamente, apoi pe niveluri de salarizare).

  The sort algorithm uses only `<` comparisons between items. While defining an `__lt__()` method will suffice for sorting, PEP 8 recommends that all six rich comparisons be implemented. This will help avoid bugs when using the same data with other ordering tools such as `max()` that rely on a different underlying method. Implementing all six comparisons also helps avoid confusion for mixed type comparisons which can call the reflected `__gt__()` method.

  Pentru exemple de sortare și pentru un scurt tutorial privind sortarea, consultați Tehnici de sortare.

@staticmethod

  Transformă o metodă într-o metodă statică.

  O metodă statică nu primește acel prim argument implicit (`self`, al unei metode oarecare). Pentru declararea unei metode statice, folosiți idiomul care urmează:

      class C:
          @staticmethod
          def f(argumentul_1, argumentul_2, argumentul_N): ...

  Formula `@staticmethod` desemnează un decorator de funcție – a se vedea Definiții de funcții pentru detalii.

  O metodă statică poate fi apelată atât prin intermediul clasei (precum în `C.f()`) cât și prin cel unei instanțe a clasei (ca în expresia `C().f()`). În plus, este apelabil și descriptorul metodei statice, astfel că acesta poate fi utilizat în definiția clasei (sub forma lui `f()`).

  Metodele statice din Python le sunt similare celor din Java ori din C++. De asemenea, consultați `classmethod()` pentru o variantă (a mecanismului de față) care ne poate fi de folos la crearea unor constructori de clase (alternativi).

  Aidoma tuturor decoratorilor, `staticmethod` poate fi apelată la fel ca o funcție obișnuită iar rezultatul respectivului apel poate fi întrebuințat. O atare capacitate se dovedește de mare ajutor atunci când ne interesează o referință la o funcție dată în corpul (de cod) al unei clase dar dorim să evităm transformarea automată a (funcți)ei într-o metodă de instanță (a clasei în cauză). Dacă vă găsiți într-o asemenea situație, faceți uz de idiomul de aici:

      def funcția_obișnuită():
          ...

      class C:
          metoda = staticmethod(funcția_obișnuită)

  Pentru mai multe informații relative la metodele statice, vedeți Ierarhia standard a tipurilor.

  Schimbat în versiunea 3.10: De acum, metodele statice pot moșteni atributele de metodă (`__module__`, `__name__`, `__qualname__`, `__doc__` și `__annotations__`), respectiv dispun de un nou atribut, `__wrapped__`, și pot fi apelate ca funcții obișnuite.

class str(*, encoding='utf-8', errors='strict')
class str(object)
class str(object, encoding, errors='strict')
class str(object, *, errors)

  Returnează o (reprezentare în) formă de `str` a (argumentu)lui object (adică, obiectul). Consultați `str()` pentru detalii.

  `str` este clasa predefinită șir de caractere. Pentru informații generale referitoare la șirurile de caractere, vedeți Tipul secvență de text – str.

sum(iterable, /, start=0)

  Îi însumează pe (argumentul) start și pe itemii (argumentu)lui iterable (adică, iterabilul), procedând de la stânga către dreapta, după care returnează rezultatul (totalul). Itemii (argumentu)lui iterable sunt, de obicei, numere în timp ce (argumentu)lui start nu i se permite să fie șir de caractere.

  Într-unele cazuri de întrebuințare, există alternative de calitate la `sum()`. Astfel, modul preferat, rapid, de concatenare a șirurilor de caractere este cel al apelării lui `''.join(sequence)`. Pentru a aduna cu precizie extinsă numerele în virgulă mobilă, consultați `math.fsum()`. Ca să concatenați un șir de iterabili, luați-o în considerare pe `itertools.chain()`.

  Schimbat în versiunea 3.8: Parametrul start se poate preciza ca argument (numai) cuvânt-cheie.

  Schimbat în versiunea 3.12: Însumarea de numere în virgulă mobilă (float-uri) se realizează cu un algoritm (nou) care oferă mai multă acuratețe și o comutativitate mai avantajoasă pentru majoritatea distribuțiilor executabile.

class super
class super(type, object_or_type=None, /)

  Returnează un obiect proxy (adică, un surogat) care va delega apelurile de metode fie unei clase părinte fie unei clase frate a (argumentu)lui type (adică, tipul de date). O atare capacitate își găsește întrebuințare (și) la accesarea (prin intermediul unei clase date a versiunii originale a) acelor metode moștenite de clasa în cauză însă pe care aceasta le-a suprascris.

  (Argumentul) object_or_type (adică, obiectul_ori_tipul) determină ordinea de rezolvare a metodelor pe care le căutăm. Căutarea începe de la clasa situată (în raport cu această ordine de rezolvare) imediat după (clasa) type.

  De exemplu, dacă această (ordine de rezolvare) `__mro__` a (argumentu)lui object_or_type este `D -> B -> C -> A -> object` iar valoarea (argumentu)lui type este `B`, atunci `super()` caută (să rezolve) în ordinea `C -> A -> object`.

  Atributul `__mro__` al clasei corespunzând (argumentu)lui object_or_type listează ordinea de căutare folosită la rezolvarea (găsirea) metodelor atât de `getattr()` cât și de `super()`. Atributul este dinamic și se poate modifica ori de câte ori ierarhia claselor, dată de mecanismul moștenirii, va fi actualizată.

  Atunci când cel de-al doilea argument (al funcției de față) lipsește, obiectul super returnat va fi nelegat. În caz că acest al doilea argument este obiect, `obj`, atunci valoarea logică a expresiei `isinstance(obj, type)` trebuie să fie adevărat. Când cel de-al doilea argument este tip (de date), `type2`, atunci valoarea logică a expresiei `issubclass(type2, type)` trebuie să fie adevărat (ceea ce are utilitate în aplicațiile privitoare la metodele de clasă).

  Atunci când (funcția de față) este apelată din corpul unei metode obișnuite a unei clase, putem omite ambele argumente (suntem în situația așa-numitei „`super()` cu zero argumente”). Aici, (clasa dată de) type va fi clasa de includere (sau de închidere ori ambientul clasei din care se apelează; de la englezescul enclosing) pe când (cel de-al doilea argument, obiectul) obj va fi primul argument al celei dintâi funcții de includere (adică, acel argument implicit tipic, `self`). (Pe cale de consecință, așa-numita `super()` cu zero argumente nu va funcționa conform așteptărilor dacă o apelăm din funcții imbricate, incluzând aici expresiile generatoare, care expresii creează, în mod implicit, funcții imbricate.)

  Există două cazuri tipice (în lumea Python-ului) de întrebuințare pentru super. Astfel, într-o ierarhie de clase datorată unei moșteniri simple (adică, monoparentale), super poate fi folosit pentru a ne referi la clasele părinte fără să le numim în mod explicit, ceea ce face codul nostru mai ușor de întreținut. Această uzanță merge aproape în paralel cu felul în care se lucrează cu super în alte limbaje de programare.

  Cel de-al doilea caz este dat de suportul (de către Python al) moștenirii multiple cooperatiste într-un mediu de execuție dinamic. Îi este specific Python-ului, nefiind întâlnit nici la limbajele cu compilare statică și nici la cele care suportă doar moștenirea simplă. Acest mecanism face posibilă implementarea „diagramelor în formă de diamant” (o reprezentare grafică sub forma unui romb, cu clase (tipuri de date) pe post de vârfuri ale rombului; făcând aluzie la simbolul iconografic al diamantului în cărțile de joc), în care mai multe clase de bază implementează (diferit) aceeași metodă (punându-și în dificultate moștenitorii care vor să folosească respectiva metodă). O proiectare de calitate impune ca astfel de implementări să dispună de o signatură neschimbată a metodelor (dat fiind că ordinea apelurilor se determină la momentul execuției și că această ordine se va adapta de îndată oricărei schimbări petrecute în ierarhia claselor, schimbare care poate include și clase frate ce nu vor fi cunoscute înainte de momentul execuției).

  În ambele cazuri de întrebuințare, un apel tipic al (metodei `metoda()` a) superclasei `B` arată așa:

      class C(B):
          def metoda(self, argumentul):
              super().metoda(argumentul)    # Face același lucru ca:
                                            # super(C, self).metoda(argumentul)

  În afară de căutarea de metode, `super()` funcționează și la căutarea de atribute. Un posibil caz de întrebuințare a ei în această privință este dat de apelarea descriptorilor dintr-o clasă părinte ori dintr-o clasă frate.

  Țineți seama de faptul că `super()` este implementată ca parte a procesului de legare în căutările atributelor cu nume-cu-puncte explicite, cum ar fi `super().__getitem__(name)`. Aceasta se realizează prin definirea unei metode `__getattribute__()` specializate în căutarea de clase într-o ordine predictibilă, ordine care să suporte moștenirea multiplă cooperatistă. Din care motiv, `super()` nu este proiectată pentru căutările implicite care utilizează instrucțiuni ori operatori ca în `super()[name]`.

  De asemenea, remarcați că, exceptându-i versiunea cu zero argumente, `super()` nu este limitată în niciun fel la folosirea de metode interioare. Astfel, versiunea sa cu două argumente își precizează argumentele cu exactitate și realizează referințe potrivite pentru ele. Cât despre ea, versiunea cu zero argumente (a funcției de față) funcționează numai în interiorul unei definiții de clasă, și aceasta deoarece compilatorul îi va adăuga automat detaliile de care este nevoie atât la rezolvarea corectă a clasei care se definește cât și la accesarea instanței curente (a clasei) în căutarea unor metode obișnuite.

  Pentru sugestii practice referitoare la cum să proiectați clase cooperatiste întrebuințându-l pe `super()`, vedeți ghidul de folosire a lui super().

class tuple(iterable=(), /)

  În loc să fie o funcție (ori o comandă), (clasa) `tuple` este, de fapt, un tip de secvență imutabilă (de date), după cum puteți afla din documentațiile din Tupluri și din Tipuri secvență – lista, tuplul, plaja de valori.

class type(object, /)
class type(name, bases, dict, /, **kwargs)

  Cu un singur argument, (funcția de față) returnează tipul (de date al argumentu)lui object (adică, obiectul). Valoarea returnată este un obiect type (adică, tip de date) și, în general, chiar obiectul pe care l-ar returna `object.__class__`.

  Funcția predefinită `isinstance()` se recomandă pentru testarea tipului (de date al) unui obiect, dat fiind că ea va lua în considerare și subclasele.

  Cu trei argumente, (funcția de față) returnează un obiect tip (de date) nou. Avem, practic, o variantă dinamică a instrucțiunii `class`. Șirul de caractere (al argumentului) name (adică, numele) desemnează numele clasei (adică, numele tipului de date pus la dispoziție de obiectul returnat) și devine atributul `__name__` (al acesteia). Tuplul (argumentului) bases (adică, clasele de bază cărora noua clasă le este urmaș) conține clasele de bază și devine atributul `__bases__`; în caz că este vid, clasa `object`, clasa de bază originară a tuturor claselor (din Python), îi va fi adăugată (tuplului) noului atribut. Dicționarul (de date al argumentului) dict conține definițiile atributelor și metodelor care sunt situate în corpul clasei; poate fi copiat ori încadrat (într-un dicționar mai mare) înainte să devină atributul `__dict__`. Următoarele două instrucțiuni creează obiecte `type` identice:

      >>> class X:
      ...     a = 1
      ...
      >>> X = type('X', (), dict(a=1))

  Vedeți și:

  - Documentație referitoare la atributele și metodele claselor

  - Obiecte tip

  Argumentele (numai) cuvânt-cheie furnizate formei cu trei argumente (a funcției de față) îi vor fi transmise mai departe mecanismului corespunzător al metaclasei (de obicei, `__init_subclass__()`) în același mod în care se procedează cu (argumentele) cuvintele-cheie din definiția unei clase oarecare (excepție făcând metaclass).

  Consultați și Personalizarea creării unei clase.

  Schimbat în versiunea 3.6: Subclasele lui `type` care nu îl suprascriu pe `type.__new__` nu mai pot utiliza forma cu un singur argument (a funcției de față) pentru a obține tipul (de date al) unui obiect.

vars()
vars(object, /)

  Returnează atributul `__dict__` al unui modul, al unei clase, al unei instanțe, precum și al oricărui alt (argument) object (adică, obiectul) care dispune de un atribut `__dict__`.

  Obiecte precum modulele și instanțele dispun de atribute `__dict__` actualizabile (direct); în schimb, diverse alte obiecte pot avea restricții de scriere în ceea ce privește atributul `__dict__` (în această situație se află clasele care fac uz de o `types.MappingProxyType` pentru a împiedica actualizarea în mod direct a dicționarelor respective).

  Dacă nu i se transmit parametri, funcția `vars()` se va comporta precum `locals()`.

  Se va lansa o excepție `TypeError` dacă (argumentul) object este precizat însă nu dispune de niciun atribut `__dict__` (ca, de exemplu, atunci când clasa lui își definește atributul `__slots__`).

  Schimbat în versiunea 3.13: Rezultatul apelării acestei funcții fără să i se transmită niciun parametru a fost actualizat după cum este prezentat în documentația funcției predefinite `locals()`.

zip(*iterables, strict=False)

  Iterează în paralel, de-a lungul mai multor iterabili, producând tupluri formate din itemi preluați din fiecare iterabil.

  Exemplu (originalul face aluzie la versuri intraductibile dintr-un cântec de grădiniță englezesc):

      >>> for itemul in zip([1, 2, 3], ['acadele', 'floricele', 'și restul bezele']):
      ...     print(itemul)
      ...
      (1, 'acadele')
      (2, 'floricele')
      (3, 'și restul bezele')

  (Mai) tehnic vorbind: `zip()` returnează un iterator de tupluri, cel de-al i-lea tuplu fiind format din toate elementele plasate, câte unul într-un singur iterabil, pe poziția a i-a în iterabilii transmiși ca parametri.

  Alt mod de a ne imagina ce face `zip()` este să ne închipuim că ea transformă linii (orizontale) în coloane (verticale) și viceversa. Adică, la fel cu ce se întâmplă atunci când construim transpusa unei matrice.

  `zip()` este leneșă: elementele nu vor fi procesate până când iterația nu ajunge la iterabilul care le conține, ca, de exemplu, atunci când întrebuințăm o buclă `for` ori când ne includem într-o `listă`.

  Un lucru de luat în seamă este că iterabilii care îi sunt transmiși lui `zip()` pot avea lungimi diferite; uneori fiindcă așa a fost proiectat, alteori pentru că s-a strecurat o greșeală în codul care a preparat acești iterabili. Python-ul oferă trei abordări diferite ale unei asemenea probleme:

  - În mod prestabilit, `zip()` se oprește atunci când ajunge la sfârșitul celui mai scurt din iterabili. Ea va ignora itemii rămași în iterabilii mai lungi (decât cel deja încheiat), trunchiind rezultatul la lungimea celui mai scurt iterabil (în original, exemplul care urmează face aluzie la un vers intraductibil al unui basm englezesc):

        >>> list(zip(range(3), ['bum', 'paf', 'trosc', 'pleosc']))
        [(0, 'bum'), (1, 'paf'), (2, 'trosc')]

  - `zip()` este folosită adeseori în situații când iterabilii sunt presupuși a fi de lungimi egale. Aici, se recomandă să întrebuințăm opțiunea `strict=True` (vizavi de argumentul strict). Datele de ieșire vor fi la fel ca în urma uzului obișnuit al lui `zip()`:

        >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
        [('a', 1), ('b', 2), ('c', 3)]

    Doar că, spre deosebire de comportamentul uzual (al funcției de față), va fi lansată o excepție `ValueError` în caz că sfârșitul vreunuia din iterabili va fi atins înainte de sfârșitul celorlalți:

        >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
        ...     print(item)
        ...
        (0, 'fee')
        (1, 'fi')
        (2, 'fo')
        Traceback (most recent call last):
          ...
        ValueError: zip() argument 2 is longer than argument 1

    În lipsa setării `strict=True`, eventualele greșeli care au condus la prezența unor iterabili de lungimi diferite nu-și vor mai face vizibilă prezența, existând însă pericolul ca ele să se manifeste în alte zone ale programului sub forma unor defecțiuni cu origine greu de localizat.

  - Iterabilii mai scurți pot fi completați cu o valoare constantă pentru a-i aduce la lungimea convenită, aceeași pentru toți. O atare întreprindere se bazează pe `itertools.zip_longest()`.

  Cazuri limită: Dacă avem doar un singur iterabil (transmis primului argument), `zip()` va returna un iterator de 1-tupluri. Dacă nu le dăm valori argumentelor, atunci va fi returnat un iterator vid (gol).

  Sfaturi și trucuri:

  - Ordinea de evaluare a iterabililor, de la stânga către dreapta, este garantată. Această particularitate face posibilă întrebuințarea următorului idiom pentru parcelarea unei secvențe de date în grupuri de lungime `n`: `zip(*[iter(s)]*n, strict=True)`. Aplicarea sa va produce repetarea aceluiași iterator de `n` ori, astfel că fiecare tuplu din datele de ieșire va avea drept conținut rezultatul a `n` apeluri (consecutive) ale iteratorului. Ca urmare, datele de intrare vor fi împărțite în calupuri (blocuri) de lungime `n`.

  - `zip()` poate fi utilizată în conjuncție cu operatorul `*` pentru a realiza o operație inversă: separarea, adică `unzip()`, componentelor unei liste (de tupluri):

        >>> x = [1, 2, 3]
        >>> y = [4, 5, 6]
        >>> list(zip(x, y))
        [(1, 4), (2, 5), (3, 6)]
        >>> x2, y2 = zip(*zip(x, y))
        >>> x == list(x2) and y == list(y2)
        True

  Schimbat în versiunea 3.10: Adăugat argumentul `strict`.

__import__(name, globals=None, locals=None, fromlist=(), level=0)

  Notă

  Aceasta este o funcție avansată, de care nu va fi nevoie la programarea de zi cu zi în Python, spre deosebire de `importlib.import_module()`.

  Funcția de față este invocată de instrucțiunea `import`. Ea poate fi înlocuită (cu o alta, personalizată; importăm modulul `builtins` și îi atribuim funcția înlocuitoare lui `builtins.__import__`) dacă suntem, realmente, interesați să îi modificăm semantica instrucțiunii `import`, doar că o asemenea întreprindere trebuie evitată în aproape toate circumstanțele (și) pentru că, de obicei, va fi mai simplu să întrebuințați ancore de import(at) (a se vedea PEP 302) pentru a vă atinge scopul fără să riscați producerea unor defecțiuni în porțiunile de cod care presupun că implementarea uzuală a mecanismului importurilor este în vigoare. Utilizarea directă a lui `__import__()` trebuie, de asemenea, înlocuită cu apelarea lui `importlib.import_module()`.

  Funcția importă modulul (dat de argumentul) name (adică, numele), utilizându-le, dacă este posibil, pe (valorile argumentelor) globals (adică, globalele) și pe locals (adică, localele) pentru a stabili cum să-l interpreteze pe name în contextul (apartenenței la un anumit) pachet. (Argumentul) fromlist (adică, din lista) prezintă numele de obiecte și de submodule care trebuie importate din modulul dat de name. Implementarea tipică nu folosește deloc argumentul locals iar pe globals îl utilizează doar la determinarea contextului de pachet cerut de instrucțiunea `import`.

  (Argumentul) level (adică, nivelul) precizează dacă se vor folosi importuri absolute (în privința căii de căutare) ori importuri relative. `0` (valoarea implicită) înseamnă că urmează să se realizeze doar importuri absolute. Valorile pozitive ale (argumentu)lui level indică numărul directoarelor părinte în care se va căuta, începând de la directorul modulului din care a fost apelată `__import__()` (de consultat PEP 328 pentru detalii).

  Dacă (valoarea transmisă către) variabila name este de forma `pachetul.modulul`, atunci va fi returnat, de obicei, doar pachetul de la nivelul cel mai înalt (adică, numele situat la stânga primului operator punct) și nu numele modulului (inclus în numele) dat de name. Cu toate acestea, atunci când dispunem de un argument fromlist nevid, modulul numit de name va fi cel returnat.

  Ca exemplu (originalul face aluzie la numele instraductibil al unei mărci de produse alimentare), instrucțiunea `import conserva` ne va conduce la un cod de octeți asemănător codului următor:

      conserva = __import__('conserva', globals(), locals(), [], 0)

  Instrucțiunea `import conserva.șunca`, la rândul său, ne va conduce la apelul de mai jos:

      conserva = __import__('conserva.șunca', globals(), locals(), [], 0)

  Observați cum returnează funcția `__import__()` doar modulul de la nivelul cel mai înalt și aceasta deoarece el este obiectul legat de un nume prin intermediul instrucțiunii `import`.

  Pe de altă parte, instrucțiunea `from conserva.șunca import ouăle, cârnatul as cârnu` ne va conduce la

      _temp = __import__('conserva.șunca', globals(), locals(), ['ouăle', 'cârnatul'], 0)
      ouăle = _temp.ouăle
      cârnu = _temp.cârnatul

  Aici, modulul `conserva.șunca` este ceea ce va returna `__import__()`. Din acest obiect, numele de importat vor fi extrase și apoi atribuite numelor corespunzătoare lor.

  Dacă tot ceea ce doriți este să importați un modul (eventual situat într-un anumit pachet) folosindu-i numele, atunci (rezumați-vă să) utilizați funcția `importlib.import_module()`.

  Schimbat în versiunea 3.3: Valorile negative ale (argumentu)lui level nu mai sunt suportate (fapt care duce la folosirea lui 0 ca valoare prestabilită a argumentului).

  Schimbat în versiunea 3.9: De acum, când se folosește în linie de comandă una din opțiunile `-E` și `-I`, va fi ignorată variabila de mediu `PYTHONCASEOK`.

Note de subsol

[ 1 ]

Remarcați faptul că parserul (analizorul sintactic) se supune doar convenției de a folosi caractere sfârșit-de-rând în stil Unix. În caz că preluați codul dintr-un fișier, asigurați-vă că este în vigoare modul de conversie al caracterelor rând-nou pentru a fi convertite toate caracterele rând-nou date în stil Windows ori Mac.