classes.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Igor Zubrycki <igorzubrycki@gmail.com>, 2021
# Tomasz Rodzen <t.rodzen@poczta.fm>, 2021
# haaritsubaki, 2023
# Rafael Fontenelle <rffontenelle@gmail.com>, 2024
# Stan Ulbrych, 2024
# Maciej Olko <maciej.olko@gmail.com>, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-04-18 14:18+0000\n"
"PO-Revision-Date: 2021-06-28 01:49+0000\n"
"Last-Translator: Maciej Olko <maciej.olko@gmail.com>, 2025\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 ""
"*Dane atrybut* odpowiadają \"zmiennym instancji\" i \"członkom danych\" w C+"
"+.  Dane atrybut nie muszą być deklarowane; podobnie jak zmienne lokalne, "
"powstają, gdy zostaną po raz pierwszy przypisane.  Na przykład, jeśli ``x`` "
"jest instancją :class:`!MyClass` utworzoną powyżej, poniższy 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 ""
"In the :class:`!MyClass` example, 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 ""
"W przykładzie :class:`!MyClass` będzie to zwracać 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ć  ``hello world`` 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ś, "
"że ``x.f()`` został wywołany bez argument powyżej, mimo że definicja funkcja "
"dla :meth:`!f` określała argument. Co się stało z argumentem? Z pewnością "
"Python rzucić wyjątek, gdy funkcja, który wymaga argument jest wywoływany "
"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ś odpowiedź: szczególną rzeczą w metodach jest to, "
"że obiekt instancji jest przekazywany jako pierwszy argument z funkcja. 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 jest równoważne wywołaniu odpowiedniej funkcja z listą argument, "
"która jest tworzona przez wstawienie obiektu instancji metody przed "
"pierwszym argument."

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 with 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 *sztuczki* 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."
msgstr ""
"Klienci powinni używać danych atrybut z ostrożnością --- klienci mogą zepsuć "
"niezmienniki utrzymywane przez metody poprzez stemplowanie ich danych "
"atrybut.  Należy pamiętać, że klienci mogą dodawać własne dane atrybut do "
"obiektu instancji bez wpływu na ważność metod, o ile unika się konfliktów "
"nazw --- ponownie, konwencja nazewnictwa może tutaj zaoszczędzić wiele "
"problemow."

msgid ""
"There is no shorthand for referencing data attributes (or other methods!) "
"from within methods.  I find that this actually increases the readability of "
"methods: there is no chance of confusing local variables and instance "
"variables when glancing through a method."
msgstr ""
"Nie ma skrótu do odwoływania się do danych atrybut (lub innych metod!) z "
"poziomu metod.  Uważam, że w rzeczywistości zwiększa to czytelność metod: "
"nie ma szans na pomylenie zmiennych lokalnych i zmiennych instancji podczas "
"przeglądania metody."

msgid ""
"Often, the first argument of a method is called ``self``.  This is nothing "
"more than a convention: the name ``self`` has absolutely no special meaning "
"to Python.  Note, however, that by not following the convention your code "
"may be less readable to other Python programmers, and it is also conceivable "
"that a *class browser* program might be written that relies upon such a "
"convention."
msgstr ""
"Często pierwsza argument metody jest nazywana ``self``.  Jest to nic więcej "
"niż konwencja: nazwa ``self`` nie ma absolutnie żadnego specjalnego "
"znaczenia dla Python. Należy jednak pamiętać, że nieprzestrzeganie tej "
"konwencji może sprawić, że kod będzie mniej czytelny dla innych programistów "
"Python, a także możliwe jest napisanie programu *przeglądarki klas*, który "
"opiera się na takiej konwencji."

msgid ""
"Any function object that is a class attribute defines a method for instances "
"of that class.  It is not necessary that the function definition is "
"textually enclosed in the class definition: assigning a function object to a "
"local variable in the class is also ok.  For example::"
msgstr ""
"Każdy obiekt funkcja będący klasą atrybut definiuje metodę dla instancji tej "
"klasy.  Nie jest konieczne, aby definicja funkcja była tekstowo zawarta w "
"definicja klasy: przypisanie obiektu funkcja do zmiennej lokalnej w klasie "
"jest również w porządku.  Na przykład::"

msgid ""
"# Function defined outside the class\n"
"def f1(self, x, y):\n"
"    return min(x, x+y)\n"
"\n"
"class C:\n"
"    f = f1\n"
"\n"
"    def g(self):\n"
"        return 'hello world'\n"
"\n"
"    h = g"
msgstr ""
"# funkcja zdefiniowane poza klasą\n"
"def f1(self, x, y):\n"
"    return min(x, x+y)\n"
"\n"
"class C:\n"
"    f = f1\n"
"\n"
"    def g(self):\n"
"        return 'hello world'\n"
"\n"
"    h = g"

