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()"   | **E** "enumerate()"     | **L** "len()" "list()"  | **R** "range()" "repr()"  |
| "all()" "any()" "anext()" | "eval()" "exec()"       | "locals()"  **M**       | "reversed()" "round()"    |
| "ascii()"  **B** "bin()"  | **F** "filter()"        | "map()" "max()"         | **S** "set()" "setattr()" |
| "bool()" "breakpoint()"   | "float()" "format()"    | "memoryview()" "min()"  | "slice()" "sorted()"      |
| "bytearray()" "bytes()"   | "frozenset()"  **G**    | **N** "next()"  **O**   | "staticmethod()" "str()"  |
| **C** "callable()"        | "getattr()" "globals()" | "object()" "oct()"      | "sum()" "super()"  **T**  |
| "chr()" "classmethod()"   | **H** "hasattr()"       | "open()" "ord()"  **P** | "tuple()" "type()"  **V** |
| "compile()" "complex()"   | "hash()" "help()"       | "pow()" "print()"       | "vars()"  **Z** "zip()"   |
| **D** "delattr()"         | "hex()"  **I** "id()"   | "property()"            | **_** "__import__()"      |
| "dict()" "dir()"          | "input()" "int()"       |                         |                           |
| "divmod()"                | "isinstance()"          |                         |                           |
|                           | "issubclass()" "iter()" |                         |                           |
+---------------------------+-------------------------+-------------------------+---------------------------+

abs(x)

   Return the absolute value of a number.  The argument may be an
   integer, a floating point number, or an object implementing
   "__abs__()". If the argument is a complex number, its magnitude is
   returned.

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.

   Nou în versiunea 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 all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

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".

   Nou în versiunea 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 any(iterable):
          for element in iterable:
              if element:
                  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(x)

   Convert an integer number to a binary string prefixed with "0b".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. Some examples:

   >>> 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')

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

class bool([x])

   Return a Boolean value, i.e. one of "True" or "False".  *x* is
   converted using the standard truth testing procedure.  If *x* is
   false or omitted, this returns "False"; otherwise, it returns
   "True".  The "bool" class is a subclass of "int" (see Numeric Types
   --- int, float, complex). It cannot be subclassed further.  Its
   only instances are "False" and "True" (see Boolean Values).

   Schimbat în versiunea 3.7: *x* is now a positional-only parameter.

breakpoint(*args, **kws)

   This function drops you into the debugger at the call site.
   Specifically, it calls "sys.breakpointhook()", passing "args" and
   "kws" straight through.  By default, "sys.breakpointhook()" calls
   "pdb.set_trace()" expecting no arguments.  In this case, it is
   purely a convenience function so you don't have to explicitly
   import "pdb" or type as much code to enter the debugger.  However,
   "sys.breakpointhook()" can be set to some other function and
   "breakpoint()" will automatically call that, allowing you to drop
   into the debugger of choice. If "sys.breakpointhook()" is not
   accessible, this function will raise "RuntimeError".

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

   Nou în versiunea 3.7.

class bytearray([source[, encoding[, errors]]])

   Î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[, encoding[, errors]]])

   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)

   Return "True" if the *object* argument appears callable, "False" if
   not.  If this returns "True", it is still possible that a call
   fails, but if it is "False", calling *object* will never succeed.
   Note that classes are callable (calling a class returns a new
   instance); instances are callable if their class has a "__call__()"
   method.

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

chr(i)

   Return the string representing a character whose Unicode code point
   is the integer *i*.  For example, "chr(97)" returns the string
   "'a'", while "chr(8364)" returns the string "'€'". This is the
   inverse of "ord()".

   The valid range for the argument is from 0 through 1,114,111
   (0x10FFFF in base 16).  "ValueError" will be raised if *i* is
   outside that range.

