# INTRODUCERE INFORMALA IN PYTHON.

# 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-09-24 07:50+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/introduction.rst:5

msgid "An Informal Introduction to Python"

msgstr "O introducere informală în Python"

#: ../../tutorial/introduction.rst:7

msgid ""

"In the following examples, input and output are distinguished by the "

"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat "

"the example, you must type everything after the prompt, when the prompt "

"appears; lines that do not begin with a prompt are output from the "

"interpreter. Note that a secondary prompt on a line by itself in an "

"example means you must type a blank line; this is used to end a multi-"

"line command."

msgstr ""

"În exemplele următoare, intrările și ieșirile se deosebesc prin prezența,"

" respectiv prin absența prompturilor (:term:`>>>` și :term:`...`): ca să "

"probați un exemplu, va trebui să tastați tot ce urmează după promptul "

"lui, atunci când vă apare promptul; liniile care nu încep cu un prompt "

"fac parte din ieșirea interpretorului. Țineți seama de faptul că prezența"

" promptului secundar de unul singur pe o linie dintr-un exemplu înseamnă "

"că trebuie să introduceți o linie goală; prin aceasta se încheie o "

"comandă de mai multe linii."

#: ../../tutorial/introduction.rst:16

msgid ""

"You can use the \"Copy\" button (it appears in the upper-right corner "

"when hovering over or tapping a code example), which strips prompts and "

"omits output, to copy and paste the input lines into your interpreter."

msgstr ""

"Folosiți butonul \"Copy\" (acesta apare în colțul din dreapta-sus atunci "

"când deplasați cursorul ori dați clic oriunde pe suprafața casetei "

"exemplului), care șterge prompturile și elimină afișările de rezultate, "

"pentru a copia și a insera liniile de cod ale exemplelor în interpretorul"

" dumneavoastră."

#: ../../tutorial/introduction.rst:22

msgid ""

"Many of the examples in this manual, even those entered at the "

"interactive prompt, include comments. Comments in Python start with the "

"hash character, ``#``, and extend to the end of the physical line. A "

"comment may appear at the start of a line or following whitespace or "

"code, but not within a string literal. A hash character within a string "

"literal is just a hash character. Since comments are to clarify code and "

"are not interpreted by Python, they may be omitted when typing in "

"examples."

msgstr ""

"Multe din exemplele acestui manual, inclusiv cele introduse la promptul "

"interactiv, includ comentarii. Comentariile încep în Python cu caracterul"

" haștag, ``#``, și țin până la finalul liniei fizice. Un comentariu poate"

" apărea la început de linie, în continuarea unui spațiu gol sau a "

"codului, dar nu în interiorul unui șir de caractere. Un caracter haștag "

"aflat în interiorul unui șir de caractere este un simplu caracter haștag."

" Deoarece comentariile sunt destinate clarificării codului și nu sunt "

"interpretate de Python, le puteți omite atunci când veți tasta exemplele."

#: ../../tutorial/introduction.rst:30

msgid "Some examples::"

msgstr "Câteva exemple"

#: ../../tutorial/introduction.rst:32

msgid ""

"# this is the first comment\n"

"spam = 1 # and this is the second comment\n"

" # ... and now a third!\n"

"text = \"# This is not a comment because it's inside quotes.\""

msgstr ""

"# acesta este primul comentariu\n"

"sâc = 1 # iar acesta este cel de-al doilea comentariu\n"

" # ... și acum un al treilea!\n"

"text = \"# Acesta nu e un comentariu pentru că este pus între ghilimele.\""

#: ../../tutorial/introduction.rst:41

msgid "Using Python as a Calculator"

msgstr "Folosind Python-ul pe post de calculator"

#: ../../tutorial/introduction.rst:43

msgid ""

"Let's try some simple Python commands. Start the interpreter and wait "

"for the primary prompt, ``>>>``. (It shouldn't take long.)"

msgstr ""

"Haideți să încercăm niște comenzi simple în Python. Porniți interpretorul"

" și așteptați să apară promptul principal, ``>>>``. (N-ar trebui să "

"dureze mult.)"

#: ../../tutorial/introduction.rst:50

msgid "Numbers"

msgstr "Numere"

#: ../../tutorial/introduction.rst:52

msgid ""

"The interpreter acts as a simple calculator: you can type an expression "

"at it and it will write the value. Expression syntax is straightforward:"

" the operators ``+``, ``-``, ``*`` and ``/`` can be used to perform "

"arithmetic; parentheses (``()``) can be used for grouping. For example::"

msgstr ""

"Interpretorul acționează ca un simplu calculator: dumneavoastră tastați o"

" expresie în el și el vă afișează valoarea ei. Sintaxa expresiei este una"

" imediată: operatorii ``+``, ``-``, ``*`` și ``/`` se folosesc la "

"aritmetică; parantezele (``()``) se utilizează la subexpresii. De "

"exemplu::"

#: ../../tutorial/introduction.rst:58

msgid ""

">>> 2 + 2\n"

"4\n"

">>> 50 - 5*6\n"