msgid ""
"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`!C` that "
"refer to function objects, and consequently they are all methods of "
"instances of :class:`!C` --- ``h`` being exactly equivalent to ``g``.  Note "
"that this practice usually only serves to confuse the reader of a program."
msgstr ""
"Teraz ``f``, ``g`` i ``h`` są wszystkie atrybut klasy :class:`!C`, które "
"odnoszą się do obiektów funkcja, a w konsekwencji wszystkie są metodami "
"instancji :class:`!C` --- ``h`` jest dokładnie równoważne ``g``. Zauważ, że "
"ta praktyka zwykle służy jedynie do zmylenia czytelnika programu."

msgid ""
"Methods may call other methods by using method attributes of the ``self`` "
"argument::"
msgstr ""
"Metody mogą wywoływać inne metody przy użyciu metody atrybut z ``self`` "
"argument ::"

msgid ""
"class Bag:\n"
"    def __init__(self):\n"
"        self.data = []\n"
"\n"
"    def add(self, x):\n"
"        self.data.append(x)\n"
"\n"
"    def addtwice(self, x):\n"
"        self.add(x)\n"
"        self.add(x)"
msgstr ""
"class Torba:\n"
"    def __init__(self):\n"
"        self.dane = []\n"
"\n"
"    def dodac(self, x):\n"
"        self.dane.append(x)\n"
"\n"
"    def  dodacDwaRazy(self, x):\n"
"        self.dodac(x)\n"
"        self.dodac(x)"

msgid ""
"Methods may reference global names in the same way as ordinary functions.  "
"The global scope associated with a method is the module containing its "
"definition.  (A class is never used as a global scope.)  While one rarely "
"encounters a good reason for using global data in a method, there are many "
"legitimate uses of the global scope: for one thing, functions and modules "
"imported into the global scope can be used by methods, as well as functions "
"and classes defined in it.  Usually, the class containing the method is "
"itself defined in this global scope, and in the next section we'll find some "
"good reasons why a method would want to reference its own class."
msgstr ""
"Metody mogą odwoływać się do nazw globalnych w taki sam sposób jak zwykłe "
"funkcje.  Zakres globalny powiązany z metodą to moduł zawierający jej "
"definicję.  (Klasa nigdy nie jest używana jako zakres globalny.) Podczas gdy "
"rzadko można napotkać dobry powód do używania danych globalnych w metodzie, "
"istnieje wiele uzasadnionych zastosowań zakresu globalnego: po pierwsze, "
"funkcja i moduł importowane do zakresu globalnego mogą być używane przez "
"metody, a także funkcja i klasy w nim zdefiniowane.  Zazwyczaj klasa "
"zawierająca metodę sama jest zdefiniowana w tym globalnym zakresie, a w "
"następnej sekcji znajdziemy kilka dobrych powodów, dla których metoda "
"chciałaby odwoływać się do własnej klasy."

msgid ""
"Each value is an object, and therefore has a *class* (also called its "
"*type*). It is stored as ``object.__class__``."
msgstr ""
"Każda wartość jest obiektem, a zatem ma *klasę* (zwaną również *typem*). "
"Jest ona przechowywana jako ``object.__class__``."

msgid "Inheritance"
msgstr "Dziedziczenie"

msgid ""
"Of course, a language feature would not be worthy of the name \"class\" "
"without supporting inheritance.  The syntax for a derived class definition "
"looks like this::"
msgstr ""
"Oczywiście funkcja językowa nie byłaby godna nazwy \"klasa\" bez obsługi "
"dziedziczenia.  Składnia pochodnej definicja klasy wygląda tak::"

msgid ""
"class DerivedClassName(BaseClassName):\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"
msgstr ""
"class DerivedClassName(BaseClassName):\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"

msgid ""
"The name :class:`!BaseClassName` must be defined in a namespace accessible "
"from the scope containing the derived class definition.  In place of a base "
"class name, other arbitrary expressions are also allowed.  This can be "
"useful, for example, when the base class is defined in another module::"
msgstr ""
"Nazwa :class:`!BaseClassName` musi być zdefiniowana w przestrzeni nazw "
"dostępnej z zakresu zawierającego pochodną definicja klasy.  Zamiast nazwy "
"klasa bazowa dozwolone są również inne dowolne wyrażenia.  Może to być "
"przydatne, na przykład, gdy klasa bazowa jest zdefiniowany w innym moduł::"

msgid "class DerivedClassName(modname.BaseClassName):"
msgstr "class DerivedClassName(modname.BaseClassName):"

msgid ""
"Execution of a derived class definition proceeds the same as for a base "
"class. When the class object is constructed, the base class is remembered.  "
"This is used for resolving attribute references: if a requested attribute is "
"not found in the class, the search proceeds to look in the base class.  This "
"rule is applied recursively if the base class itself is derived from some "
"other class."
msgstr ""
"Wykonanie pochodnej definicja klasy przebiega tak samo, jak w przypadku "
"klasa bazowa. Gdy konstruowany jest obiekt klasy, zapamiętywany jest klasa "
"bazowa.  Jest to wykorzystywane do rozwiązywania referencji atrybut: jeśli "
"żądany atrybut nie zostanie znaleziony w klasie, wyszukiwanie jest "
"kontynuowane w klasie bazowej. Ta reguła jest stosowana rekurencyjnie, jeśli "
"sama klasa bazowa jest pochodną innej klasy."

