classes.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-05-08 19:31+0000\n"
"PO-Revision-Date: 2026-05-08 17:18+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2026\n"
"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pl\n"
"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "
"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "
"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid "Classes"
msgstr "Klasy"

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 ""
"Klasy umożliwiają łączenie danych i funkcjonalności. Tworzenie nowej klasy, "
"tworzy nowy *typ* obiektu, umożliwiając tworzenie nowych *instancji* tego "
"typu. Do każdej instancji klasy można przypisać atrybuty służące do "
"utrzymywania jej stanu. Instancje klas mogą również posiadać metody "
"(zdefiniowane przez klasę) umożliwiające modyfikację ich stanu."

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 ""
"W porównaniu do innych języków programowania, w Pythonie, mechanizm "
"dodawania nowych klas wymaga niewielkiej ilości nowej składni i semantyki. "
"Jest to połączenie mechanizmu klas, które można znaleźć w C++ i Modula-3. "
"Klasy w Pythonie dostarczają wszystkie standardowe cechy programowania "
"obiektowego: mechanizm dziedziczenia klas pozwala na wiele klas bazowych, "
"klasy pochodne mogą nadpisać każdą metodę klasy lub klas bazowych i metoda "
"może wywołać metody klas bazowych o tej samej nazwie. Obiekty mogą zawierać "
"dowolną ilość i rodzaj danych. Zarówno klasy jak i moduły są częścią "
"dynamicznej natury Pythona: są tworzone w trakcie działania programu i mogą "
"być modyfikowane później, po stworzeniu."

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 ""
"Korzystając z terminologii C++, składniki klas (także pola) są *publiczne* "
"(z wyjątkiem zobacz poniżej :ref:`tut-private`), a wszystkie metody są "
"*wirtualne*. Podobnie jak w Moduli-3, nie ma skrótów pozwalających na "
"odnoszenie się do składników klas z ich metod: metoda jest deklarowana "
"poprzez podanie wprost jako pierwszego argumentu obiektu, który w czasie "
"wywołania metody zostanie jej przekazany niejawnie. Podobnie jak w "
"Smalltalku, same klasy także są obiektami. Dostarcza nam to wyrażeń "
"semantycznych pozwalających na importowanie i zmianę nazw klasy. Inaczej niż "
"w C++ i Moduli-3 wbudowane typy mogą stanowić klasy, z których klasa "
"użytkownika będzie dziedziczyć. Podobnie jak w C++, większość wbudowanych "
"operatorów ze specjalną składnią (operatory arytmetyczne, indeksowanie) może "
"być przedefiniowane przez instancje klasy."

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 ""
"(Z powodu braku ogólnie zaakceptowanej terminologii w kontekście klas, będę "
"używał terminów ze Smalltalk i C++. Użyłbym Modula-3 ponieważ semantyka jego "
"programowania obiektowego jest bliższa Pythonowi niż C++ ale zakładam, że "
"mniej czytelników o nim słyszało.)"

msgid "A Word About Names and Objects"
msgstr "Kilka słów o nazwach i obiektach"

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 ""
"Obiekty mają indywidualność, a wiele nazw (w wielu zakresach) może być "
"powiązanych z tym samym obiektem. Jest to znane jako aliasing w innych "
"językach. Zwykle nie jest to doceniane na pierwszy rzut oka w Pythonie i "
"można je bezpiecznie zignorować, gdy mamy do czynienia z niezmiennymi typami "
"podstawowymi (liczby, ciągi znaków, krotki). Jednak aliasing ma "
"prawdopodobnie zaskakujący wpływ na semantykę kodu Pythona, który obejmuje "
"zmienne obiekty, takie jak listy, słowniki i większość innych typów. Jest to "
"zwykle wykorzystywane z korzyścią dla programu, ponieważ aliasy pod pewnymi "
"względami zachowują się jak wskaźniki. Na przykład przekazanie obiektu jest "
"tanie, ponieważ implementacja przekazuje tylko wskaźnik; a jeśli funkcja "
"modyfikuje obiekt przekazany jako argument, wywołujący zobaczy zmianę --- "
"eliminuje to potrzebę stosowania dwóch różnych mechanizmów przekazywania "
"argumentów, jak w Pascalu."

