# CLASE.

# 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/classes.rst:5

msgid "Classes"

msgstr "Clase"

#: ../../tutorial/classes.rst:7

msgid ""

"Classes provide a means of bundling data and functionality together. "

"Creating a new class creates a new *type* of object, allowing new "

"*instances* of that type to be made. Each class instance can have "

"attributes attached to it for maintaining its state. Class instances can"

" also have methods (defined by its class) for modifying its state."

msgstr ""

"Clasele constituie o modalitate de a aduce laolaltă date și "

"funcționalități. Atunci când creăm o clasă nouă, creăm un nou *tip* de "

"obiecte, adică stabilim felul în care pot fi construite *instanțe* ale "

"tipului respectiv. Fiecărei instanțe a unei clase oarecare îi putem atașa "

"atribute în scopul păstrării stării instanței în cauză. Instanțele clasei "

"pot dispune și de metode (definite în cadrul acelei clase), folosite la "

"modificarea stărilor lor."

#: ../../tutorial/classes.rst:13

msgid ""

"Compared with other programming languages, Python's class mechanism adds "

"classes with a minimum of new syntax and semantics. It is a mixture of "

"the class mechanisms found in C++ and Modula-3. Python classes provide "

"all the standard features of Object Oriented Programming: the class "

"inheritance mechanism allows multiple base classes, a derived class can "

"override any methods of its base class or classes, and a method can call "

"the method of a base class with the same name. Objects can contain "

"arbitrary amounts and kinds of data. As is true for modules, classes "

"partake of the dynamic nature of Python: they are created at runtime, and"

" can be modified further after creation."

msgstr ""

"În comparație cu alte limbaje de programare, mecanismul claselor din Python "

"adaugă clase (la familia de tipuri de date deja existente) cu un minim de "

"sintaxă, respectiv de "

"`semantică <https://en.wikipedia.org/wiki/Semantics_(computer_science)>`_ "

"(în sensul dat în teoria compilatoarelor). El este o mixtură a mecanismelor "

"privitoare la clase pe care le găsim în C++ și în Modula-3. Clasele (din) "

"Python posedă toate trăsăturile tipice pe care le cere *Programarea "

"orientată-obiect* (adică, POO; se folosesc și constructele *Programare "

"orientată pe obiecte*, respectiv *Programare orientată înspre obiecte*): "

"mecanismul de moștenire a claselor îngăduie mai multe clase de bază "

"(numite și *superclase* ori *clase-părinte*), orice clasă derivată își "

"poate suprascrie (de la englezescul, în jargon, *override*) metodele "

"moștenite de la una sau de la mai multe din clasele de bază, iar orice "

"metodă (a unei anumite clase) poate apela metoda omonimă a uneia din "

"clasele de bază (ale clasei respective). Obiectele pot conține cantități "

"și tipuri oarecare de date. Aidoma modulelor, clasele împărtășesc natura "

"dinamică a Python-ului: ele sunt create în timpul execuției (sau, în jargon "

"informatic, la *runtime*) și pot fi modificate după ce au fost create."

#: ../../tutorial/classes.rst:23

msgid ""

"In C++ terminology, normally class members (including the data members) "

"are *public* (except see below :ref:`tut-private`), and all member "

"functions are *virtual*. As in Modula-3, there are no shorthands for "

"referencing the object's members from its methods: the method function is"

" declared with an explicit first argument representing the object, which "

"is provided implicitly by the call. As in Smalltalk, classes themselves "

"are objects. This provides semantics for importing and renaming. Unlike"

" C++ and Modula-3, built-in types can be used as base classes for "

"extension by the user. Also, like in C++, most built-in operators with "

"special syntax (arithmetic operators, subscripting etc.) can be redefined"

" for class instances."

msgstr ""

"Urmând terminologia C++, membrii obișnuiți ai unei clase (incluzând aici "

"*datele-membru*; sunt utilizate și constructele *datele membre*, respectiv "

"*variabilele de instanță*) sunt *publici* (cu excepția, vezi mai jos, "

":ref:`tut-private`), pe când toate funcțiile-membru (ori *funcțiile "

"membre*) sunt *virtuale*. La fel ca în Modula-3, nu există simplificări "

"de notație care să deosebească membrii unui obiect de metodele obiectului: "

"funcția metodă se declară cu primul argument (dat) explicit ca "

"reprezentând obiectul, acesta urmând a fi transmis, în mod implicit, la "

"apelul funcției. Precum în Smalltalk, clasele însele sunt obiecte. O atare "

"particularitate aduce cu sine o semantică a importării și a redenumirii. "

"Spre deosebire de C++ ori de Modula-3, tipurile predefinite (de date) pot "

"fi întrebuințate drept clase de bază la extinderile realizate de "

"către utilizator. De asemeni, ca în C++, majoritatea operatorilor "

"predefiniți care au o sintaxă specială (cum ar fi operatorii aritmetici, "

"operatorul de indexare șamd.) pot fi redefiniți pentru instanțele unor "

"clase oarecare."

#: ../../tutorial/classes.rst:34

msgid ""

"(Lacking universally accepted terminology to talk about classes, I will "

"make occasional use of Smalltalk and C++ terms. I would use Modula-3 "

"terms, since its object-oriented semantics are closer to those of Python "

"than C++, but I expect that few readers have heard of it.)"

msgstr ""

"(Dată fiind lipsa unei terminologii unanim acceptate în discuțiile relative "

"la clase, vom folosi ocazional formulări specifice C++-ului și Smalltalk-"

"ului. Am fi întrebuințat termeni din Modula-3, căci semantica orientată-"

"obiect a acestuia este mai apropiată de Python decât cea a C++-ului, dacă "

"nu am bănui că prea puțini dintre cititori au auzit de acest limbaj.)"

#: ../../tutorial/classes.rst:43

msgid "A Word About Names and Objects"

msgstr "O vorbă despre nume și obiecte"

#: ../../tutorial/classes.rst:45

msgid ""