msgid ""
"There's nothing special about instantiation of derived classes: "
"``DerivedClassName()`` creates a new instance of the class.  Method "
"references are resolved as follows: the corresponding class attribute is "
"searched, descending down the chain of base classes if necessary, and the "
"method reference is valid if this yields a function object."
msgstr ""
"Nie ma nic specjalnego w instancjonowaniu klas pochodnych: "
"``DerivedClassName()`` tworzy nową instancję klasy.  Odniesienia do metod są "
"rozwiązywane w następujący sposób: odpowiednia klasa atrybut jest "
"przeszukiwana, w razie potrzeby schodząc w dół łańcucha klas bazowych, a "
"odniesienie do metody jest ważne, jeśli daje to obiekt funkcja."

msgid ""
"Derived classes may override methods of their base classes.  Because methods "
"have no special privileges when calling other methods of the same object, a "
"method of a base class that calls another method defined in the same base "
"class may end up calling a method of a derived class that overrides it.  "
"(For C++ programmers: all methods in Python are effectively ``virtual``.)"
msgstr ""
"Klasy pochodne mogą nadpisywać metody swoich klas bazowych.  Ponieważ metody "
"nie mają specjalnych przywilejów podczas wywoływania innych metod tego "
"samego obiektu, metoda klasa bazowa, która wywołuje inną metodę zdefiniowaną "
"w tym samym klasa bazowa może skończyć się wywołaniem metody klasy "
"pochodnej, która ją nadpisuje.  (Dla programistów C++: wszystkie metody w "
"Python są efektywnie ``virtual``)."

msgid ""
"An overriding method in a derived class may in fact want to extend rather "
"than simply replace the base class method of the same name. There is a "
"simple way to call the base class method directly: just call ``BaseClassName."
"methodname(self, arguments)``.  This is occasionally useful to clients as "
"well.  (Note that this only works if the base class is accessible as "
"``BaseClassName`` in the global scope.)"
msgstr ""
"Metoda nadrzędna w klasie pochodnej może w rzeczywistości chcieć rozszerzyć, "
"a nie tylko zastąpić metodę klasa bazowa o tej samej nazwie. Istnieje prosty "
"sposób na bezpośrednie wywołanie metody klasa bazowa: wystarczy wywołać "
"``BaseClassName.methodname(self, arguments)``.  Jest to czasami przydatne "
"również dla klientów.  (Należy pamiętać, że działa to tylko wtedy, gdy klasa "
"bazowa jest dostępna jako ``BaseClassName`` w zakresie globalnym)."

msgid "Python has two built-in functions that work with inheritance:"
msgstr "Python ma dwa wbudowane funkcje, które pracuja z dziedziczeniem:"

msgid ""
"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` "
"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "
"derived from :class:`int`."
msgstr ""
"Użyj :func:`isinstance` do sprawdzenia typu instancji: ``isinstance(obj, "
"int)`` będzie ``True`` tylko wtedy, gdy ``obj.__class__`` jest :class:`int` "
"lub jakąś klasą pochodną od :class:`int`."

msgid ""
"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "
"is ``True`` since :class:`bool` is a subclass of :class:`int`.  However, "
"``issubclass(float, int)`` is ``False`` since :class:`float` is not a "
"subclass of :class:`int`."
msgstr ""
"Użyj :func:`issubclass` do sprawdzenia dziedziczenia klas: "
"``issubclass(bool, int)`` jest ``True``, ponieważ :class:`bool` jest "
"podklasa z :class:`int`. Jednak ``issubclass(float, int)`` jest ``False``, "
"ponieważ :class:`float` nie jest podklasa z :class:`int`."

msgid "Multiple Inheritance"
msgstr "Dziedziczenie wielokrotne"

msgid ""
"Python supports a form of multiple inheritance as well.  A class definition "
"with multiple base classes looks like this::"
msgstr ""
"Python obsługuje również dziedziczenie wielokrotne.  Strona definicja klasy "
"z wieloma klasami bazowymi wygląda tak::"

msgid ""
"class DerivedClassName(Base1, Base2, Base3):\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"
msgstr ""
"class NazwaKlasyPochodnej(Baza1, Baza2, Baza3):\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"

msgid ""
"For most purposes, in the simplest cases, you can think of the search for "
"attributes inherited from a parent class as depth-first, left-to-right, not "
"searching twice in the same class where there is an overlap in the "
"hierarchy. Thus, if an attribute is not found in :class:`!DerivedClassName`, "
"it is searched for in :class:`!Base1`, then (recursively) in the base "
"classes of :class:`!Base1`, and if it was not found there, it was searched "
"for in :class:`!Base2`, and so on."
msgstr ""
"Dla większości celów, w najprostszych przypadkach, można myśleć o "
"wyszukiwaniu atrybut odziedziczonym po klasie nadrzędnej jako o wyszukiwaniu "
"w głąb, od lewej do prawej, nie szukając dwa razy w tej samej klasie, gdy "
"hierarchia się pokrywa. Tak więc, jeśli atrybut nie zostanie znaleziony w :"
"class:`!DerivedClassName`, jest szukany w :class:`!Base1`, a następnie "
"(rekurencyjnie) w klasach bazowych :class:`!Base1`, a jeśli nie zostanie tam "
"znaleziony, jest szukany w :class:`!Base2` i tak dalej."