msgid "Python Scopes and Namespaces"
msgstr "Zasięgi widoczności i przestrzenie nazw w Pythonie"

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 ""
"Przed wprowadzeniem klas, najpierw muszę powiedzieć ci coś o zasadach "
"zakresu Pythona. Definicje klas stosują kilka zgrabnych sztuczek z "
"przestrzeniami nazw, a żeby w pełni zrozumieć, co się dzieje, trzeba "
"wiedzieć, jak działają zakresy i przestrzenie nazw."

msgid "Let's begin with some definitions."
msgstr "Zacznijmy od kilku definicji."

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 ""
"*Przestrzeń nazw* to odwzorowanie z nazw na obiekty. Większość przestrzeni "
"nazw jest obecnie implementowana jako słowniki Pythona, ale to zwykle nie "
"jest zauważalne w żaden sposób (z wyjątkiem wydajności), a to może się "
"zmienić w przyszłości. Przykładami przestrzeni nazw są: zbiór nazw "
"wbudowanych (zawierający funkcje np. :func:`abs` i nazwy wbudowanych "
"wyjątków); nazwy globalne w module; oraz nazwy lokalne w wywołaniu funkcji. "
"W pewnym sensie zbiór atrybutów obiektu również tworzy przestrzeń nazw. "
"Ważną rzeczą, którą należy wiedzieć o przestrzeniach nazw, jest to, że nie "
"ma absolutnie żadnych relacji między nazwami w różnych przestrzeniach nazw; "
"na przykład, dwa różne moduły mogą zdefiniować funkcję ``maximize`` bez "
"zamieszania --- użytkownicy modułów muszą poprzedzić go nazwą modułu."

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 ""
"Nawiasem mówiąc, używam słowa *atrybut* dla każdej nazwy następującej po "
"kropce --- na przykład w wyrażeniu ``z.real``, ``real`` jest atrybutem "
"obiektu ``z``. Ściśle mówiąc, odniesienia do nazw w modułach są "
"odniesieniami atrybutowymi: w wyrażeniu ``modname.funcname``, ``modname`` "
"jest obiektem modułu, a ``funcname`` jest jego atrybutem. W tym przypadku "
"istnieje proste odwzorowanie między atrybutami modułu i nazwami globalnymi "
"zdefiniowanymi w module: mają tę samą przestrzeń nazw! [#]_"

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 ""
"Atrybuty mogą być tylko do odczytu lub zapisywalne. W tym drugim przypadku "
"możliwe jest przypisanie do atrybutu. Atrybuty modułu są zapisywalne: można "
"zapisać ``modname.the_answer = 42``.  Zapisywalne atrybuty można również "
"usunąć za pomocą instrukcji :keyword:`del`. Na przykład, ``del modname."
"the_answer`` usunie atrybut :attr:`!the_answer` z obiektu o nazwie "
"``modname``."

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 ""
"Przestrzenie nazw są tworzone w różnych momentach i mają różny czas życia. "
"Przestrzeń nazw zawierająca nazwy wbudowane jest tworzona podczas "
"uruchamiania interpretera Pythona i nigdy nie jest usuwana. Globalna "
"przestrzeń nazw dla modułu jest tworzona, gdy wczytywana jest definicja "
"modułu; zwykle przestrzenie nazw modułu również trwają do zakończenia "
"działania interpretera. Instrukcje wykonywane przez wywołanie interpretera "
"najwyższego poziomu, zarówno odczytane z pliku skryptu, jak i interaktywnie, "
"są uważane za część modułu o nazwie :mod:`__main__`, więc mają swoją własną "
"globalną przestrzeń nazw. (Nazwy wbudowane w rzeczywistości również znajdują "
"się w module; nazwany jest on :mod:`builtins`)."

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 ""
"Lokalna przestrzeń nazw dla funkcji jest tworzona przy wywołaniu funkcji i "
"usuwana, gdy funkcja zwraca wynik lub rzuca wyjątek, którego nie obsługuje. "
"(Właściwie, zapominanie byłoby lepszym słowem na opisanie tego, co "
"faktycznie się dzieje). Oczywiście, każde wywołanie rekurencyjne ma swoją "
"własną lokalną przestrzeń nazw."

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 ""
"*Zakres* to tekstowy obszar programu Python, w którym przestrzeń nazw jest "
"bezpośrednio dostępna. „Bezpośrednio dostępna” oznacza tutaj, że "
"niekwalifikowane odwołanie do nazwy próbuje znaleźć ją w przestrzeni nazw."

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 ""
"Chociaż zakresy są określane statycznie, są używane dynamicznie. Cały czas w "
"trakcie wykonywania programu istnieją 3 lub 4 zagnieżdżone zakresy, których "
"przestrzenie nazw są bezpośrednio dostępne:"