@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 C:
          @classmethod
          def f(cls, arg1, arg2): ...

   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: Class methods now inherit the method
   attributes ("__module__", "__name__", "__qualname__", "__doc__" and
   "__annotations__") and have a new "__wrapped__" attribute.

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).

   Această funcție va lansa o excepție "SyntaxError" dacă sursa
   compilată nu este validă, respectiv o excepție "ValueError" atunci
   când sursa conține octeți *null*.

   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*.

   Nou în versiunea 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([real[, imag]])

   Return a complex number with the value *real* + *imag**1j or
   convert a string or number to a complex number.  If the first
   parameter is a string, it will be interpreted as a complex number
   and the function must be called without a second parameter.  The
   second parameter can never be a string. Each argument may be any
   numeric type (including complex).  If *imag* is omitted, it
   defaults to zero and the constructor serves as a numeric conversion
   like "int" and "float".  If both arguments are omitted, returns
   "0j".

   For a general Python object "x", "complex(x)" delegates to
   "x.__complex__()".  If "__complex__()" is not defined then it falls
   back to "__float__()".  If "__float__()" is not defined then it
   falls back to "__index__()".

   Notă:

     When converting from a string, the string must not contain
     whitespace around the central "+" or "-" operator.  For example,
     "complex('1+2j')" is fine, but "complex('1 + 2j')" raises
     "ValueError".

   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: Falls back to "__index__()" if
   "__complex__()" and "__float__()" are not defined.

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(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

   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([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.

   If the object has a method named "__dir__()", this method will be
   called and must return the list of attributes. This allows objects
   that implement a custom "__getattr__()" or "__getattribute__()"
   function to customize the way "dir()" reports their attributes.

   If the object does not provide "__dir__()", the function tries its
   best to gather information from the object's "__dict__" attribute,
   if defined, and from its type object.  The resulting list is not
   necessarily complete and may be inaccurate when the object has a
   custom "__getattr__()".

   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)

   Take two (non-complex) numbers as arguments and return a pair of
   numbers consisting of their quotient and remainder when using
   integer division.  With mixed operand types, the rules for binary
   arithmetic operators apply.  For integers, the result is the same
   as "(a // b, a % b)". For floating point numbers the result is "(q,
   a % b)", where *q* is usually "math.floor(a / b)" but may be 1 less
   than that.  In any case "q * b + a % b" is very close to *a*, if "a
   % b" is non-zero it has the same sign as *b*, and "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(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

eval(expression[, globals[, locals]])

   The arguments are a string and optional globals and locals.  If
   provided, *globals* must be a dictionary.  If provided, *locals*
   can be any mapping object.

   The *expression* argument is parsed and evaluated as a Python
   expression (technically speaking, a condition list) using the
   *globals* and *locals* dictionaries 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
   *expression* 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* dictionary is omitted it defaults to the *globals*
   dictionary.  If both dictionaries are omitted, the expression is
   executed with the *globals* and *locals* in the environment where
   "eval()" is called.  Note, *eval()* does not have access to the
   *nested scopes* (non-locals) in the enclosing environment.

   The return value is the result of the evaluated expression. Syntax
   errors are reported as exceptions.  Example:

   >>> 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.

exec(object[, globals[, locals]])

   This function supports dynamic execution of Python code. *object*
   must be either a string or a code object.  If it is a string, the
   string is parsed as a suite of Python statements which is then
   executed (unless a syntax error occurs). [1] If it is a code
   object, it is simply executed.  In all cases, the code that's
   executed is expected to be valid as file input (see the section
   File input in the Reference Manual). Be aware that the "nonlocal",
   "yield",  and "return" statements may not be used outside of
   function definitions even within the context of code passed to the
   "exec()" function. The return value is "None".

   In all cases, if the optional parts are omitted, the code is
   executed in the current scope.  If only *globals* is provided, it
   must be a dictionary (and not a subclass of dictionary), which will
   be used for both the global and the local variables.  If *globals*
   and *locals* are given, they are used for the global and local
   variables, respectively.  If provided, *locals* can be any mapping
   object.  Remember that at the module level, globals and locals are
   the same dictionary. If exec gets two separate objects as *globals*
   and *locals*, the code will be executed as if it were embedded in a
   class definition.

   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()".

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

   Notă:

     The built-in functions "globals()" and "locals()" return the
     current global and local dictionary, respectively, which may be
     useful to pass around for use as the second and third argument to
     "exec()".

   Notă:

     The default *locals* act as described for function "locals()"
     below: modifications to the default *locals* dictionary should
     not be attempted. Pass an explicit *locals* dictionary if you
     need to see effects of the code on *locals* after function
     "exec()" returns.

filter(function, iterable)

   Construct an iterator from those elements of *iterable* for which
   *function* returns true.  *iterable* may be either a sequence, a
   container which supports iteration, or an iterator.  If *function*
   is "None", the identity function is assumed, that is, all elements
   of *iterable* that are false are removed.

   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".

   See "itertools.filterfalse()" for the complementary function that
   returns elements of *iterable* for which *function* returns false.

class float([x])

   Return a floating point number constructed from a number or string
   *x*.

   If the argument is a string, it should contain a decimal number,
   optionally preceded by a sign, and optionally embedded in
   whitespace.  The optional sign may be "'+'" or "'-'"; a "'+'" sign
   has no effect on the value produced.  The argument may also be a
   string representing a NaN (not-a-number), or positive or negative
   infinity.  More precisely, the input must conform to the
   "floatvalue" production rule in the following grammar, after
   leading and trailing whitespace characters are removed:

      sign        ::= "+" | "-"
      infinity    ::= "Infinity" | "inf"
      nan         ::= "nan"
      digitpart   ::= digit (["_"] digit)*
      number      ::= [digitpart] "." digitpart | digitpart ["."]
      exponent    ::= ("e" | "E") ["+" | "-"] digitpart
      floatnumber ::= number [exponent]
      floatvalue  ::= [sign] (floatnumber | infinity | nan)

   Here "digit" is a Unicode decimal digit (character in the Unicode
   general category "Nd"). Case is not significant, so, for example,
   "inf", "Inf", "INFINITY", and "iNfINity" are all acceptable
   spellings for positive infinity.

   Otherwise, if the argument is an integer or a floating point
   number, a floating point number with the same value (within
   Python's floating point precision) is returned.  If the argument is
   outside the range of a Python float, an "OverflowError" will be
   raised.

   For a general Python object "x", "float(x)" delegates to
   "x.__float__()".  If "__float__()" is not defined then it falls
   back to "__index__()".

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

   Examples:

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

   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: *x* is now a positional-only parameter.

   Schimbat în versiunea 3.8: Falls back to "__index__()" if
   "__float__()" is not defined.

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)".

   A call to "format(value, format_spec)" is translated to
   "type(value).__format__(value, format_spec)" which bypasses the
   instance dictionary when searching for the value's "__format__()"
   method.  A "TypeError" exception is raised if the method search
   reaches "object" and the *format_spec* is non-empty, or if either
   the *format_spec* or the return value are not strings.

   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[, 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ă:

     For objects with custom "__hash__()" methods, note that "hash()"
     truncates the return value based on the bit width of the host
     machine. See "__hash__()" for details.

help([object])

   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(x)

   Convert an integer number to a lowercase hexadecimal string
   prefixed with "0x". If *x* is not a Python "int" object, it has to
   define an "__index__()" method that returns an integer. Some
   examples:

   >>> 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()".

   **CPython implementation detail:** 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([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([x])
class int(x, base=10)

   Return an integer object constructed from a number or string *x*,
   or return "0" if no arguments are given.  If *x* defines
   "__int__()", "int(x)" returns "x.__int__()".  If *x* defines
   "__index__()", it returns "x.__index__()".  If *x* defines
   "__trunc__()", it returns "x.__trunc__()". For floating point
   numbers, this truncates towards zero.

   If *x* is not a number or if *base* is given, then *x* must be a
   string, "bytes", or "bytearray" instance representing an integer in
   radix *base*.  Optionally, the string can be preceded by "+" or "-"
   (with no space in between), have leading zeros, be surrounded by
   whitespace, and have single underscores interspersed between
   digits.

   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: *x* is now a positional-only parameter.

   Schimbat în versiunea 3.8: Falls back to "__index__()" if
   "__int__()" is not defined.

   Schimbat în versiunea 3.10.7: "int" string inputs and string
   representations can be limited to help avoid denial of service
   attacks. A "ValueError" is raised when the limit is exceeded while
   converting a string *x* to an "int" or when converting an "int"
   into a string would exceed the limit. See the integer string
   conversion length limitation documentation.

isinstance(object, classinfo)

   Return "True" if the *object* argument is an instance of the
   *classinfo* argument, or of a (direct, indirect, or *virtual*)
   subclass thereof.  If *object* is not an object of the given type,
   the function always returns "False". If *classinfo* is a tuple of
   type objects (or recursively, other such tuples) or a Union Type of
   multiple types, return "True" if *object* is an instance of any of
   the types. If *classinfo* is not a type or tuple of types and such
   tuples, a "TypeError" exception is raised.

   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(object[, sentinel])

   Return an *iterator* object.  The first argument is interpreted
   very differently depending on the presence of the second argument.
   Without a second argument, *object* must be a collection object
   which supports the *iterable* protocol (the "__iter__()" method),
   or it must support the sequence protocol (the "__getitem__()"
   method with integer arguments starting at "0").  If it does not
   support either of those protocols, "TypeError" is raised. If the
   second argument, *sentinel*, is given, then *object* must be a
   callable object.  The iterator created in this case will call
   *object* with no arguments for each call to its "__next__()"
   method; if the value returned is equal to *sentinel*,
   "StopIteration" will be raised, otherwise the value will be
   returned.

   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('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

len(s)

   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*).

   **CPython implementation detail:** (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()

   Update and return a dictionary representing the current local
   symbol table. Free variables are returned by "locals()" when it is
   called in function blocks, but not in class blocks. Note that at
   the module level, "locals()" and "globals()" are the same
   dictionary.

   Notă:

     The contents of this dictionary should not be modified; changes
     may not affect the values of local and free variables used by the
     interpreter.

map(function, iterable, ...)

   Return an iterator that applies *function* to every item of
   *iterable*, yielding the results.  If additional *iterable*
   arguments are passed, *function* must take that many arguments and
   is applied to the items from all iterables in parallel.  With
   multiple iterables, the iterator stops when the shortest iterable
   is exhausted.  For cases where the function inputs are already
   arranged into argument tuples, see "itertools.starmap()".

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

   Î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)".

   Nou în versiunea 3.4: The *default* keyword-only argument.

   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, default])
min(arg1, arg2, *args[, key])

   Î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)".

   Nou în versiunea 3.4: The *default* keyword-only argument.

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

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

   Return a new featureless object.  "object" is a base for all
   classes. It has methods that are common to all instances of Python
   classes.  This function does not accept any arguments.

   Notă:

     "object" does *not* have a "__dict__", so you can't assign
     arbitrary attributes to an instance of the "object" class.

oct(x)

   Convert an integer number to an octal string prefixed with "0o".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. For example:

   >>> 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".)

   *mode* is an optional string that specifies the mode in which the
   file is opened.  It defaults to "'r'" which means open for reading
   in text mode. Other common values are "'w'" for writing (truncating
   the file if it already exists), "'x'" for exclusive creation, and
   "'a'" for appending (which on *some* Unix systems, means that *all*
   writes append to the end of the file regardless of the current seek
   position).  In text mode, if *encoding* is not specified the
   encoding used is platform-dependent:
   "locale.getpreferredencoding(False)" is called to get the current
   locale encoding. (For reading and writing raw bytes use binary mode
   and leave *encoding* unspecified.)  The available modes are:

   +-----------+-----------------------------------------------------------------+
   | Caracter  | Semnificația                                                    |
   | ul        |                                                                 |
   |===========|=================================================================|
   | "'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*.

   There is an additional mode character permitted, "'U'", which no
   longer has any effect, and is considered deprecated. It previously
   enabled *universal newlines* in text mode, which became the default
   behavior in Python 3.0. Refer to the documentation of the newline
   parameter for further details.

   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).

   *buffering* is an optional integer used to set the buffering
   policy.  Pass 0 to switch buffering off (only allowed in binary
   mode), 1 to select line buffering (only usable in text mode), and
   an integer > 1 to indicate the size in bytes of a fixed-size chunk
   buffer. Note that specifying a buffer size this way applies for
   binary buffered I/O, but "TextIOWrapper" (i.e., files opened with
   "mode='r+'") would have another buffering. To disable buffering in
   "TextIOWrapper", consider using the "write_through" flag for
   "io.TextIOWrapper.reconfigure()". When no *buffering* argument is
   given, the default buffering policy works as follows:

   * Binary files are buffered in fixed-size chunks; the size of the
     buffer is chosen using a heuristic trying to determine the
     underlying device's "block size" and falling back on
     "io.DEFAULT_BUFFER_SIZE".  On many systems, the buffer will
     typically be 4096 or 8192 bytes long.

   * 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.

   *encoding* is the name of the encoding used to decode or encode the
   file. This should only be used in text mode.  The default encoding
   is platform dependent (whatever "locale.getpreferredencoding()"
   returns), but any *text encoding* supported by Python can be used.
   See the "codecs" module for the list of supported encodings.

   (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'" is only supported when writing to a file.
     Characters not supported by the encoding are replaced with the
     appropriate XML character reference "&#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
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('This will be written to somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # don't leak a file descriptor

   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".

   Raises an auditing event "open" with arguments "file", "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*.

   Deprecated since version 3.4, removed in version 3.10: The "'U'"
   mode.

      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".

ord(c)

   Given a string representing one Unicode character, return an
   integer representing the Unicode code point of that character.  For
   example, "ord('a')" returns the integer "97" and "ord('€')" (Euro
   sign) returns "8364".  This is the inverse of "chr()".

pow(base, exp[, mod])

   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".

   The arguments must have numeric types.  With mixed operand types,
   the coercion rules for binary arithmetic operators apply.  For
   "int" operands, the result has the same type as the operands (after
   coercion) unless the second argument is negative; in that case, all
   arguments are converted to float and a float result is delivered.
   For example, "pow(10, 2)" returns "100", but "pow(10, -2)" returns
   "0.01".  For a negative base of type "int" or "float" and a non-
   integral exponent, a complex result is delivered.  For example,
   "pow(-9, 0.5)" returns a value close to "3j".

   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 getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "I'm the 'x' property.")

   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 Parrot:
          def __init__(self):
              self._voltage = 100000

          @property
          def voltage(self):
              """Get the current voltage."""
              return self._voltage

   The "@property" decorator turns the "voltage()" method into a
   "getter" for a read-only attribute with the same name, and it sets
   the docstring for *voltage* to "Get the current voltage."

   A property object has "getter", "setter", and "deleter" methods
   usable as decorators that create a copy of the property with the
   corresponding accessor function set to the decorated function.
   This is best explained with an example:

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

          @property
          def x(self):
              """I'm the 'x' property."""
              return self._x

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

          @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).

class range(stop)
class range(start, stop[, step])

   Î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)

   Return a string containing a printable representation of an object.
   For many types, this function makes an attempt to return a string
   that would yield an object with the same value when passed to
   "eval()"; otherwise, the representation is a string enclosed in
   angle brackets that contains the name of the type of the object
   together with additional information often including the name and
   address of the object.  A class can control what this function
   returns for its instances by defining a "__repr__()" method. If
   "sys.displayhook()" is not accessible, this function will raise
   "RuntimeError".