msgid ""
"In fact, it is slightly more complex than that; the method resolution order "
"changes dynamically to support cooperative calls to :func:`super`.  This "
"approach is known in some other multiple-inheritance languages as call-next-"
"method and is more powerful than the super call found in single-inheritance "
"languages."
msgstr ""
"W rzeczywistości jest to nieco bardziej skomplikowane; kolejność "
"rozwiązywania metod zmienia się dynamicznie, aby wspierać kooperacyjne "
"wywołania :func:`super`. Podejście to jest znane w niektórych innych "
"językach wielokrotnego dziedziczenia jako call-next-method i jest bardziej "
"wydajne niż super wywołanie występujące w językach pojedynczego "
"dziedziczenia."

msgid ""
"Dynamic ordering is necessary because all cases of multiple inheritance "
"exhibit one or more diamond relationships (where at least one of the parent "
"classes can be accessed through multiple paths from the bottommost class).  "
"For example, all classes inherit from :class:`object`, so any case of "
"multiple inheritance provides more than one path to reach :class:`object`.  "
"To keep the base classes from being accessed more than once, the dynamic "
"algorithm linearizes the search order in a way that preserves the left-to-"
"right ordering specified in each class, that calls each parent only once, "
"and that is monotonic (meaning that a class can be subclassed without "
"affecting the precedence order of its parents). Taken together, these "
"properties make it possible to design reliable and extensible classes with "
"multiple inheritance.  For more detail, see :ref:`python_2.3_mro`."
msgstr ""
"Dynamiczne porządkowanie jest konieczne, ponieważ wszystkie przypadki "
"wielokrotnego dziedziczenia wykazują jedną lub więcej relacji diamentowych "
"(w których co najmniej jedna z klas nadrzędnych może być dostępna poprzez "
"wiele ścieżek z najniższej klasy).  Na przykład, wszystkie klasy dziedziczą "
"z :class:`object`, więc każdy przypadek wielokrotnego dziedziczenia zapewnia "
"więcej niż jedną ścieżkę dostępu do :class:`object`.  Aby zapobiec "
"wielokrotnemu dostępowi do klas bazowych, algorytm dynamiczny linearyzuje "
"kolejność wyszukiwania w sposób, który zachowuje kolejność od lewej do "
"prawej określoną w każdej klasie, która wywołuje każdego rodzica tylko raz i "
"która jest monotoniczna (co oznacza, że klasa może być podklasowana bez "
"wpływu na kolejność pierwszeństwa jej rodziców). Łącznie właściwości te "
"umożliwiają projektowanie niezawodnych i rozszerzalnych klas z wielokrotnym "
"dziedziczeniem.  Więcej szczegółów można znaleźć na stronie :ref:"
"`python_2.3_mro`."

msgid "Private Variables"
msgstr "Zmienne prywatne"

msgid ""
"\"Private\" instance variables that cannot be accessed except from inside an "
"object don't exist in Python.  However, there is a convention that is "
"followed by most Python code: a name prefixed with an underscore (e.g. "
"``_spam``) should be treated as a non-public part of the API (whether it is "
"a function, a method or a data member).  It should be considered an "
"implementation detail and subject to change without notice."
msgstr ""
"\"Prywatne\" zmienne instancje, do których nie można uzyskać dostępu inaczej "
"niż z wnętrza obiektu, nie istnieją w Python. Istnieje jednak konwencja, "
"której przestrzega większość kodu Python: nazwa poprzedzona podkreśleniem "
"(np. ``_spam``) powinna być traktowana jako niepubliczna część API "
"(niezależnie od tego, czy jest to funkcja, metoda czy członek danych).  "
"Należy ją traktować jako szczegół implementacji i może ona ulec zmianie bez "
"powiadomienia."

msgid ""
"Since there is a valid use-case for class-private members (namely to avoid "
"name clashes of names with names defined by subclasses), there is limited "
"support for such a mechanism, called :dfn:`name mangling`.  Any identifier "
"of the form ``__spam`` (at least two leading underscores, at most one "
"trailing underscore) is textually replaced with ``_classname__spam``, where "
"``classname`` is the current class name with leading underscore(s) "
"stripped.  This mangling is done without regard to the syntactic position of "
"the identifier, as long as it occurs within the definition of a class."
msgstr ""
"Ponieważ istnieje uzasadniony przypadek użycia dla członków klasy-prywatnej "
"(mianowicie, aby uniknąć kolizji nazw z nazwami zdefiniowanymi przez "
"podklasa), istnieje ograniczone wsparcie dla takiego mechanizmu, zwanego :"
"dfn:`name mangling`.  Każdy identyfikator w postaci ``__spam`` (co najmniej "
"dwa początkowe podkreślenia, co najwyżej jedno końcowe podkreślenie) jest "
"tekstowo zastępowany przez ``_classname__spam``, gdzie ``classname`` jest "
"bieżącą nazwą klasy z usuniętymi początkowymi podkreśleniami.  Zamiana ta "
"jest wykonywana bez względu na pozycję składniową identyfikatora, o ile "
"występuje on w definicji klasy."

