# TURUL PE SCURT AL BIBLIOTECII STANDARD --- PARTEA II.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Octavian Mustafa <octawian@yahoo.com>, 2025.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-06-17 17:56+0300\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language: ro\n"
"Language-Team: ro <octawian@yahoo.com>\n"
"Plural-Forms: nplurals=3; plural=(n==1 ? 0 : (n==0 || (n%100 > 0 && n%100"
" < 20)) ? 1 : 2);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.17.0\n"

#: ../../tutorial/stdlib2.rst:5
msgid "Brief Tour of the Standard Library --- Part II"
msgstr "Turul pe scurt al bibliotecii standard --- Partea II"

#: ../../tutorial/stdlib2.rst:7
msgid ""
"This second tour covers more advanced modules that support professional "
"programming needs.  These modules rarely occur in small scripts."
msgstr ""
"În partea a doua a turului ne vom referi la module avansate care deservesc "
"nevoile programatorului profesionist. Nu este de așteptat ca astfel de "
"module să apară prea des în scripturile de dimensiuni mici."

#: ../../tutorial/stdlib2.rst:14
msgid "Output Formatting"
msgstr "Formatarea ieșirii"

#: ../../tutorial/stdlib2.rst:16
msgid ""
"The :mod:`reprlib` module provides a version of :func:`repr` customized "
"for abbreviated displays of large or deeply nested containers::"
msgstr ""
"Modulul :mod:`reprlib` ne pune la dispoziție o versiune a funcției "
":func:`repr` adaptată la afișările cu *abrevieri de conținut* "
"atât pentru `containere masive <https://ro.wikipedia.org/wiki/"
"Cel_mai_lung_cuv%C3%A2nt_%C3%AEn_rom%C3%A2n%C4%83>`_ "
"cât și pentru containerele cu imbricări multiple (stratificate)::"

#: ../../tutorial/stdlib2.rst:19
#, python-brace-format
msgid ""
">>> import reprlib\n"
">>> reprlib.repr(set('supercalifragilisticexpialidocious'))\n"
"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""
msgstr ""
">>> import reprlib\n"
">>> reprlib.repr(set('pneumonoultramicroscopicsilicovolcaniconioza'))\n"
"\"{'a', 'c', 'e', 'i', 'l', 'm', ...}\""

#: ../../tutorial/stdlib2.rst:23
msgid ""
"The :mod:`pprint` module offers more sophisticated control over printing "
"both built-in and user defined objects in a way that is readable by the "
"interpreter. When the result is longer than one line, the \"pretty "
"printer\" adds line breaks and indentation to more clearly reveal data "
"structure::"
msgstr ""
"Modulul :mod:`pprint` oferă un control (încă și) mai sofisticat asupra "
"afișării atât a obiectelor predefinite cât și a celor definite de "
"utilizator, control care le face pe acestea lizibile pentru interpretor. "
"În caz că rezultatul va depăși lungimea unui rând, \"tipograful îngrijit\" "
"(sau *realizatorul de aranjări sugestive*; de la englezescul `pretty "
"printer <https://en.wikipedia.org/wiki/Pretty-printing>`_) îi va adăuga "
"caractere sfârșit-de-rând și indentări pentru a revela cu claritate "
"structura datelor (ce trebuie afișate)::"

#: ../../tutorial/stdlib2.rst:28
msgid ""
">>> import pprint\n"
">>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',\n"
"...     'yellow'], 'blue']]]\n"
"...\n"
">>> pprint.pprint(t, width=30)\n"
"[[[['black', 'cyan'],\n"
"   'white',\n"
"   ['green', 'red']],\n"
"  [['magenta', 'yellow'],\n"
"   'blue']]]"
msgstr ""
">>> import pprint\n"
">>> paletă = [[[['negru', 'turcoaz'], 'alb', ['verde',\n"
"...           'roșu']], [['fucsia', 'galben'], 'albastru']]]\n"
"...\n"
">>> pprint.pprint(paletă, width=30)\n"
"[[[['negru', 'turcoaz'],\n"
"   'alb',\n"
"   ['verde', 'roșu']],\n"
"  [['fucsia', 'galben'],\n"
"   'albastru']]]"

#: ../../tutorial/stdlib2.rst:39
msgid ""
"The :mod:`textwrap` module formats paragraphs of text to fit a given "
"screen width::"
msgstr ""
"Modulul :mod:`textwrap` formatează paragrafele de text pentru ca acestea "
"să încapă pe un ecran (de terminal) cu lungimea dată::"

#: ../../tutorial/stdlib2.rst:42
msgid ""
">>> import textwrap\n"
">>> doc = \"\"\"The wrap() method is just like fill() except that it "
"returns\n"
"... a list of strings instead of one big string with newlines to separate"
"\n"
"... the wrapped lines.\"\"\"\n"
"...\n"
">>> print(textwrap.fill(doc, width=40))\n"
"The wrap() method is just like fill()\n"
"except that it returns a list of strings\n"
"instead of one big string with newlines\n"
"to separate the wrapped lines."
msgstr ""
">>> import textwrap\n"
">>> documentul = \"\"\"Metoda wrap() este la fel cu metoda fill() doar că "
"returnează\n"
"... o listă de șiruri de caractere în locul unui șir de caractere foarte "
"lung care\n"
"... conține caractere sfârșit-de-rând pentru a putea să delimiteze "
"rândurile\n"
"... în care a fost împărțit.\"\"\"\n"
"...\n"
">>> print(textwrap.fill(documentul, width=40))\n"
"Metoda wrap() este la fel cu metoda\n"
"fill() doar că returnează o listă de\n"
"șiruri de caractere în locul unui șir de\n"
"caractere foarte lung care conține\n"
"caractere sfârșit-de-rând pentru a putea\n"
"să delimiteze rândurile în care a fost\n"
"împărțit."