"20\n"

">>> (50 - 5*6) / 4\n"

"5.0\n"

">>> 8 / 5 # division always returns a floating-point number\n"

"1.6"

msgstr ""

">>> 2 + 2\n"

"4\n"

">>> 50 - 5*6\n"

"20\n"

">>> (50 - 5*6) / 4\n"

"5.0\n"

">>> 8 / 5 # împărțirea întoarce întotdeauna numere în virgulă mobilă\n"

"1.6"

#: ../../tutorial/introduction.rst:67

msgid ""

"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, "

"the ones with a fractional part (e.g. ``5.0``, ``1.6``) have type "

":class:`float`. We will see more about numeric types later in the "

"tutorial."

msgstr ""

"Numerele întregi (precum ``2``, ``4``, ``20``) sunt de tipul "

":class:`int`, cele cu parte fracționară (cum ar fi ``5.0``, ``1.6``) de "

"tipul :class:`float`. Vom reveni ulterior la tipurile numerice în "

"tutorial."

#: ../../tutorial/introduction.rst:71

msgid ""

"Division (``/``) always returns a float. To do :term:`floor division` "

"and get an integer result you can use the ``//`` operator; to calculate "

"the remainder you can use ``%``::"

msgstr ""

"Împărțirea (``/``) întoarce întotdeauna un număr în virgulă mobilă. "

"Pentru a găsi :term:`partea întreagă la împărțirea cu rest <floor "

"division>`, cu alte cuvinte, pentru a obține un rezultat întreg al "

"împărțirii va trebui să folosiți operatorul ``//``; pentru calculul "

"restului, utilizați-l pe ``%``::"

#: ../../tutorial/introduction.rst:75

#, python-format

msgid ""

">>> 17 / 3 # classic division returns a float\n"

"5.666666666666667\n"

">>>\n"

">>> 17 // 3 # floor division discards the fractional part\n"

"5\n"

">>> 17 % 3 # the % operator returns the remainder of the division\n"

"2\n"

">>> 5 * 3 + 2 # floored quotient * divisor + remainder\n"

"17"

msgstr ""

">>> 17 / 3 # împărțirea obișnuită întoarce un număr în virgulă mobilă\n"

"5.666666666666667\n"

">>>\n"

">>> 17 // 3 # împărțirea cu rest elimină partea fracționară\n"

"5\n"

">>> 17 % 3 # operatorul % întoarce restul împărțirii\n"

"2\n"

">>> 5 * 3 + 2 # câtul * împărțitorul + restul\n"

"17"

#: ../../tutorial/introduction.rst:85

msgid ""

"With Python, it is possible to use the ``**`` operator to calculate "

"powers [#]_::"

msgstr "În Python, puteți folosi operatorul ``**`` pentru a calcula puteri [#]_::"

#: ../../tutorial/introduction.rst:87

msgid ""

">>> 5 ** 2 # 5 squared\n"

"25\n"

">>> 2 ** 7 # 2 to the power of 7\n"

"128"

msgstr ""

">>> 5 ** 2 # 5 la pătrat\n"

"25\n"

">>> 2 ** 7 # 2 la puterea a 7-a\n"

"128"

#: ../../tutorial/introduction.rst:92

msgid ""

"The equal sign (``=``) is used to assign a value to a variable. "

"Afterwards, no result is displayed before the next interactive prompt::"

msgstr ""

"Semnul egal (``=``) se folosește pentru a atribui o valoare unei "

"variabile. După aceasta, nu se se va afișa nimic până la apariția "

"următorului prompt interactiv::"

#: ../../tutorial/introduction.rst:95

msgid ""

">>> width = 20\n"

">>> height = 5 * 9\n"

">>> width * height\n"

"900"

msgstr ""

">>> lățime = 20\n"

">>> lungime = 5 * 9\n"

">>> lățime * lungime\n"

"900"

#: ../../tutorial/introduction.rst:100

msgid ""

"If a variable is not \"defined\" (assigned a value), trying to use it "

"will give you an error::"

msgstr ""

"Dacă o variabilă nu este \"definită\" (nu i s-a atribuit o valoare), "

"atunci când veți încerca să o folosiți vi se va semnala o eroare::"

#: ../../tutorial/introduction.rst:103

msgid ""

">>> n # try to access an undefined variable\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"NameError: name 'n' is not defined"

msgstr ""

">>> popescu # încercați să accesați o variabilă nedefinită\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"NameError: name 'popescu' is not defined"

#: ../../tutorial/introduction.rst:108

msgid ""

"There is full support for floating point; operators with mixed type "

"operands convert the integer operand to floating point::"

msgstr ""

"Folosirea numerelor în virgulă mobilă are suport complet; operatorii cu "

"operanzi de tipuri diferite vor converti operandul întreg la un operand "

"în virgulă mobilă corespunzător::"

#: ../../tutorial/introduction.rst:111

msgid ""

">>> 4 * 3.75 - 1\n"

"14.0"

msgstr ""

">>> 4 * 3.75 - 1\n"

"14.0"