msgid ""
"The :ref:`private name mangling specifications <private-name-mangling>` for "
"details and special cases."
msgstr ""
"Szczegółowe informacje i przypadki specjalne znajdują się w specyfikacji :"
"ref:`private name mangling <private-name-mangling>`."

msgid ""
"Name mangling is helpful for letting subclasses override methods without "
"breaking intraclass method calls.  For example::"
msgstr ""
"Manipulowanie nazwami jest pomocne w umożliwieniu podklasa nadpisywania "
"metod bez przerywania wywołań metod wewnątrzklasowych.  Na przykład::"

msgid ""
"class Mapping:\n"
"    def __init__(self, iterable):\n"
"        self.items_list = []\n"
"        self.__update(iterable)\n"
"\n"
"    def update(self, iterable):\n"
"        for item in iterable:\n"
"            self.items_list.append(item)\n"
"\n"
"    __update = update   # private copy of original update() method\n"
"\n"
"class MappingSubclass(Mapping):\n"
"\n"
"    def update(self, keys, values):\n"
"        # provides new signature for update()\n"
"        # but does not break __init__()\n"
"        for item in zip(keys, values):\n"
"            self.items_list.append(item)"
msgstr ""
"class Mapping:\n"
"    def __init__(self, iterable):\n"
"        self.przedmiot_lista = []\n"
"        self.__update(iterable)\n"
"\n"
"    def update(self, iterable):\n"
"        for przedmiot in iterable:\n"
"            self.przedmiot_lista.append(przedmiot)\n"
"\n"
"    __update = update # prywatna kopia oryginalnej metody update()\n"
"\n"
"class MappingSubklasa(Mapping):\n"
"\n"
"    def update(self, keys, values):\n"
"        # zapewnia nową sygnaturę dla update()\n"
"        # ale nie przerywa __init__()\n"
"        for item in zip(keys, values):\n"
"            self.items_list.append(item)"

msgid ""
"The above example would work even if ``MappingSubclass`` were to introduce a "
"``__update`` identifier since it is replaced with ``_Mapping__update`` in "
"the ``Mapping`` class  and ``_MappingSubclass__update`` in the "
"``MappingSubclass`` class respectively."
msgstr ""
"Powyższy przykład zadziała nawet wtedy, gdy ``MappingSubclass`` wprowadzi "
"identyfikator ``__update``, ponieważ zostanie on zastąpiony odpowiednio "
"``_Mapping__update`` w klasie ``Mapping`` i ``_MappingSubclass__update`` w "
"klasie ``MappingSubclass``."

msgid ""
"Note that the mangling rules are designed mostly to avoid accidents; it "
"still is possible to access or modify a variable that is considered "
"private.  This can even be useful in special circumstances, such as in the "
"debugger."
msgstr ""
"Należy pamiętać, że reguły mieszania zostały zaprojektowane głównie w celu "
"uniknięcia wypadków; nadal możliwy jest dostęp lub modyfikacja zmiennej, "
"która jest uważana za prywatną.  Może to być nawet przydatne w szczególnych "
"okolicznościach, takich jak debugger."

msgid ""
"Notice that code passed to ``exec()`` or ``eval()`` does not consider the "
"classname of the invoking class to be the current class; this is similar to "
"the effect of the ``global`` statement, the effect of which is likewise "
"restricted to code that is byte-compiled together.  The same restriction "
"applies to ``getattr()``, ``setattr()`` and ``delattr()``, as well as when "
"referencing ``__dict__`` directly."
msgstr ""
"Zauważ, że kod przekazany do ``exec()`` lub ``eval()`` nie uważa nazwy klasy "
"wywołującej za bieżącą klasę; jest to podobne do efektu ``global`` "
"instrukcja , którego efekt jest również ograniczony do kodu, który jest "
"kompilowany bajtowo.  To samo ograniczenie dotyczy ``getattr()``, "
"``setattr()`` i ``delattr()``, a także bezpośredniego odwoływania się do "
"``__dict__``."

msgid "Odds and Ends"
msgstr "Przypadki losowe"

msgid ""
"Sometimes it is useful to have a data type similar to the Pascal \"record\" "
"or C \"struct\", bundling together a few named data items. The idiomatic "
"approach is to use :mod:`dataclasses` for this purpose::"
msgstr ""
"Czasami przydatne jest posiadanie typu danych podobnego do \"rekordu\" "
"Pascala lub \"struktury\" C, łączącego kilka nazwanych elementów danych. "
"Idiomatycznym podejściem jest użycie w tym celu :mod:`dataclasses`::"