#: ../../tutorial/stdlib2.rst:53
msgid ""
"The :mod:`locale` module accesses a database of culture specific data "
"formats. The grouping attribute of locale's format function provides a "
"direct way of formatting numbers with group separators::"
msgstr ""
"Modulul :mod:`locale` accesează o bază de date (POSIX) cu formate de date "
"specifice diverselor *culturi*. Atributul de *grupare* al funcției de "
"format din (modulul) *locale* ne pune la îndemână o modalitate imediată de "
"formatare a numerelor cu ajutorul separatoarelor de grup::"

#: ../../tutorial/stdlib2.rst:57
#, python-format
msgid ""
">>> import locale\n"
">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"
"'English_United States.1252'\n"
">>> conv = locale.localeconv()          # get a mapping of conventions\n"
">>> x = 1234567.8\n"
">>> locale.format_string(\"%d\", x, grouping=True)\n"
"'1,234,567'\n"
">>> locale.format_string(\"%s%.*f\", (conv['currency_symbol'],\n"
"...                      conv['frac_digits'], x), grouping=True)\n"
"'$1,234,567.80'"
msgstr ""
">>> import locale\n"
">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"
"'English_United States.1252'\n"
">>> # Obțineți o mapare a convențiilor (obiceiurile locale):\n"
">>> convenții = locale.localeconv()\n"
">>> numărul = 1234567.8\n"
">>> locale.format_string(\"%d\", numărul, grouping=True)\n"
"'1,234,567'\n"
">>> locale.format_string(\"%s%.*f\", (convenții['currency_symbol'],\n"
"...                      convenții['frac_digits'], numărul),\n"
"...                      grouping=True)\n"
"'$1,234,567.80'"

#: ../../tutorial/stdlib2.rst:72
msgid "Templating"
msgstr "Folosirea șabloanelor"

#: ../../tutorial/stdlib2.rst:74
msgid ""
"The :mod:`string` module includes a versatile :class:`~string.Template` "
"class with a simplified syntax suitable for editing by end-users.  This "
"allows users to customize their applications without having to alter the "
"application."
msgstr ""
"Modulul :mod:`string` include o clasă :class:`~string.Template` versatilă "
"a cărei sintaxă simplificată o face ușor de întrebuințat de către "
"utilizatori. Cu ajutorul său, aceștia pot să-și personalizeze aplicațiile "
"fără a fi nevoiți să opereze modificări în codul de bază al respectivelor "
"aplicații."

#: ../../tutorial/stdlib2.rst:78
msgid ""
"The format uses placeholder names formed by ``$`` with valid Python "
"identifiers (alphanumeric characters and underscores).  Surrounding the "
"placeholder with braces allows it to be followed by more alphanumeric "
"letters with no intervening spaces.  Writing ``$$`` creates a single "
"escaped ``$``::"
msgstr ""
"Formatul (din șablon) utilizează *nume de înlocuire* construite din "
"identificatori valizi în Python (adică, alcătuiți doar din caractere "
"alfanumerice și din caractere bară jos; atenție, doar caractere ASCII) "
"pe care le prefațăm cu ``$``. Numele de înlocuire se încadrează cu "
"acolade, ceea ce le permite să fie urmate de (și mai multe) litere "
"alfanumerice, însă acestea *fără spații goale* printre ele. Pentru "
"escaparea unui caracter ``$``, el va fi inserat sub forma ``$$``::"

#: ../../tutorial/stdlib2.rst:83
#, python-brace-format
msgid ""
">>> from string import Template\n"
">>> t = Template('${village}folk send $$10 to $cause.')\n"
">>> t.substitute(village='Nottingham', cause='the ditch fund')\n"
"'Nottinghamfolk send $10 to the ditch fund.'"
msgstr ""
">>> from string import Template\n"
">>> șablonul = Template(\"Amice-din-orașul-${localitatea}City, \"\n"
"...                     \"dă și matale $$10 pe $visul_nostru.\")\n"
">>> șablonul.substitute(localitatea='Medgidia',\n"
"...                     visul_nostru='apa gârlei')\n"
"'Amice-din-orașul-MedgidiaCity, dă și matale $10 pe apa gârlei.'"

#: ../../tutorial/stdlib2.rst:88
msgid ""
"The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` "
"when a placeholder is not supplied in a dictionary or a keyword argument."
"  For mail-merge style applications, user supplied data may be incomplete"
" and the :meth:`~string.Template.safe_substitute` method may be more "
"appropriate --- it will leave placeholders unchanged if data is missing::"
msgstr ""
"Metoda :meth:`~string.Template.substitute` ridică o excepție "
":exc:`KeyError` dacă vreun nume de înlocuire nu îi va fi furnizat fie de "
"către un argument de tip dicționar de date fie de un argument cuvânt-cheie. "
"În cazul unor aplicații cu documente construite în stilul "
"`Mail Merge <https://support.microsoft.com/en-gb/topic/how-to-use-the-mail-"
"merge-feature-in-word-to-create-and-to-print-form-letters-that-use-the-"
"data-from-an-excel-worksheet-d8709e29-c106-2348-7e38-13eecc338679>`_ "
"(îmbinare-de-mesaje) survin situații când datele oferite de utilizator "
"rămân incomplete, din care motiv utilizarea metodei "
":meth:`~string.Template.safe_substitute` ar putea fi (mai) potrivită --- "
"căci aceasta nu va modifica numele de înlocuire dacă lipsesc datele "
"corespunzătoare respectivelor nume. Exemplul de mai jos face referire la "
"`episodul cu rândunica <https://montypython.fandom.com/wiki/Swallow>`_ "
"(Monty Python)::"