"Objects have individuality, and multiple names (in multiple scopes) can "

"be bound to the same object. This is known as aliasing in other "

"languages. This is usually not appreciated on a first glance at Python, "

"and can be safely ignored when dealing with immutable basic types "

"(numbers, strings, tuples). However, aliasing has a possibly surprising "

"effect on the semantics of Python code involving mutable objects such as "

"lists, dictionaries, and most other types. This is usually used to the "

"benefit of the program, since aliases behave like pointers in some "

"respects. For example, passing an object is cheap since only a pointer "

"is passed by the implementation; and if a function modifies an object "

"passed as an argument, the caller will see the change --- this eliminates"

" the need for two different argument passing mechanisms as in Pascal."

msgstr ""

"Obiectele au individualitate și este permis ca nume diferite (din *domenii "

"de valabilitate* distincte; de la englezescul *scope*; se folosește și "

"constructul *domenii de vizibilitate*) să fie legate de același obiect. În "

"alte limbaje de programare, o atare permisiune este cunoscută drept "

"*întrebuințare de pseudonime* (de la englezescul *aliasing*; sau *atribuire "

"de pseudonime*). Pseudonimele se folosesc rar de către cei aflați la primul "

"contact cu Python-ul, utilizarea lor putând fi evitată în mod eficient "

"atunci când avem de a face, în programul nostru, cu tipurile de date "

"elementare care sunt imutabile (numere, șiruri de caractere, tupluri). Pe "

"de altă parte, atribuirea de pseudonime poate avea efecte neașteptate "

"asupra semanticii programelor Python care întrebuințează obiecte mutabile "

"precum listele, dicționarele de date șamd. Pseudonimele îi sunt utile unui "

"program Python deoarece se comportă ca niște *pointeri* în anumite "

"privințe. De exemplu, transmiterea (ca argument al unei funcții oarecare) "

"unui obiect este ieftină căci implementarea se îngrijește să fie transmis "

"doar un pointer; iar dacă funcția va modifica obiectul transmis ei ca "

"argument, atunci apelantul va observa schimbarea intervenită --- ceea ce "

"elimină nevoia de a dispune de două mecanisme de transmitere a "

"argumentelor, ca în Pascal."

#: ../../tutorial/classes.rst:61

msgid "Python Scopes and Namespaces"

msgstr "Domenii de valabilitate și spații de nume în Python"

#: ../../tutorial/classes.rst:63

msgid ""

"Before introducing classes, I first have to tell you something about "

"Python's scope rules. Class definitions play some neat tricks with "

"namespaces, and you need to know how scopes and namespaces work to fully "

"understand what's going on. Incidentally, knowledge about this subject is"

" useful for any advanced Python programmer."

msgstr ""

"Înainte de a introduce clasele, trebuie să discutăm puțin despre regulile "

"Python-ului în ceea ce privește domeniile de valabilitate. Definițiile "

"claselor le joacă adesea feste celor care utilizează spațiile de nume (de "

"la englezescul *namespace*), așa că este important să cunoașteți precis cum "

"funcționează domeniile de valabilitate și spațiile de nume pentru a putea "

"urmări îndeaproape cum evoluează lucrurile. Că tot a venit vorba, "

"cunoașterea acestei problematici îi este utilă oricărui programator matur "

"în Python."

#: ../../tutorial/classes.rst:69

msgid "Let's begin with some definitions."

msgstr "Să începem cu câteva definiții."

#: ../../tutorial/classes.rst:71

msgid ""

"A *namespace* is a mapping from names to objects. Most namespaces are "

"currently implemented as Python dictionaries, but that's normally not "

"noticeable in any way (except for performance), and it may change in the "

"future. Examples of namespaces are: the set of built-in names "

"(containing functions such as :func:`abs`, and built-in exception names);"

" the global names in a module; and the local names in a function "

"invocation. In a sense the set of attributes of an object also form a "

"namespace. The important thing to know about namespaces is that there is"

" absolutely no relation between names in different namespaces; for "

"instance, two different modules may both define a function ``maximize`` "

"without confusion --- users of the modules must prefix it with the module"

" name."

msgstr ""

"Un *spațiu de nume* este o *asociere* (sau o *corespondență*; de la "

"englezescul *mapping*; se folosește, ca jargon informatic, și termenul de "

"*mapare*) a unor nume cu niște obiecte. Cele mai multe spații de nume sunt "

"implementate în Python, la momentul de față, ca dicționare de date, însă "

"respectiva implementare nu iese în evidență prin nimic (poate cu excepția "

"performanței) și există posibilitatea ca ea să se schimbe în viitor. "

"Exemple de spații de nume sunt următoarele: setul numelor predefinite "

"(conținând funcții precum :func:`abs`, respectiv nume de excepții "

"predefinite); numele globale dintr-un modul; ori numele locale dintr-un "

"apel de funcție. Lucrul important de reținut despre spațiile de nume este "

"că nu există niciun fel de legătură între numele situate în spații de nume "

"diferite; de exemplu, două module distincte pot defini fără pericol de "

"confuzie (câte) o funcție intitulată ``maximizează`` -- ca să folosească o "

"astfel de funcție, utilizatorii modulelor vor avea de prefixat numele ei cu "

"numele modulului care o conține."

#: ../../tutorial/classes.rst:82

msgid ""

"By the way, I use the word *attribute* for any name following a dot --- "

"for example, in the expression ``z.real``, ``real`` is an attribute of "

"the object ``z``. Strictly speaking, references to names in modules are "

"attribute references: in the expression ``modname.funcname``, ``modname``"

" is a module object and ``funcname`` is an attribute of it. In this case"

" there happens to be a straightforward mapping between the module's "

"attributes and the global names defined in the module: they share the "

"same namespace! [#]_"

msgstr ""

"Apropo, folosim cuvântul *atribut* pentru a ne referi la orice nume care îi "

"urmează unui (`operator <https://isocpp.org/blog/2016/02/a-bit-of-"