msgid ""
"from dataclasses import dataclass\n"
"\n"
"@dataclass\n"
"class Employee:\n"
"    name: str\n"
"    dept: str\n"
"    salary: int"
msgstr ""
"from dataclasses import dataclass\n"
"\n"
"@dataclass\n"
"class Pracownik:\n"
"    imie: str\n"
"    dzial: str\n"
"    pensja: int"

msgid ""
">>> john = Employee('john', 'computer lab', 1000)\n"
">>> john.dept\n"
"'computer lab'\n"
">>> john.salary\n"
"1000"
msgstr ""
">>> stanislaw = Pracownik('stanislaw', 'pracownia komputerowa, 1000)\n"
">>> stanislaw.dzial\n"
"'pracownia komputerowa'\n"
">>> stanislaw.pensja\n"
"1000"

msgid ""
"A piece of Python code that expects a particular abstract data type can "
"often be passed a class that emulates the methods of that data type "
"instead.  For instance, if you have a function that formats some data from a "
"file object, you can define a class with methods :meth:`~io.TextIOBase.read` "
"and :meth:`~io.TextIOBase.readline` that get the data from a string buffer "
"instead, and pass it as an argument."
msgstr ""
"Fragment kodu Python, który oczekuje określonego abstrakcyjnego typu danych, "
"może często zostać przekazany klasie, która emuluje metody tego typu "
"danych.  Na przykład, jeśli masz klasę funkcja, która formatuje pewne dane z "
"obiektu pliku, możesz zdefiniować klasę z metodami :meth:`~io.TextIOBase."
"read` i :meth:`~io.TextIOBase.readline`, które pobierają dane z bufora napis "
"i przekazują je jako argument."

msgid ""
":ref:`Instance method objects <instance-methods>` have attributes, too: :"
"attr:`m.__self__ <method.__self__>` is the instance object with the method :"
"meth:`!m`, and :attr:`m.__func__ <method.__func__>` is the :ref:`function "
"object <user-defined-funcs>` corresponding to the method."
msgstr ""
":ref:`Obiekty metod instancji <instance-methods>` także mają atrybuty: :attr:"
"`m.__self__ <method.__self__>` jest obiektem instancji z metodą :meth:`!m`, "
"i :attr:`m.__func__ <method.__func__>` jest :ref:`obiektem funkcji <user-"
"defined-funcs>` odpowiadającym metodzie."

msgid "Iterators"
msgstr "Iteratory"

msgid ""
"By now you have probably noticed that most container objects can be looped "
"over using a :keyword:`for` statement::"
msgstr ""
"Prawdopodobnie zauważyłeś już, że większość obiektów kontenera  można "
"iterować za pomocą :keyword:`for` instrukcja ::"

msgid ""
"for element in [1, 2, 3]:\n"
"    print(element)\n"
"for element in (1, 2, 3):\n"
"    print(element)\n"
"for key in {'one':1, 'two':2}:\n"
"    print(key)\n"
"for char in \"123\":\n"
"    print(char)\n"
"for line in open(\"myfile.txt\"):\n"
"    print(line, end='')"
msgstr ""
"for element in [1, 2, 3]:\n"
"    print(element)\n"
"for element in (1, 2, 3):\n"
"    print(element)\n"
"for key in {'one':1, 'two':2}:\n"
"    print(key)\n"
"for char in \"123\":\n"
"    print(char)\n"
"for line in open(\"mojplik.txt\"):\n"
"    print(line, end='')"

msgid ""
"This style of access is clear, concise, and convenient.  The use of "
"iterators pervades and unifies Python.  Behind the scenes, the :keyword:"
"`for` statement calls :func:`iter` on the container object.  The function "
"returns an iterator object that defines the method :meth:`~iterator."
"__next__` which accesses elements in the container one at a time.  When "
"there are no more elements, :meth:`~iterator.__next__` raises a :exc:"
"`StopIteration` exception which tells the :keyword:`!for` loop to "
"terminate.  You can call the :meth:`~iterator.__next__` method using the :"
"func:`next` built-in function; this example shows how it all works::"
msgstr ""
"Ten styl dostępu jest jasny, zwięzły i wygodny.  Użycie iterators przenika i "
"ujednolica Python.  Za kulisami, :keyword:`for` instrukcja wywołuje :func:"
"`iter` na obiekcie kontenera.  Obiekt funkcja zwracać i iterator definiują "
"metodę :meth:`~iterator.__next__`, która uzyskuje dostęp do elementów w "
"kontenerze jeden po drugim.  Gdy nie ma więcej elementów, :meth:`~iterator."
"__next__` rzucić wyjątek :exc:`StopIteration`, który informuje pętlę :"
"keyword:`!for` o zakończeniu.  Metodę :meth:`~iterator.__next__` można "
"wywołać za pomocą :func:`next` wbudowanej funkcja; ten przykład pokazuje, "
"jak to wszystko działa::"