#: ../../tutorial/stdlib2.rst:94
msgid ""
">>> t = Template('Return the $item to $owner.')\n"
">>> d = dict(item='unladen swallow')\n"
">>> t.substitute(d)\n"
"Traceback (most recent call last):\n"
"  ...\n"
"KeyError: 'owner'\n"
">>> t.safe_substitute(d)\n"
"'Return the unladen swallow to $owner.'"
msgstr ""
">>> șablonul = Template('De înapoiat $colet la $expeditor.')\n"
">>> dicționarul = dict(colet='rândunica fără nimica')\n"
">>> șablonul.substitute(dicționarul)\n"
"Traceback (most recent call last):\n"
"  ...\n"
"KeyError: 'expeditor'\n"
">>> șablonul.safe_substitute(dicționarul)\n"
"'De înapoiat rândunica fără nimica la $expeditor.'"

#: ../../tutorial/stdlib2.rst:103
msgid ""
"Template subclasses can specify a custom delimiter.  For example, a batch"
" renaming utility for a photo browser may elect to use percent signs for "
"placeholders such as the current date, image sequence number, or file "
"format::"
msgstr ""
"Urmașele clasei *Template* își pot personaliza *delimitatorul*. De exemplu, "
"un script utilitar de redenumire a unor loturi de fotografii, atașat unui "
"album fotografic, poate întrebuința semnul grafic *procent* pe post de "
"caracter de înlocuire pentru șiruri de caractere precum data "
"calendaristică, numărul (de ordine în lot al) fișierului foto, respectiv "
"extensia fișierului::"

#: ../../tutorial/stdlib2.rst:107
#, python-brace-format, python-format
msgid ""
">>> import time, os.path\n"
">>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"
">>> class BatchRename(Template):\n"
"...     delimiter = '%'\n"
"...\n"
">>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format):  ')\n"
"Enter rename style (%d-date %n-seqnum %f-format):  Ashley_%n%f\n"
"\n"
">>> t = BatchRename(fmt)\n"
">>> date = time.strftime('%d%b%y')\n"
">>> for i, filename in enumerate(photofiles):\n"
"...     base, ext = os.path.splitext(filename)\n"
"...     newname = t.substitute(d=date, n=i, f=ext)\n"
"...     print('{0} --> {1}'.format(filename, newname))\n"
"\n"
"img_1074.jpg --> Ashley_0.jpg\n"
"img_1076.jpg --> Ashley_1.jpg\n"
"img_1077.jpg --> Ashley_2.jpg"
msgstr ""
">>> import string, time, os.path\n"
">>> fișiere_foto = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"
">>> class RedenumeșteLotul(string.Template):\n"
"...     delimiter = '%' # suprascriem atributul delimiter\n"
"...\n"
">>> formatul = input(\"Introduceți stilul redenumirii \"\n"
"...                  \"(%d-data %n-numărul %f-extensia_fișierului):  \")\n"
"Introduceți stilul redenumirii (%d-data %n-numărul %f-extensia_fișierului):"
"  Viorica_%n%f\n"
"\n"
">>> șablonul = RedenumeșteLotul(formatul)\n"
">>> data = time.strftime('%d%b%y')\n"
">>> for i, nume_de_fișier in enumerate(fișiere_foto):\n"
"...     baza, extensia = os.path.splitext(nume_de_fișier)\n"
"...     noul_nume = șablonul.substitute(d=data, n=i, f=extensia)\n"
"...     print('{0} --> {1}'.format(nume_de_fișier, noul_nume))\n"
"\n"
"img_1074.jpg --> Viorica_0.jpg\n"
"img_1076.jpg --> Viorica_1.jpg\n"
"img_1077.jpg --> Viorica_2.jpg"

#: ../../tutorial/stdlib2.rst:126
msgid ""
"Another application for templating is separating program logic from the "
"details of multiple output formats.  This makes it possible to substitute"
" custom templates for XML files, plain text reports, and HTML web "
"reports."
msgstr ""
"Ceea ce face șabloanele atât de utile în practică este chiar caracteristica "
"esențială a acestora, și anume *separarea* logicii unui program de afișarea "
"rezultatelor execuției lui. Astfel, pot fi construite șabloane "
"personalizate pentru introducerea convenabilă a acestor rezultate în "
"fișiere XML, în rapoarte sub formă de text simplu, ori în rapoarte HTML "
"destinate Internetului."

#: ../../tutorial/stdlib2.rst:134
msgid "Working with Binary Data Record Layouts"
msgstr "Lucrul cu machete ale înregistrărilor de date binare"

#: ../../tutorial/stdlib2.rst:136
msgid ""
"The :mod:`struct` module provides :func:`~struct.pack` and "
":func:`~struct.unpack` functions for working with variable length binary "
"record formats.  The following example shows how to loop through header "
"information in a ZIP file without using the :mod:`zipfile` module.  Pack "
"codes ``\"H\"`` and ``\"I\"`` represent two and four byte unsigned "
"numbers respectively.  The ``\"<\"`` indicates that they are standard "
"size and in little-endian byte order::"
msgstr ""
"Modulul :mod:`struct` ne pune la dispoziție funcțiile :func:`~struct.pack` "
"și :func:`~struct.unpack` pentru a putea manipula formate de înregistrări "
"binare de lungimi diverse. Exemplul de mai jos ne arată cum putem parcurge "
"informația din antetul unui fișier ZIP fără a face uz de modulul "
":mod:`zipfile`. Codurile de arhivare (de la englezescul *pack*) ``\"H\"`` "
"și ``\"I\"`` reprezintă numere întregi fără semn (cu lungime) de doi și "
"respectiv de patru octeți. Semnul ``\"<\"`` ne arată că datele au lungime "
"standard și sunt dispuse în formatul de stocare inversat (sau de *memorare "
"inversată*; de la englezescul, ca jargon informatic, *little-endian*)::"