"background-for-the-operator-dot-proposal-bjarne-stroustrup>`_) "

"punct --- cum ar fi faptul că, în expresia ``z.real``, ``real`` "

"(`partea reală <https://en.wikipedia.org/wiki/Complex_number>`_) "

"este un atribut al obiectului ``z``. Într-o exprimare riguroasă, referirea "

"la numele dintr-un modul este o referire la niște atribute: în expresia "

"``nume_de_modul.nume_de_funcție``, ``nume_de_modul`` desemnează numele unui "

"modul pe când ``nume_de_funcție`` pe cel al unui atribut al acestui modul. "

"În cazul de față se întâmplă să existe o mapare ușor de sesizat între "

"atributele modulului și numele globale definite în modul: ele împart "

"același spațiu de nume! [#]_"

#: ../../tutorial/classes.rst:90

msgid ""

"Attributes may be read-only or writable. In the latter case, assignment "

"to attributes is possible. Module attributes are writable: you can write"

" ``modname.the_answer = 42``. Writable attributes may also be deleted "

"with the :keyword:`del` statement. For example, ``del "

"modname.the_answer`` will remove the attribute :attr:`!the_answer` from "

"the object named by ``modname``."

msgstr ""

"Atributele pot fi sau *doar-de-citit* sau *editabile* (de la englezescul "

"*writable*). În cel de-al doilea caz, atributelor li se pot asigna valori. "

"Atributele unui modul sunt editabile: putem scrie ``nume_de_modul.răspunsul "

"= 42``. De asemeni, atributele editabile pot fi șterse, cu ajutorul "

"instrucțiunii :keyword:`del`. De exemplu, ``del nume_de_modul.răspunsul`` "

"va elimina atributul :attr:`!răspunsul` din obiectul numit "

"``nume_de_modul``."

#: ../../tutorial/classes.rst:96

msgid ""

"Namespaces are created at different moments and have different lifetimes."

" The namespace containing the built-in names is created when the Python "

"interpreter starts up, and is never deleted. The global namespace for a "

"module is created when the module definition is read in; normally, module"

" namespaces also last until the interpreter quits. The statements "

"executed by the top-level invocation of the interpreter, either read from"

" a script file or interactively, are considered part of a module called "

":mod:`__main__`, so they have their own global namespace. (The built-in "

"names actually also live in a module; this is called :mod:`builtins`.)"

msgstr ""

"Spațiile de nume sunt create la momente de timp diferite și au durate de "

"viață variate. Spațiul de nume care conține numele predefinite este creat "

"la pornirea interpretorului de Python, fără a mai fi șters pe întreaga "

"durată a funcționării acestuia. Spațiul de nume global al unui modul este "

"creat odată cu citirea de către interpretor a definiției modulului în "

"cauză; în mod obișnuit, spațiile de nume ale modulelor rămân în viață până "

"la oprirea interpretorului. Instrucțiunile executate de o invocare de la "

"cel mai înalt nivel a interpretorului, fie că au fost citite dintr-un "

"fișier de script fie că au fost introduse în mod interactiv, sunt "

"considerate că făcând parte dintr-un modul numit :mod:`__main__`, astfel "

"că ele posedă propriul lor spațiu de nume global. (Numele predefinite, la "

"rândul lor, funcționează într-un modul; acesta se numește :mod:`builtins`.)"

#: ../../tutorial/classes.rst:106

msgid ""

"The local namespace for a function is created when the function is "

"called, and deleted when the function returns or raises an exception that"

" is not handled within the function. (Actually, forgetting would be a "

"better way to describe what actually happens.) Of course, recursive "

"invocations each have their own local namespace."

msgstr ""

"Spațiul de nume local al unei funcții este creat la apelul funcției și este "

"șters fie la returnarea din execuția codului funcției fie atunci când, în "

"codul funcției, este ridicată o excepție care nu va fi interceptată în "

"cadrul funcției respective. (De fapt, *uitare* ar fi termenul potrivit "

"pentru a descrie ceea ce se întâmplă cu adevărat într-o atare situație.) "

"Evident, invocările recursive ale unei funcții au fiecare propriul său "

"spațiu de nume."

#: ../../tutorial/classes.rst:112

msgid ""

"A *scope* is a textual region of a Python program where a namespace is "

"directly accessible. \"Directly accessible\" here means that an "

"unqualified reference to a name attempts to find the name in the "

"namespace."

msgstr ""

"Un *domeniu de valabilitate* este o zonă de text dintr-un program Python "

"în care un anumit spațiu de nume este accesibil în mod direct. Prin "

"\"accesibil în mod direct\" înțelegem faptul că referințele *necalificate* "

"la nume oarecare reușesc să identifice despre ce nume este vorba în acel "

"spațiu de nume."

#: ../../tutorial/classes.rst:116

msgid ""

"Although scopes are determined statically, they are used dynamically. At "

"any time during execution, there are 3 or 4 nested scopes whose "

"namespaces are directly accessible:"

msgstr ""

"Cu toate că domeniile de valabilitate sunt stabilite *static*, utilizarea "

"lor se face *dinamic*. La orice moment de timp de pe parcursul execuției "

"unui program Python, există 3 sau 4 domenii de valabilitate imbricate la "

"ale căror spații de nume avem acces în mod direct:"

#: ../../tutorial/classes.rst:120

msgid "the innermost scope, which is searched first, contains the local names"

msgstr ""

"domeniul de valabilitate poziționat cel mai adânc în interiorul "

"codului, acela din care va începe orice căutare de nume, el conține "

"numele locale"

#: ../../tutorial/classes.rst:121

msgid ""

"the scopes of any enclosing functions, which are searched starting with "

"the nearest enclosing scope, contain non-local, but also non-global names"

msgstr ""

"domeniile de valabilitate ale funcțiilor care înglobează codul (de la "

"englezescul *enclosing*), în care căutările de nume se realizează pornind "

"de la domeniul de includere (al codului) situat cel mai adânc, acestea "

"deținând atât nume ne-locale cât și nume ne-globale"

