Învață Python: comenzi explicate cu exemple

Toate funcțiile

Lista completă a funcțiilor încorporate, a cuvintelor cheie, a metodelor tipurilor de bază și a funcțiilor din cele mai folosite module standard, cu semnătura exactă din Python 3.14. Cele cu link au o pagină dedicată, cu explicații și exemple.

Cuvinte cheie și funcții încorporate (109)

Funcție	Ce face
abs	Valoarea absolută a unui număr (fără semn); modulul pentru numere complexe. abs(x, /)
aiter	Obține un iterator asincron dintr-un iterabil asincron (Python 3.10+). aiter(async_iterable, /)
all	True dacă toate elementele sunt adevărate (sau colecția e goală). all(iterable, /)
and	„Și” logic: adevărat doar dacă ambele părți sunt adevărate; se oprește la prima valoare falsă.
anext	Următorul element dintr-un iterator asincron; se folosește cu await (Python 3.10+). anext(async_iterator[, default])
any	True dacă cel puțin un element este adevărat. any(iterable, /)
as	Dă un nume nou la import, în with sau în except (ex. import numpy as np).
ascii	Ca repr(), dar înlocuiește caracterele non-ASCII cu secvențe \x, \u sau \U. ascii(obj, /)
assert	Verifică o condiție; dacă este falsă, aruncă AssertionError. Ignorat cu python -O.
async	Marchează o funcție, buclă sau bloc with ca asincron (async def, async for, async with).
await	Așteaptă rezultatul unei corutine sau al unei operații asincrone.
bin	Textul unui întreg în baza 2, cu prefixul 0b. bin(number, /)
bool	Tipul logic; transformă o valoare în True sau False. bool(object=False, /)
break	Oprește imediat bucla for sau while curentă.
breakpoint	Oprește programul și pornește depanatorul pdb (Python 3.7+). breakpoint(*args, **kws)
bytearray	Secvență de octeți modificabilă (varianta mutabilă a lui bytes). bytearray(iterable_of_ints) / bytearray(string, encoding[, errors]) / bytearray(bytes_or_buffer) / bytearray(int) / bytearray()
bytes	Secvență imutabilă de octeți (valori 0-255), pentru date binare și text codificat. bytes(iterable_of_ints) / bytes(string, encoding[, errors]) / bytes(bytes_or_buffer) / bytes(int) / bytes()
callable	True dacă obiectul poate fi apelat ca o funcție. callable(obj, /)
case	O ramură a unei instrucțiuni match, cu modelul comparat (Python 3.10+).
chr	Caracterul corespunzător unui cod Unicode (ex. chr(65) este „A”). chr(i, /)
class	Definește o clasă nouă, cu atribute și metode.
classmethod	Decorator: metoda primește clasa (cls) în loc de obiect. classmethod(function, /)
compile	Transformă un text cu cod Python într-un obiect cod, rulat apoi cu exec() sau eval(). compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1, *, _feature_version=-1)
complex	Creează un număr complex din parte reală și imaginară sau dintr-un text. complex(real=0, imag=0)
continue	Sare peste restul pasului curent și trece la următoarea repetare a buclei.
def	Definește o funcție.
del	Șterge o variabilă, un element de listă sau o cheie de dicționar.
delattr	Șterge un atribut al unui obiect, dat prin nume (text). delattr(obj, name, /)
dict	Creează un dicționar (perechi cheie: valoare). dict() / dict(mapping)
dir	Lista numelor (atribute, metode) dintr-un obiect sau din locul curent. dir([object])
divmod	Returnează deodată câtul întreg și restul împărțirii: (a // b, a % b). divmod(x, y, /)
elif	Ramură suplimentară a unui if, verificată doar dacă ramurile anterioare au fost false.
else	Ramura finală a unui if; apare și după for, while și try.
enumerate	Parcurge o colecție dând perechi (poziție, element). enumerate(iterable, start=0)
eval	Calculează o expresie Python primită ca text. Periculos pe date nesigure. eval(source, /, globals=None, locals=None)
except	Prinde un anumit tip de excepție apărut în blocul try.
exec	Rulează instrucțiuni Python primite ca text. Periculos pe date nesigure. exec(source, /, globals=None, locals=None, *, closure=None)
exit	Închide interpretorul; ajutor pentru consola interactivă (în scripturi folosește sys.exit()). exit(code=None)
False	Valoarea logică „fals”; egală cu 0 în calcule.
filter	Păstrează elementele pentru care o funcție returnează o valoare adevărată. filter(function, iterable, /)
finally	Bloc care rulează mereu la ieșirea din try, cu sau fără eroare.
float	Tipul numerelor zecimale; transformă un text sau un număr în float. float(x=0, /)
for	Buclă care parcurge, pe rând, elementele unei colecții.
format	Formatează o valoare după un șablon (zecimale, aliniere, separatori, baze). format(value, format_spec='', /)
from	Importă anumite nume dintr-un modul (from math import sqrt); apare și în raise … from.
frozenset	Mulțime imutabilă; poate fi cheie de dicționar sau element al altei mulțimi. frozenset(iterable=(), /)
getattr	Citește un atribut al unui obiect după nume, cu valoare implicită opțională. getattr(object, name[, default])
global	Permite unei funcții să modifice o variabilă de la nivelul modulului.
globals	Dicționarul variabilelor globale ale modulului curent. globals()
hasattr	True dacă obiectul are atributul cu numele dat. hasattr(obj, name, /)
hash	Valoarea hash a unui obiect imutabil, folosită de dict și set. hash(obj, /)
help	Afișează documentația unui obiect sau pornește ajutorul interactiv. help(*args, **kwds)
hex	Textul unui întreg în baza 16, cu prefixul 0x. hex(number, /)
id	Identitatea unică a unui obiect pe durata existenței lui. id(obj, /)
if	Execută un bloc de cod doar dacă o condiție este adevărată.
import	Încarcă un modul ca să îi poți folosi funcțiile.
in	Verifică apartenența la o colecție (x in lista); în for, parcurge colecția.
input	Citește un rând tastat de utilizator și îl returnează ca text. input(prompt='', /)
int	Tipul numerelor întregi; transformă un text sau un float în întreg. int([x]) / int(x, base=10)
is	Verifică dacă două nume arată spre același obiect (identitate, nu egalitate).
isinstance	True dacă obiectul este de tipul dat (sau al unei subclase). isinstance(obj, class_or_tuple, /)
issubclass	True dacă o clasă moștenește altă clasă. issubclass(cls, class_or_tuple, /)
iter	Obține un iterator dintr-o colecție sau dintr-o funcție cu valoare de oprire. iter(iterable) / iter(callable, sentinel)
lambda	Creează o funcție anonimă dintr-o singură expresie.
len	Numărul de elemente dintr-o colecție sau de caractere dintr-un text. len(obj, /)
list	Creează o listă (colecție ordonată și modificabilă). list(iterable=(), /)
locals	Dicționarul variabilelor locale din locul curent. locals()
map	Aplică o funcție fiecărui element din una sau mai multe colecții. map(function, iterable, /, *iterables, strict=False)
match	Compară o valoare cu mai multe modele (pattern matching), Python 3.10+.
max	Cel mai mare element dintr-o colecție sau dintre mai multe valori. max(iterable, *[, default=obj, key=func]) / max(arg1, arg2, *args, *[, key=func])
memoryview	Acces fără copiere la memoria unui obiect binar (bytes, bytearray). memoryview(object)
min	Cel mai mic element dintr-o colecție sau dintre mai multe valori. min(iterable, *[, default=obj, key=func]) / min(arg1, arg2, *args, *[, key=func])
next	Următorul element dintr-un iterator, cu valoare implicită opțională. next(iterator[, default])
None	Valoarea specială pentru „nimic” sau „lipsă”; se verifică cu „is None”.
nonlocal	Permite unei funcții interioare să modifice o variabilă din funcția care o conține.
not	Negație logică: transformă adevărat în fals și invers.
object	Clasa de bază a tuturor claselor; object() creează un obiect gol, unic. object()
oct	Textul unui întreg în baza 8, cu prefixul 0o. oct(number, /)
open	Deschide un fișier pentru citire sau scriere. open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
or	„Sau” logic: returnează prima valoare adevărată sau ultima valoare.
ord	Codul Unicode al unui caracter (ex. ord(„A”) este 65). ord(character, /)
pass	Instrucțiune care nu face nimic; ține locul unui bloc gol.
pow	Ridicare la putere; cu al treilea argument, putere modulară rapidă. pow(base, exp, mod=None)
print	Afișează valori pe ecran sau într-un fișier. print(*args, sep=' ', end='\n', file=None, flush=False)
property	Transformă metode în atribut calculat, cu citire și scriere controlate. property(fget=None, fset=None, fdel=None, doc=None)
quit	La fel ca exit(): închide consola interactivă. quit(code=None)
raise	Aruncă o excepție.
range	Șir de numere întregi, folosit mai ales în bucle for. range(stop) / range(start, stop[, step])
repr	Reprezentarea exactă, „tehnică”, a unei valori, utilă la depanare. repr(obj, /)
return	Încheie funcția și trimite înapoi un rezultat.
reversed	Iterator care parcurge o secvență de la sfârșit la început. reversed(sequence, /)
round	Rotunjește un număr la întreg sau la un număr de zecimale (la par la jumătate). round(number, ndigits=None)
set	Creează o mulțime: colecție fără duplicate și fără ordine. set(iterable=(), /)
setattr	Setează un atribut al unui obiect după nume. setattr(obj, name, value, /)
slice	Obiect felie, echivalentul lui [start:stop:pas], care poate fi refolosit. slice(stop) / slice(start, stop[, step])
sorted	Listă nouă cu elementele sortate, cu cheie și ordine inversă opționale. sorted(iterable, /, *, key=None, reverse=False)
staticmethod	Decorator: metoda nu primește nici obiectul, nici clasa. staticmethod(function, /)
str	Tipul textelor; transformă orice valoare în text. str(object='') / str(bytes_or_buffer[, encoding[, errors]])
sum	Suma elementelor unei colecții, pornind de la o valoare inițială. sum(iterable, /, start=0)
super	Acces la metodele clasei părinte dintr-o subclasă. super() / super(type) / super(type, obj) / super(type, type2)
True	Valoarea logică „adevărat”; egală cu 1 în calcule.
try	Începe un bloc în care erorile pot fi prinse cu except.
tuple	Creează un tuplu (colecție ordonată, imutabilă). tuple(iterable=(), /)
type	Tipul unei valori; cu trei argumente, creează o clasă nouă. type(object) / type(name, bases, dict, **kwds)
vars	Dicționarul cu atributele unui obiect (__dict__) sau variabilele locale. vars([object])
while	Buclă care se repetă cât timp o condiție este adevărată.
with	Folosește un context manager (ex. un fișier) și îl închide automat la final.
yield	Produce o valoare dintr-un generator și îi suspendă execuția până la cererea următoare.
zip	Grupează element cu element mai multe colecții parcurse în paralel. zip(*iterables, strict=False)

Șiruri de caractere, bytes și expresii regulate (str, bytes, string, re) (135)

Funcție	Ce face
bytes.capitalize	Primul octet-literă ASCII mare, restul mici. bytes.capitalize()
bytes.center	Centrează octeții pe o lățime dată. bytes.center(width, fillchar=b' ', /)
bytes.count	Numărul de apariții ale unei secvențe de octeți. bytes.count(sub[, start[, end]])
bytes.decode	Transformă octeții în text după o codificare (implicit UTF-8). bytes.decode(encoding='utf-8', errors='strict')
bytes.endswith	True dacă octeții se termină cu sufixul dat. bytes.endswith(suffix[, start[, end]])
bytes.expandtabs	Înlocuiește tab-urile cu spații. bytes.expandtabs(tabsize=8)
bytes.find	Poziția primei apariții a unei secvențe de octeți sau -1. bytes.find(sub[, start[, end]])
bytes.fromhex	Creează bytes dintr-un text hexazecimal (ex. „49 61”). bytes.fromhex(string, /)
bytes.hex	Scrie octeții ca text hexazecimal, cu separator opțional. bytes.hex([sep[, bytes_per_sep]])
bytes.index	Ca find(), dar aruncă ValueError dacă secvența lipsește. bytes.index(sub[, start[, end]])
bytes.isalnum	True dacă toți octeții sunt litere sau cifre ASCII. bytes.isalnum()
bytes.isalpha	True dacă toți octeții sunt litere ASCII. bytes.isalpha()
bytes.isascii	True dacă toți octeții sunt sub 128. bytes.isascii()
bytes.isdigit	True dacă toți octeții sunt cifre ASCII. bytes.isdigit()
bytes.islower	True dacă literele ASCII sunt toate mici. bytes.islower()
bytes.isspace	True dacă toți octeții sunt spații albe ASCII. bytes.isspace()
bytes.istitle	True dacă fiecare cuvânt ASCII începe cu majusculă. bytes.istitle()
bytes.isupper	True dacă literele ASCII sunt toate mari. bytes.isupper()
bytes.join	Lipește mai multe obiecte bytes, cu octeții curenți ca separator. bytes.join(iterable_of_bytes, /)
bytes.ljust	Aliniază la stânga pe o lățime dată. bytes.ljust(width, fillchar=b' ', /)
bytes.lower	Literele ASCII devin mici. bytes.lower()
bytes.lstrip	Elimină octeții dați (implicit spații) de la început. bytes.lstrip(bytes=None, /)
bytes.maketrans	Creează un tabel de 256 de octeți pentru bytes.translate(). bytes.maketrans(frm, to, /)
bytes.partition	Împarte la prima apariție a separatorului: (înainte, sep, după). bytes.partition(sep, /)
bytes.removeprefix	Elimină prefixul dat, dacă există (Python 3.9+). bytes.removeprefix(prefix, /)
bytes.removesuffix	Elimină sufixul dat, dacă există (Python 3.9+). bytes.removesuffix(suffix, /)
bytes.replace	Înlocuiește aparițiile unei secvențe de octeți. bytes.replace(old, new, count=-1, /)
bytes.rfind	Poziția ultimei apariții a unei secvențe de octeți sau -1. bytes.rfind(sub[, start[, end]])
bytes.rindex	Ca rfind(), dar aruncă ValueError dacă secvența lipsește. bytes.rindex(sub[, start[, end]])
bytes.rjust	Aliniază la dreapta pe o lățime dată. bytes.rjust(width, fillchar=b' ', /)
bytes.rpartition	Împarte la ultima apariție a separatorului. bytes.rpartition(sep, /)
bytes.rsplit	Împarte de la dreapta după un separator. bytes.rsplit(sep=None, maxsplit=-1)
bytes.rstrip	Elimină octeții dați (implicit spații) de la sfârșit. bytes.rstrip(bytes=None, /)
bytes.split	Împarte octeții într-o listă după un separator. bytes.split(sep=None, maxsplit=-1)
bytes.splitlines	Împarte octeții în rânduri. bytes.splitlines(keepends=False)
bytes.startswith	True dacă octeții încep cu prefixul dat. bytes.startswith(prefix[, start[, end]])
bytes.strip	Elimină octeții dați (implicit spații) de la ambele capete. bytes.strip(bytes=None, /)
bytes.swapcase	Inversează literele ASCII mari și mici. bytes.swapcase()
bytes.title	Prima literă ASCII a fiecărui cuvânt mare. bytes.title()
bytes.translate	Înlocuiește octeți după un tabel și poate șterge octeți. bytes.translate(table, /, delete=b'')
bytes.upper	Literele ASCII devin mari. bytes.upper()
bytes.zfill	Completează cu zerouri ASCII la stânga. bytes.zfill(width, /)
re.compile	Compilează o expresie regulată într-un obiect Pattern refolosibil. re.compile(pattern, flags=0)
re.escape	Protejează caracterele speciale, ca textul să fie căutat literal. re.escape(pattern)
re.findall	Lista tuturor potrivirilor (sau a grupurilor) dintr-un text. re.findall(pattern, string, flags=0)
re.finditer	Iterator de obiecte Match pentru toate potrivirile. re.finditer(pattern, string, flags=0)
re.fullmatch	Potrivire doar dacă tot textul corespunde modelului. re.fullmatch(pattern, string, flags=0)
re.Match	Obiectul unei potriviri: textul găsit, grupurile și pozițiile. re.Match()
re.match	Potrivire doar la începutul textului. re.match(pattern, string, flags=0)
re.Match.end	Poziția de după sfârșitul potrivirii (sau al unui grup). Match.end(group=0, /)
re.Match.expand	Completează un șablon cu grupurile potrivirii (\1, \g<nume>). Match.expand(template)
re.Match.group	Textul potrivirii sau al unuia ori mai multor grupuri. Match.group([group1, ...])
re.Match.groupdict	Dicționarul grupurilor cu nume. Match.groupdict(default=None)
re.Match.groups	Tuplul tuturor grupurilor capturate. Match.groups(default=None)
re.Match.span	Tuplul (start, end) al potrivirii sau al unui grup. Match.span(group=0, /)
re.Match.start	Poziția de început a potrivirii (sau a unui grup). Match.start(group=0, /)
re.Pattern	Expresie regulată compilată, cu metode search, match, sub etc. re.Pattern()
re.Pattern.findall	Toate potrivirile modelului compilat, cu poziții de început/sfârșit opționale. Pattern.findall(string, pos=0, endpos=9223372036854775807)
re.Pattern.finditer	Iterator de obiecte Match pentru modelul compilat. Pattern.finditer(string, pos=0, endpos=9223372036854775807)
re.Pattern.fullmatch	Verifică dacă tot textul se potrivește modelului compilat. Pattern.fullmatch(string, pos=0, endpos=9223372036854775807)
re.Pattern.match	Verifică potrivirea la începutul textului cu modelul compilat. Pattern.match(string, pos=0, endpos=9223372036854775807)
re.Pattern.scanner	Obiect intern de scanare pas cu pas; nedocumentat oficial. Pattern.scanner(string, pos=0, endpos=9223372036854775807)
re.Pattern.search	Prima potrivire oriunde în text, cu modelul compilat. Pattern.search(string, pos=0, endpos=9223372036854775807)
re.Pattern.split	Împarte textul după modelul compilat. Pattern.split(string, maxsplit=0)
re.Pattern.sub	Înlocuiește potrivirile modelului compilat. Pattern.sub(repl, string, count=0)
re.Pattern.subn	Ca sub(), dar returnează și numărul de înlocuiri. Pattern.subn(repl, string, count=0)
re.purge	Golește cache-ul intern de expresii compilate. re.purge()
re.RegexFlag	Enumerarea flag-urilor (IGNORECASE, MULTILINE, DOTALL, VERBOSE…). re.RegexFlag(*values)
re.search	Prima potrivire a modelului oriunde în text. re.search(pattern, string, flags=0)
re.split	Împarte textul oriunde se potrivește modelul. re.split(pattern, string, maxsplit=0, flags=0)
re.sub	Înlocuiește potrivirile cu un text sau cu rezultatul unei funcții. re.sub(pattern, repl, string, count=0, flags=0)
re.subn	Ca sub(), dar returnează (text_nou, număr_înlocuiri). re.subn(pattern, repl, string, count=0, flags=0)
str.capitalize	Prima literă mare, restul mici. str.capitalize()
str.casefold	Litere mici „agresive”, pentru comparații fără diferențe de majuscule (ß devine ss). str.casefold()
str.center	Centrează textul pe o lățime dată, completând cu un caracter. str.center(width, fillchar=' ', /)
str.count	Numărul de apariții ale unui subșir, fără suprapuneri. str.count(sub[, start[, end]])
str.encode	Transformă textul în bytes după o codificare (implicit UTF-8). str.encode(encoding='utf-8', errors='strict')
str.endswith	True dacă textul se termină cu sufixul dat (sau cu unul dintr-un tuplu). str.endswith(suffix[, start[, end]])
str.expandtabs	Înlocuiește tab-urile cu spații, aliniind pe coloane. str.expandtabs(tabsize=8)
str.find	Poziția primei apariții a unui subșir sau -1. str.find(sub[, start[, end]])
str.format	Completează câmpurile {} ale unui șablon cu valori. str.format(*args, **kwargs)
str.format_map	Ca format(), dar ia valorile direct dintr-un dicționar. str.format_map(mapping, /)
str.index	Ca find(), dar aruncă ValueError dacă subșirul lipsește. str.index(sub[, start[, end]])
str.isalnum	True dacă textul conține doar litere și cifre. str.isalnum()
str.isalpha	True dacă textul conține doar litere (inclusiv cu diacritice). str.isalpha()
str.isascii	True dacă toate caracterele sunt ASCII (sau textul e gol). str.isascii()
str.isdecimal	True dacă textul conține doar cifre zecimale, cele acceptate de int(). str.isdecimal()
str.isdigit	True dacă textul conține doar cifre (inclusiv exponenți ca ²). str.isdigit()
str.isidentifier	True dacă textul poate fi nume de variabilă în Python. str.isidentifier()
str.islower	True dacă toate literele (cel puțin una) sunt mici. str.islower()
str.isnumeric	True dacă toate caracterele sunt numerice (inclusiv fracții ca ½). str.isnumeric()
str.isprintable	True dacă textul nu conține caractere de control (ex. \n, \t). str.isprintable()
str.isspace	True dacă textul conține doar spații albe. str.isspace()
str.istitle	True dacă fiecare cuvânt începe cu majusculă și continuă cu litere mici. str.istitle()
str.isupper	True dacă toate literele (cel puțin una) sunt mari. str.isupper()
str.join	Lipește textele unei colecții, cu textul curent ca separator. str.join(iterable, /)
str.ljust	Aliniază la stânga pe o lățime dată, completând la dreapta. str.ljust(width, fillchar=' ', /)
str.lower	Toate literele mici. str.lower()
str.lstrip	Elimină spațiile (sau caracterele date) de la început. str.lstrip(chars=None, /)
str.maketrans	Construiește tabelul de traducere pentru translate(). str.maketrans(x[, y[, z]])
str.partition	Împarte la prima apariție a separatorului: (înainte, sep, după). str.partition(sep, /)
str.removeprefix	Elimină prefixul dat, dacă există (Python 3.9+). str.removeprefix(prefix, /)
str.removesuffix	Elimină sufixul dat, dacă există (Python 3.9+). str.removesuffix(suffix, /)
str.replace	Înlocuiește aparițiile unui subșir cu altul. str.replace(old, new, /, count=-1)
str.rfind	Poziția ultimei apariții a unui subșir sau -1. str.rfind(sub[, start[, end]])
str.rindex	Ca rfind(), dar aruncă ValueError dacă subșirul lipsește. str.rindex(sub[, start[, end]])
str.rjust	Aliniază la dreapta pe o lățime dată, completând la stânga. str.rjust(width, fillchar=' ', /)
str.rpartition	Împarte la ultima apariție a separatorului: (înainte, sep, după). str.rpartition(sep, /)
str.rsplit	Ca split(), dar taie de la dreapta (contează cu maxsplit). str.rsplit(sep=None, maxsplit=-1)
str.rstrip	Elimină spațiile (sau caracterele date) de la sfârșit. str.rstrip(chars=None, /)
str.split	Împarte textul într-o listă după un separator sau după spații. str.split(sep=None, maxsplit=-1)
str.splitlines	Împarte textul în rânduri, recunoscând \n, \r\n și \r. str.splitlines(keepends=False)
str.startswith	True dacă textul începe cu prefixul dat (sau cu unul dintr-un tuplu). str.startswith(prefix[, start[, end]])
str.strip	Elimină spațiile (sau caracterele date) de la ambele capete. str.strip(chars=None, /)
str.swapcase	Inversează literele mari și mici. str.swapcase()
str.title	Prima literă a fiecărui cuvânt mare, restul mici. str.title()
str.translate	Înlocuiește sau șterge caractere după un tabel de traducere. str.translate(table, /)
str.upper	Toate literele mari. str.upper()
str.zfill	Completează cu zerouri la stânga, păstrând semnul în față. str.zfill(width, /)
string.ascii_letters	Literele ASCII mici și mari: a-z și A-Z.
string.ascii_lowercase	Literele ASCII mici: abcdefghijklmnopqrstuvwxyz.
string.ascii_uppercase	Literele ASCII mari: ABCDEFGHIJKLMNOPQRSTUVWXYZ.
string.capwords	Majusculă la începutul fiecărui cuvânt separat prin spații. string.capwords(s, sep=None)
string.digits	Cifrele zecimale: 0123456789.
string.Formatter	Clasa din spatele lui str.format(), extensibilă cu reguli proprii. string.Formatter()
string.hexdigits	Cifrele hexazecimale: 0-9, a-f, A-F.
string.octdigits	Cifrele octale: 01234567.
string.printable	Toate caracterele ASCII tipăribile: litere, cifre, punctuație, spații.
string.punctuation	Semnele de punctuație ASCII: !”#$%&'()*+,-./:;<=>?@[\]^_`{|}~.
string.Template	Șablon simplu cu marcaje $nume, sigur pentru texte scrise de utilizatori. string.Template(template)
string.Template.get_identifiers	Lista numelor folosite în șablon (Python 3.11+). Template.get_identifiers()
string.Template.is_valid	True dacă șablonul nu are marcaje greșite (Python 3.11+). Template.is_valid()
string.Template.safe_substitute	Completează șablonul, lăsând neschimbate marcajele fără valoare. Template.safe_substitute(mapping={}, /, **kws)
string.Template.substitute	Completează șablonul; KeyError dacă lipsește o valoare. Template.substitute(mapping={}, /, **kws)
string.whitespace	Caracterele de spațiu alb ASCII: spațiu, tab, rânduri noi etc.

Liste, dicționare, mulțimi și iteratoare (list, dict, set, tuple, collections, itertools, functools) (121)

Funcție	Ce face
collections.ChainMap	Vedere unică peste mai multe dicționare, căutate pe rând. collections.ChainMap(*maps)
collections.ChainMap.clear	Golește primul dicționar din lanț. ChainMap.clear()
collections.ChainMap.copy	ChainMap nou cu o copie a primului dicționar. ChainMap.copy()
collections.ChainMap.fromkeys	ChainMap nou dintr-o listă de chei cu aceeași valoare. ChainMap.fromkeys(iterable, value=None, /)
collections.ChainMap.get	Valoarea cheii, căutată în toate dicționarele, sau o valoare implicită. ChainMap.get(key, default=None)
collections.ChainMap.new_child	ChainMap nou cu un dicționar adăugat în față. ChainMap.new_child(m=None, **kwargs)
collections.ChainMap.pop	Scoate o cheie din primul dicționar. ChainMap.pop(key, *args)
collections.ChainMap.popitem	Scoate o pereche din primul dicționar. ChainMap.popitem()
collections.Counter	Dicționar care numără aparițiile fiecărei valori. collections.Counter(iterable=None, /, **kwds)
collections.Counter.copy	Copie a numărătorii. Counter.copy()
collections.Counter.elements	Iterator care repetă fiecare element de atâtea ori cât îi este numărul. Counter.elements()
collections.Counter.fromkeys	Nedefinită pentru Counter: aruncă NotImplementedError. Counter.fromkeys(iterable, v=None)
collections.Counter.most_common	Lista celor mai frecvente valori, ca perechi (valoare, număr). Counter.most_common(n=None)
collections.Counter.subtract	Scade numărători (rezultatele pot deveni zero sau negative). Counter.subtract(iterable=None, /, **kwds)
collections.Counter.total	Suma tuturor numărătorilor (Python 3.10+). Counter.total()
collections.Counter.update	Adună numărători noi din colecții sau dicționare. Counter.update(iterable=None, /, **kwds)
collections.defaultdict	Dicționar care creează automat valori implicite pentru cheile lipsă. collections.defaultdict(default_factory=None, /, [...])
collections.deque	Coadă cu două capete, rapidă la adăugare și scoatere la ambele capete. collections.deque([iterable[, maxlen]])
collections.deque.append	Adaugă un element la dreapta. deque.append(item, /)
collections.deque.appendleft	Adaugă un element la stânga. deque.appendleft(item, /)
collections.deque.clear	Șterge toate elementele. deque.clear()
collections.deque.copy	Copie superficială a cozii. deque.copy()
collections.deque.count	De câte ori apare o valoare. deque.count(value, /)
collections.deque.extend	Adaugă mai multe elemente la dreapta. deque.extend(iterable, /)
collections.deque.extendleft	Adaugă mai multe elemente la stânga (ordinea lor se inversează). deque.extendleft(iterable, /)
collections.deque.index	Poziția primei apariții a unei valori. deque.index(x[, start[, stop]])
collections.deque.insert	Inserează un element pe o poziție. deque.insert(index, value, /)
collections.deque.pop	Scoate și returnează elementul din dreapta. deque.pop()
collections.deque.popleft	Scoate și returnează elementul din stânga. deque.popleft()
collections.deque.remove	Șterge prima apariție a unei valori. deque.remove(value, /)
collections.deque.reverse	Inversează ordinea elementelor, pe loc. deque.reverse()
collections.deque.rotate	Rotește elementele cu n poziții la dreapta (sau la stânga, cu n negativ). deque.rotate(n=1, /)
collections.namedtuple	Creează un tip de tuplu cu câmpuri accesibile prin nume. collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
collections.OrderedDict	Dicționar cu operații de ordonare: mutare la capete, popitem la început. collections.OrderedDict([items])
collections.OrderedDict.clear	Șterge toate cheile. OrderedDict.clear()
collections.OrderedDict.copy	Copie superficială, cu aceeași ordine. OrderedDict.copy()
collections.OrderedDict.fromkeys	OrderedDict nou cu cheile date și aceeași valoare. OrderedDict.fromkeys(iterable, value=None)
collections.OrderedDict.items	Vedere cu perechile, în ordine. OrderedDict.items()
collections.OrderedDict.keys	Vedere cu cheile, în ordine. OrderedDict.keys()
collections.OrderedDict.move_to_end	Mută o cheie la sfârșit sau, cu last=False, la început. OrderedDict.move_to_end(key, last=True)
collections.OrderedDict.pop	Scoate o cheie și returnează valoarea. OrderedDict.pop(key[, default])
collections.OrderedDict.popitem	Scoate ultima pereche sau, cu last=False, prima. OrderedDict.popitem(last=True)
collections.OrderedDict.setdefault	Returnează valoarea cheii, adăugând-o dacă lipsește. OrderedDict.setdefault(key, default=None)
collections.OrderedDict.update	Adaugă sau suprascrie chei. OrderedDict.update([other, ]**kwargs)
collections.OrderedDict.values	Vedere cu valorile, în ordine. OrderedDict.values()
collections.UserDict	Clasă de bază pentru dicționare proprii, ușor de extins. collections.UserDict(dict=None, /, **kwargs)
collections.UserList	Clasă de bază pentru liste proprii, ușor de extins. collections.UserList(initlist=None)
collections.UserString	Clasă de bază pentru texte proprii, ușor de extins. collections.UserString(seq)
dict.clear	Șterge toate cheile dicționarului. dict.clear()
dict.copy	Copie superficială a dicționarului. dict.copy()
dict.fromkeys	Dicționar nou cu cheile date, toate cu aceeași valoare. dict.fromkeys(iterable, value=None, /)
dict.get	Valoarea unei chei sau o valoare implicită, fără KeyError. dict.get(key, default=None, /)
dict.items	Vedere cu perechile (cheie, valoare), pentru parcurgere. dict.items()
dict.keys	Vedere cu cheile dicționarului. dict.keys()
dict.pop	Scoate o cheie și returnează valoarea; implicit opțional dacă lipsește. dict.pop(key[, default])
dict.popitem	Scoate și returnează ultima pereche adăugată. dict.popitem()
dict.setdefault	Returnează valoarea cheii, adăugând-o cu o valoare implicită dacă lipsește. dict.setdefault(key, default=None, /)
dict.update	Adaugă sau suprascrie chei dintr-un alt dicționar sau din perechi. dict.update([other, ]**kwargs)
dict.values	Vedere cu valorile dicționarului. dict.values()
functools.cache	Decorator: memorează nelimitat rezultatele funcției (Python 3.9+). functools.cache(user_function, /)
functools.cached_property	Proprietate calculată o singură dată per obiect. functools.cached_property(func)
functools.cmp_to_key	Transformă o funcție de comparare într-o cheie pentru sorted(). functools.cmp_to_key(mycmp)
functools.lru_cache	Decorator: memorează rezultatele ultimelor apeluri. functools.lru_cache(maxsize=128, typed=False)
functools.partial	Funcție nouă cu unele argumente deja completate. functools.partial(func, /, *args, **keywords)
functools.partialmethod	Ca partial(), pentru metodele unei clase. functools.partialmethod(func, /, *args, **keywords)
functools.reduce	Reduce o colecție la o valoare, aplicând repetat o funcție cu două argumente. functools.reduce(function, iterable[, initial], /)
functools.singledispatch	Funcție generică cu implementări alese după tipul primului argument. functools.singledispatch(func)
functools.singledispatchmethod	Ca singledispatch, pentru metode. functools.singledispatchmethod(func)
functools.total_ordering	Generează operatorii de comparare lipsă dintr-o clasă. functools.total_ordering(cls)
functools.update_wrapper	Copiază numele și documentația funcției originale pe înveliș. functools.update_wrapper(wrapper, wrapped, assigned=('__module__', '__name__', '__qualname__', '__doc__', '__annotate__', '__type_params__'), updated=('__dict__',))
functools.wraps	Decorator pentru înveliș: păstrează numele și documentația originalului. functools.wraps(wrapped, assigned=('__module__', '__name__', '__qualname__', '__doc__', '__annotate__', '__type_params__'), updated=('__dict__',))
itertools.accumulate	Totaluri parțiale sau alt rezultat acumulat pas cu pas. itertools.accumulate(iterable, func=None, *, initial=None)
itertools.batched	Împarte în tupluri de câte n elemente (Python 3.12+). itertools.batched(iterable, n, *, strict=False)
itertools.chain	Parcurge mai multe colecții una după alta. itertools.chain(*iterables)
itertools.combinations	Toate grupurile de r elemente, fără să conteze ordinea. itertools.combinations(iterable, r)
itertools.combinations_with_replacement	Grupuri de r elemente în care un element se poate repeta. itertools.combinations_with_replacement(iterable, r)
itertools.compress	Păstrează elementele pentru care selectorul de pe aceeași poziție e adevărat. itertools.compress(data, selectors)
itertools.count	Numără la infinit de la start, cu pasul dat. itertools.count(start=0, step=1)
itertools.cycle	Repetă la infinit elementele unei colecții. itertools.cycle(iterable, /)
itertools.dropwhile	Sare elementele de la început cât timp condiția e adevărată, apoi dă tot restul. itertools.dropwhile(predicate, iterable, /)
itertools.filterfalse	Păstrează elementele pentru care condiția este falsă. itertools.filterfalse(function, iterable, /)
itertools.groupby	Grupează elementele consecutive cu aceeași cheie. itertools.groupby(iterable, key=None)
itertools.islice	Felie dintr-un iterator: start, stop, pas (fără valori negative). itertools.islice(iterable, stop) / itertools.islice(iterable, start, stop[, step])
itertools.pairwise	Perechile de elemente vecine: (a, b), (b, c)… (Python 3.10+). itertools.pairwise(iterable, /)
itertools.permutations	Toate aranjamentele de r elemente, în care ordinea contează. itertools.permutations(iterable, r=None)
itertools.product	Produsul cartezian al mai multor colecții. itertools.product(*iterables, repeat=1)
itertools.repeat	Repetă o valoare de n ori sau la infinit. itertools.repeat(object [,times])
itertools.starmap	Aplică o funcție pe tupluri, despachetate în argumente. itertools.starmap(function, iterable, /)
itertools.takewhile	Ia elementele de la început cât timp condiția e adevărată. itertools.takewhile(predicate, iterable, /)
itertools.tee	Creează n iteratoare independente din unul singur. itertools.tee(iterable, n=2, /)
itertools.zip_longest	Ca zip(), dar până la cea mai lungă colecție, cu valoare de completare. itertools.zip_longest(*iterables, fillvalue=None)
list.append	Adaugă un element la sfârșitul listei. list.append(object, /)
list.clear	Șterge toate elementele listei, păstrând același obiect. list.clear()
list.copy	Copie superficială a listei (ca lista[:]). list.copy()
list.count	De câte ori apare o valoare în listă. list.count(value, /)
list.extend	Adaugă la final toate elementele altei colecții. list.extend(iterable, /)
list.index	Poziția primei apariții a unei valori; ValueError dacă lipsește. list.index(value, start=0, stop=9223372036854775807, /)
list.insert	Inserează un element înaintea poziției date. list.insert(index, object, /)
list.pop	Scoate și returnează elementul de pe o poziție (implicit ultimul). list.pop(index=-1, /)
list.remove	Șterge prima apariție a unei valori; ValueError dacă lipsește. list.remove(value, /)
list.reverse	Inversează ordinea elementelor, pe loc. list.reverse()
list.sort	Sortează lista pe loc, cu key și reverse opționale. list.sort(*, key=None, reverse=False)
set.add	Adaugă un element în mulțime (fără efect dacă există deja). set.add(object, /)
set.clear	Șterge toate elementele mulțimii. set.clear()
set.copy	Copie superficială a mulțimii. set.copy()
set.difference	Elementele care sunt în mulțime, dar nu în celelalte (a – b). set.difference(*others)
set.difference_update	Elimină din mulțime elementele celorlalte colecții (a -= b). set.difference_update(*others)
set.discard	Șterge un element dacă există, fără eroare. set.discard(object, /)
set.intersection	Elementele comune tuturor mulțimilor (a & b). set.intersection(*others)
set.intersection_update	Păstrează în mulțime doar elementele comune (a &= b). set.intersection_update(*others)
set.isdisjoint	True dacă mulțimile nu au niciun element comun. set.isdisjoint(other, /)
set.issubset	True dacă toate elementele sunt și în cealaltă colecție (a <= b). set.issubset(other, /)
set.issuperset	True dacă mulțimea conține toate elementele celeilalte (a >= b). set.issuperset(other, /)
set.pop	Scoate și returnează un element oarecare. set.pop()
set.remove	Șterge un element; KeyError dacă lipsește. set.remove(object, /)
set.symmetric_difference	Elementele care sunt în exact una dintre mulțimi (a ^ b). set.symmetric_difference(other, /)
set.symmetric_difference_update	Păstrează doar elementele aflate în exact una dintre mulțimi (a ^= b). set.symmetric_difference_update(other, /)
set.union	Toate elementele din mulțimile date, fără duplicate (a | b). set.union(*others)
set.update	Adaugă în mulțime elementele altor colecții (a |= b). set.update(*others)
tuple.count	De câte ori apare o valoare în tuplu. tuple.count(value, /)
tuple.index	Poziția primei apariții a unei valori în tuplu. tuple.index(value, start=0, stop=9223372036854775807, /)

Numere, matematică, numere aleatorii și statistică (int, float, math, random, statistics) (130)

Funcție	Ce face
float.as_integer_ratio	Valoarea exactă a numărului ca fracție (numărător, numitor). float.as_integer_ratio()
float.conjugate	Conjugatul complex; pentru un float este chiar numărul. float.conjugate()
float.from_number	Creează un float doar dintr-un număr, refuzând textele (Python 3.14+). float.from_number(number, /)
float.fromhex	Creează un float din reprezentarea hexazecimală exactă. float.fromhex(string, /)
float.hex	Reprezentarea hexazecimală exactă a numărului. float.hex()
float.is_integer	True dacă numărul nu are parte fracționară (ex. 4.0). float.is_integer()
int.as_integer_ratio	Numărul ca fracție (numărător, 1) (Python 3.8+). int.as_integer_ratio()
int.bit_count	Numărul de biți 1 din valoarea absolută (Python 3.10+). int.bit_count()
int.bit_length	Câți biți sunt necesari pentru a scrie numărul în binar. int.bit_length()
int.conjugate	Conjugatul complex; pentru un întreg este chiar numărul. int.conjugate()
int.from_bytes	Creează un întreg din octeți, cu ordinea big sau little. int.from_bytes(bytes, byteorder='big', *, signed=False)
int.is_integer	Mereu True; există pentru compatibilitate cu float (Python 3.12+). int.is_integer()
int.to_bytes	Scrie întregul pe un număr fix de octeți. int.to_bytes(length=1, byteorder='big', *, signed=False)
math.acos	Arccosinus, rezultat în radiani (argument între -1 și 1). math.acos(x, /)
math.acosh	Inversa cosinusului hiperbolic (argument ≥ 1). math.acosh(x, /)
math.asin	Arcsinus, rezultat în radiani (argument între -1 și 1). math.asin(x, /)
math.asinh	Inversa sinusului hiperbolic. math.asinh(x, /)
math.atan	Arctangentă, rezultat în radiani. math.atan(x, /)
math.atan2	Unghiul punctului (x, y) față de axa Ox, între -π și π. math.atan2(y, x, /)
math.atanh	Inversa tangentei hiperbolice (argument între -1 și 1). math.atanh(x, /)
math.cbrt	Rădăcina cubică, inclusiv pentru numere negative (Python 3.11+). math.cbrt(x, /)
math.ceil	Rotunjire în sus la cel mai apropiat întreg. math.ceil(x, /)
math.comb	Numărul de combinări C(n, k): alegeri fără ordine (Python 3.8+). math.comb(n, k, /)
math.copysign	Mărimea primului număr cu semnul celui de-al doilea. math.copysign(x, y, /)
math.cos	Cosinusul unui unghi în radiani. math.cos(x, /)
math.cosh	Cosinusul hiperbolic. math.cosh(x, /)
math.degrees	Transformă radiani în grade. math.degrees(x, /)
math.dist	Distanța euclidiană dintre două puncte (Python 3.8+). math.dist(p, q, /)
math.e	Constanta e = 2.718281828459045, baza logaritmului natural.
math.erf	Funcția de eroare din statistică. math.erf(x, /)
math.erfc	Funcția de eroare complementară, 1 – erf(x), precisă pentru x mare. math.erfc(x, /)
math.exp	e la puterea x. math.exp(x, /)
math.exp2	2 la puterea x (Python 3.11+). math.exp2(x, /)
math.expm1	e la puterea x minus 1, precis pentru x foarte mic. math.expm1(x, /)
math.fabs	Valoarea absolută, mereu ca float. math.fabs(x, /)
math.factorial	Factorialul unui întreg nenegativ: n! = 1 · 2 · … · n. math.factorial(n, /)
math.floor	Rotunjire în jos la cel mai apropiat întreg. math.floor(x, /)
math.fma	x * y + z calculat cu o singură rotunjire (Python 3.13+). math.fma(x, y, z, /)
math.fmod	Restul împărțirii pentru float, cu semnul deîmpărțitului. math.fmod(x, y, /)
math.frexp	Descompune un float în mantisă și exponent de 2. math.frexp(x, /)
math.fsum	Suma exactă (corect rotunjită) a unor numere zecimale. math.fsum(seq, /)
math.gamma	Funcția gamma, generalizarea factorialului la numere reale. math.gamma(x, /)
math.gcd	Cel mai mare divizor comun al unor întregi. math.gcd(*integers)
math.hypot	Lungimea unui vector: √(x² + y² + …). math.hypot(*coordinates)
math.inf	Infinitul pozitiv, ca float.
math.isclose	True dacă două numere sunt egale în limita unei toleranțe. math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
math.isfinite	True dacă numărul nu este nici infinit, nici NaN. math.isfinite(x, /)
math.isinf	True dacă numărul este plus sau minus infinit. math.isinf(x, /)
math.isnan	True dacă valoarea este NaN („nu este număr”). math.isnan(x, /)
math.isqrt	Partea întreagă a rădăcinii pătrate a unui întreg, exactă (Python 3.8+). math.isqrt(n, /)
math.lcm	Cel mai mic multiplu comun al unor întregi (Python 3.9+). math.lcm(*integers)
math.ldexp	Calculează m * 2**e (inversa lui frexp). math.ldexp(x, i, /)
math.lgamma	Logaritmul natural al valorii absolute a funcției gamma. math.lgamma(x, /)
math.log	Logaritmul natural sau în baza dată. math.log(x, [base=math.e])
math.log10	Logaritmul în baza 10. math.log10(x, /)
math.log1p	ln(1 + x), precis pentru x foarte mic. math.log1p(x, /)
math.log2	Logaritmul în baza 2. math.log2(x, /)
math.modf	Separă partea fracționară de cea întreagă: (frac, întreg). math.modf(x, /)
math.nan	Valoarea NaN („nu este număr”), ca float.
math.nextafter	Următorul float reprezentabil de la x spre y. math.nextafter(x, y, /, *, steps=None)
math.perm	Numărul de aranjamente: alegeri în care ordinea contează (Python 3.8+). math.perm(n, k=None, /)
math.pi	Constanta π = 3.141592653589793.
math.pow	x la puterea y, ca float. math.pow(x, y, /)
math.prod	Produsul tuturor elementelor unei colecții (Python 3.8+). math.prod(iterable, /, *, start=1)
math.radians	Transformă grade în radiani. math.radians(x, /)
math.remainder	Restul față de cel mai apropiat multiplu (standardul IEEE 754). math.remainder(x, y, /)
math.sin	Sinusul unui unghi în radiani. math.sin(x, /)
math.sinh	Sinusul hiperbolic. math.sinh(x, /)
math.sqrt	Rădăcina pătrată, ca float. math.sqrt(x, /)
math.sumprod	Suma produselor perechilor din două liste (Python 3.12+). math.sumprod(p, q, /)
math.tan	Tangenta unui unghi în radiani. math.tan(x, /)
math.tanh	Tangenta hiperbolică, cu valori între -1 și 1. math.tanh(x, /)
math.tau	Constanta τ = 2π = 6.283185307179586.
math.trunc	Taie partea zecimală (rotunjire spre zero). math.trunc(x, /)
math.ulp	Distanța de la x la următorul float mai mare. math.ulp(x, /)
random.betavariate	Număr aleator din distribuția beta, între 0 și 1. random.betavariate(alpha, beta)
random.binomialvariate	Numărul de succese din n încercări cu probabilitatea p (Python 3.12+). random.binomialvariate(n=1, p=0.5)
random.choice	Un element ales aleator dintr-o secvență. random.choice(seq)
random.choices	k alegeri aleatoare cu revenire, cu ponderi opționale. random.choices(population, weights=None, *, cum_weights=None, k=1)
random.expovariate	Număr aleator din distribuția exponențială (timpi de așteptare). random.expovariate(lambd=1.0)
random.gammavariate	Număr aleator din distribuția gamma. random.gammavariate(alpha, beta)
random.gauss	Număr aleator din distribuția normală (Gauss). random.gauss(mu=0.0, sigma=1.0)
random.getrandbits	Întreg aleator format din k biți. random.getrandbits(k, /)
random.getstate	Salvează starea curentă a generatorului. random.getstate()
random.lognormvariate	Număr aleator din distribuția log-normală. random.lognormvariate(mu, sigma)
random.normalvariate	Număr aleator din distribuția normală. random.normalvariate(mu=0.0, sigma=1.0)
random.paretovariate	Număr aleator din distribuția Pareto. random.paretovariate(alpha)
random.randbytes	n octeți aleatori (Python 3.9+; nu pentru securitate). random.randbytes(n)
random.randint	Întreg aleator între a și b, inclusiv capetele. random.randint(a, b)
random.Random	Generator de numere aleatoare independent, cu stare proprie. random.Random(x=None)
random.random	Float aleator în intervalul [0.0, 1.0). random.random()
random.randrange	Întreg aleator dintr-un range(start, stop, step). random.randrange(start, stop=None, step=1)
random.sample	k elemente distincte alese aleator, fără repetare. random.sample(population, k, *, counts=None)
random.seed	Fixează sămânța generatorului, pentru rezultate repetabile. random.seed(a=None, version=2)
random.setstate	Restaurează o stare salvată cu getstate(). random.setstate(state)
random.shuffle	Amestecă o listă pe loc. random.shuffle(x)
random.SystemRandom	Generator bazat pe sursa de aleatoriu a sistemului, nereproductibil. random.SystemRandom(x=None)
random.triangular	Număr aleator din distribuția triunghiulară. random.triangular(low=0.0, high=1.0, mode=None)
random.uniform	Float aleator între a și b. random.uniform(a, b)
random.vonmisesvariate	Unghi aleator din distribuția von Mises. random.vonmisesvariate(mu, kappa)
random.weibullvariate	Număr aleator din distribuția Weibull. random.weibullvariate(alpha, beta)
statistics.correlation	Coeficientul de corelație Pearson sau Spearman (Python 3.10+). statistics.correlation(x, y, /, *, method='linear')
statistics.covariance	Covarianța de eșantion a două serii (Python 3.10+). statistics.covariance(x, y, /)
statistics.fmean	Media aritmetică rapidă, ca float, cu ponderi opționale (Python 3.8+). statistics.fmean(data, weights=None)
statistics.geometric_mean	Media geometrică, pentru rate de creștere (Python 3.8+). statistics.geometric_mean(data)
statistics.harmonic_mean	Media armonică, pentru medii de viteze sau rate. statistics.harmonic_mean(data, weights=None)
statistics.kde	Estimarea densității cu nuclee: funcție netedă a distribuției (Python 3.13+). statistics.kde(data, h, kernel='normal', *, cumulative=False)
statistics.kde_random	Generator de valori aleatoare după o densitate KDE (Python 3.13+). statistics.kde_random(data, h, kernel='normal', *, seed=None)
statistics.linear_regression	Panta și interceptul dreptei de regresie (Python 3.10+). statistics.linear_regression(x, y, /, *, proportional=False)
statistics.mean	Media aritmetică, păstrând tipul exact al datelor. statistics.mean(data)
statistics.median	Valoarea din mijloc (media celor două din mijloc la număr par). statistics.median(data)
statistics.median_grouped	Mediana estimată pentru date grupate în intervale. statistics.median_grouped(data, interval=1.0)
statistics.median_high	Mediana, ca valoare existentă: cea mai mare dintre cele două din mijloc. statistics.median_high(data)
statistics.median_low	Mediana, ca valoare existentă: cea mai mică dintre cele două din mijloc. statistics.median_low(data)
statistics.mode	Valoarea cea mai frecventă. statistics.mode(data)
statistics.multimode	Lista tuturor valorilor cu frecvența maximă (Python 3.8+). statistics.multimode(data)
statistics.NormalDist	Distribuția normală ca obiect: probabilități, percentile, eșantioane (Python 3.8+). statistics.NormalDist(mu=0.0, sigma=1.0)
statistics.NormalDist.cdf	Probabilitatea ca o valoare să fie cel mult x. NormalDist.cdf(x)
statistics.NormalDist.from_samples	Estimează o distribuție normală din date. NormalDist.from_samples(data)
statistics.NormalDist.inv_cdf	Valoarea sub care se află proporția p a distribuției. NormalDist.inv_cdf(p)
statistics.NormalDist.overlap	Suprapunerea dintre două distribuții normale (0-1). NormalDist.overlap(other)
statistics.NormalDist.pdf	Densitatea de probabilitate în x. NormalDist.pdf(x)
statistics.NormalDist.quantiles	Punctele care împart distribuția în n părți egale. NormalDist.quantiles(n=4)
statistics.NormalDist.samples	n valori aleatoare din distribuție, cu sămânță opțională. NormalDist.samples(n, *, seed=None)
statistics.NormalDist.zscore	La câte abateri standard de medie se află x (Python 3.9+). NormalDist.zscore(x)
statistics.pstdev	Abaterea standard a populației (împarte la n). statistics.pstdev(data, mu=None)
statistics.pvariance	Varianța populației (împarte la n). statistics.pvariance(data, mu=None)
statistics.quantiles	Punctele care împart datele în n intervale egale (Python 3.8+). statistics.quantiles(data, *, n=4, method='exclusive')
statistics.stdev	Abaterea standard a eșantionului (împarte la n – 1). statistics.stdev(data, xbar=None)
statistics.variance	Varianța eșantionului (împarte la n – 1). statistics.variance(data, xbar=None)

Dată și oră (datetime, time) (80)

Funcție	Ce face
datetime.date	O dată calendaristică fără oră: an, lună, zi. datetime.date(year, month, day)
datetime.date.ctime	Data ca text în stilul C, ex. „Mon Oct 19 00:00:00 2026”. date.ctime()
datetime.date.fromisocalendar	Data din an, săptămâna ISO și ziua săptămânii (Python 3.8+). date.fromisocalendar(year, week, day)
datetime.date.fromisoformat	Citește o dată din text ISO, ex. „2026-10-19”. date.fromisoformat(object, /)
datetime.date.fromordinal	Data corespunzătoare unui număr de zile de la 1 ianuarie anul 1. date.fromordinal(ordinal)
datetime.date.fromtimestamp	Data locală corespunzătoare unui timestamp Unix. date.fromtimestamp(timestamp, /)
datetime.date.isocalendar	Anul ISO, numărul săptămânii și ziua din săptămână. date.isocalendar()
datetime.date.isoformat	Data ca text ISO: AAAA-LL-ZZ. date.isoformat()
datetime.date.isoweekday	Ziua din săptămână: luni = 1, duminică = 7. date.isoweekday()
datetime.date.replace	Copie a datei cu anul, luna sau ziua schimbate. date.replace(year=self.year, month=self.month, day=self.day)
datetime.date.strftime	Formatează data ca text după un șablon (%d.%m.%Y). date.strftime(format)
datetime.date.strptime	Citește o dată dintr-un text după un șablon (Python 3.14+). date.strptime(date_string, format)
datetime.date.timetuple	Data ca time.struct_time. date.timetuple()
datetime.date.today	Data de azi, după ceasul local. date.today()
datetime.date.toordinal	Numărul zilei de la 1 ianuarie anul 1. date.toordinal()
datetime.date.weekday	Ziua din săptămână: luni = 0, duminică = 6. date.weekday()
datetime.datetime	O dată cu oră, opțional cu fus orar. datetime.datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])
datetime.datetime.astimezone	Același moment, convertit în alt fus orar. datetime.astimezone(tz=None)
datetime.datetime.combine	Unește un date și un time într-un datetime. datetime.combine(date, time, tzinfo=time.tzinfo)
datetime.datetime.ctime	Data și ora ca text în stilul C. datetime.ctime()
datetime.datetime.date	Partea de dată, ca obiect date. datetime.date()
datetime.datetime.dst	Cât din decalajul față de UTC se datorează orei de vară. datetime.dst()
datetime.datetime.fromisoformat	Citește data și ora din text ISO (orice variantă din Python 3.11). datetime.fromisoformat(object, /)
datetime.datetime.fromtimestamp	Data și ora pentru un timestamp Unix, într-un fus dat. datetime.fromtimestamp(timestamp, tz=None)
datetime.datetime.isoformat	Data și ora ca text ISO, ex. „2026-10-19T14:30:00”. datetime.isoformat(sep='T', timespec='auto')
datetime.datetime.now	Data și ora curentă, opțional într-un fus orar. datetime.now(tz=None)
datetime.datetime.replace	Copie cu unele componente schimbate (oră, zi, fus). datetime.replace(year=self.year, month=self.month, day=self.day, hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)
datetime.datetime.strptime	Citește data și ora dintr-un text după un șablon. datetime.strptime(date_string, format)
datetime.datetime.time	Partea de oră, fără fus orar. datetime.time()
datetime.datetime.timestamp	Timestamp-ul Unix al momentului (secunde de la 1970). datetime.timestamp()
datetime.datetime.timetuple	Momentul ca time.struct_time. datetime.timetuple()
datetime.datetime.timetz	Partea de oră, cu fusul orar. datetime.timetz()
datetime.datetime.tzname	Numele fusului orar, ex. „EEST”. datetime.tzname()
datetime.datetime.utcfromtimestamp	Dată UTC naivă dintr-un timestamp; învechită din Python 3.12. datetime.utcfromtimestamp(timestamp)
datetime.datetime.utcnow	Ora UTC curentă, naivă; învechită din Python 3.12. datetime.utcnow()
datetime.datetime.utcoffset	Decalajul față de UTC, ca timedelta. datetime.utcoffset()
datetime.datetime.utctimetuple	Momentul convertit în UTC, ca time.struct_time. datetime.utctimetuple()
datetime.time	O oră din zi, fără dată, opțional cu fus orar. datetime.time([hour[, minute[, second[, microsecond[, tzinfo]]]]])
datetime.time.dst	Partea de oră de vară din decalaj, pentru o oră cu fus. time.dst()
datetime.time.fromisoformat	Citește o oră din text ISO, ex. „08:05:30”. time.fromisoformat(object, /)
datetime.time.isoformat	Ora ca text ISO: HH:MM:SS. time.isoformat(timespec='auto')
datetime.time.replace	Copie a orei cu componente schimbate. time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)
datetime.time.strftime	Formatează ora ca text după un șablon. time.strftime(format)
datetime.time.strptime	Citește o oră dintr-un text după un șablon (Python 3.14+). time.strptime(date_string, format)
datetime.time.tzname	Numele fusului orar al orei. time.tzname()
datetime.time.utcoffset	Decalajul față de UTC al orei. time.utcoffset()
datetime.timedelta	O durată de timp: zile, secunde, microsecunde. datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
datetime.timedelta.total_seconds	Toată durata, în secunde. timedelta.total_seconds()
datetime.timezone	Fus orar cu decalaj fix față de UTC. datetime.timezone(offset, name=None)
datetime.timezone.dst	Mereu None: un fus fix nu are oră de vară. timezone.dst(object, /)
datetime.timezone.fromutc	Convertește un moment UTC în ora acestui fus (folosit de astimezone). timezone.fromutc(object, /)
datetime.timezone.tzname	Numele fusului (cel dat sau „UTC+02:00”). timezone.tzname(object, /)
datetime.timezone.utcoffset	Decalajul fix față de UTC. timezone.utcoffset(object, /)
datetime.tzinfo	Clasa de bază abstractă pentru fusurile orare. datetime.tzinfo()
time.asctime	Un struct_time ca text: „Thu Jan 1 00:00:00 1970”. time.asctime([tuple])
time.clock_getres	Rezoluția unui ceas al sistemului (Unix). time.clock_getres(clk_id)
time.clock_gettime	Citește un anumit ceas al sistemului, în secunde (Unix). time.clock_gettime(clk_id, /)
time.clock_gettime_ns	Citește un ceas al sistemului, în nanosecunde (Unix). time.clock_gettime_ns(clk_id, /)
time.clock_settime	Setează un ceas al sistemului; cere drepturi de administrator. time.clock_settime(clk_id, time)
time.clock_settime_ns	Setează un ceas al sistemului, în nanosecunde. time.clock_settime_ns(clk_id, time)
time.ctime	Un timestamp ca text, în ora locală. time.ctime(seconds)
time.get_clock_info	Informații despre un ceas: implementare, rezoluție, monotonie. time.get_clock_info(name: str)
time.gmtime	Timestamp convertit în struct_time UTC. time.gmtime([seconds])
time.localtime	Timestamp convertit în struct_time pe ora locală. time.localtime([seconds])
time.mktime	struct_time pe ora locală convertit în timestamp. time.mktime(object, /)
time.monotonic	Ceas care nu merge niciodată înapoi, pentru termene și durate. time.monotonic()
time.monotonic_ns	Ca monotonic(), în nanosecunde. time.monotonic_ns()
time.perf_counter	Ceasul cu cea mai mare rezoluție, pentru măsurarea duratelor. time.perf_counter()
time.perf_counter_ns	Ca perf_counter(), în nanosecunde. time.perf_counter_ns()
time.process_time	Timpul de procesor folosit de procesul curent. time.process_time()
time.process_time_ns	Ca process_time(), în nanosecunde. time.process_time_ns()
time.sleep	Oprește execuția pentru un număr de secunde. time.sleep(object, /)
time.strftime	Formatează un struct_time (implicit ora curentă) ca text. time.strftime(format[, tuple])
time.strptime	Citește un text într-un struct_time după un șablon. time.strptime(string, format)
time.struct_time	Tuplu cu nume: an, lună, zi, oră, minut, secundă, zi din săptămână și din an. time.struct_time(iterable=(), /)
time.thread_time	Timpul de procesor folosit de firul de execuție curent. time.thread_time()
time.thread_time_ns	Ca thread_time(), în nanosecunde. time.thread_time_ns()
time.time	Ora curentă ca timestamp Unix, în secunde. time.time()
time.time_ns	Ora curentă ca timestamp Unix, în nanosecunde. time.time_ns()
time.tzset	Aplică fusul orar din variabila de mediu TZ (Unix). time.tzset()