#: ../../tutorial/stdlib2.rst:144
msgid ""
"import struct\n"
"\n"
"with open('myfile.zip', 'rb') as f:\n"
"    data = f.read()\n"
"\n"
"start = 0\n"
"for i in range(3):                      # show the first 3 file headers\n"
"    start += 14\n"
"    fields = struct.unpack('<IIIHH', data[start:start+16])\n"
"    crc32, comp_size, uncomp_size, filenamesize, extra_size = fields\n"
"\n"
"    start += 16\n"
"    filename = data[start:start+filenamesize]\n"
"    start += filenamesize\n"
"    extra = data[start:start+extra_size]\n"
"    print(filename, hex(crc32), comp_size, uncomp_size)\n"
"\n"
"    start += extra_size + comp_size     # skip to the next header"
msgstr ""
">>> import struct\n"
">>> # Fișierul fișierul_meu.zip este arhiva ZIP a (minim) 3 fișiere text:\n"
">>> with open('fișierul_meu.zip', 'rb') as f:\n"
"...    datele = f.read()\n"
"...\n"
">>> început = 0\n"
">>> for i in range(3):                # afișează primele 3 antete\n"
"...                                   # de fișier\n"
"...    început += 14\n"
"...    câmpuri = struct.unpack('<IIIHH', datele[început:început+16])\n"
"...    crc32 \\\n"
"...    ,mărime_comprimate \\\n"
"...    ,mărime_necomprimate \\\n"
"...    ,mărime_numedefișier \\\n"
"...    ,mărime_suplimentar = câmpuri\n"
"...    început += 16\n"
"...    numedefișier = datele[început:început+mărime_numedefișier]\n"
"...    început += mărime_numedefișier\n"
"...    suplimentar = datele[început:început+mărime_suplimentar]\n"
"...    print(numedefișier \\\n"
"...          ,hex(crc32) \\\n"
"...          ,mărime_comprimate \\\n"
"...          ,mărime_necomprimate)\n"
"...    început += mărime_suplimentar \\\n"
"...             + mărime_necomprimate # trecem la antetul următor"

#: ../../tutorial/stdlib2.rst:167
msgid "Multi-threading"
msgstr "Execuții multifilare"

#: ../../tutorial/stdlib2.rst:169
msgid ""
"Threading is a technique for decoupling tasks which are not sequentially "
"dependent.  Threads can be used to improve the responsiveness of "
"applications that accept user input while other tasks run in the "
"background.  A related use case is running I/O in parallel with "
"computations in another thread."
msgstr ""
"Execuția *pe mai multe fire* (sau *multifir* ori *multifilară*; de la "
"englezescul *threading*) a unui program este o tehnică de organizare a "
"execuției acestuia prin care se decuplează *sarcinile* (sau *subunitățile*; "
"de la englezescul *task*) programului care nu depind (în mod direct) una "
"de cealaltă. *Firele de execuție* (numite și *procese de categorie "
"ușoară*) pot fi întrebuințate pentru a îmbunătăți *receptivitatea* unei "
"aplicații la acțiunile utilizatorului său în timp ce execuția sarcinilor "
"de durată se desfășoară *în fundal* (asincron). Un caz de utilizare "
"relevant este cel al *rulării* (îndeplinirii) unor sarcini I/E (mai lente, "
"de obicei) *în paralel* cu realizarea de sarcini de calcul, acestea din "
"urmă fiind efectuate în alt fir de execuție."

#: ../../tutorial/stdlib2.rst:174
msgid ""
"The following code shows how the high level :mod:`threading` module can "
"run tasks in background while the main program continues to run::"
msgstr ""
"Fragmentul de cod care urmează ne arată cum poate modulul de nivel înalt "
":mod:`threading` să execute sarcini în fundal pe când programul principal "
"rulează (în prim-plan)::"

#: ../../tutorial/stdlib2.rst:177
msgid ""
"import threading, zipfile\n"
"\n"
"class AsyncZip(threading.Thread):\n"
"    def __init__(self, infile, outfile):\n"
"        threading.Thread.__init__(self)\n"
"        self.infile = infile\n"
"        self.outfile = outfile\n"
"\n"
"    def run(self):\n"
"        f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)\n"
"        f.write(self.infile)\n"
"        f.close()\n"
"        print('Finished background zip of:', self.infile)\n"
"\n"
"background = AsyncZip('mydata.txt', 'myarchive.zip')\n"
"background.start()\n"
"print('The main program continues to run in foreground.')\n"
"\n"
"background.join()    # Wait for the background task to finish\n"
"print('Main program waited until background was done.')"
msgstr ""
"import threading, zipfile\n"
"\n"
"class ArhivareaZipAsincronă(threading.Thread):\n"
"    def __init__(self, fișier_de_intrare, fișier_de_ieșire):\n"
"        threading.Thread.__init__(self)\n"
"        self.fișier_de_intrare = fișier_de_intrare\n"
"        self.fișier_de_ieșire = fișier_de_ieșire\n"
"\n"
"    def run(self):    # suprascriem metoda run() a clasei Thread\n"
"        f = zipfile.ZipFile(self.fișier_de_ieșire, 'w', \\\n"
"                            zipfile.ZIP_DEFLATED)\n"
"        f.write(self.fișier_de_intrare)\n"
"        f.close()\n"
"        print('Terminat arhivarea zip, în fundal, a lui:', \\\n"
"              self.fișier_de_intrare)\n"
"\n"
"în_fundal = ArhivareaZipAsincronă('datele_mele.txt', 'arhiva_mea.zip')\n"
"în_fundal.start()\n"
"print('Programul principal rulează (în continuare) în prim-plan.')\n"
"\n"
"în_fundal.join()    # Așteptăm să se încheie sarcina de fundal\n"
"print('Programul principal a așteptat încheierea sarcinii de fundal.')"

