Funcții predefinite

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

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

abs(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:

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

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

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

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.