reversed(seq)

   Return a reverse *iterator*.  *seq* must be an object which has a
   "__reversed__()" method or supports the sequence protocol (the
   "__len__()" method and the "__getitem__()" method with integer
   arguments starting at "0").

round(number[, ndigits])

   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 Floating
     Point Arithmetic:  Issues and Limitations 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])

   Return a *slice* object representing the set of indices specified
   by "range(start, stop, step)".  The *start* and *step* arguments
   default to "None".  Slice objects have read-only data attributes
   "start", "stop", and "step" which merely return the argument values
   (or their default).  They have no other explicit functionality;
   however, they are used by NumPy and other third-party packages.
   Slice objects are also generated when extended indexing syntax is
   used.  For example: "a[start:stop:step]" or "a[start:stop, i]".
   See "itertools.islice()" for an alternate version that returns an
   iterator.

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).

   Algoritmul de sortare întrebuințează numai comparații "<" ale
   itemilor. Deși definirea unei singure metode "__lt__()" va fi de
   ajuns pentru efectuarea de sortări, **PEP 8** recomandă să fie
   implementate toate cele șase comparații elaborate (de la
   englezescul, în jargon informatic, *rich comparisons*). O asemenea
   întreprindere ne va scuti de (munca de reparare a eventualelor)
   erori survenite atunci când vom folosi aceleași date de sortat cu
   alte unelte informatice de ordonare, precum "max()", unelte bazate
   pe metode de comparație diferite (și care ne vor conduce la
   rezultate diferite). În plus, implementarea tuturor celor șase
   metode de comparație ne va servi inclusiv la evitarea unor confuzii
   atunci când realizăm comparații între itemi de tipuri (de date)
   diferite, asemenea comparații putând utiliza reflexii ale metodei
   "__gt__()".

   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(arg1, arg2, ...): ...

   Formula "@staticmethod" desemnează un *decorator* de funcție -- a
   se vedea Definiții de funcții pentru detalii.

   A static method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()"). Moreover, they can be called
   as regular functions (such as "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 regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

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

   Schimbat în versiunea 3.10: Static methods now inherit the method
   attributes ("__module__", "__name__", "__qualname__", "__doc__" and
   "__annotations__"), have a new "__wrapped__" attribute, and are now
   callable as regular functions.

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

   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.

   For some use cases, there are good alternatives to "sum()". The
   preferred, fast way to concatenate a sequence of strings is by
   calling "''.join(sequence)".  To add floating point values with
   extended precision, see "math.fsum()".  To concatenate a series of
   iterables, consider using "itertools.chain()".

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

class super([type[, object-or-type]])

   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.

   The *object-or-type* determines the *method resolution order* to be
   searched.  The search starts from the class right after the *type*.

   For example, if "__mro__" of *object-or-type* is "D -> B -> C -> A
   -> object" and the value of *type* is "B", then "super()" searches
   "C -> A -> object".

   The "__mro__" attribute of the *object-or-type* lists the method
   resolution search order used by both "getattr()" and "super()".
   The attribute is dynamic and can change whenever the inheritance
   hierarchy is updated.

   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ă).

   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 method(self, arg):
              super().method(arg)    # This does the same thing as:
                                     # super(C, self).method(arg)

   Î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.

   Note that "super()" is implemented as part of the binding process
   for explicit dotted attribute lookups such as
   "super().__getitem__(name)". It does so by implementing its own
   "__getattribute__()" method for searching classes in a predictable
   order that supports cooperative multiple inheritance. Accordingly,
   "super()" is undefined for implicit lookups using statements or
   operators such as "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, **kwds)

   With one argument, return the type of an *object*.  The return
   value is a type object and generally the same object as returned by
   "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.

   With three arguments, return a new type object.  This is
   essentially a dynamic form of the "class" statement. The *name*
   string is the class name and becomes the "__name__" attribute. The
   *bases* tuple contains the base classes and becomes the "__bases__"
   attribute; if empty, "object", the ultimate base of all classes, is
   added.  The *dict* dictionary contains attribute and method
   definitions for the class body; it may be copied or wrapped before
   becoming the "__dict__" attribute. The following two statements
   create identical "type" objects:

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

   See also Type Objects.

   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: Subclasses of "type" which don't
   override "type.__new__" may no longer use the one-argument form to
   get the type of an object.

vars([object])

   Return the "__dict__" attribute for a module, class, instance, or
   any other object with a "__dict__" attribute.

   Objects such as modules and instances have an updateable "__dict__"
   attribute; however, other objects may have write restrictions on
   their "__dict__" attributes (for example, classes use a
   "types.MappingProxyType" to prevent direct dictionary updates).

   Without an argument, "vars()" acts like "locals()".  Note, the
   locals dictionary is only useful for reads since updates to the
   locals dictionary are ignored.

   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__").

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 item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
      ...     print(item)
      ...
      (1, 'sugar')
      (2, 'spice')
      (3, 'everything nice')

   (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), ['fee', 'fi', 'fo', 'fum']))
        [(0, 'fee'), (1, 'fi'), (2, 'fo')]

   * "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:

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

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

      spam = __import__('spam.ham', 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__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
      eggs = _temp.eggs
      saus = _temp.sausage

   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.