#: ../../tutorial/introduction.rst:114

msgid ""

"In interactive mode, the last printed expression is assigned to the "

"variable ``_``. This means that when you are using Python as a desk "

"calculator, it is somewhat easier to continue calculations, for example::"

msgstr ""

"În modul interactiv, ultima expresie afișată va fi atribuită variabilei "

"``_``. Ceea ce înseamnă că, atunci când folosiți Python-ul drept "

"calculator de birou, este cumva mai ușor să continuați calculele lungi, "

"ca de exemplu::"

#: ../../tutorial/introduction.rst:118

msgid ""

">>> tax = 12.5 / 100\n"

">>> price = 100.50\n"

">>> price * tax\n"

"12.5625\n"

">>> price + _\n"

"113.0625\n"

">>> round(_, 2)\n"

"113.06"

msgstr ""

">>> taxele = 12.5 / 100\n"

">>> prețul = 100.50\n"

">>> prețul * taxele\n"

"12.5625\n"

">>> prețul + _\n"

"113.0625\n"

">>> round(_, 2)\n"

"113.06"

#: ../../tutorial/introduction.rst:127

msgid ""

"This variable should be treated as read-only by the user. Don't "

"explicitly assign a value to it --- you would create an independent local"

" variable with the same name masking the built-in variable with its magic"

" behavior."

msgstr ""

"Această variabilă trebuie considerată ca fiind doar-de-citit de către "

"utilizator. Nu-i atribuiți în mod explicit nicio valoare --- dacă o veți "

"face, atunci veți fi definit o variabilă locală, independentă, cu același"

" nume, care va masca variabila predefinită în limbaj cu tot cu purtarea "

"ei magică."

#: ../../tutorial/introduction.rst:131

msgid ""

"In addition to :class:`int` and :class:`float`, Python supports other "

"types of numbers, such as :class:`~decimal.Decimal` and "

":class:`~fractions.Fraction`. Python also has built-in support for "

":ref:`complex numbers <typesnumeric>`, and uses the ``j`` or ``J`` suffix"

" to indicate the imaginary part (e.g. ``3+5j``)."

msgstr ""

"În afară de :class:`int` și de :class:`float`, Python-ul suportă și alte "

"tipuri de numere, precum :class:`~decimal.Decimal` și "

":class:`~fractions.Fraction`. De asemeni, Python-ul are suport predefinit"

" pentru :ref:`numerele complexe <typesnumeric>` și folosește sufixul "

"``j`` sau ``J`` pentru a desemna partea imaginară (ca în ``3+5j``)."

#: ../../tutorial/introduction.rst:141

msgid "Text"

msgstr "Text"

#: ../../tutorial/introduction.rst:143

msgid ""

"Python can manipulate text (represented by type :class:`str`, so-called "

"\"strings\") as well as numbers. This includes characters \"``!``\", "

"words \"``rabbit``\", names \"``Paris``\", sentences \"``Got your "

"back.``\", etc. \"``Yay! :)``\". They can be enclosed in single quotes "

"(``'...'``) or double quotes (``\"...\"``) with the same result [#]_."

msgstr ""

"Python-ul poate manipula textul (reprezentat de tipul :class:`str`, așa-"

"numitele \"șiruri de caractere\"; de la englezescul *string*, la "

"singular) la fel de bine ca numerele. Acesta include caractere precum "

"\"``!``\", cuvinte cum ar fi \"``iepure``\", nume ca \"``Paris``\", "

"propoziții de felul lui \"``Te ajut eu.``\", șamd. \"``Uraa! :)``\". "

"Toate acestea pot fi încadrate fie de ghilimele simple (``'...'``) fie de"

" ghilimele duble (``\"...\"``), cu același rezultat [#]_. Exemplul care "

"urmează folosește *referințe intraductibile* la scheciurile Monty Python."

" Astfel, apar expresiile `spam eggs "

"<https://en.wikipedia.org/wiki/Spam_(food)>`_ și `Paris rabbit got your "

"back <https://en.wikipedia.org/wiki/Rabbit_of_Caerbannog>`_."

#: ../../tutorial/introduction.rst:149

msgid ""

">>> 'spam eggs' # single quotes\n"

"'spam eggs'\n"

">>> \"Paris rabbit got your back :)! Yay!\" # double quotes\n"

"'Paris rabbit got your back :)! Yay!'\n"

">>> '1975' # digits and numerals enclosed in quotes are also strings\n"

"'1975'"

msgstr ""

">>> 'cărniță oușoare' # ghilimele simple\n"

"'cărniță oușoare'\n"

">>> \"Paris iepurașul ți-apără sălașul :)! Uraa!\" # ghilimele duble\n"

"'Paris iepurașul ți-apără sălașul :)! Uraa!'\n"

">>> '1975' # cifrele și numerele dintre ghilimele simple sunt șiruri de "

"caractere\n"

"'1975'"

#: ../../tutorial/introduction.rst:158

msgid ""

"To quote a quote, we need to \"escape\" it, by preceding it with ``\\``. "