#: ../../tutorial/stdlib2.rst:198
msgid ""
"The principal challenge of multi-threaded applications is coordinating "
"threads that share data or other resources.  To that end, the threading "
"module provides a number of synchronization primitives including locks, "
"events, condition variables, and semaphores."
msgstr ""
"Dificultatea principală a aplicațiilor *multifir* (adică, a aplicațiilor "
"cu execuție pe mai multe fire) este cea a *coordonării* acestor fire de "
"execuție vizavi de accesul la date ori la alte resurse (memorie, șamd.). "
"În acest scop, modulul *threading* ne furnizează un număr de *primitive "
"de sincronizare*, precum *blocări* (sau *zăvoare*; de la englezescul "
"*lock*), evenimente, variabile de control și semafoare."

#: ../../tutorial/stdlib2.rst:203
msgid ""
"While those tools are powerful, minor design errors can result in "
"problems that are difficult to reproduce.  So, the preferred approach to "
"task coordination is to concentrate all access to a resource in a single "
"thread and then use the :mod:`queue` module to feed that thread with "
"requests from other threads. Applications using :class:`~queue.Queue` "
"objects for inter-thread communication and coordination are easier to "
"design, more readable, and more reliable."
msgstr ""
"Chiar dacă aceste unelte sunt puternice, erorile de proiectare (fie și) "
"minore ne pot pune în fața unor complicații dificil de reprodus (în "
"mod sistematic). Din acest motiv, abordarea preferată în practică în "
"ceea ce privește coordonarea sarcinilor este să realizăm (toată) "
"accesarea resurselor într-un singur fir de execuție și să utilizăm modulul "
":mod:`queue` pentru a *hrăni* acest fir cu *cereri* din partea celorlalte "
"fire de execuție. Aplicațiile care întrebuințează obiecte "
":class:`~queue.Queue` pentru *comunicarea între fire* (sau *comunicarea "
"interprocese*) și pentru coordonarea acestora sunt (mai) ușor de proiectat, "
"(mai) stabile și au codul-sursă (mai) facil de citit."

#: ../../tutorial/stdlib2.rst:214
msgid "Logging"
msgstr "Jurnalizarea"

#: ../../tutorial/stdlib2.rst:216
msgid ""
"The :mod:`logging` module offers a full featured and flexible logging "
"system. At its simplest, log messages are sent to a file or to "
"``sys.stderr``::"
msgstr ""
"Modulul :mod:`logging` ne pune la dispoziție un sistem de jurnalizare "
"flexibil și complet accesorizat. Folosite în modul cel mai simplu cu "
"putință, mesajele de (introdus în) jurnal îi sunt transmise fie unui "
"fișier (prestabilit) fie (fluxului) ``sys.stderr``::"

#: ../../tutorial/stdlib2.rst:219
#, python-format
msgid ""
"import logging\n"
"logging.debug('Debugging information')\n"
"logging.info('Informational message')\n"
"logging.warning('Warning:config file %s not found', 'server.conf')\n"
"logging.error('Error occurred')\n"
"logging.critical('Critical error -- shutting down')"
msgstr ""
"import logging\n"
"logging.debug('Informații de depanare')\n"
"logging.info('Mesaj de informare')\n"
"logging.warning('Avertisment: fișierul de configurare %s negăsit', 'serverul.conf')\n"
"logging.error('Eroare survenită')\n"
"logging.critical('Eroare critică -- opresc sistemul')"

#: ../../tutorial/stdlib2.rst:226
msgid "This produces the following output:"
msgstr "Iată ce se va afișa:"

#: ../../tutorial/stdlib2.rst:228
msgid ""
"WARNING:root:Warning:config file server.conf not found\n"
"ERROR:root:Error occurred\n"
"CRITICAL:root:Critical error -- shutting down"
msgstr ""
"WARNING:root:Avertisment: fișierul de configurare serverul.conf negăsit\n"
"ERROR:root:Eroare survenită\n"
"CRITICAL:root:Eroare critică -- opresc sistemul"

#: ../../tutorial/stdlib2.rst:234
msgid ""
"By default, informational and debugging messages are suppressed and the "
"output is sent to standard error.  Other output options include routing "
"messages through email, datagrams, sockets, or to an HTTP Server.  New "
"filters can select different routing based on message priority: "
":const:`~logging.DEBUG`, :const:`~logging.INFO`, "
":const:`~logging.WARNING`, :const:`~logging.ERROR`, and "
":const:`~logging.CRITICAL`."
msgstr ""
"În mod prestabilit, atât mesajele informative cât și cele de depanare sunt "
"suprimate (de la jurnalizare) în timp ce ieșirea (conținutul) lor se "
"trimite către fluxul standard de eroare. Alte opțiuni de ieșire includ "
"*distribuirea* (sau *rutarea*; de la englezescul, ca jargon informatic, "
"*routing*) mesajelor prin poșta electronică, datagrame, socluri, ori către "
"un server HTTP. Filtre suplimentare permit alegerea unor distribuiri bazate "
"pe *prioritatea mesajelor*: "
":const:`~logging.DEBUG`, :const:`~logging.INFO`, "
":const:`~logging.WARNING`, :const:`~logging.ERROR`, precum și "
":const:`~logging.CRITICAL`."

#: ../../tutorial/stdlib2.rst:241
msgid ""
"The logging system can be configured directly from Python or can be "
"loaded from a user editable configuration file for customized logging "
"without altering the application."
msgstr ""
"Sistemul de jurnalizare se poate configura atât direct din Python cât și "
"indirect, prin încărcarea setărilor dintr-un fișier de configurare care "
"poate fi editat de către utilizator, permițându-se astfel jurnalizări "
"personalizate a căror introducere să nu necesite modificarea codului-"
"sursă de bază al aplicației."

#: ../../tutorial/stdlib2.rst:249
msgid "Weak References"
msgstr "Referințe slabe"