msgid "the innermost scope, which is searched first, contains the local names"
msgstr ""
"najbardziej wewnętrzny zakres, który jest przeszukiwany jako pierwszy, "
"zawiera nazwy lokalne"

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 ""
"zakresy wszystkich otaczających funkcji, które są przeszukiwane począwszy od "
"najbliższego otaczającego zakresu, zawierają nazwy nielokalne, ale także "
"nieglobalne"

msgid "the next-to-last scope contains the current module's global names"
msgstr "przedostatni zakres zawiera globalne nazwy bieżącego modułu"

msgid ""
"the outermost scope (searched last) is the namespace containing built-in "
"names"
msgstr ""
"najbardziej zewnętrznym zakresem (przeszukiwanym jako ostatni) jest "
"przestrzeń nazw zawierająca nazwy wbudowane"

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 ""
"Jeśli nazwa jest zadeklarowana jako globalna, wtedy wszystkie referencje i "
"przypisania przechodzą bezpośrednio do przedostatniego zakresu zawierającego "
"globalne nazwy modułu.  Aby ponownie powiązać zmienne znajdujące się poza "
"najbardziej wewnętrznym zakresem, można użyć instrukcji :keyword:`nonlocal`; "
"jeśli nie są zadeklarowane jako nielokalne, zmienne te są tylko do odczytu "
"(próba zapisu do takiej zmiennej po prostu utworzy *nową* zmienną lokalną w "
"najbardziej wewnętrznym zakresie, pozostawiając identycznie nazwaną zmienną "
"zewnętrzną bez zmian)."

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 ""
"Zazwyczaj zakres lokalny odwołuje się do nazw lokalnych (tekstowo) bieżącej "
"funkcji. Poza funkcjami, zakres lokalny odwołuje się do tej samej "
"przestrzeni nazw, co zakres globalny: przestrzeni nazw modułu. Definicje "
"klas umieszczają jeszcze jedną przestrzeń nazw w zakresie lokalnym."

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 ""
"Ważne jest, aby zdać sobie sprawę, że zakresy są określane tekstowo: "
"globalny zakres funkcji zdefiniowany w module jest przestrzenią nazw tego "
"modułu, bez względu na to, skąd lub przez jaki alias funkcja jest "
"wywoływana. Z drugiej strony, rzeczywiste wyszukiwanie nazw odbywa się "
"dynamicznie, w czasie wykonywania --- jednak definicja języka ewoluuje w "
"kierunku statycznego rozpoznawania nazw, w czasie „kompilacji”, więc nie "
"należy polegać na dynamicznym rozpoznawaniu nazw!  (W rzeczywistości zmienne "
"lokalne są już określane statycznie)."

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 ""
"Szczególnym dziwactwem Pythona jest to, że – jeśli nie działa instrukcja :"
"keyword:`global` lub :keyword:`nonlocal` – przypisanie do nazw zawsze trafia "
"do najbardziej wewnętrznego zakresu. Przypisania nie kopiują danych – po "
"prostu wiążą nazwy z obiektami. To samo dotyczy usuwania: instrukcja ``del "
"x`` usuwa wiązanie ``x`` z przestrzeni nazw, do której odwołuje się zakres "
"lokalny. W rzeczywistości wszystkie operacje, które wprowadzają nowe nazwy, "
"używają zakresu lokalnego: w szczególności instrukcje :keyword:`import` i "
"definicje funkcji wiążą nazwę modułu lub funkcji w zakresie lokalnym."

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 ""
"Instrukcja :keyword:`global` może być użyta do wskazania, że określone "
"zmienne znajdują się w zakresie globalnym i powinny być tam ponownie "
"wiązane; instrukcja :keyword:`nonlocal` wskazuje, że określone zmienne "
"znajdują się w zakresie otaczającym i powinny być tam ponownie wiązane."