Fișiere, căi, JSON și CSV (os.path, pathlib, shutil, json, csv) (146)

Funcție	Ce face
csv.Dialect	Clasa de bază care descrie un format CSV. csv.Dialect()
csv.DictReader	Citește un CSV cu antet, fiecare rând ca dicționar. csv.DictReader(f, fieldnames=None, restkey=None, restval=None, dialect='excel', *args, **kwds)
csv.DictWriter	Scrie dicționare într-un CSV, cu antet. csv.DictWriter(f, fieldnames, restval='', extrasaction='raise', dialect='excel', *args, **kwds)
csv.excel	Dialectul implicit: virgulă, ghilimele duble, \r\n. csv.excel()
csv.excel_tab	Dialect Excel cu tab ca separator. csv.excel_tab()
csv.field_size_limit	Citește sau schimbă lungimea maximă a unui câmp. csv.field_size_limit([new_limit])
csv.get_dialect	Returnează un dialect înregistrat după nume. csv.get_dialect(name)
csv.list_dialects	Lista numelor dialectelor înregistrate. csv.list_dialects()
csv.reader	Citește un CSV, fiecare rând ca listă de texte. csv.reader(iterable, /, dialect='excel', **fmtparams)
csv.register_dialect	Salvează un set de opțiuni de format sub un nume. csv.register_dialect(name, /, dialect='excel', **fmtparams)
csv.Sniffer	Ghicește separatorul și existența antetului. csv.Sniffer()
csv.unix_dialect	Dialect cu \n la capăt de rând și toate valorile între ghilimele. csv.unix_dialect()
csv.unregister_dialect	Șterge un dialect înregistrat. csv.unregister_dialect(name)
csv.writer	Scrie liste de valori într-un CSV. csv.writer(fileobj, /, dialect='excel', **fmtparams)
json.dump	Scrie o valoare Python ca JSON într-un fișier deschis. json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
json.dumps	Transformă o valoare Python în text JSON. json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
json.JSONDecoder	Clasa care citește JSON; raw_decode() citește o valoare dintr-un text mai lung. json.JSONDecoder(*, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)
json.JSONEncoder	Clasa care scrie JSON; extensibilă prin metoda default(). json.JSONEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)
json.load	Citește JSON dintr-un fișier deschis. json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
json.loads	Transformă un text JSON în valori Python. json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
os.path.abspath	Calea absolută, normalizată, pornind de la directorul curent. os.path.abspath(path)
os.path.basename	Ultima parte a căii: numele fișierului. os.path.basename(p)
os.path.commonpath	Cel mai lung director comun al mai multor căi. os.path.commonpath(paths)
os.path.commonprefix	Cel mai lung prefix comun, caracter cu caracter (poate da căi invalide). os.path.commonprefix(m)
os.path.dirname	Directorul din cale, fără numele fișierului. os.path.dirname(p)
os.path.exists	True dacă la cale există ceva (urmărind legăturile simbolice). os.path.exists(path)
os.path.expanduser	Înlocuiește ~ cu directorul personal al utilizatorului. os.path.expanduser(path)
os.path.expandvars	Înlocuiește $VARIABILA cu valoarea variabilei de mediu. os.path.expandvars(path)
os.path.getatime	Momentul ultimului acces, ca timestamp. os.path.getatime(filename)
os.path.getctime	Momentul schimbării metadatelor (Unix) sau al creării (Windows). os.path.getctime(filename)
os.path.getmtime	Momentul ultimei modificări a conținutului, ca timestamp. os.path.getmtime(filename)
os.path.getsize	Mărimea fișierului, în octeți. os.path.getsize(filename)
os.path.isabs	True dacă este o cale absolută. os.path.isabs(s)
os.path.isdevdrive	True dacă se află pe un Dev Drive Windows; False în rest. os.path.isdevdrive(path)
os.path.isdir	True dacă este un director existent. os.path.isdir(s)
os.path.isfile	True dacă este un fișier obișnuit existent. os.path.isfile(path)
os.path.isjunction	True dacă este un „junction” Windows (Python 3.12+). os.path.isjunction(path)
os.path.islink	True dacă însăși calea este o legătură simbolică. os.path.islink(path)
os.path.ismount	True dacă este un punct de montare (ex. /). os.path.ismount(path)
os.path.join	Unește bucăți de cale cu separatorul sistemului. os.path.join(a, *p)
os.path.lexists	Ca exists(), dar True și pentru legăturile simbolice rupte. os.path.lexists(path)
os.path.normcase	Normalizează majusculele și separatorii (are efect doar pe Windows). os.path.normcase(s)
os.path.normpath	Curăță calea: elimină . și .. și separatorii dubli. os.path.normpath(path)
os.path.realpath	Calea reală, cu legăturile simbolice rezolvate. os.path.realpath(filename, *, strict=False)
os.path.relpath	Calea relativă de la un director de pornire. os.path.relpath(path, start=None)
os.path.samefile	True dacă două căi indică același fișier de pe disc. os.path.samefile(f1, f2)
os.path.sameopenfile	True dacă doi descriptori deschiși indică același fișier. os.path.sameopenfile(fp1, fp2)
os.path.samestat	True dacă două rezultate os.stat() descriu același fișier. os.path.samestat(s1, s2)
os.path.split	Împarte calea în (director, nume). os.path.split(p)
os.path.splitdrive	Separă unitatea (ex. C:) de restul căii. os.path.splitdrive(p)
os.path.splitext	Separă extensia: (rădăcină, .ext). os.path.splitext(p)
os.path.splitroot	Separă unitatea, rădăcina și restul căii (Python 3.12+). os.path.splitroot(p)
pathlib.Path	Cale de fișier ca obiect, cu metode de citire, scriere și verificare. pathlib.Path(*args, **kwargs)
pathlib.Path.absolute	Calea absolută, fără rezolvarea legăturilor sau a lui .. Path.absolute()
pathlib.Path.anchor	Unitatea și rădăcina căii (ex. / sau C:\). Path.anchor
pathlib.Path.as_posix	Calea ca text cu bare oblice /. Path.as_posix()
pathlib.Path.as_uri	Calea absolută ca URI file://. Path.as_uri()
pathlib.Path.chmod	Schimbă permisiunile fișierului. Path.chmod(mode, *, follow_symlinks=True)
pathlib.Path.copy	Copiază fișierul sau directorul (recursiv) la o cale nouă (Python 3.14+). Path.copy(target, **kwargs)
pathlib.Path.copy_into	Copiază fișierul sau directorul într-un director (Python 3.14+). Path.copy_into(target_dir, **kwargs)
pathlib.Path.cwd	Directorul de lucru curent. Path.cwd()
pathlib.Path.exists	True dacă la cale există ceva. Path.exists(*, follow_symlinks=True)
pathlib.Path.expanduser	Înlocuiește ~ cu directorul personal. Path.expanduser()
pathlib.Path.from_uri	Creează o cale dintr-un URI file:// (Python 3.13+). Path.from_uri(uri)
pathlib.Path.full_match	True dacă toată calea se potrivește unui model glob cu ** (Python 3.13+). Path.full_match(pattern, *, case_sensitive=None)
pathlib.Path.glob	Căile din director care se potrivesc unui model. Path.glob(pattern, *, case_sensitive=None, recurse_symlinks=False)
pathlib.Path.group	Numele grupului proprietar (Unix). Path.group(*, follow_symlinks=True)
pathlib.Path.hardlink_to	Face din cale o legătură fizică spre alt fișier (Python 3.10+). Path.hardlink_to(target)
pathlib.Path.home	Directorul personal al utilizatorului. Path.home()
pathlib.Path.is_absolute	True dacă este o cale absolută. Path.is_absolute()
pathlib.Path.is_block_device	True dacă este un dispozitiv bloc (ex. un disc). Path.is_block_device()
pathlib.Path.is_char_device	True dacă este un dispozitiv caracter (ex. /dev/null). Path.is_char_device()
pathlib.Path.is_dir	True dacă este un director. Path.is_dir(*, follow_symlinks=True)
pathlib.Path.is_fifo	True dacă este un canal cu nume (FIFO). Path.is_fifo()
pathlib.Path.is_file	True dacă este un fișier obișnuit. Path.is_file(*, follow_symlinks=True)
pathlib.Path.is_junction	True dacă este un „junction” Windows (Python 3.12+). Path.is_junction()
pathlib.Path.is_mount	True dacă este un punct de montare. Path.is_mount()
pathlib.Path.is_relative_to	True dacă se află sub calea dată (Python 3.9+). Path.is_relative_to(other)
pathlib.Path.is_reserved	True pentru nume rezervate Windows; învechită din Python 3.13. Path.is_reserved()
pathlib.Path.is_socket	True dacă este un socket Unix. Path.is_socket()
pathlib.Path.is_symlink	True dacă este o legătură simbolică. Path.is_symlink()
pathlib.Path.iterdir	Elementele aflate direct în director. Path.iterdir()
pathlib.Path.joinpath	Unește calea cu alte bucăți (ca operatorul /). Path.joinpath(*pathsegments)
pathlib.Path.lchmod	Schimbă permisiunile legăturii simbolice înseși. Path.lchmod(mode)
pathlib.Path.lstat	Informațiile stat ale legăturii simbolice înseși. Path.lstat()
pathlib.Path.match	True dacă sfârșitul căii se potrivește unui model glob. Path.match(path_pattern, *, case_sensitive=None)
pathlib.Path.mkdir	Creează directorul, opțional cu părinții lipsă. Path.mkdir(mode=511, parents=False, exist_ok=False)
pathlib.Path.move	Mută fișierul sau directorul la o cale nouă (Python 3.14+). Path.move(target)
pathlib.Path.move_into	Mută fișierul sau directorul într-un director (Python 3.14+). Path.move_into(target_dir)
pathlib.Path.name	Ultima componentă a căii. Path.name
pathlib.Path.open	Deschide fișierul, ca funcția open(). Path.open(mode='r', buffering=-1, encoding=None, errors=None, newline=None)
pathlib.Path.owner	Numele utilizatorului proprietar (Unix). Path.owner(*, follow_symlinks=True)
pathlib.Path.parent	Directorul care conține calea. Path.parent
pathlib.Path.parents	Șirul tuturor directoarelor strămoș. Path.parents
pathlib.Path.parts	Tuplul componentelor căii. Path.parts
pathlib.Path.read_bytes	Citește tot fișierul ca bytes. Path.read_bytes()
pathlib.Path.read_text	Citește tot fișierul ca text. Path.read_text(encoding=None, errors=None, newline=None)
pathlib.Path.readlink	Destinația unei legături simbolice (Python 3.9+). Path.readlink()
pathlib.Path.relative_to	Calea relativă față de altă cale. Path.relative_to(other, *, walk_up=False)
pathlib.Path.rename	Redenumește sau mută fișierul. Path.rename(target)
pathlib.Path.replace	Redenumește, suprascriind ținta dacă există. Path.replace(target)
pathlib.Path.resolve	Calea absolută, cu legăturile simbolice și .. rezolvate. Path.resolve(strict=False)
pathlib.Path.rglob	Căutare recursivă după un model glob. Path.rglob(pattern, *, case_sensitive=None, recurse_symlinks=False)
pathlib.Path.rmdir	Șterge un director gol. Path.rmdir()
pathlib.Path.samefile	True dacă două căi indică același fișier. Path.samefile(other_path)
pathlib.Path.stat	Informații despre fișier: mărime, date, permisiuni. Path.stat(*, follow_symlinks=True)
pathlib.Path.stem	Numele fără ultima extensie. Path.stem
pathlib.Path.suffix	Ultima extensie (ex. .gz). Path.suffix
pathlib.Path.suffixes	Lista tuturor extensiilor (ex. [‘.tar’, ‘.gz’]). Path.suffixes
pathlib.Path.symlink_to	Face din cale o legătură simbolică spre ținta dată. Path.symlink_to(target, target_is_directory=False)
pathlib.Path.touch	Creează un fișier gol sau îi actualizează data modificării. Path.touch(mode=438, exist_ok=True)
pathlib.Path.unlink	Șterge fișierul sau legătura. Path.unlink(missing_ok=False)
pathlib.Path.walk	Parcurge recursiv directorul, ca os.walk() (Python 3.12+). Path.walk(top_down=True, on_error=None, follow_symlinks=False)
pathlib.Path.with_name	Cale nouă cu alt nume în același director. Path.with_name(name)
pathlib.Path.with_segments	Construiește o cale nouă de același tip din bucăți (Python 3.12+). Path.with_segments(*pathsegments)
pathlib.Path.with_stem	Cale nouă cu altă rădăcină a numelui (Python 3.9+). Path.with_stem(stem)
pathlib.Path.with_suffix	Cale nouă cu altă extensie. Path.with_suffix(suffix)
pathlib.Path.write_bytes	Scrie bytes în fișier, înlocuind conținutul. Path.write_bytes(data)
pathlib.Path.write_text	Scrie text în fișier, înlocuind conținutul. Path.write_text(data, encoding=None, errors=None, newline=None)
pathlib.PosixPath	Path concret pentru Linux și macOS. pathlib.PosixPath(*args, **kwargs)
pathlib.PurePath	Cale doar ca text, fără acces la disc. pathlib.PurePath(*args, **kwargs)
pathlib.PurePosixPath	Cale Unix pură, utilizabilă pe orice sistem. pathlib.PurePosixPath(*args, **kwargs)
pathlib.PureWindowsPath	Cale Windows pură, utilizabilă pe orice sistem. pathlib.PureWindowsPath(*args, **kwargs)
pathlib.WindowsPath	Path concret pentru Windows. pathlib.WindowsPath(*args, **kwargs)
shutil.chown	Schimbă proprietarul sau grupul, acceptând nume (Unix). shutil.chown(path, user=None, group=None, *, dir_fd=None, follow_symlinks=True)
shutil.copy	Copiază conținutul și permisiunile unui fișier. shutil.copy(src, dst, *, follow_symlinks=True)
shutil.copy2	Copiază conținutul, permisiunile și datele fișierului. shutil.copy2(src, dst, *, follow_symlinks=True)
shutil.copyfile	Copiază doar conținutul, într-un fișier destinație. shutil.copyfile(src, dst, *, follow_symlinks=True)
shutil.copyfileobj	Copiază între două fișiere deschise, pe bucăți. shutil.copyfileobj(fsrc, fdst, length=0)
shutil.copymode	Copiază doar permisiunile. shutil.copymode(src, dst, *, follow_symlinks=True)
shutil.copystat	Copiază permisiunile și datele, fără conținut. shutil.copystat(src, dst, *, follow_symlinks=True)
shutil.copytree	Copiază recursiv un director întreg. shutil.copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False, dirs_exist_ok=False)
shutil.disk_usage	Spațiul total, folosit și liber de pe disc. shutil.disk_usage(path)
shutil.get_archive_formats	Lista formatelor de arhivare disponibile. shutil.get_archive_formats()
shutil.get_terminal_size	Dimensiunea terminalului, cu valoare de rezervă. shutil.get_terminal_size(fallback=(80, 24))
shutil.get_unpack_formats	Lista formatelor de dezarhivare și extensiile lor. shutil.get_unpack_formats()
shutil.ignore_patterns	Creează un filtru de modele de ignorat pentru copytree(). shutil.ignore_patterns(*patterns)
shutil.make_archive	Creează o arhivă zip sau tar dintr-un director. shutil.make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0, dry_run=0, owner=None, group=None, logger=None)
shutil.move	Mută un fișier sau director, inclusiv pe alt disc. shutil.move(src, dst, copy_function=copy2)
shutil.register_archive_format	Înregistrează un format de arhivare propriu. shutil.register_archive_format(name, function, extra_args=None, description='')
shutil.register_unpack_format	Înregistrează un format de dezarhivare propriu. shutil.register_unpack_format(name, extensions, function, extra_args=None, description='')
shutil.rmtree	Șterge un director cu tot conținutul. shutil.rmtree(path, ignore_errors=False, onerror=None, *, onexc=None, dir_fd=None)
shutil.unpack_archive	Extrage o arhivă, ghicind formatul după extensie. shutil.unpack_archive(filename, extract_dir=None, format=None, *, filter=None)
shutil.unregister_archive_format	Elimină un format de arhivare înregistrat. shutil.unregister_archive_format(name)
shutil.unregister_unpack_format	Elimină un format de dezarhivare înregistrat. shutil.unregister_unpack_format(name)
shutil.which	Calea completă a unui program din PATH. shutil.which(cmd, mode=1, path=None)