#: ../../tutorial/classes.rst:123

msgid "the next-to-last scope contains the current module's global names"

msgstr "penultimul (dinspre interiorul către exteriorul codului) domeniu "

"de valabilitate conține numele globale ale modulului curent"

#: ../../tutorial/classes.rst:124

msgid ""

"the outermost scope (searched last) is the namespace containing built-in "

"names"

msgstr ""

"domeniul de valabilitate cel mai de sus (ultimul în care se va căuta "

"numele respectiv) este spațiul de nume care cuprinde numele predefinite"

#: ../../tutorial/classes.rst:126

msgid ""

"If a name is declared global, then all references and assignments go "

"directly to the next-to-last scope containing the module's global names."

" To rebind variables found outside of the innermost scope, the "

":keyword:`nonlocal` statement can be used; if not declared nonlocal, "

"those variables are read-only (an attempt to write to such a variable "

"will simply create a *new* local variable in the innermost scope, leaving"

" the identically named outer variable unchanged)."

msgstr ""

"Atunci când un nume este declarat ca fiind *global*, toate referirile la "

"el precum și toate atribuirile către el vor fi realizate în domeniul de "

"valabilitate penultim, adică în domeniul care deține toate numele globale "

"ale modulului. Pentru a lega din nou variabilele găsite în exteriorul "

"celui mai adânc situat dintre domeniile de valabilitate poate fi "

"întrebuințată instrucțiunea :keyword:`nonlocal` (adică, o declarație de "

"ne-local); dacă nu au fost declarate drept ne-locale, atunci asemenea "

"variabile sunt doar-de-citit (orice tentativă de a edita o atare "

"variabilă va conduce la crearea unei variabile locale *noi*, conținută în "

"domeniul de valabilitate poziționat cel mai adânc, în timp ce numele "

"omonim din exterior nu-și va modifica valoarea)."

#: ../../tutorial/classes.rst:133

msgid ""

"Usually, the local scope references the local names of the (textually) "

"current function. Outside functions, the local scope references the same"

" namespace as the global scope: the module's namespace. Class definitions"

" place yet another namespace in the local scope."

msgstr ""

"Domeniul de valabilitate local se referă, în mod obișnuit, la numele locale "

"ale (chiar) funcției de față. În exteriorul codului de funcții, domeniul "

"de valabilitate local face referire la același spațiu de nume ca și "

"domeniul de valabilitate global: adică la spațiul de nume al modulului. "

"Definițiile claselor, la rândul lor, plasează alte spații de nume în "

"domeniul de valabilitate local."

#: ../../tutorial/classes.rst:138

msgid ""

"It is important to realize that scopes are determined textually: the "

"global scope of a function defined in a module is that module's "

"namespace, no matter from where or by what alias the function is called."

" On the other hand, the actual search for names is done dynamically, at "

"run time --- however, the language definition is evolving towards static "

"name resolution, at \"compile\" time, so don't rely on dynamic name "

"resolution! (In fact, local variables are already determined "

"statically.)"

msgstr ""

"Este important să realizăm că domeniile de valabilitate se determină "

"textual: domeniul de valabilitate global al unei funcții definite într-"

"un modul este chiar spațiul de nume al modulului respectiv, indiferent "

"de unde ori sub ce pseudonim s-a realizat apelul funcției în cauză. Pe "

"de altă parte, căutarea efectivă a unui anumit nume se realizează "

"dinamic, pe parcursul execuției programului --- cu toate acestea, "

"definiția Python-ului ca limbaj de programare evoluează către o "

"rezolvare statică a numelor, adică una la momentul \"compilării\", "

"motiv pentru care vă recomandăm să nu vă bazați pe rezolvări dinamice "

"de nume! (În fapt, variabilele locale sunt deja determinate static.)"

#: ../../tutorial/classes.rst:146

msgid ""

"A special quirk of Python is that -- if no :keyword:`global` or "

":keyword:`nonlocal` statement is in effect -- assignments to names always"

" go into the innermost scope. Assignments do not copy data --- they just "

"bind names to objects. The same is true for deletions: the statement "

"``del x`` removes the binding of ``x`` from the namespace referenced by "

"the local scope. In fact, all operations that introduce new names use "

"the local scope: in particular, :keyword:`import` statements and function"

" definitions bind the module or function name in the local scope."

msgstr ""

"O caracteristică aparte a Python-ului -- atunci când nu ne găsim sub "

"efectul vreuneia din instrucțiunile :keyword:`global` ori "

":keyword:`nonlocal` -- este aceea că atribuirile către nume se fac "

"întotdeauna în domeniul de valabilitate poziționat cel mai adânc în "

"interiorul codului. Atribuirile nu copiază date --- ele doar leagă "

"nume de obiecte. Același lucru este valabil și pentru ștergeri: "

"instrucțiunea ``del x`` elimină legătura lui ``x`` din spațiul de "

"nume la care se referă domeniul de valabilitate local. În fapt, orice "

"operație care introduce nume noi întrebuințează domeniul de valabilitate "

"local: în particular, instrucțiunile :keyword:`import` precum și "

"definițiile de funcții leagă fie numele modulului fie numele funcției "

"de domeniul de valabilitate local."

#: ../../tutorial/classes.rst:154

msgid ""

"The :keyword:`global` statement can be used to indicate that particular "

"variables live in the global scope and should be rebound there; the "

":keyword:`nonlocal` statement indicates that particular variables live in"

" an enclosing scope and should be rebound there."

msgstr ""

"Instrucțiunea :keyword:`global` poate fi utilizată la a arăta că o anume "

"variabilă trăiește în domeniul de valabilitate global, astfel că trebuie "

"re-legată (tot) în el; instrucțiunea :keyword:`nonlocal` indică faptul că "

"variabila respectivă trăiește într-un domeniu de valabilitate care "

"înglobează codul de față, deci că va trebui re-legată în acela."

#: ../../tutorial/classes.rst:162

msgid "Scopes and Namespaces Example"