msgid ""
">>> s = 'abc'\n"
">>> it = iter(s)\n"
">>> it\n"
"<str_iterator object at 0x10c90e650>\n"
">>> next(it)\n"
"'a'\n"
">>> next(it)\n"
"'b'\n"
">>> next(it)\n"
"'c'\n"
">>> next(it)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    next(it)\n"
"StopIteration"
msgstr ""
">>> s = 'abc'\n"
">>> it = iter(s)\n"
">>> it\n"
"<str_iterator object at 0x10c90e650>\n"
">>> next(it)\n"
"'a'\n"
">>> next(it)\n"
"'b'\n"
">>> next(it)\n"
"'c'\n"
">>> next(it)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    next(it)\n"
"StopIteration"

msgid ""
"Having seen the mechanics behind the iterator protocol, it is easy to add "
"iterator behavior to your classes.  Define an :meth:`~container.__iter__` "
"method which returns an object with a :meth:`~iterator.__next__` method.  If "
"the class defines :meth:`!__next__`, then :meth:`!__iter__` can just return "
"``self``::"
msgstr ""
"Po zapoznaniu się z mechaniką stojącą za protokołem iterator, łatwo jest "
"dodać iterator zachowanie do swoich klas.  Zdefiniuj metodę :meth:"
"`~container.__iter__`, która zwracać obiekt z metodą :meth:`~iterator."
"__next__`.  Jeśli klasa definiuje :meth:`!__next__`, to :meth:`!__iter__` "
"może po prostu zwracać ``self`` ::"

msgid ""
"class Reverse:\n"
"    \"\"\"Iterator for looping over a sequence backwards.\"\"\"\n"
"    def __init__(self, data):\n"
"        self.data = data\n"
"        self.index = len(data)\n"
"\n"
"    def __iter__(self):\n"
"        return self\n"
"\n"
"    def __next__(self):\n"
"        if self.index == 0:\n"
"            raise StopIteration\n"
"        self.index = self.index - 1\n"
"        return self.data[self.index]"
msgstr ""
"class Reverse:\n"
"    \"\"\"iterator do zapętlania sekwencji wstecz. \"\"\"\n"
"    def __init__(self, dane):\n"
"        self.dane = dane\n"
"        self.indeks = len(dane)\n"
"\n"
"    def __iter__(self):\n"
"        return self\n"
"\n"
"    def __next__(self):\n"
"        if self.indeks == 0:\n"
"            raise StopIteration\n"
"        self.indeks = self.indeks - 1\n"
"        return self.data[self.indeks]"

msgid ""
">>> rev = Reverse('spam')\n"
">>> iter(rev)\n"
"<__main__.Reverse object at 0x00A1DB50>\n"
">>> for char in rev:\n"
"...     print(char)\n"
"...\n"
"m\n"
"a\n"
"p\n"
"s"
msgstr ""
">>> rev = Reverse('spam')\n"
">>> iter(rev)\n"
"<__main__.Reverse object at 0x00A1DB50>\n"
">>> for char in rev:\n"
"... print(char)\n"
"...\n"
"m\n"
"a\n"
"p\n"
"s"

msgid "Generators"
msgstr "Generatory"

msgid ""
":term:`Generators <generator>` are a simple and powerful tool for creating "
"iterators.  They are written like regular functions but use the :keyword:"
"`yield` statement whenever they want to return data.  Each time :func:`next` "
"is called on it, the generator resumes where it left off (it remembers all "
"the data values and which statement was last executed).  An example shows "
"that generators can be trivially easy to create::"
msgstr ""
":term:`Generatory <generator>` są prostym i potężnym narzędziem do tworzenia "
"iteratorów.  Są one pisane jak zwykłe funkcje, ale używają instrukcji :"
"keyword:`yield` za każdym razem, gdy chcą zwracać dane.  Za każdym razem, "
"gdy :func:`next` jest na nim wywoływany, generator wznawia działanie od "
"miejsca, w którym zostało przerwane (pamięta wszystkie wartości danych i "
"które instrukcje było ostatnio wykonywane). Przykład pokazuje, że tworzenie "
"generatorów może być banalnie proste::"

msgid ""
"def reverse(data):\n"
"    for index in range(len(data)-1, -1, -1):\n"
"        yield data[index]"
msgstr ""
"def reverse(dane):\n"
"    for indeks in range(len(dane)-1, -1, -1):\n"
"        yield dane[indeks]"

msgid ""
">>> for char in reverse('golf'):\n"
"...     print(char)\n"
"...\n"
"f\n"
"l\n"
"o\n"
"g"
msgstr ""
">>> for char in reverse('golf'):\n"
"...     print(char)\n"
"...\n"
"f\n"
"l\n"
"o\n"
"g"