msgid "Scopes and Namespaces Example"
msgstr "Przykład zakresów i przestrzeni nazw"

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 ""
"Oto przykład pokazujący, jak odwoływać się do różnych zakresów i przestrzeni "
"nazw oraz jak :keyword:`global` i :keyword:`nonlocal` wpływają na wiązanie "
"zmiennych::"

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 scope_test():\n"
"    def do_local():\n"
"        spam = \"lokalna konserwa\"\n"
"\n"
"    def do_nonlocal():\n"
"        nonlocal spam\n"
"        spam = \"nielokalna konserwa\"\n"
"\n"
"    def do_global():\n"
"        global spam\n"
"        spam = \"globalna konserwa\"\n"
"\n"
"    spam = \"testowa konserwa\"\n"
"    do_local()\n"
"    print(\"Po przypisaniu lokalnym:\", spam)\n"
"    do_nonlocal()\n"
"    print(\"Po przypisaniu nielokalnym:\", spam)\n"
"    do_global()\n"
"    print(\"Po przypisaniu globalnym:\", spam)\n"
"\n"
"scope_test()\n"
"print(\"W globalnym zakresie:\", spam)"

msgid "The output of the example code is:"
msgstr "Wyjście przykładowego kodu to:"

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 ""
"Po przypisaniu lokalnym: testowa konserwa\n"
"Po przypisaniu nielokalnym: nielokalna konserwa\n"
"Po przypisaniu globalnym: nielokalna konserwa\n"
"W globalnym zakresie: globalna konserwa"

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 ""
"Zauważ, że *lokalne* przypisanie (które jest domyślne) nie zmieniło wiązania "
"*spam* w *scope_test*. Przypisanie :keyword:`nonlocal`  zmieniło wiązanie "
"*spam* w *scope_test*, a przypisanie :keyword:`global` zmieniło wiązanie na "
"poziomie modułu."

msgid ""
"You can also see that there was no previous binding for *spam* before the :"
"keyword:`global` assignment."
msgstr ""
"Można również zauważyć, że nie było wcześniejszego powiązania dla *spam* "
"przed przypisaniem :keyword:`global`."

msgid "A First Look at Classes"
msgstr "Pierwsze spojrzenie na klasy"

msgid ""
"Classes introduce a little bit of new syntax, three new object types, and "
"some new semantics."
msgstr ""
"Klasy wprowadzają trochę nowej składni, trzy nowe typy obiektów i trochę "
"nowej semantyki."

msgid "Class Definition Syntax"
msgstr "Składnia definicji klasy"

msgid "The simplest form of class definition looks like this::"
msgstr "Najprostsza forma definicji klasy wygląda następująco::"