"Alternatively, we can use the other type of quotation marks::"

msgstr ""

"Ca să citați ghilimelele (simple sau duble), trebuie să le \"salvați\" "

"(de la englezescul *escape*; vom utiliza constructele: caracter escape, "

"secvență escape, a escapa și derivate ale lor, întâlnite în literatura de"

" specialitate) prefixându-le cu ``\\``. Altfel, puteți încadra textul "

"respectiv cu celălalt tip de semne de punctuație pentru citare::"

#: ../../tutorial/introduction.rst:161

msgid ""

">>> 'doesn\\'t' # use \\' to escape the single quote...\n"

"\"doesn't\"\n"

">>> \"doesn't\" # ...or use double quotes instead\n"

"\"doesn't\"\n"

">>> '\"Yes,\" they said.'\n"

"'\"Yes,\" they said.'\n"

">>> \"\\\"Yes,\\\" they said.\"\n"

"'\"Yes,\" they said.'\n"

">>> '\"Isn\\'t,\" they said.'\n"

"'\"Isn\\'t,\" they said.'"

msgstr ""

">>> 'McDonald\\'s' # folosim \\' ca sa inserăm ghilimele simple...\n"

"\"McDonald's\"\n"

">>> \"McDonald's\" # ...sau folosim ghilimelele duble\n"

"\"McDonald's\"\n"

">>> '\"Da,\" ziseră ei.'\n"

"'\"Da,\" ziseră ei.'\n"

">>> \"\\\"Da,\\\" ziseră ei.\"\n"

"'\"Da,\" ziseră ei.'\n"

">>> '\"Omu\\' nostru,\" spuseră ei.'\n"

"'\"Omu\\' nostru,\" spuseră ei.'"

#: ../../tutorial/introduction.rst:172

msgid ""

"In the Python shell, the string definition and output string can look "

"different. The :func:`print` function produces a more readable output, "

"by omitting the enclosing quotes and by printing escaped and special "

"characters::"

msgstr ""

"În interpretorul de comenzi Python, rezultatul afișării unui șir de "

"caractere poate să difere mult de definiția șirului de caractere. Funcția"

" :func:`print` produce o afișare lizibilă a acestuia, omițând ghilimele "

"care îl încadrează și tipărind caracterele escape, respectiv caracterele "

"speciale::"

#: ../../tutorial/introduction.rst:176

msgid ""

">>> s = 'First line.\\nSecond line.' # \\n means newline\n"

">>> s # without print(), special characters are included in the string\n"

"'First line.\\nSecond line.'\n"

">>> print(s) # with print(), special characters are interpreted, so \\n "

"produces new line\n"

"First line.\n"

"Second line."

msgstr ""

">>> s = 'Prima linie.\\nA doua linie.' # \\n înseamnă linie nouă\n"

">>> s # fără print() caracterele speciale vor fi inserate în șir\n"

"'Prima linie.\\nA doua linie.'\n"

">>> print(s) # cu print() caracterele speciale vor fi interpretate, deci"

" \\n va produce o linie nouă\n"

"Prima linie.\n"

"A doua linie."

#: ../../tutorial/introduction.rst:183

msgid ""

"If you don't want characters prefaced by ``\\`` to be interpreted as "

"special characters, you can use *raw strings* by adding an ``r`` before "

"the first quote::"

msgstr ""

"Dacă nu doriți să fie interpretate drept caractere speciale caracterele "

"prefațate cu ``\\``, atunci puteți utiliza *șirurile brute* (de la "

"englezescul *raw*) de caractere adăugând un ``r`` înaintea ghilimelelor "

"simple de început::"

#: ../../tutorial/introduction.rst:187

msgid ""

">>> print('C:\\some\\name') # here \\n means newline!\n"

"C:\\some\n"

"ame\n"

">>> print(r'C:\\some\\name') # note the r before the quote\n"

"C:\\some\\name"

msgstr ""

">>> print('C:\\prenume\\nume') # aici \\n înseamnă linie nouă!\n"

"C:\\prenume\n"

"ume\n"

">>> print(r'C:\\prenume\\nume') # remarcați r-ul dinaintea ghilimelelor\n"

"C:\\prenume\\nume"

#: ../../tutorial/introduction.rst:193

msgid ""

"There is one subtle aspect to raw strings: a raw string may not end in an"

" odd number of ``\\`` characters; see :ref:`the FAQ entry <faq-"

"programming-raw-string-backslash>` for more information and workarounds."

msgstr ""

"Există o subtilitate vizavi de șirurile brute de caractere: un șir brut "

"de caractere nu se poate termina cu un număr impar de caractere ``\\``; "

"vedeți :ref:`rubrica FAQ/IFF (întrebări formulate frecvent) <faq-"

"programming-raw-string-backslash>` pentru mai multe informații și tehnici"

" de evitare a dificultăților."

#: ../../tutorial/introduction.rst:198

msgid ""

"String literals can span multiple lines. One way is using triple-quotes:"

" ``\"\"\"...\"\"\"`` or ``'''...'''``. End-of-line characters are "