#: ../../tutorial/stdlib2.rst:251
msgid ""
"Python does automatic memory management (reference counting for most "
"objects and :term:`garbage collection` to eliminate cycles).  The memory "
"is freed shortly after the last reference to it has been eliminated."
msgstr ""
"Python-ul își administrează memoria în mod automat (realizând atât "
"*contorizarea referințelor* pentru majoritatea obiectelor cât și "
":term:`colectarea gunoiului <garbage collection>` pentru eliminarea "
"*circularităților*). Orice zonă de memorie (rezervată) va fi eliberată "
"la puțin timp după ce a fost eliminată (și) ultima referință la ea."

#: ../../tutorial/stdlib2.rst:255
msgid ""
"This approach works fine for most applications but occasionally there is "
"a need to track objects only as long as they are being used by something "
"else. Unfortunately, just tracking them creates a reference that makes "
"them permanent. The :mod:`weakref` module provides tools for tracking "
"objects without creating a reference.  When the object is no longer "
"needed, it is automatically removed from a weakref table and a callback "
"is triggered for weakref objects.  Typical applications include caching "
"objects that are expensive to create::"
msgstr ""
"O atare abordare funcționează mulțumitor pentru cele mai multe dintre "
"aplicații, însă câteodată este nevoie ca urmărirea anumitor obiecte să "
"fie realizată doar atâta vreme cât ceva anume (din sistem) le "
"întrebuințează. Din păcate, simpla urmărire a unui obiect creează o "
"referință la acesta, care referință îl va face permanent (nemuritor). "
"Modulul :mod:`weakref` conține unelte pentru urmărirea unor obiecte fără "
"să se creeze nicio referință la ele. Atunci când un obiect anume nu mai "
"este folosit, el va fi eliminat automat dintr-o tabelă de *referințe slabe* "
"(de la englezescul, ca jargon informatic, *weakref*) și o *rutină de "
"răspuns* (sau un *apel de răspuns*; de la englezescul, ca jargon "
"informatic, *callback*) va fi declanșată pentru respectivul obiect "
"*weakref*. Întrebuințările tipice ale referințelor slabe includ *memorarea "
"locală rapidă* (de la englezescul, ca jargon informatic, *caching*) a "
"obiectelor care sunt costisitor de creat::"

#: ../../tutorial/stdlib2.rst:263
msgid ""
">>> import weakref, gc\n"
">>> class A:\n"
"...     def __init__(self, value):\n"
"...         self.value = value\n"
"...     def __repr__(self):\n"
"...         return str(self.value)\n"
"...\n"
">>> a = A(10)                   # create a reference\n"
">>> d = weakref.WeakValueDictionary()\n"
">>> d['primary'] = a            # does not create a reference\n"
">>> d['primary']                # fetch the object if it is still alive\n"
"10\n"
">>> del a                       # remove the one reference\n"
">>> gc.collect()                # run garbage collection right away\n"
"0\n"
">>> d['primary']                # entry was automatically removed\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    d['primary']                # entry was automatically removed\n"
"  File \"C:/python313/lib/weakref.py\", line 46, in __getitem__\n"
"    o = self.data[key]()\n"
"KeyError: 'primary'"
msgstr ""
">>> import weakref, gc\n"
">>> class A:\n"
"...     def __init__(self, valoarea):\n"
"...         self.valoarea = valoarea\n"
"...     def __repr__(self):\n"
"...         return str(self.valoarea)\n"
"...\n"
">>> a = A(10)                            # creăm o referință (x)\n"
">>> dicționarul = weakref.WeakValueDictionary()\n"
">>> dicționarul['referință primară'] = a # nu creează nicio referință\n"
">>> dicționarul['referință primară']     # găsește-l, dacă e în viață\n"
"10\n"
">>> del a                                # elimină referința (x)\n"
">>> gc.collect()                         # colectează gunoiul (chiar acum)\n"
"0\n"
">>> dicționarul['referință primară']     # eliminat automat din tabelă\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    dicționarul['referință primară']     # eliminat automat din tabelă\n"
"  File \"C:/python313/lib/weakref.py\", line 46, in __getitem__\n"
"    o = self.data[key]()\n"
"KeyError: 'referință primară'"

#: ../../tutorial/stdlib2.rst:290
msgid "Tools for Working with Lists"
msgstr "Unelte pentru lucrul cu liste"

#: ../../tutorial/stdlib2.rst:292
msgid ""
"Many data structure needs can be met with the built-in list type. "
"However, sometimes there is a need for alternative implementations with "
"different performance trade-offs."
msgstr ""
"Multe din cerințele unor structuri (abstracte) de date pot fi deservite "
"de tipul predefinit (de date) *listă*. Cu toate acestea, în anumite "
"situații este nevoie de implementări alternative ale unei structuri de "
"date, punându-se în balanță, la alegerea lor, *performanțe* specifice."

#: ../../tutorial/stdlib2.rst:296
msgid ""
"The :mod:`array` module provides an :class:`~array.array` object that is "
"like a list that stores only homogeneous data and stores it more "
"compactly.  The following example shows an array of numbers stored as two"
" byte unsigned binary numbers (typecode ``\"H\"``) rather than the usual "
"16 bytes per entry for regular lists of Python int objects::"
msgstr ""
"Modulul :mod:`array` dispune de obiectul :class:`~array.array` (adică, "
"tipul *tablou*, *vector* ori *matrice*) care îi seamănă listei, doar că nu "
"poate stoca decât date de același tip (omogene) iar stocarea propriu-zisă "
"se face (mai) compact. Exemplul de mai jos prezintă un tablou de numere "
"întregi stocate sub formă de numere binare fără semn (lungi) de câte doi "
"octeți (și având *codul de tip* ``\"H\"``), aceasta spre deosebire de "
"cazul listelor Python uzuale formate din obiecte *int*, în care fiecare "
"item este stocat pe câte 16 octeți::"