msgid ""
"class ClassName:\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"
msgstr ""
"class ClassName:\n"
"    <instrukcja-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <instrukcja-N>"

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 ""
"Definicje klas, podobnie jak definicje funkcji (instrukcje :keyword:`def`), "
"muszą zostać wykonane, zanim będą miały jakikolwiek efekt. (Można sobie "
"wyobrazić umieszczenie definicji klasy w gałęzi instrukcji :keyword:`if` lub "
"wewnątrz funkcji.)"

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 ""
"W praktyce, instrukcje wewnątrz definicji klasy będą zwykle definicjami "
"funkcji, ale inne instrukcje są dozwolone, a czasem przydatne --- wrócimy do "
"tego później. Definicje funkcji wewnątrz klasy zwykle mają specyficzną formę "
"listy argumentów, podyktowaną konwencjami wywoływania metod --- ponownie, "
"zostanie to wyjaśnione później."

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 ""
"Po wejściu w definicję klasy tworzona jest nowa przestrzeń nazw i używana "
"jako zakres lokalny --- a zatem wszystkie przypisania do zmiennych lokalnych "
"trafiają do tej nowej przestrzeni nazw. W szczególności, definicje funkcji "
"wiążą nazwę nowej funkcji w tej przestrzeni nazw."

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 ""
"Kiedy definicja klasy jest opuszczana normalnie (przez koniec), tworzony "
"jest *obiekt klasy*. Jest to w zasadzie opakowanie wokół zawartości "
"przestrzeni nazw utworzonej przez definicję klasy; dowiemy się więcej o "
"obiektach klas w następnej sekcji. Oryginalny zakres lokalny (ten, który "
"obowiązywał tuż przed wprowadzeniem definicji klasy) zostaje przywrócony, a "
"obiekt klasy jest powiązany z nazwą klasy podaną w nagłówku definicja klasy "
"(:class:`!ClassName` w przykładzie)."

msgid "Class Objects"
msgstr "Obiekty klas"

msgid ""
"Class objects support two kinds of operations: attribute references and "
"instantiation."
msgstr ""
"Obiekty klas obsługują dwa rodzaje operacji: odniesienia do atrybutów i "
"tworzenie instancji."

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 ""
"*Odniesienia do atrybutów* używają standardowej składni używanej dla "
"wszystkich odniesień do atrybutów w Pythonie: ``obj.name``.  Prawidłowe "
"nazwy atrybutów to wszystkie nazwy, które znajdowały się w przestrzeni nazw "
"klasy, gdy obiekt klasy został utworzony. Tak więc, jeśli definicja klasy "
"wyglądała tak::"

msgid ""
"class MyClass:\n"
"    \"\"\"A simple example class\"\"\"\n"
"    i = 12345\n"
"\n"
"    def f(self):\n"
"        return 'hello world'"
msgstr ""
"class MyClass:\n"
"    \"\"\"Prosta przykładowa klasa\"\"\"\n"
"    i = 12345\n"
"\n"
"    def f(self):\n"
"        return 'witaj świecie'"

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 ""
"wtedy ``MyClass.i`` i ``MyClass.f`` są poprawnymi odniesieniami do "
"atrybutów, zwracającymi odpowiednio liczbę całkowitą i funkcję. Do atrybutów "
"klasowych można również przypisywać wartości, więc można zmienić wartość "
"``MyClass.i`` przez przypisanie. :attr:`~type.__doc__` jest również "
"poprawnym atrybutem, zwracającym docstring należący do klasy: ``\"Prosta "
"przykładowa klasa\"``."

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 ""
"*Instancjonowanie* klasy używa notacji funkcji. Wystarczy wyobrazić sobie, "
"że obiekt klasy jest bezparametrową funkcją, która zwraca nową instancję "
"klasy. Na przykład (zakładając powyższą klasę)::"

msgid "x = MyClass()"
msgstr "x = MyClass()"