"automatically included in the string, but it's possible to prevent this "

"by adding a ``\\`` at the end of the line. In the following example, the"

" initial newline is not included::"

msgstr ""

"Valorile literale (de la englezescul *literals*; vom folosi și "

"constructele: literal, literale, întâlnite în literatura de specialitate)"

" șir-de-caractere se pot întinde pe mai multe linii. Pentru aceasta "

"puteți utiliza semne de citare triple: ``\"\"\"...\"\"\"`` sau "

"``'''...'''``. Caracterele sfârșit-de-linie sunt incluse automat în șirul"

" de caractere, ceea ce poate fi evitat prin adăugarea unui ``\\`` la "

"final de linie. În exemplul următor, caracterul linie-nouă inițial nu va "

"fi inserat::"

#: ../../tutorial/introduction.rst:204

msgid ""

">>> print(\"\"\"\\\n"

"... Usage: thingy [OPTIONS]\n"

"... -h Display this usage message\n"

"... -H hostname Hostname to connect to\n"

"... \"\"\")\n"

"Usage: thingy [OPTIONS]\n"

" -h Display this usage message\n"

" -H hostname Hostname to connect to\n"

"\n"

">>>"

msgstr ""

">>> print(\"\"\"\\\n"

"... Mod de folosință: comanda [OPȚIUNI]\n"

"... -h Afișati acest mesaj de utilizare\n"

"... -H numele_gazdei Numele gazdei la care vreți să vă conectați"

"\n"

"... \"\"\")\n"

"Mod de folosință: comanda [OPȚIUNI]\n"

" -h Afișati acest mesaj de utilizare\n"

" -H numele_gazdei Numele gazdei la care vreți să vă conectați\n"

"\n"

">>>"

#: ../../tutorial/introduction.rst:215

msgid ""

"Strings can be concatenated (glued together) with the ``+`` operator, and"

" repeated with ``*``::"

msgstr ""

"Șirurile de caractere pot fi concatenate (lipite unul de celălalt) cu "

"operatorul ``+``, respectiv repetate cu operatorul ``*``::"

#: ../../tutorial/introduction.rst:218

msgid ""

">>> # 3 times 'un', followed by 'ium'\n"

">>> 3 * 'un' + 'ium'\n"

"'unununium'"

msgstr ""

">>> # 'un' de 3 ori, urmat de 'ium'\n"

">>> 3 * 'un' + 'ium'\n"

"'unununium'"

#: ../../tutorial/introduction.rst:222

msgid ""

"Two or more *string literals* (i.e. the ones enclosed between quotes) "

"next to each other are automatically concatenated. ::"

msgstr ""

"Două sau mai multe *literale șir-de-caractere* (adică șiruri de caractere"

" încadrate de semne de citare), odată ce sunt plasate unul lângă "

"celălalt, vor fi concatenate automat::"

#: ../../tutorial/introduction.rst:225

msgid ""

">>> 'Py' 'thon'\n"

"'Python'"

msgstr ""

">>> 'Py' 'thon'\n"

"'Python'"

#: ../../tutorial/introduction.rst:228

msgid "This feature is particularly useful when you want to break long strings::"

msgstr ""

"Această caracteristică este utilă mai ales atunci când intenționați să "

"porționați șirurile lungi de caractere::"

#: ../../tutorial/introduction.rst:230

msgid ""

">>> text = ('Put several strings within parentheses '\n"

"... 'to have them joined together.')\n"

">>> text\n"

"'Put several strings within parentheses to have them joined together.'"

msgstr ""

">>> textul = ('Puneți mai multe șiruri de caractere între paranteze '\n"

"... 'pentru ca ele să fie îmbinate.')\n"

">>> textul\n"

"'Puneți mai multe șiruri de caractere între paranteze pentru ca ele să\n"

"fie îmbinate.'"

#: ../../tutorial/introduction.rst:235

msgid ""

"This only works with two literals though, not with variables or "

"expressions::"

msgstr ""

"Această tehnică funcționează numai cu valori literale, deci nu cu "

"variabile și nici cu expresii::"

#: ../../tutorial/introduction.rst:237

msgid ""

">>> prefix = 'Py'\n"

">>> prefix 'thon' # can't concatenate a variable and a string literal\n"

" File \"<stdin>\", line 1\n"

" prefix 'thon'\n"

" ^^^^^^\n"

"SyntaxError: invalid syntax\n"

">>> ('un' * 3) 'ium'\n"

" File \"<stdin>\", line 1\n"

" ('un' * 3) 'ium'\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

msgstr ""

">>> prefixul = 'Py'\n"

">>> prefixul 'thon' # nu concatenăm o variabilă cu o valoare literală\n"

" File \"<stdin>\", line 1\n"

" prefix 'thon'\n"

" ^^^^^^\n"

"SyntaxError: invalid syntax\n"

">>> ('un' * 3) 'ium'\n"

" File \"<stdin>\", line 1\n"

" ('un' * 3) 'ium'\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

#: ../../tutorial/introduction.rst:249