msgstr "Un exemplu cu domenii de valabilitate și spații de nume"

#: ../../tutorial/classes.rst:164

msgid ""

"This is an example demonstrating how to reference the different scopes "

"and namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect "

"variable binding::"

msgstr ""

"Acesta este un exemplu care ilustrează cum trebuie referențiate diversele "

"domenii de valabilitate și spațiile de nume, respectiv cum afectează "

"cuvintele-cheie :keyword:`global` și :keyword:`nonlocal` legarea unei "

"variabile oarecare::"

#: ../../tutorial/classes.rst:168

msgid ""

"def scope_test():\n"

" def do_local():\n"

" spam = \"local spam\"\n"

"\n"

" def do_nonlocal():\n"

" nonlocal spam\n"

" spam = \"nonlocal spam\"\n"

"\n"

" def do_global():\n"

" global spam\n"

" spam = \"global spam\"\n"

"\n"

" spam = \"test spam\"\n"

" do_local()\n"

" print(\"After local assignment:\", spam)\n"

" do_nonlocal()\n"

" print(\"After nonlocal assignment:\", spam)\n"

" do_global()\n"

" print(\"After global assignment:\", spam)\n"

"\n"

"scope_test()\n"

"print(\"In global scope:\", spam)"

msgstr ""

"def testează_domeniul_de_vizibilitate():\n"

" def construiește_ceva_local():\n"

" șuncă = \"șuncă produsă local\"\n"

"\n"

" def construiește_ceva_nelocal():\n"

" nonlocal șuncă\n"

" șuncă = \"șuncă produsă ne-local\"\n"

"\n"

" def construiește_ceva_global():\n"

" global șuncă\n"

" șuncă = \"șuncă produsă global\"\n"

"\n"

" șuncă = \"testez șunca\"\n"

" construiește_ceva_local()\n"

" print(\"După asignarea locală:\", șuncă)\n"

" construiește_ceva_nelocal()\n"

" print(\"După asignarea ne-locală:\", șuncă)\n"

" construiește_ceva_global()\n"

" print(\"După asignarea globală:\", șuncă)\n"

"\n"

"testează_domeniul_de_vizibilitate()\n"

"print(\"În domeniul de valabilitate global:\", șuncă)"

#: ../../tutorial/classes.rst:191

msgid "The output of the example code is:"

msgstr "Rezultatul rulării codului din exemplu este următorul:"

#: ../../tutorial/classes.rst:193

msgid ""

"After local assignment: test spam\n"

"After nonlocal assignment: nonlocal spam\n"

"After global assignment: nonlocal spam\n"

"In global scope: global spam"

msgstr ""

"După asignarea locală: testez șunca\n"

"După asignarea ne-locală: șuncă produsă ne-local\n"

"După asignarea globală: șuncă produsă ne-local\n"

"În domeniul de valabilitate global: șuncă produsă global"

#: ../../tutorial/classes.rst:200

msgid ""

"Note how the *local* assignment (which is default) didn't change "

"*scope_test*\\'s binding of *spam*. The :keyword:`nonlocal` assignment "

"changed *scope_test*\\'s binding of *spam*, and the :keyword:`global` "

"assignment changed the module-level binding."

msgstr ""

"Remarcați că atribuirea *local* (deci, cea standard) nu a modificat "

"legarea lui *șuncă* dată de *testează_domeniul_de_vizibilitate*. În "

"schimb, atribuirea :keyword:`nonlocal` a schimbat legarea lui *șuncă* dată "

"de *testează_domeniul_de_vizibilitate*, respectiv atribuirea "

":keyword:`global` a modificat legarea la nivel de modul."

#: ../../tutorial/classes.rst:205

msgid ""

"You can also see that there was no previous binding for *spam* before the"

" :keyword:`global` assignment."

msgstr ""

"În plus, puteți observa că *șuncă* nu a fost legat în niciun fel până la "

"momentul asignării :keyword:`global`."

#: ../../tutorial/classes.rst:212

msgid "A First Look at Classes"

msgstr "Prima privire aruncată asupra claselor"

#: ../../tutorial/classes.rst:214

msgid ""

"Classes introduce a little bit of new syntax, three new object types, and"

" some new semantics."

msgstr ""

"Clasele aduc un strop de nou în conținutul sintaxei, alte trei tipuri de "

"obiecte, precum și ceva noutăți la semantică."

#: ../../tutorial/classes.rst:221

msgid "Class Definition Syntax"

msgstr "Sintaxa definiției unei clase"

#: ../../tutorial/classes.rst:223

msgid "The simplest form of class definition looks like this::"

msgstr "Cea mai simplă formă a definiției unei clase arată astfel::"

#: ../../tutorial/classes.rst:225

msgid ""

"class ClassName:\n"

" <statement-1>\n"

" .\n"

" .\n"

" .\n"

" <statement-N>"

msgstr ""

"class NumeleClasei:\n"

" <instrucțiunea-1>\n"

" .\n"

" .\n"

" .\n"

" <instrucțiunea-N>"

#: ../../tutorial/classes.rst:232

msgid ""

"Class definitions, like function definitions (:keyword:`def` statements) "

"must be executed before they have any effect. (You could conceivably "

"place a class definition in a branch of an :keyword:`if` statement, or "

"inside a function.)"

msgstr ""

"Definițiile de clase, aidoma definițiilor de funcții (instrucțiuni "

":keyword:`def`) trebuie executate mai întâi pentru a avea efect. (Dat "

"fiind că nu este exclus să plasați o definiție de clasă într-una din "

"ramificațiile unei instrucțiuni :keyword:`if`, după cum nu este imposibil "

"nici să o inserați în codul vreunei funcții.)"

#: ../../tutorial/classes.rst:236

msgid ""

"In practice, the statements inside a class definition will usually be "

"function definitions, but other statements are allowed, and sometimes "

"useful --- we'll come back to this later. The function definitions "

"inside a class normally have a peculiar form of argument list, dictated "