msgid ""
"creates a new *instance* of the class and assigns this object to the local "
"variable ``x``."
msgstr ""
"tworzy nową *instancję* klasy i przypisuje ten obiekt do zmiennej lokalnej "
"``x``."

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 ""
"Operacja instancjonowania („wywołanie” obiektu klasy) tworzy pusty obiekt. "
"Wiele klas lubi tworzyć obiekty z instancjami dostosowanymi do określonego "
"stanu początkowego. Dlatego klasa może zdefiniować specjalną metodę o "
"nazwie :meth:`~object.__init__`, taką jak ta::"

msgid ""
"def __init__(self):\n"
"    self.data = []"
msgstr ""
"def __init__(self):\n"
"    self.data = []"

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 ""
"Gdy klasa definiuje metodę :meth:`~object.__init__`, instancjonowanie klasy "
"automatycznie wywołuje :meth:`!__init__` dla nowo utworzonej instancji "
"klasy. Tak więc w tym przykładzie nową, zainicjalizowaną instancję można "
"uzyskać przez::"

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 ""
"Oczywiście metoda :meth:`~object.__init__` może mieć argumenty dla większej "
"elastyczności. W takim przypadku argumenty podane operatorowi "
"instancjonowania klasy są przekazywane do :meth:`!__init__`.  Na przykład ::"

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 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)"

msgid "Instance Objects"
msgstr "Obiekty instancji"

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 ""
"Co możemy zrobić z obiektami instancji? Jedynymi operacjami rozumianymi "
"przez obiekty instancji są odniesienia do atrybutów. Istnieją dwa rodzaje "
"poprawnych nazw atrybutów: atrybuty danych i metody."

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 ""
"*Atrybuty danych* odpowiadają „zmiennym instancji” w Smalltalku i "
"„składowym” w C++.  Atrybuty danych nie muszą być deklarowane; podobnie jak "
"zmienna lokalna, powstają, gdy zostaną po raz pierwszy przypisane. Na "
"przykład, jeśli ``x`` jest instancją :class:`!MyClass` utworzonej powyżej, "
"następujący fragment kodu wydrukuje wartość ``16``, bez pozostawiania śladu::"

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.counter = 1\n"
"while x.counter < 10:\n"
"    x.counter = x.counter * 2\n"
"print(x.counter)\n"
"del x.counter"

msgid ""
"The other kind of instance attribute reference is a *method*. A method is a "
"function that \"belongs to\" an object."
msgstr ""
"Innym rodzajem odniesienia do atrybutu instancji jest *metoda*. Metoda to "
"funkcja, która „należy” do obiektu."

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 ""
"Prawidłowe nazwy metod obiektu instancji zależą od jego klasy. Z definicji "
"wszystkie atrybuty klasy, które są obiektami funkcji definiują odpowiednie "
"metody jej instancji. Tak więc w naszym przykładzie, ``x.f`` jest poprawnym "
"odwołaniem do metody, ponieważ ``MyClass.f`` jest funkcją, ale ``x.i`` nie "
"jest, ponieważ ``MyClass.i`` nie jest.  Ale ``x.f`` nie jest tym samym co "
"``MyClass.f`` --- jest *obiektem metody*, a nie obiektem funkcji."

msgid "Method Objects"
msgstr "Obiekty metod"

msgid "Usually, a method is called right after it is bound::"
msgstr "Zazwyczaj metoda jest wywoływana zaraz po jej powiązaniu::"

msgid "x.f()"
msgstr "x.f()"

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 ""
"Jeśli ``x = MyClass()``, jak powyżej, powyższe zwróci napis ``'hello "
"world'`` . Nie jest jednak konieczne wywoływanie metody od razu: ``x.f`` "
"jest obiektem metody i może być przechowywany i wywoływany później.  Na "
"przykład::"