msgid ""

"If you want to concatenate variables or a variable and a literal, use "

"``+``::"

msgstr ""

"Dacă doriți să concatenați variabile ori o variabilă cu o valoare "

"literală, atunci folosiți ``+``-ul::"

#: ../../tutorial/introduction.rst:251

msgid ""

">>> prefix + 'thon'\n"

"'Python'"

msgstr ""

">>> prefixul + 'thon'\n"

"'Python'"

#: ../../tutorial/introduction.rst:254

msgid ""

"Strings can be *indexed* (subscripted), with the first character having "

"index 0. There is no separate character type; a character is simply a "

"string of size one::"

msgstr ""

"Șirurile de caractere pot fi *indexate* (numerotate), primul caracter din"

" șir având indicele 0. Nu există tipul caracter de sine stătător; un "

"caracter este doar un șir de caractere cu lungimea 1::"

#: ../../tutorial/introduction.rst:258

msgid ""

">>> word = 'Python'\n"

">>> word[0] # character in position 0\n"

"'P'\n"

">>> word[5] # character in position 5\n"

"'n'"

msgstr ""

">>> cuvântul = 'Python'\n"

">>> cuvântul[0] # caracterul de pe poziția 0\n"

"'P'\n"

">>> cuvântul[5] # caracterul de pe poziția 5\n"

"'n'"

#: ../../tutorial/introduction.rst:264

msgid "Indices may also be negative numbers, to start counting from the right::"

msgstr ""

"Indici pot fi și numerele negative, dacă dorim să începem numărătoarea de"

" la dreapta::"

#: ../../tutorial/introduction.rst:266

msgid ""

">>> word[-1] # last character\n"

"'n'\n"

">>> word[-2] # second-last character\n"

"'o'\n"

">>> word[-6]\n"

"'P'"

msgstr ""

">>> cuvântul[-1] # ultimul caracter\n"

"'n'\n"

">>> cuvântul[-2] # penultimul caracter\n"

"'o'\n"

">>> cuvântul[-6]\n"

"'P'"

#: ../../tutorial/introduction.rst:273

msgid "Note that since -0 is the same as 0, negative indices start from -1."

msgstr ""

"Remarcați că, deoarece -0 este totuna cu 0, indicii negativi încep de la "

"-1."

#: ../../tutorial/introduction.rst:275

msgid ""

"In addition to indexing, *slicing* is also supported. While indexing is "

"used to obtain individual characters, *slicing* allows you to obtain a "

"substring::"

msgstr ""

"În afară de indexare, este suportată și *tranșarea* (felierea, de la "

"englezescul *slicing*). În timp ce indexarea se folosește la obținerea de"

" caractere individuale, *tranșarea* vă permite să extrageți un subșir de "

"caractere::"

#: ../../tutorial/introduction.rst:278

msgid ""

">>> word[0:2] # characters from position 0 (included) to 2 (excluded)\n"

"'Py'\n"

">>> word[2:5] # characters from position 2 (included) to 5 (excluded)\n"

"'tho'"

msgstr ""

">>> cuvântul[0:2] # caractere de la poziția 0 (cu) până la 2 (fără)\n"

"'Py'\n"

">>> cuvântul[2:5] # caractere de la poziția 2 (cu) până la 5 (fără)\n"

"'tho'"

#: ../../tutorial/introduction.rst:283

msgid ""

"Slice indices have useful defaults; an omitted first index defaults to "

"zero, an omitted second index defaults to the size of the string being "

"sliced. ::"

msgstr ""

"Indicii unei tranșe au valori implicite utile; un indice de început, "

"odată ce este omis, va fi implicit zero pe când un indice de final, omis,"

" va lua în mod implicit ca valoare lungimea șirului de caractere în curs "

"de tranșare."

#: ../../tutorial/introduction.rst:286

msgid ""

">>> word[:2] # character from the beginning to position 2 (excluded)\n"

"'Py'\n"

">>> word[4:] # characters from position 4 (included) to the end\n"

"'on'\n"

">>> word[-2:] # characters from the second-last (included) to the end\n"

"'on'"

msgstr ""

">>> cuvântul[:2] # caractere de la început până la poziția 2 (fără)\n"

"'Py'\n"

">>> cuvântul[4:] # caractere de la poziția 4 (cu) până la sfârșit\n"

"'on'\n"

">>> cuvântul[-2:] # caractere de la penultimul (cu) până la final\n"

"'on'"

#: ../../tutorial/introduction.rst:293

msgid ""

"Note how the start is always included, and the end always excluded. This"

" makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"

msgstr ""

"Remarcați că începutul este întotdeauna inclus, pe când finalul este "

"întotdeauna lipsă. Această proprietate face ca ``s[:i] + s[i:]`` să fie "

"egal întotdeauna cu ``s``::"

#: ../../tutorial/introduction.rst:296

msgid ""

">>> word[:2] + word[2:]\n"

"'Python'\n"

">>> word[:4] + word[4:]\n"

"'Python'"

msgstr ""