"by the calling conventions for methods --- again, this is explained "

"later."

msgstr ""

"În practică, instrucțiunile din codul definiției unei clase vor fi mai "

"ales definiții de funcții, cu toate că sunt permise și altfel de "

"instrucțiuni, și încă cu mult folos --- vom reveni la aceasta mai "

"târziu. Definițiile de funcții din interiorul (codului) unei clase "

"impun (de obicei) o formă neobișnuită a listei de argumente, formă "

"dictată de convențiile de apel ale metodelor --- și aceste aspecte vor "

"fi explicate ulterior."

#: ../../tutorial/classes.rst:242

msgid ""

"When a class definition is entered, a new namespace is created, and used "

"as the local scope --- thus, all assignments to local variables go into "

"this new namespace. In particular, function definitions bind the name of"

" the new function here."

msgstr ""

"Atunci când interpretorul citește definiția unei clase, un spațiu de nume "

"(nou) va fi creat și întrebuințat ca domeniu de valabilitate local --- "

"astfel, toate atribuirile către variabile locale vor fi realizate în cadrul "

"acestui (nou) spațiu de nume. În particular, definițiile de funcții leagă "

"fiecare nume nou de funcție de acest domeniu de valabilitate."

#: ../../tutorial/classes.rst:247

msgid ""

"When a class definition is left normally (via the end), a *class object* "

"is created. This is basically a wrapper around the contents of the "

"namespace created by the class definition; we'll learn more about class "

"objects in the next section. The original local scope (the one in effect"

" just before the class definition was entered) is reinstated, and the "

"class object is bound here to the class name given in the class "

"definition header (:class:`!ClassName` in the example)."

msgstr ""

"Atunci când interpretorul părăsește în mod normal codul unei definiții de "

"clasă (deci, după ce a ajuns la finalul acestui cod), va fi creat un "

"*obiect clasă*. Acesta este, în fapt, o *împachetare* (sau o *învelitoare*; "

"de la englezescul *wrapper*) a conținutului acelui spațiu de nume creat de "

"însăși definiția clasei; vom afla mai multe despre obiectele clasă în "

"secțiunea următoare. Domeniul de valabilitate local în care ne aflam "

"(adică, domeniul vizibil înainte ca interpretorul să ajungă la definiția "

"clasei) este reinstaurat iar obiectul clasă este legat de numele clasei dat "

"în antetul definiției acesteia (:class:`!NumeleClasei` din exemplul nostru)."

#: ../../tutorial/classes.rst:259

msgid "Class Objects"

msgstr "Obiectele clasă"

#: ../../tutorial/classes.rst:261

msgid ""

"Class objects support two kinds of operations: attribute references and "

"instantiation."

msgstr ""

"Obiectele clasă permit două feluri de operații: referirea la atribute și "

"instanțierea."

#: ../../tutorial/classes.rst:264

msgid ""

"*Attribute references* use the standard syntax used for all attribute "

"references in Python: ``obj.name``. Valid attribute names are all the "

"names that were in the class's namespace when the class object was "

"created. So, if the class definition looked like this::"

msgstr ""

"*Referirea la atribute* (de clasă; sau *referențierea atributelor* ori "

"*referința la atribute*) întrebuințează sintaxa tipică din Python a "

"referirii la atribute oarecare: ``obiect.nume``. Numele valide de atribute "

"alcătuiesc întreg ansamblul de nume din spațiul de nume al clasei la "

"momentul creării obiectului clasă. Astfel, dacă definiția clasei arată ca "

"mai jos::"

#: ../../tutorial/classes.rst:269

msgid ""

"class MyClass:\n"

" \"\"\"A simple example class\"\"\"\n"

" i = 12345\n"

"\n"

" def f(self):\n"

" return 'hello world'"

msgstr ""

"class ClasaMea:\n"

" \"\"\"Un exemplu simplist de clasă\"\"\"\n"

" i = 12345\n"

"\n"

" def f(self):\n"

" return 'salutare, lume'"

#: ../../tutorial/classes.rst:276

msgid ""

"then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, "

"returning an integer and a function object, respectively. Class "

"attributes can also be assigned to, so you can change the value of "

"``MyClass.i`` by assignment. :attr:`~type.__doc__` is also a valid "

"attribute, returning the docstring belonging to the class: ``\"A simple "

"example class\"``."

msgstr ""

"atunci ``ClasaMea.i`` și ``ClasaMea.f`` sunt referiri valide la atribute, "

"care returnează un număr întreg, respectiv un obiect funcție. Atributelor "

"de clasă le putem realiza asignări, așa că valoarea lui ``ClasaMea.i`` "

"poate fi modificată prin atribuire. Și :attr:`~type.__doc__` este un "

"atribut valid, returnând docstring-ul clasei: ``\"Un exemplu simplist "

"de clasă\"``."

#: ../../tutorial/classes.rst:282

msgid ""

"Class *instantiation* uses function notation. Just pretend that the "

"class object is a parameterless function that returns a new instance of "

"the class. For example (assuming the above class)::"

msgstr ""

"*Instanțierea* unei clase utilizează notația cu `operatorul funcție "

"<https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B>`_. Ne putem "

"închipui că obiectul clasă este o funcție fără parametri care întoarce "

"o (nouă) instanță a clasei. De exemplu (folosind clasa de mai sus)::"

#: ../../tutorial/classes.rst:286 ../../tutorial/classes.rst:303

msgid "x = MyClass()"

msgstr "x = ClasaMea()"

#: ../../tutorial/classes.rst:288

msgid ""

"creates a new *instance* of the class and assigns this object to the "

"local variable ``x``."

msgstr ""

"creează o *instanță* nouă a clasei și îi atribuie obiectul nou creat "

"variabilei locale ``x``."

#: ../../tutorial/classes.rst:291

msgid ""

"The instantiation operation (\"calling\" a class object) creates an empty"

" object. Many classes like to create objects with instances customized to"

" a specific initial state. Therefore a class may define a special method "