Sistem de operare și procese (os, sys, subprocess) (245)

Funcție	Ce face
os.abort	Oprește imediat procesul cu SIGABRT, fără curățenie. os.abort()
os.access	Verifică dreptul de citire, scriere sau execuție asupra unui fișier. os.access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)
os.chdir	Schimbă directorul de lucru curent. os.chdir(path)
os.chflags	Setează flag-uri speciale ale unui fișier (BSD, macOS). os.chflags(path, flags, follow_symlinks=True)
os.chmod	Schimbă permisiunile unui fișier. os.chmod(path, mode, *, dir_fd=None, follow_symlinks=True)
os.chown	Schimbă proprietarul și grupul unui fișier, prin UID și GID (Unix). os.chown(path, uid, gid, *, dir_fd=None, follow_symlinks=True)
os.chroot	Schimbă directorul rădăcină al procesului (cere root). os.chroot(path)
os.close	Închide un descriptor de fișier. os.close(fd)
os.closerange	Închide toți descriptorii dintr-un interval. os.closerange(fd_low, fd_high, /)
os.confstr	Valori text de configurare ale sistemului (Unix). os.confstr(name, /)
os.cpu_count	Numărul de procesoare logice. os.cpu_count()
os.ctermid	Numele terminalului care controlează procesul. os.ctermid()
os.curdir	Textul pentru directorul curent: „.”.
os.device_encoding	Codificarea unui terminal, sau None dacă descriptorul nu e terminal. os.device_encoding(fd)
os.devnull	Calea dispozitivului „nul”: /dev/null sau nul.
os.DirEntry	Un element returnat de os.scandir(): nume, cale, tip și informații stat. os.DirEntry()
os.dup	Duplică un descriptor de fișier. os.dup(fd, /)
os.dup2	Copiază un descriptor peste un număr ales (ex. redirecționarea stdout). os.dup2(fd, fd2, inheritable=True)
os.environ	Dicționarul variabilelor de mediu.
os.execl	Înlocuiește procesul cu alt program; argumente separate. os.execl(file, *args)
os.execle	Ca execl, cu un dicționar de mediu la final. os.execle(file, *args)
os.execlp	Ca execl, căutând programul în PATH. os.execlp(file, *args)
os.execlpe	Ca execlp, cu dicționar de mediu. os.execlpe(file, *args)
os.execv	Înlocuiește procesul cu alt program; argumente ca listă. os.execv(path, argv, /)
os.execve	Ca execv, cu dicționar de mediu. os.execve(path, argv, env)
os.execvp	Ca execv, căutând programul în PATH. os.execvp(file, args)
os.execvpe	Ca execvp, cu dicționar de mediu. os.execvpe(file, args, env)
os.fchdir	Schimbă directorul curent pornind de la un descriptor. os.fchdir(fd)
os.fchmod	Schimbă permisiunile unui fișier deschis. os.fchmod(fd, mode)
os.fchown	Schimbă proprietarul unui fișier deschis. os.fchown(fd, uid, gid)
os.fdopen	Creează un obiect fișier dintr-un descriptor. os.fdopen(fd, mode='r', buffering=-1, encoding=None, *args, **kwargs)
os.fork	Creează un proces copil identic (Unix). os.fork()
os.forkpty	Fork cu procesul copil legat la un pseudo-terminal nou. os.forkpty()
os.fpathconf	Limite ale sistemului de fișiere pentru un fișier deschis. os.fpathconf(fd, name, /)
os.fsdecode	Transformă un nume de fișier în text, cu codificarea sistemului. os.fsdecode(filename)
os.fsencode	Transformă un nume de fișier în bytes, cu codificarea sistemului. os.fsencode(filename)
os.fspath	Transformă un obiect cale (Path) în str sau bytes. os.fspath(path)
os.fstat	Informații stat pentru un fișier deschis. os.fstat(fd)
os.fstatvfs	Informații despre sistemul de fișiere al unui fișier deschis. os.fstatvfs(fd, /)
os.fsync	Forțează scrierea pe disc a datelor unui fișier. os.fsync(fd)
os.ftruncate	Taie sau extinde un fișier deschis la o lungime dată. os.ftruncate(fd, length, /)
os.fwalk	Ca os.walk, dar dă și un descriptor pentru fiecare director (Unix). os.fwalk(top='.', topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None)
os.get_blocking	True dacă descriptorul este în mod blocant. os.get_blocking(fd, /)
os.get_exec_path	Lista directoarelor din PATH. os.get_exec_path(env=None)
os.get_inheritable	True dacă descriptorul este moștenit de procesele pornite. os.get_inheritable(fd, /)
os.get_terminal_size	Dimensiunea terminalului; OSError dacă nu este terminal. os.get_terminal_size(fd=STDOUT_FILENO, /)
os.getcwd	Directorul de lucru curent, ca text. os.getcwd()
os.getcwdb	Directorul de lucru curent, ca bytes. os.getcwdb()
os.getegid	ID-ul efectiv al grupului procesului. os.getegid()
os.getenv	Valoarea unei variabile de mediu, cu valoare implicită. os.getenv(key, default=None)
os.getenvb	Valoarea unei variabile de mediu, ca bytes (Unix). os.getenvb(key, default=None)
os.geteuid	ID-ul efectiv al utilizatorului procesului. os.geteuid()
os.getgid	ID-ul real al grupului procesului. os.getgid()
os.getgrouplist	Grupurile din care face parte un utilizator. os.getgrouplist(user, group, /)
os.getgroups	Grupurile suplimentare ale procesului curent. os.getgroups()
os.getloadavg	Încărcarea medie a sistemului în ultimele 1, 5 și 15 minute. os.getloadavg()
os.getlogin	Numele utilizatorului conectat la terminal. os.getlogin()
os.getpgid	Grupul de procese al unui proces. os.getpgid(pid)
os.getpgrp	Grupul de procese al procesului curent. os.getpgrp()
os.getpid	ID-ul procesului curent (PID). os.getpid()
os.getppid	ID-ul procesului părinte. os.getppid()
os.getpriority	Prioritatea de planificare (nice) a unui proces, grup sau utilizator. os.getpriority(which, who)
os.getsid	ID-ul sesiunii unui proces. os.getsid(pid, /)
os.getuid	ID-ul real al utilizatorului procesului. os.getuid()
os.grantpt	Acordă acces la capătul slave al unui pseudo-terminal (Python 3.13+). os.grantpt(fd, /)
os.initgroups	Încarcă grupurile suplimentare ale unui utilizator (cere root). os.initgroups(username, gid, /)
os.isatty	True dacă descriptorul este un terminal. os.isatty(fd, /)
os.kill	Trimite un semnal unui proces. os.kill(pid, signal, /)
os.killpg	Trimite un semnal unui grup de procese. os.killpg(pgid, signal, /)
os.lchflags	Setează flag-uri pe legătura simbolică însăși (BSD, macOS). os.lchflags(path, flags)
os.lchmod	Schimbă permisiunile legăturii simbolice înseși (nu pe Linux). os.lchmod(path, mode)
os.lchown	Schimbă proprietarul legăturii simbolice înseși. os.lchown(path, uid, gid)
os.linesep	Capătul de rând al sistemului: \n sau \r\n.
os.link	Creează o legătură fizică (hard link). os.link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)
os.listdir	Lista numelor dintr-un director. os.listdir(path=None)
os.lockf	Pune, verifică sau scoate un blocaj pe o porțiune de fișier (Unix). os.lockf(fd, command, length, /)
os.login_tty	Face dintr-un descriptor terminalul de control al procesului (Python 3.11+). os.login_tty(fd, /)
os.lseek	Mută poziția de citire/scriere a unui descriptor. os.lseek(fd, position, whence, /)
os.lstat	Informații stat pentru legătura simbolică însăși. os.lstat(path, *, dir_fd=None)
os.major	Numărul „major” dintr-un număr de dispozitiv. os.major(device, /)
os.makedev	Compune un număr de dispozitiv din major și minor. os.makedev(major, minor, /)
os.makedirs	Creează un director cu toți părinții lipsă. os.makedirs(name, mode=511, exist_ok=False)
os.minor	Numărul „minor” dintr-un număr de dispozitiv. os.minor(device, /)
os.mkdir	Creează un director. os.mkdir(path, mode=511, *, dir_fd=None)
os.mkfifo	Creează un canal cu nume (FIFO). os.mkfifo(path, mode=438, *, dir_fd=None)
os.mknod	Creează un fișier special: FIFO sau dispozitiv. os.mknod(path, mode=384, device=0, *, dir_fd=None)
os.name	Numele sistemului: ‘posix’ sau ‘nt’.
os.nice	Crește valoarea nice (scade prioritatea) procesului. os.nice(increment, /)
os.open	Deschide un fișier la nivel jos și returnează un descriptor. os.open(path, flags, mode=511, *, dir_fd=None)
os.openpty	Creează o pereche master/slave de pseudo-terminal. os.openpty()
os.pardir	Textul pentru directorul părinte: „..”.
os.pathconf	Limite ale sistemului de fișiere pentru o cale. os.pathconf(path, name)
os.pipe	Creează o țeavă: pereche de descriptori citire/scriere. os.pipe()
os.popen	Rulează o comandă în shell și returnează un fișier cu ieșirea ei. os.popen(cmd, mode='r', buffering=-1)
os.posix_openpt	Deschide un pseudo-terminal nou (Python 3.13+). os.posix_openpt(oflag, /)
os.posix_spawn	Pornește un program nou într-un singur pas (Python 3.8+). os.posix_spawn(path, argv, env, /, *, file_actions=(), setpgroup=None, resetids=False, setsid=False, setsigmask=(), setsigdef=(), scheduler=None)
os.posix_spawnp	Ca posix_spawn, căutând programul în PATH. os.posix_spawnp(path, argv, env, /, *, file_actions=(), setpgroup=None, resetids=False, setsid=False, setsigmask=(), setsigdef=(), scheduler=None)
os.pread	Citește de la o poziție dată, fără a muta cursorul. os.pread(fd, length, offset, /)
os.preadv	Citește de la o poziție dată în mai multe buffere. os.preadv(fd, buffers, offset, flags=0, /)
os.ptsname	Numele capătului slave al unui pseudo-terminal (Python 3.13+). os.ptsname(fd, /)
os.putenv	Setează o variabilă de mediu la nivel de sistem (fără os.environ). os.putenv(name, value, /)
os.pwrite	Scrie la o poziție dată, fără a muta cursorul. os.pwrite(fd, buffer, offset, /)
os.pwritev	Scrie mai multe buffere la o poziție dată. os.pwritev(fd, buffers, offset, flags=0, /)
os.read	Citește cel mult n octeți dintr-un descriptor. os.read(fd, length, /)
os.readinto	Citește dintr-un descriptor direct într-un buffer (Python 3.14+). os.readinto(fd, buffer, /)
os.readlink	Destinația unei legături simbolice. os.readlink(path, *, dir_fd=None)
os.readv	Citește dintr-un descriptor în mai multe buffere. os.readv(fd, buffers, /)
os.register_at_fork	Înregistrează funcții apelate înainte și după fork(). os.register_at_fork(*, before=None, after_in_parent=None, after_in_child=None)
os.reload_environ	Reîncarcă os.environ din mediul procesului (Python 3.14+). os.reload_environ()
os.remove	Șterge un fișier. os.remove(path, *, dir_fd=None)
os.removedirs	Șterge un director gol și părinții rămași goi. os.removedirs(name)
os.rename	Redenumește sau mută un fișier sau director. os.rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
os.renames	Redenumește, creând directoarele noi și ștergând pe cele golite. os.renames(old, new)
os.replace	Redenumește, înlocuind ținta pe orice sistem (atomic pe același disc). os.replace(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
os.rmdir	Șterge un director gol. os.rmdir(path, *, dir_fd=None)
os.scandir	Parcurge un director, cu obiecte DirEntry. os.scandir(path=None)
os.sched_get_priority_max	Prioritatea maximă pentru o politică de planificare. os.sched_get_priority_max(policy)
os.sched_get_priority_min	Prioritatea minimă pentru o politică de planificare. os.sched_get_priority_min(policy)
os.sched_yield	Cedează voluntar procesorul. os.sched_yield()
os.sendfile	Copiază date dintr-un fișier într-un socket, în nucleu. os.sendfile(out_fd, in_fd, offset, count, headers=(), trailers=(), flags=0)
os.sep	Separatorul de căi: / sau \.
os.set_blocking	Pune un descriptor în mod blocant sau neblocant. os.set_blocking(fd, blocking, /)
os.set_inheritable	Alege dacă descriptorul este moștenit de procesele pornite. os.set_inheritable(fd, inheritable, /)
os.setegid	Setează ID-ul efectiv al grupului. os.setegid(egid, /)
os.seteuid	Setează ID-ul efectiv al utilizatorului. os.seteuid(euid, /)
os.setgid	Setează ID-ul grupului procesului. os.setgid(gid, /)
os.setgroups	Setează grupurile suplimentare ale procesului (cere root). os.setgroups(groups, /)
os.setpgid	Mută un proces într-un grup de procese. os.setpgid(pid, pgrp, /)
os.setpgrp	Creează un grup nou pentru procesul curent. os.setpgrp()
os.setpriority	Setează prioritatea de planificare. os.setpriority(which, who, priority)
os.setregid	Setează ID-urile reale și efective ale grupului. os.setregid(rgid, egid, /)
os.setreuid	Setează ID-urile reale și efective ale utilizatorului. os.setreuid(ruid, euid, /)
os.setsid	Creează o sesiune nouă, desprinzând procesul de terminal. os.setsid()
os.setuid	Setează ID-ul utilizatorului procesului. os.setuid(uid, /)
os.spawnl	Pornește un program; argumente separate. os.spawnl(mode, file, *args)
os.spawnle	Ca spawnl, cu dicționar de mediu. os.spawnle(mode, file, *args)
os.spawnlp	Ca spawnl, căutând programul în PATH. os.spawnlp(mode, file, *args)
os.spawnlpe	Ca spawnlp, cu dicționar de mediu. os.spawnlpe(mode, file, *args)
os.spawnv	Pornește un program; argumente ca listă. os.spawnv(mode, file, args)
os.spawnve	Ca spawnv, cu dicționar de mediu. os.spawnve(mode, file, args, env)
os.spawnvp	Ca spawnv, căutând programul în PATH. os.spawnvp(mode, file, args)
os.spawnvpe	Ca spawnvp, cu dicționar de mediu. os.spawnvpe(mode, file, args, env)
os.stat	Informații despre un fișier: mărime, permisiuni, proprietar, date. os.stat(path, *, dir_fd=None, follow_symlinks=True)
os.statvfs	Informații despre sistemul de fișiere: blocuri libere, inode-uri. os.statvfs(path)
os.strerror	Mesajul de eroare pentru un cod errno. os.strerror(code, /)
os.symlink	Creează o legătură simbolică. os.symlink(src, dst, target_is_directory=False, *, dir_fd=None)
os.sync	Scrie pe disc toate datele aflate în memoria tampon a sistemului. os.sync()
os.sysconf	Valori numerice de configurare ale sistemului. os.sysconf(name, /)
os.system	Rulează o comandă în shell și returnează starea ei. os.system(command)
os.tcgetpgrp	Grupul de procese din prim-planul unui terminal. os.tcgetpgrp(fd, /)
os.tcsetpgrp	Setează grupul din prim-planul unui terminal. os.tcsetpgrp(fd, pgid, /)
os.times	Timpii de procesor ai procesului și ai copiilor lui. os.times()
os.truncate	Taie sau extinde un fișier la o lungime dată. os.truncate(path, length)
os.ttyname	Numele dispozitivului terminal al unui descriptor. os.ttyname(fd, /)
os.umask	Setează masca de permisiuni pentru fișierele noi. os.umask(mask, /)
os.uname	Informații despre sistem: nume, versiune nucleu, arhitectură (Unix). os.uname()
os.unlink	Șterge un fișier (la fel ca os.remove). os.unlink(path, *, dir_fd=None)
os.unlockpt	Deblochează capătul slave al unui pseudo-terminal (Python 3.13+). os.unlockpt(fd, /)
os.unsetenv	Șterge o variabilă de mediu la nivel de sistem. os.unsetenv(name, /)
os.urandom	n octeți aleatori, potriviți pentru criptografie. os.urandom(size, /)
os.utime	Setează momentele de acces și de modificare ale unui fișier. os.utime(path, times=None, *, ns, dir_fd=None, follow_symlinks=True)
os.wait	Așteaptă terminarea oricărui proces copil. os.wait()
os.wait3	Ca wait, plus resursele consumate de copil. os.wait3(options)
os.wait4	Așteaptă un anumit copil și returnează și resursele consumate. os.wait4(pid, options)
os.waitid	Așteaptă un proces, cu opțiuni fine, și returnează informații detaliate. os.waitid(idtype, id, options, /)
os.waitpid	Așteaptă terminarea unui anumit proces copil. os.waitpid(pid, options, /)
os.waitstatus_to_exitcode	Transformă starea de la wait() în cod de ieșire (Python 3.9+). os.waitstatus_to_exitcode(status)
os.walk	Parcurge recursiv un arbore de directoare. os.walk(top, topdown=True, onerror=None, followlinks=False)
os.WCOREDUMP	True dacă procesul oprit a generat un fișier core. os.WCOREDUMP(status, /)
os.WEXITSTATUS	Codul de ieșire dintr-o stare returnată de wait(). os.WEXITSTATUS(status)
os.WIFCONTINUED	True dacă procesul suspendat a fost reluat. os.WIFCONTINUED(status)
os.WIFEXITED	True dacă procesul s-a terminat normal, cu exit. os.WIFEXITED(status)
os.WIFSIGNALED	True dacă procesul a fost oprit de un semnal. os.WIFSIGNALED(status)
os.WIFSTOPPED	True dacă procesul a fost suspendat. os.WIFSTOPPED(status)
os.write	Scrie bytes într-un descriptor. os.write(fd, data, /)
os.writev	Scrie mai multe buffere dintr-un singur apel. os.writev(fd, buffers, /)
os.WSTOPSIG	Semnalul care a suspendat procesul. os.WSTOPSIG(status)
os.WTERMSIG	Semnalul care a oprit procesul. os.WTERMSIG(status)
subprocess.call	Rulează un program și returnează codul de ieșire. subprocess.call(*popenargs, timeout=None, **kwargs)
subprocess.check_call	Rulează un program; eroare dacă eșuează. subprocess.check_call(*popenargs, **kwargs)
subprocess.check_output	Rulează un program și returnează ieșirea; eroare dacă eșuează. subprocess.check_output(*popenargs, timeout=None, **kwargs)
subprocess.CompletedProcess	Rezultatul lui run(): args, returncode, stdout, stderr. subprocess.CompletedProcess(args, returncode, stdout=None, stderr=None)
subprocess.CompletedProcess.check_returncode	Aruncă CalledProcessError dacă returncode nu e 0. CompletedProcess.check_returncode()
subprocess.getoutput	Rulează o comandă shell și returnează ieșirea ca text. subprocess.getoutput(cmd, *, encoding=None, errors=None)
subprocess.getstatusoutput	Rulează o comandă shell și returnează (cod, ieșire). subprocess.getstatusoutput(cmd, *, encoding=None, errors=None)
subprocess.Popen	Pornește un program și îl controlează în timp ce rulează. subprocess.Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, user=None, group=None, extra_groups=None, encoding=None, errors=None, text=None, umask=-1, pipesize=-1, process_group=None)
subprocess.Popen.communicate	Trimite date, citește toată ieșirea și așteaptă terminarea. Popen.communicate(input=None, timeout=None)
subprocess.Popen.kill	Oprește forțat procesul (SIGKILL pe Unix). Popen.kill()
subprocess.Popen.poll	Codul de ieșire, sau None dacă procesul încă rulează. Popen.poll()
subprocess.Popen.send_signal	Trimite un semnal procesului. Popen.send_signal(sig)
subprocess.Popen.terminate	Cere oprirea procesului (SIGTERM pe Unix). Popen.terminate()
subprocess.Popen.wait	Așteaptă terminarea și returnează codul de ieșire. Popen.wait(timeout=None)
subprocess.run	Rulează un program, așteaptă și returnează un CompletedProcess. subprocess.run(*popenargs, input=None, capture_output=False, timeout=None, check=False, **kwargs)
sys.activate_stack_trampoline	Face funcțiile Python vizibile în profilerul perf (Linux, 3.12+). sys.activate_stack_trampoline(backend, /)
sys.addaudithook	Înregistrează o funcție apelată pentru evenimentele de audit (3.8+). sys.addaudithook(hook)
sys.argv	Lista argumentelor din linia de comandă.
sys.audit	Emite un eveniment de audit propriu. sys.audit(event, /, *args)
sys.breakpointhook	Funcția apelată de breakpoint(); implicit pornește pdb. sys.breakpointhook(*args, **kwargs)
sys.byteorder	Ordinea octeților procesorului: ‘little’ sau ‘big’.
sys.call_tracing	Apelează o funcție cu urmărirea activă, din interiorul unui tracer. sys.call_tracing(func, args, /)
sys.deactivate_stack_trampoline	Dezactivează trambulina perf. sys.deactivate_stack_trampoline()
sys.displayhook	Funcția care afișează rezultatele în consola interactivă. sys.displayhook(object, /)
sys.exc_info	Tuplul (tip, valoare, traceback) al excepției tratate. sys.exc_info()
sys.excepthook	Funcția apelată pentru excepțiile neprinse. sys.excepthook(exctype, value, traceback, /)
sys.exception	Excepția tratată în prezent, sau None (Python 3.11+). sys.exception()
sys.executable	Calea interpretorului Python care rulează.
sys.exit	Încheie programul cu un cod de ieșire sau un mesaj. sys.exit(status=None, /)
sys.get_asyncgen_hooks	Funcțiile înregistrate pentru generatoarele asincrone. sys.get_asyncgen_hooks()
sys.get_coroutine_origin_tracking_depth	Câte cadre rețin corutinele despre locul creării. sys.get_coroutine_origin_tracking_depth()
sys.get_int_max_str_digits	Limita de cifre la conversia text–int (Python 3.11+). sys.get_int_max_str_digits()
sys.getallocatedblocks	Numărul de blocuri de memorie alocate de interpretor. sys.getallocatedblocks()
sys.getdefaultencoding	Codificarea implicită a textelor: ‘utf-8’. sys.getdefaultencoding()
sys.getdlopenflags	Flag-urile folosite la încărcarea extensiilor C (Unix). sys.getdlopenflags()
sys.getfilesystemencodeerrors	Tratarea erorilor la codificarea numelor de fișiere. sys.getfilesystemencodeerrors()
sys.getfilesystemencoding	Codificarea numelor de fișiere. sys.getfilesystemencoding()
sys.getprofile	Funcția de profilare curentă. sys.getprofile()
sys.getrecursionlimit	Adâncimea maximă a recursivității. sys.getrecursionlimit()
sys.getrefcount	Numărul de referințe către un obiect. sys.getrefcount(object, /)
sys.getsizeof	Mărimea unui obiect în memorie, în octeți (fără conținut). sys.getsizeof(object [, default])
sys.getswitchinterval	Intervalul de comutare între fire. sys.getswitchinterval()
sys.gettrace	Funcția de urmărire curentă. sys.gettrace()
sys.getunicodeinternedsize	Numărul de texte internate (Python 3.12+). sys.getunicodeinternedsize(*, _only_immortal=False)
sys.intern	Păstrează o singură copie a unui text în memorie. sys.intern(string, /)
sys.is_finalizing	True în timpul opririi interpretorului. sys.is_finalizing()
sys.is_remote_debug_enabled	True dacă procesul acceptă atașarea unui depanator (Python 3.14+). sys.is_remote_debug_enabled()
sys.is_stack_trampoline_active	True dacă trambulina perf este activă. sys.is_stack_trampoline_active()
sys.maxsize	Cel mai mare index posibil al unei liste (2**63 – 1 pe 64 de biți).
sys.modules	Dicționarul modulelor deja încărcate.
sys.path	Lista directoarelor în care se caută modulele.
sys.platform	Platforma: ‘linux’, ‘darwin’ sau ‘win32’.
sys.remote_exec	Rulează un script în alt proces Python (Python 3.14+). sys.remote_exec(pid, script)
sys.set_asyncgen_hooks	Înregistrează funcții pentru generatoarele asincrone. sys.set_asyncgen_hooks([firstiter] [, finalizer])
sys.set_coroutine_origin_tracking_depth	Setează câte cadre rețin corutinele despre locul creării. sys.set_coroutine_origin_tracking_depth(depth)
sys.set_int_max_str_digits	Schimbă limita de cifre la conversia text–int. sys.set_int_max_str_digits(maxdigits)
sys.setdlopenflags	Setează flag-urile pentru încărcarea extensiilor C. sys.setdlopenflags(flags, /)
sys.setprofile	Înregistrează o funcție de profilare (apeluri și ieșiri). sys.setprofile(function, /)
sys.setrecursionlimit	Schimbă adâncimea maximă a recursivității. sys.setrecursionlimit(limit, /)
sys.setswitchinterval	Schimbă intervalul de comutare între fire. sys.setswitchinterval(interval, /)
sys.settrace	Înregistrează o funcție de urmărire pentru fiecare apel și rând. sys.settrace(function, /)
sys.stderr	Ieșirea pentru erori.
sys.stdin	Intrarea standard.
sys.stdout	Ieșirea standard, folosită de print().
sys.unraisablehook	Funcția apelată pentru erorile care nu pot fi aruncate (ex. din __del__). sys.unraisablehook(unraisable, /)
sys.version	Versiunea completă a interpretorului, ca text.
sys.version_info	Versiunea ca tuplu comparabil: (3, 14, 7, ‘final’, 0).