">>> cuvântul[:2] + cuvântul[2:]\n"

"'Python'\n"

">>> cuvântul[:4] + cuvântul[4:]\n"

"'Python'"

#: ../../tutorial/introduction.rst:301

msgid ""

"One way to remember how slices work is to think of the indices as "

"pointing *between* characters, with the left edge of the first character "

"numbered 0. Then the right edge of the last character of a string of *n* "

"characters has index *n*, for example::"

msgstr ""

"O metodă de a ține minte cum funcționează tranșatul este să vă imaginați "

"indicii ca țintind *între* caractere, iar muchia stângă a primului "

"caracter ca fiind numerotată cu 0. Atunci, muchia dreaptă a ultimului "

"caracter al unui șir de caractere de *n* caractere va avea indexul *n*, "

"ca de exemplu::"

#: ../../tutorial/introduction.rst:306

msgid ""

" +---+---+---+---+---+---+\n"

" | P | y | t | h | o | n |\n"

" +---+---+---+---+---+---+\n"

" 0 1 2 3 4 5 6\n"

"-6 -5 -4 -3 -2 -1"

msgstr ""

" +---+---+---+---+---+---+\n"

" | P | y | t | h | o | n |\n"

" +---+---+---+---+---+---+\n"

" 0 1 2 3 4 5 6\n"

"-6 -5 -4 -3 -2 -1"

#: ../../tutorial/introduction.rst:312

msgid ""

"The first row of numbers gives the position of the indices 0...6 in the "

"string; the second row gives the corresponding negative indices. The "

"slice from *i* to *j* consists of all characters between the edges "

"labeled *i* and *j*, respectively."

msgstr ""

"Primul rând de numere dă poziția fiecăruia dintre indicii 0...6 ai "

"șirului de caractere; cel de-al doilea rând pe cea a indicilor negativi "

"corespunzători. Tranșa de la *i* la *j* constă din toate caracterele "

"situate între muchiile notate cu *i* și respectiv cu *j*."

#: ../../tutorial/introduction.rst:317

msgid ""

"For non-negative indices, the length of a slice is the difference of the "

"indices, if both are within bounds. For example, the length of "

"``word[1:3]`` is 2."

msgstr ""

"Pentru indicii nenegativi, lungimea unei tranșe este diferența indicilor,"

" aceasta dacă amândoi sunt în limita valorilor permise. De exemplu, "

"lungimea lui ``cuvântul[1:3]`` este 2."

#: ../../tutorial/introduction.rst:321

msgid "Attempting to use an index that is too large will result in an error::"

msgstr "Încercarea de a folosi un indice prea mare va conduce la o eroare::"

#: ../../tutorial/introduction.rst:323

msgid ""

">>> word[42] # the word only has 6 characters\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"IndexError: string index out of range"

msgstr ""

">>> cuvântul[42] # cuvântul are numai 6 caractere\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"IndexError: string index out of range"

#: ../../tutorial/introduction.rst:328

msgid ""

"However, out of range slice indexes are handled gracefully when used for "

"slicing::"

msgstr ""

"Cu toate acestea, indicii care depășesc plaja valorilor permise vor fi "

"rezolvați cu eleganță atunci când îi folosim la tranșare::"

#: ../../tutorial/introduction.rst:331

msgid ""

">>> word[4:42]\n"

"'on'\n"

">>> word[42:]\n"

"''"

msgstr ""

">>> cuvântul[4:42]\n"

"'on'\n"

">>> cuvântul[42:]\n"

"''"

#: ../../tutorial/introduction.rst:336

msgid ""

"Python strings cannot be changed --- they are :term:`immutable`. "

"Therefore, assigning to an indexed position in the string results in an "

"error::"

msgstr ""

"Șirurile de caractere Python nu pot fi modificate --- ele sunt "

":term:`imutabile <immutable>`. De aceea, atribuirea de valori unei "

"poziții indexate dintr-un șir de caractere va produce o eroare::"

#: ../../tutorial/introduction.rst:339

msgid ""

">>> word[0] = 'J'\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: 'str' object does not support item assignment\n"

">>> word[2:] = 'py'\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: 'str' object does not support item assignment"

msgstr ""

">>> cuvântul[0] = 'J'\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: 'str' object does not support item assignment\n"

">>> cuvântul[2:] = 'py'\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: 'str' object does not support item assignment"

#: ../../tutorial/introduction.rst:348

msgid "If you need a different string, you should create a new one::"

msgstr ""

"Dacă este nevoie să modificați un șir de caractere, atunci va trebui să "

"creați un șir de caractere nou::"

#: ../../tutorial/introduction.rst:350

msgid ""

">>> 'J' + word[1:]\n"

"'Jython'\n"

">>> word[:2] + 'py'\n"

"'Pypy'"

msgstr ""

">>> 'J' + cuvântul[1:]\n"

"'Jython'\n"

">>> cuvântul[:2] + 'py'\n"

"'Pypy'"

#: ../../tutorial/introduction.rst:355

msgid "The built-in function :func:`len` returns the length of a string::"