#: ../../tutorial/stdlib2.rst:302
msgid ""
">>> from array import array\n"
">>> a = array('H', [4000, 10, 700, 22222])\n"
">>> sum(a)\n"
"26932\n"
">>> a[1:3]\n"
"array('H', [10, 700])"
msgstr ""
">>> from array import array\n"
">>> tablou = array('H', [4000, 10, 700, 22222])\n"
">>> sum(tablou)\n"
"26932\n"
">>> tablou[1:3]\n"
"array('H', [10, 700])"

#: ../../tutorial/stdlib2.rst:309
msgid ""
"The :mod:`collections` module provides a :class:`~collections.deque` "
"object that is like a list with faster appends and pops from the left "
"side but slower lookups in the middle. These objects are well suited for "
"implementing queues and breadth first tree searches::"
msgstr ""
"Modulul :mod:`collections` ne furnizează obiectul "
":class:`~collections.deque` (adică, tipul *deque* ori *coadă cu două "
"capete*) care îi seamănă listei, doar că acceptă (de la englezescul "
"*append*) și elimină (de la englezescul *pop*) itemi la și de la "
"capete mai repede decât o poate face o listă, respectiv caută itemi (de la "
"englezescul *lookup*) mai încet decât poate o listă atunci când itemii "
"respectivi se găsesc în interiorul (mijlocul) său. Instanțele acestui tip "
"sunt cum nu se poate mai potrivite pentru implementarea de *cozi* (FIFO, "
"LIFO), respectiv de *căutări în lățime* (a unor itemi) în diverși *arbori* "
"de date::"

#: ../../tutorial/stdlib2.rst:314
msgid ""
">>> from collections import deque\n"
">>> d = deque([\"task1\", \"task2\", \"task3\"])\n"
">>> d.append(\"task4\")\n"
">>> print(\"Handling\", d.popleft())\n"
"Handling task1"
msgstr ""
">>> from collections import deque\n"
">>> coada_cu_două_capete = deque([\"sarcina1\", \"sarcina2\", \\\n"
"...                               \"sarcina3\"])\n"
">>> coada_cu_două_capete.append(\"sarcina4\")\n"
">>> print(\"Mă ocup de \", coada_cu_două_capete.popleft())\n"
"Mă ocup de sarcina1"

#: ../../tutorial/stdlib2.rst:322
msgid ""
"unsearched = deque([starting_node])\n"
"def breadth_first_search(unsearched):\n"
"    node = unsearched.popleft()\n"
"    for m in gen_moves(node):\n"
"        if is_goal(m):\n"
"            return m\n"
"        unsearched.append(m)"
msgstr ""
"unde_caut = deque([nodul_de_început])\n"
"def căutare_în_lățime(unde_caut):     # căutare breadth-first\n"
"    nodul = unde_caut.popleft()\n"
"    for c in ce_mi_am_propus(nodul):\n"
"        if este_țelul_meu(c):\n"
"            return c\n"
"        unde_caut.append(c)"

#: ../../tutorial/stdlib2.rst:330
msgid ""
"In addition to alternative list implementations, the library also offers "
"other tools such as the :mod:`bisect` module with functions for "
"manipulating sorted lists::"
msgstr ""
"În plus față de implementările alternative ale *listei*, biblioteca ne pune "
"la dispoziție și altfel de unelte, precum cele din modulul :mod:`bisect` "
"care conține funcții pentru manipularea listelor (deja) *sortate*::"

#: ../../tutorial/stdlib2.rst:334
msgid ""
">>> import bisect\n"
">>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]"
"\n"
">>> bisect.insort(scores, (300, 'ruby'))\n"
">>> scores\n"
"[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, "
"'python')]"
msgstr ""
">>> import bisect\n"
">>> scoruri = [(100, 'Perl'), (200, 'Tcl'), (400, 'Lua'), (500, 'Python')]"
"\n"
">>> bisect.insort(scoruri, (300, 'Ruby'))\n"
">>> scoruri\n"
"[(100, 'Perl'), (200, 'Tcl'), (300, 'Ruby'), (400, 'Lua'), (500, "
"'Python')]"

#: ../../tutorial/stdlib2.rst:340
msgid ""
"The :mod:`heapq` module provides functions for implementing heaps based "
"on regular lists.  The lowest valued entry is always kept at position "
"zero.  This is useful for applications which repeatedly access the "
"smallest element but do not want to run a full list sort::"
msgstr ""
"Modulul :mod:`heapq` deține funcții pentru implementarea structurilor "
"arborescente *heap* (adică, generic, *grămadă*; se utilizează de multe "
"ori, în mod superficial, și expresia *coadă cu priorități*) folosind "
"*lista* obișnuită. Itemul cu *cea mai mică valoare* este păstrat "
"întotdeauna în poziția *zero*. Această caracteristică a structurilor *heap* "
"le face să fie de folos pentru aplicațiile în care accesăm în mod frecvent "
"elementul cu cea mai mică valoare (dintr-o listă de valori) dar nu dorim "
"să realizăm o sortare completă a listei::"

#: ../../tutorial/stdlib2.rst:345
msgid ""
">>> from heapq import heapify, heappop, heappush\n"
">>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"
">>> heapify(data)                      # rearrange the list into heap "
"order\n"
">>> heappush(data, -5)                 # add a new entry\n"
">>> [heappop(data) for i in range(3)]  # fetch the three smallest entries"
"\n"
"[-5, 0, 1]"
msgstr ""
">>> from heapq import heapify, heappop, heappush\n"
">>> datele = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"
">>> # reorganizăm lista pentru a avea o ordonare de heap:\n"
">>> heapify(datele)\n"
">>> heappush(datele, -5)               # introducem un item\n"
">>> # extragem cele mai mici trei valori:\n"
">>> [heappop(datele) for i in range(3)]\n"
"[-5, 0, 1]"