msgid ""
"xf = x.f\n"
"while True:\n"
"    print(xf())"
msgstr ""
"xf = x.f\n"
"while True:\n"
"    print(xf())"

msgid "will continue to print ``hello world`` until the end of time."
msgstr "będzie drukować  ``witaj świecie`` do końca czasu."

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 ""
"Co dokładnie dzieje się, gdy wywoływana jest metoda? Być może zauważyłeś(-"
"łaś), że powyżej ``x.f()`` została wywołana bez argumentu, mimo że definicja "
"funkcji dla :meth:`!f` określała argument. Co się stało z argumentem? Z "
"pewnością Python rzuca wyjątek, gdy funkcja, który wymaga argumentu jest "
"wywoływana bez żadnego --- nawet jeśli argument nie jest faktycznie używany…"

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 ""
"Właściwie, być może zgadłeś(-łaś) odpowiedź: szczególną rzeczą w metodach "
"jest to, że obiekt instancji jest przekazywany jako pierwszy argument "
"funkcji. W naszym przykładzie wywołanie ``x.f()`` jest dokładnie równoważne "
"wywołaniu ``MyClass.f(x)``. Ogólnie rzecz biorąc, wywołanie metody z listą "
"*n* argumentów jest równoważne wywołaniu odpowiedniej funkcji z listą "
"argumentów, która jest tworzona przez wstawienie obiektu instancji metody "
"przed pierwszym argumentem."

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 ""
"Ogólnie rzecz biorąc, metody działają w następujący sposób.  Gdy odwoływane "
"jest nie-dane atrybut instancji, wyszukiwana jest klasa instancji. Jeśli "
"nazwa wskazuje na prawidłową klasę atrybut, która jest obiektem funkcja, "
"odwołania zarówno do obiektu instancji, jak i obiektu funkcja są pakowane do "
"obiektu metody.  Gdy obiekt metody jest wywoływany z listą argument, nowa "
"lista argument jest konstruowana z  instancji obiektu i listy argument, a "
"obiekt funkcja jest wywoływany z tą nową listą argument."

msgid "Class and Instance Variables"
msgstr "Zmienne klas i instancji"

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 ""
"Ogólnie rzecz biorąc, zmienne instancji są dla danych unikalnych dla każdej "
"instancji, a zmienne klasy są dla atrybutów i metod współdzielonych przez "
"wszystkie instancje klasy::"

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 Dog:\n"
"\n"
"  kind = 'pies' # zmienna klasowa współdzielona przez wszystkie instancje\n"
"\n"
"  def __init__(self, name):\n"
"    self.name = name # zmienna instancji unikalna dla każdej instancji\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Zito')\n"
">>> d.kind # współdzielona przez wszystkie psy\n"
"'pies'\n"
">>> e.kind # współdzielona przez wszystkie psy\n"
"'pies'\n"
">>> d.name # unikalna dla d\n"
"'Fido'\n"
">>> e.name # unikalna dla e\n"
"'Zito'"

msgid ""
"As discussed in :ref:`tut-object`, shared data can have possibly surprising "
"effects involving :term:`mutable` objects such as lists and dictionaries. "
"For example, the *tricks* list in the following code should not be used as a "
"class variable because just a single list would be shared by all *Dog* "
"instances::"
msgstr ""
"Jak omówiono w :ref:`tut-object`, współdzielone dane mogą mieć zaskakujące "
"efekty z udziałem :term:`mutable` obiektów takich jak listy i słownik. Na "
"przykład, lista *tricks* w poniższym kodzie nie powinna być używana jako "
"zmienna klasowa, ponieważ tylko jedna lista byłaby współdzielona przez "
"wszystkie instancje klasy *Dog*::"