msgid ""
"Anything that can be done with generators can also be done with class-based "
"iterators as described in the previous section.  What makes generators so "
"compact is that the :meth:`~iterator.__iter__` and :meth:`~generator."
"__next__` methods are created automatically."
msgstr ""
"Wszystko, co można zrobić za pomocą generatorów, można również zrobić za "
"pomocą iteratorów opartych na klasach, jak opisano w poprzedniej sekcji.  "
"Kompaktowość generatorów polega na tym, że metody :meth:`~iterator.__iter__` "
"i :meth:`~generator.__next__` są tworzone automatycznie."

msgid ""
"Another key feature is that the local variables and execution state are "
"automatically saved between calls.  This made the function easier to write "
"and much more clear than an approach using instance variables like ``self."
"index`` and ``self.data``."
msgstr ""
"Inną kluczową cechą jest to, że zmienne lokalne i stan wykonania są "
"automatycznie zapisywane między wywołaniami.  Sprawia to, że funkcja jest "
"łatwiejszy do napisania i znacznie bardziej przejrzysty niż podejście "
"wykorzystujące zmienne instancji, takie jak ``self.index`` i ``self.data``."

msgid ""
"In addition to automatic method creation and saving program state, when "
"generators terminate, they automatically raise :exc:`StopIteration`. In "
"combination, these features make it easy to create iterators with no more "
"effort than writing a regular function."
msgstr ""
"Oprócz automatycznego tworzenia metod i zapisywania stanu programu, po "
"zakończeniu generatory automatycznie rzucić :exc:`StopIteration` . W "
"połączeniu, funkcje te ułatwiają tworzenie iteratorów bez większego wysiłku "
"niż napisanie zwykłego funkcja."

msgid "Generator Expressions"
msgstr "generator wyrażenia"

msgid ""
"Some simple generators can be coded succinctly as expressions using a syntax "
"similar to list comprehensions but with parentheses instead of square "
"brackets. These expressions are designed for situations where the generator "
"is used right away by an enclosing function.  Generator expressions are more "
"compact but less versatile than full generator definitions and tend to be "
"more memory friendly than equivalent list comprehensions."
msgstr ""
"Niektóre proste generatory mogą być kodowane w zwięzły sposób jako wyrażenia "
"przy użyciu składni podobnej do list comprehensions, ale z nawiasami zamiast "
"nawiasów kwadratowych. Wyrażenia te są przeznaczone do sytuacji, w których "
"generator jest używane od razu przez otaczającą je funkcja. Wyrażenia "
"generator są bardziej zwięzłe, ale mniej wszechstronne niż pełne definicje "
"generator i zwykle są bardziej przyjazne dla pamięci niż równoważne "
"wyrażenia listowe."

msgid "Examples::"
msgstr "Przykłady::"

msgid ""
">>> sum(i*i for i in range(10))                 # sum of squares\n"
"285\n"
"\n"
">>> xvec = [10, 20, 30]\n"
">>> yvec = [7, 5, 3]\n"
">>> sum(x*y for x,y in zip(xvec, yvec))         # dot product\n"
"260\n"
"\n"
">>> unique_words = set(word for line in page  for word in line.split())\n"
"\n"
">>> valedictorian = max((student.gpa, student.name) for student in "
"graduates)\n"
"\n"
">>> data = 'golf'\n"
">>> list(data[i] for i in range(len(data)-1, -1, -1))\n"
"['f', 'l', 'o', 'g']"
msgstr ""
">>> sum(i*i for i in range(10))                 # suma kwadratów\n"
"285\n"
"\n"
">>> xvec = [10, 20, 30]\n"
">>> yvec = [7, 5, 3]\n"
">>> sum(x*y for x,y in zip(xvec, yvec))         # iloczyn skalarny\n"
"260\n"
"\n"
">>> unique_words = set(word for line in page for word in line.split())\n"
"\n"
">>> valedictorian = max((student.gpa, student.name) for student in "
"graduates)\n"
"\n"
">>> data = 'golf'\n"
">>> list(data[i] for i in range(len(data)-1, -1, -1))\n"
"['f', 'l', 'o', 'g']"

msgid "Footnotes"
msgstr "Przypisy"

msgid ""
"Except for one thing.  Module objects have a secret read-only attribute "
"called :attr:`~object.__dict__` which returns the dictionary used to "
"implement the module's namespace; the name ``__dict__`` is an attribute but "
"not a global name. Obviously, using this violates the abstraction of "
"namespace implementation, and should be restricted to things like post-"
"mortem debuggers."
msgstr ""
"Z wyjątkiem jednej rzeczy. Obiekty moduł mają tajną tylko do odczytu atrybut "
"o nazwie :attr:`~object.__dict__`, która zwracać słownik służy do "
"implementacji przestrzeni nazw moduł; nazwa ``__dict__`` jest atrybut, ale "
"nie jest nazwą globalną. Oczywiście korzystanie z tego narusza abstrakcję "
"implementacji przestrzeni nazw i powinno być ograniczone do takich rzeczy, "
"jak debugery post-mortem."

msgid "object"
msgstr "obiekt"

msgid "method"
msgstr "metoda"

msgid "name"
msgstr "nazwa"

msgid "mangling"
msgstr "maglowanie"