#: ../../tutorial/stdlib2.rst:356
msgid "Decimal Floating-Point Arithmetic"
msgstr "Aritmetică în virgulă mobilă pentru numere zecimale"

#: ../../tutorial/stdlib2.rst:358
msgid ""
"The :mod:`decimal` module offers a :class:`~decimal.Decimal` datatype for"
" decimal floating-point arithmetic.  Compared to the built-in "
":class:`float` implementation of binary floating point, the class is "
"especially helpful for"
msgstr ""
"Modulul :mod:`decimal` ne oferă tipul de date :class:`~decimal.Decimal`, "
"dedicat aritmeticii zecimale în virgulă mobilă. Prin comparație cu "
"implementarea predefinită :class:`float` a numerelor binare în virgulă "
"mobilă, clasa de față este realmente utilă pentru"

#: ../../tutorial/stdlib2.rst:362
msgid ""
"financial applications and other uses which require exact decimal "
"representation,"
msgstr ""
"aplicațiile financiare ori alte aplicații în care se cer *reprezentări "
"exacte* în baza zece ale datelor numerice,"

#: ../../tutorial/stdlib2.rst:364
msgid "control over precision,"
msgstr "situațiile în care *controlul* (numerelor) este mai important "
"decât *precizia* (cifrelor din dreapta virgulei),"

#: ../../tutorial/stdlib2.rst:365
msgid "control over rounding to meet legal or regulatory requirements,"
msgstr ""
"cazurile când *rotunjirea* valorilor numerice trebuie să țină seama de "
"cerințe legale sau de alte reglementări specifice,"

#: ../../tutorial/stdlib2.rst:366
msgid "tracking of significant decimal places, or"
msgstr ""
"monitorizea cifrelor zecimale *semnificative* din dreapta punctului "
"(virgulei), respectiv pentru"

#: ../../tutorial/stdlib2.rst:367
msgid ""
"applications where the user expects the results to match calculations "
"done by hand."
msgstr ""
"aplicațiile la care utilizatorul se așteaptă ca rezultatele diverselor "
"operații să se potrivească cu cele obținute chiar de el în urma calculelor "
"*făcute cu creionul pe hârtie*."

#: ../../tutorial/stdlib2.rst:370
msgid ""
"For example, calculating a 5% tax on a 70 cent phone charge gives "
"different results in decimal floating point and binary floating point. "
"The difference becomes significant if the results are rounded to the "
"nearest cent::"
msgstr ""
"Cu titlu de exemplu, calculul unei taxe de 5% la valoarea de 70 de cenți a "
"unei facturi de convorbiri telefonice produce un rezultat diferit, atunci "
"când este efectuat în virgulă mobilă *binară*, de rezultatul obținut în "
"virgulă mobilă *zecimală*. Iar diferența nu mai poate fi trecută cu vederea "
"dacă rotunjim rezultatele până la obținerea *celui mai apropiat* cent::"

#: ../../tutorial/stdlib2.rst:374
msgid ""
">>> from decimal import *\n"
">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"
"Decimal('0.74')\n"
">>> round(.70 * 1.05, 2)\n"
"0.73"
msgstr ""
">>> from decimal import *\n"
">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"
"Decimal('0.74')\n"
">>> round(.70 * 1.05, 2)\n"
"0.73"

#: ../../tutorial/stdlib2.rst:380
msgid ""
"The :class:`~decimal.Decimal` result keeps a trailing zero, automatically"
" inferring four place significance from multiplicands with two place "
"significance.  Decimal reproduces mathematics as done by hand and avoids "
"issues that can arise when binary floating point cannot exactly represent"
" decimal quantities."
msgstr ""
"Rezultatul :class:`~decimal.Decimal` păstrează zerouri pe post de sufix, "
"presupunând în mod automat că, în urma multiplicării unor operanzi cu câte "
"două cifre semnificative la dreapta punctului, el va avea patru cifre "
"semnificative după punct. Clasa *Decimal* reproduce matematica făcută cu "
"creionul pe hârtie și evită, astfel, complicații care pot surveni atunci "
"când anumite cantități zecimale nu sunt reprezentabile exact cu valori "
"binare în virgulă mobilă."

#: ../../tutorial/stdlib2.rst:386
msgid ""
"Exact representation enables the :class:`~decimal.Decimal` class to "
"perform modulo calculations and equality tests that are unsuitable for "
"binary floating point::"
msgstr ""
"Întrebuințarea de reprezentări exacte îi permite clasei "
":class:`~decimal.Decimal` să realizeze atât împărțiri cu rest (calcule "
"cu operatorul *modulo*) cât și testări de egalități care nu sunt "
"realizabile cu numere binare în virgulă mobilă::"

#: ../../tutorial/stdlib2.rst:390
msgid ""
">>> Decimal('1.00') % Decimal('.10')\n"
"Decimal('0.00')\n"
">>> 1.00 % 0.10\n"
"0.09999999999999995\n"
"\n"
">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"
"True\n"
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False"
msgstr ""
">>> Decimal('1.00') % Decimal('.10')\n"
"Decimal('0.00')\n"
">>> 1.00 % 0.10\n"
"0.09999999999999995\n"
"\n"
">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"
"True\n"
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False"

#: ../../tutorial/stdlib2.rst:400
msgid ""
"The :mod:`decimal` module provides arithmetic with as much precision as "
"needed::"
msgstr ""
"În modulul :mod:`decimal`, aritmetica poate fi efectuată cu *precizia* "
"stabilită de către utilizator::"

#: ../../tutorial/stdlib2.rst:402
msgid ""
">>> getcontext().prec = 36\n"
">>> Decimal(1) / Decimal(7)\n"
"Decimal('0.142857142857142857142857142857142857')"
msgstr ""
">>> getcontext().prec = 36\n"
">>> Decimal(1) / Decimal(7)\n"
"Decimal('0.142857142857142857142857142857142857')"