msgstr ""

"Funcția predefinită :func:`len` returnează lungimea unui șir de "

"caractere. Șirul de caractere `supercalifragilistic... "

"<https://ro.wikipedia.org/wiki/Supercalifragilisticexpialidocious>`_ este"

" intraductibil::"

#: ../../tutorial/introduction.rst:357

msgid ""

">>> s = 'supercalifragilisticexpialidocious'\n"

">>> len(s)\n"

"34"

msgstr ""

">>> s = 'supercalifragilisticexpialidocious'\n"

">>> len(s)\n"

"34"

#: ../../tutorial/introduction.rst:364

msgid ":ref:`textseq`"

msgstr ":ref:`Tipul secvență de text -- str <textseq>`"

#: ../../tutorial/introduction.rst:365

msgid ""

"Strings are examples of *sequence types*, and support the common "

"operations supported by such types."

msgstr ""

"Șirurile de caractere sunt exemple ale *tipurilor secvență de date* și "

"permit operațiile suportate în mod obișnuit de asemenea tipuri."

#: ../../tutorial/introduction.rst:368

msgid ":ref:`string-methods`"

msgstr ":ref:`Metodele șirurilor de caractere <string-methods>`"

#: ../../tutorial/introduction.rst:369

msgid ""

"Strings support a large number of methods for basic transformations and "

"searching."

msgstr ""

"Șirurile de caractere suportă un număr mare de metode privind "

"transformările uzuale și căutarea."

#: ../../tutorial/introduction.rst:372

msgid ":ref:`f-strings`"

msgstr ":ref:`f-șiruri <f-strings>`"

#: ../../tutorial/introduction.rst:373

msgid "String literals that have embedded expressions."

msgstr "Valori literale șir-de-caractere care includ expresii."

#: ../../tutorial/introduction.rst:375

msgid ":ref:`formatstrings`"

msgstr ":ref:`Sintaxa șirurilor de format <formatstrings>`"

#: ../../tutorial/introduction.rst:376

msgid "Information about string formatting with :meth:`str.format`."

msgstr "Informații despre formatarea șirurilor de caractere cu :meth:`str.format`."

#: ../../tutorial/introduction.rst:378

msgid ":ref:`old-string-formatting`"

msgstr ""

":ref:`Formatarea șirurilor de caractere în vechiul stil printf <old-"

"string-formatting>`"

#: ../../tutorial/introduction.rst:379

msgid ""

"The old formatting operations invoked when strings are the left operand "

"of the ``%`` operator are described in more detail here."

msgstr ""

"Vechile operații de formatare invocate atunci când șiruri de caractere "

"îi sunt operand stâng operatorului ``%`` sunt descrise în detaliu aici."

#: ../../tutorial/introduction.rst:386

msgid "Lists"

msgstr "Liste"

#: ../../tutorial/introduction.rst:388

msgid ""

"Python knows a number of *compound* data types, used to group together "

"other values. The most versatile is the *list*, which can be written as "

"a list of comma-separated values (items) between square brackets. Lists "

"might contain items of different types, but usually the items all have "

"the same type. ::"

msgstr ""

"Python-ul înțelege mai multe tipuri de date *compozite*, folosite la "

"punerea laolaltă de valori diverse. Cel mai versatil dintre tipuri este "

"*lista*, pe care o putem scrie în formă de șir încadrat de paranteze "

"drepte și format din valori (itemi) separate între ele prin virgule. "

"Listele pot conține itemi de tipuri diferite, însă cel mai adesea toți "

"itemii sunt de același tip. ::"

#: ../../tutorial/introduction.rst:393

msgid ""

">>> squares = [1, 4, 9, 16, 25]\n"

">>> squares\n"

"[1, 4, 9, 16, 25]"

msgstr ""

">>> pătrate_perfecte = [1, 4, 9, 16, 25]\n"

">>> pătrate_perfecte\n"

"[1, 4, 9, 16, 25]"

#: ../../tutorial/introduction.rst:397

msgid ""

"Like strings (and all other built-in :term:`sequence` types), lists can "

"be indexed and sliced::"

msgstr ""

"Aidoma șirurilor de caractere (și a tuturor tipurilor :term:`secvență "

"<sequence>` predefinite), listele pot fi atât indexate cât și tranșate::"

#: ../../tutorial/introduction.rst:400

msgid ""

">>> squares[0] # indexing returns the item\n"

"1\n"

">>> squares[-1]\n"

"25\n"

">>> squares[-3:] # slicing returns a new list\n"

"[9, 16, 25]"

msgstr ""

">>> pătrate_perfecte[0] # indexarea returnează itemul corespunzător\n"

"1\n"

">>> pătrate_perfecte[-1]\n"

"25\n"

">>> pătrate_perfecte[-3:] # felierea returnează o listă nouă\n"

"[9, 16, 25]"

#: ../../tutorial/introduction.rst:407

msgid "Lists also support operations like concatenation::"

msgstr "De asemenea, listele suportă operații precum concatenarea::"

#: ../../tutorial/introduction.rst:409