"named :meth:`~object.__init__`, like this::"

msgstr ""

"Operația de *instanțiere* (adică de \"apelare\" a unui obiect clasă; de la "

"englezescul *instantiation*) creează un obiect *gol* (vid). Pentru multe "

"clase utilizate în practică se dorește crearea de instanțe particularizate "

"printr-o *stare inițială* specificată (de către utilizator). Din acest "

"motiv, unei clase îi poate fi definită o metodă specială, numită "

":meth:`~object.__init__`, după cum urmează::"

#: ../../tutorial/classes.rst:296

msgid ""

"def __init__(self):\n"

" self.data = []"

msgstr ""

"def __init__(self):\n"

" self.datele_clasei = []"

#: ../../tutorial/classes.rst:299

msgid ""

"When a class defines an :meth:`~object.__init__` method, class "

"instantiation automatically invokes :meth:`!__init__` for the newly "

"created class instance. So in this example, a new, initialized instance "

"can be obtained by::"

msgstr ""

"Atunci când în codul unei clase este definită (și) metoda "

":meth:`~object.__init__`, instanțierea clasei respective va invoca în mod "

"automat această metodă pentru nou creata instanță a clasei. Așadar, în "

"exemplul nostru, o instanță nouă, *inițializată*, poate fi obținută prin::"

#: ../../tutorial/classes.rst:305

msgid ""

"Of course, the :meth:`~object.__init__` method may have arguments for "

"greater flexibility. In that case, arguments given to the class "

"instantiation operator are passed on to :meth:`!__init__`. For example, "

"::"

msgstr ""

"Firește, metoda :meth:`~object.__init__` poate primi argumente, această "

"caracteristică sporindu-i flexibilitatea în utilizare. Într-o atare "

"situație, argumentele date operatorului de instanțiere a clasei îi vor fi "

"transmise lui :meth:`!__init__`. Astfel,"

#: ../../tutorial/classes.rst:309

msgid ""

">>> class Complex:\n"

"... def __init__(self, realpart, imagpart):\n"

"... self.r = realpart\n"

"... self.i = imagpart\n"

"...\n"

">>> x = Complex(3.0, -4.5)\n"

">>> x.r, x.i\n"

"(3.0, -4.5)"

msgstr ""

">>> class NumărComplex:\n"

"... def __init__(self, partea_reală, partea_imaginară):\n"

"... self.real = partea_reală\n"

"... self.imaginar = partea_imaginară\n"

"...\n"

">>> x = NumărComplex(3.0, -4.5)\n"

">>> x.real, x.imaginar\n"

"(3.0, -4.5)"

#: ../../tutorial/classes.rst:322

msgid "Instance Objects"

msgstr "Obiectele instanță"

#: ../../tutorial/classes.rst:324

msgid ""

"Now what can we do with instance objects? The only operations understood"

" by instance objects are attribute references. There are two kinds of "

"valid attribute names: data attributes and methods."

msgstr ""

"Odată ajunși aici, la ce putem întrebuința aceste obiecte instanță? "

"Singurele operații înțelese de obiectele instanță sunt referențierile de "

"atribute. Există două tipuri de nume de atribute valide: atributele datelor "

"(sau *atributele de date*) și metodele (adică, *atributele de funcții*)."

#: ../../tutorial/classes.rst:328

msgid ""

"*data attributes* correspond to \"instance variables\" in Smalltalk, and "

"to \"data members\" in C++. Data attributes need not be declared; like "

"local variables, they spring into existence when they are first assigned "

"to. For example, if ``x`` is the instance of :class:`!MyClass` created "

"above, the following piece of code will print the value ``16``, without "

"leaving a trace::"

msgstr ""

"*atributele de date* le corespund \"variabilelor de instanță\" din "

"Smalltalk, respectiv \"membrilor date\" din C++. Atributele (de) date "

"nu au nevoie să fie *declarate*; asemenea variabilelor locale, ele "

"*prind viață* (sunt *vivificate*) doar atunci când li se face o atribuire "

"*pentru prima oară*. De exemplu, dacă ``x`` este instanța lui "

":class:`!ClasaMea` creată mai sus, atunci următorul fragment de cod va "

"produce afișarea lui ``16``, fără să lase urme (în starea viitoarea a "

"lui ``x``)::"

#: ../../tutorial/classes.rst:334

msgid ""

"x.counter = 1\n"

"while x.counter < 10:\n"

" x.counter = x.counter * 2\n"

"print(x.counter)\n"

"del x.counter"

msgstr ""

"x.contor = 1\n"

"while x.contor < 10:\n"

" x.contor = x.contor * 2\n"

"print(x.contor)\n"

"del x.contor"

#: ../../tutorial/classes.rst:340

msgid ""

"The other kind of instance attribute reference is a *method*. A method is"

" a function that \"belongs to\" an object."

msgstr ""

"Celălalt fel de referențiere de atribute de care dispune instanța este "

"*metoda*. O metodă este o funcție care \"îi aparține\" unui obiect."

#: ../../tutorial/classes.rst:345

msgid ""

"Valid method names of an instance object depend on its class. By "

"definition, all attributes of a class that are function objects define "

"corresponding methods of its instances. So in our example, ``x.f`` is a "

"valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is"

" not, since ``MyClass.i`` is not. But ``x.f`` is not the same thing as "

"``MyClass.f`` --- it is a *method object*, not a function object."

msgstr ""

"Numele valide de metode ale unui obiect instanță depind de clasa acestui "

"obiect instanță. Prin definiție, toate atributele unei clase care sunt "

"obiecte funcție definesc metodele corespunzătoare (omonime) ale instanțelor "

"clasei. Așa că, în exemplul nostru, ``x.f`` este o referire validă la o "

"metodă, deoarece ``ClasaMea.f`` este funcție, pe când ``x.i`` nu este "

"validă ca referire la vreo metodă pentru că ``ClasaMea.i`` nu este "

"funcție. Atenție, ``x.f`` nu este același lucru cu ``ClasaMea.f`` --- "