msgid ""
"class Dog:\n"
"\n"
"    tricks = []             # mistaken use of a class variable\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.add_trick('roll over')\n"
">>> e.add_trick('play dead')\n"
">>> d.tricks                # unexpectedly shared by all dogs\n"
"['roll over', 'play dead']"
msgstr ""
"class Dog:\n"
"\n"
"    tricks = []             # błędne użycie zmiennej klasowej\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.add_trick('przewróć się')\n"
">>> e.add_trick('udawaj martwego')\n"
">>> d.tricks                # nieoczekiwanie współdzielone przez wszystkie "
"psy\n"
"['przewróć się', 'udawaj martwego']"

msgid "Correct design of the class should use an instance variable instead::"
msgstr ""
"Prawidłowy projekt klasy powinien zamiast tego używać zmiennej instancji::"

msgid ""
"class Dog:\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"        self.tricks = []    # creates a new empty list for each dog\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.add_trick('roll over')\n"
">>> e.add_trick('play dead')\n"
">>> d.tricks\n"
"['roll over']\n"
">>> e.tricks\n"
"['play dead']"
msgstr ""
"class Dog:\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"        self.tricks = []    # tworzy nową pustą listę dla każdego psa\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Zito')\n"
">>> d.add_trick('przewróć się')\n"
">>> e.add_trick('udawaj martwego')\n"
">>> d.tricks\n"
"['przewróć się']\n"
">>> e.tricks\n"
"['udawaj martwego']"

msgid "Random Remarks"
msgstr "Uwagi losowe"

msgid ""
"If the same attribute name occurs in both an instance and in a class, then "
"attribute lookup prioritizes the instance::"
msgstr ""
"Jeśli ten sam atrybut występuje zarówno w instancji, jak i w klasie, wówczas "
"wyszukiwanie atrybut nadaje priorytet instancji::"

msgid ""
">>> class Warehouse:\n"
"...    purpose = 'storage'\n"
"...    region = 'west'\n"
"...\n"
">>> w1 = Warehouse()\n"
">>> print(w1.purpose, w1.region)\n"
"storage west\n"
">>> w2 = Warehouse()\n"
">>> w2.region = 'east'\n"
">>> print(w2.purpose, w2.region)\n"
"storage east"
msgstr ""
">>> class Magazyn:\n"
"...     cel = 'przechowywanie'\n"
"...     region = 'zachód'\n"
"...\n"
">>> m1 = Magazyn()\n"
">>> print(m1.cel, m1.region)\n"
"przechowywanie zachód\n"
">>> m2 = Magazyn()\n"
">>> m2.region = 'wschód'\n"
">>> print(m2.cel, m2.region)\n"
"przechowywanie wschód"

msgid ""
"Data attributes may be referenced by methods as well as by ordinary users "
"(\"clients\") of an object.  In other words, classes are not usable to "
"implement pure abstract data types.  In fact, nothing in Python makes it "
"possible to enforce data hiding --- it is all based upon convention.  (On "
"the other hand, the Python implementation, written in C, can completely hide "
"implementation details and control access to an object if necessary; this "
"can be used by extensions to Python written in C.)"
msgstr ""
"Do danych atrybut mogą odwoływać się zarówno metody, jak i zwykli "
"użytkownicy (\"klienci\") obiektu.  Innymi słowy, klasy nie nadają się do "
"implementacji czysto abstrakcyjnych typów danych.  W rzeczywistości nic w "
"Python nie umożliwia wymuszenia ukrywania danych --- wszystko opiera się na "
"konwencji.  (Z drugiej strony, implementacja Python, napisana w C, może "
"całkowicie ukryć szczegóły implementacji i kontrolować dostęp do obiektu, "
"jeśli to konieczne; może to być wykorzystane przez rozszerzenia Python "
"napisane w C)."

msgid ""
"Clients should use data attributes with care --- clients may mess up "
"invariants maintained by the methods by stamping on their data attributes.  "
"Note that clients may add data attributes of their own to an instance object "
"without affecting the validity of the methods, as long as name conflicts are "
"avoided --- again, a naming convention can save a lot of headaches here."