"primul este un *obiect metodă*, nu un obiect funcție."

#: ../../tutorial/classes.rst:356

msgid "Method Objects"

msgstr "Obiectele metodă"

#: ../../tutorial/classes.rst:358

msgid "Usually, a method is called right after it is bound::"

msgstr ""

"Adesea, o metodă va fi apelată de îndată ce a fost legată (de un anumit "

"obiect)::"

#: ../../tutorial/classes.rst:360

msgid "x.f()"

msgstr "x.f()"

#: ../../tutorial/classes.rst:362

msgid ""

"If ``x = MyClass()``, as above, this will return the string ``'hello "

"world'``. However, it is not necessary to call a method right away: "

"``x.f`` is a method object, and can be stored away and called at a later "

"time. For example::"

msgstr ""

"Dacă ``x = MyClass()``, ca mai sus, un atare apel va returna șirul de "

"caractere ``'salutare, lume'``. Pe de altă parte, nu este nevoie să "

"apelăm metodele imediat: cum ``x.f`` este un obiect metodă, el poate fi "

"stocat undeva și apelat la momentul dorit. De exemplu::"

#: ../../tutorial/classes.rst:366

msgid ""

"xf = x.f\n"

"while True:\n"

" print(xf())"

msgstr ""

"xf = x.f\n"

"while True:\n"

" print(xf())"

#: ../../tutorial/classes.rst:370

msgid "will continue to print ``hello world`` until the end of time."

msgstr ""

"va afișa ``salutare, lume`` fără să se mai oprească din a da binețe."

#: ../../tutorial/classes.rst:372

msgid ""

"What exactly happens when a method is called? You may have noticed that "

"``x.f()`` was called without an argument above, even though the function "

"definition for :meth:`!f` specified an argument. What happened to the "

"argument? Surely Python raises an exception when a function that requires"

" an argument is called without any --- even if the argument isn't "

"actually used..."

msgstr ""

"Ce se întâmplă, cu adevărat, atunci când se apelează o metodă? Probabil că "

"ați remarcat faptul că ``x.f()`` a fost apelat, în codul de mai sus, fără "

"să i se dea niciun argument, chiar dacă definiția lui :meth:`!f` specifica "

"un anume argument. Oare ce s-a întâmplat cu acest argument? Doar știm că "

"Python-ul va lansa o excepție atunci când vreo funcție care cerere argument "

"este apelată fără niciun argument --- chiar dacă argumentul nici măcar nu "

"urmează să fie folosit..."

#: ../../tutorial/classes.rst:378

msgid ""

"Actually, you may have guessed the answer: the special thing about "

"methods is that the instance object is passed as the first argument of "

"the function. In our example, the call ``x.f()`` is exactly equivalent "

"to ``MyClass.f(x)``. In general, calling a method with a list of *n* "

"arguments is equivalent to calling the corresponding function with an "

"argument list that is created by inserting the method's instance object "

"before the first argument."

msgstr ""

"Păi, se prea poate să fi ghicit, deja, răspunsul: un lucru special "

"privind metodele este acela că obiectul instanță îi este transmis "

"metodei ca *prim argument* al său. În exemplul nostru, apelul ``x.f()`` "

"este absolut echivalent cu ``ClasaMea.f(x)``. Practic, a apela o "

"metodă cu o listă de *n* argumente este totuna cu a apela funcția "

"corespondentă a acestei metode cu o listă de argumente formată prin "

"inserarea obiectului instanță (de care *aparține* metoda) înaintea "

"primului din cele *n* argumente."

#: ../../tutorial/classes.rst:385

msgid ""

"In general, methods work as follows. When a non-data attribute of an "

"instance is referenced, the instance's class is searched. If the name "

"denotes a valid class attribute that is a function object, references to "

"both the instance object and the function object are packed into a method"

" object. When the method object is called with an argument list, a new "

"argument list is constructed from the instance object and the argument "

"list, and the function object is called with this new argument list."

msgstr ""

"În general, metodele funcționează după cum urmează. Atunci când un "

"atribut non-dată este referențiat, va fi căutată instanța clasei (sale). "

"Dacă numele (atributului) denotă un atribut valid al clasei iar acest "

"atribut este un obiect funcție, atunci referirile (referințele) respective, "

"atât la obiectul instanță cât și la obiectul funcție, vor fi împachetate "

"într-un obiect metodă. Dacă obiectul metodă este apelat cu o listă de "

"argumente, atunci o nouă listă de argumente va fi construită din obiectul "

"instanță și din elementele listei de argumente în cauză, obiectul funcție "

"corespunzător fiind apelat cu această (nou formată) listă de argumente."

#: ../../tutorial/classes.rst:398

msgid "Class and Instance Variables"

msgstr "Variabile de clasă și variabile de instanță"

#: ../../tutorial/classes.rst:400

msgid ""

"Generally speaking, instance variables are for data unique to each "

"instance and class variables are for attributes and methods shared by all"

" instances of the class::"

msgstr ""

"În jargon POO, variabilele de instanță se referă la datele care îi sunt "

"unice fiecărei instanțe, respectiv variabilele de clasă se referă la "

"atributele și metodele comune tuturor instanțelor clasei respective::"

#: ../../tutorial/classes.rst:404

msgid ""

"class Dog:\n"

"\n"

" kind = 'canine' # class variable shared by all instances\n"

"\n"

" def __init__(self, name):\n"

" self.name = name # instance variable unique to each instance\n"

"\n"

">>> d = Dog('Fido')\n"

">>> e = Dog('Buddy')\n"

">>> d.kind # shared by all dogs\n"

"'canine'\n"

">>> e.kind # shared by all dogs\n"

"'canine'\n"

">>> d.name # unique to d\n"

"'Fido'\n"

">>> e.name # unique to e\n"

"'Buddy'"

msgstr ""

"class Câine:\n"

"\n"

" genul = 'canis' # variabilă de clasă comună tuturor\n"

" # instanțelor\n"

"\n"