# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001 Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # # Translators: # python-doc bot, 2025 # Maciej Olko , 2026 # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.14\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2026-03-29 14:28+0000\n" "PO-Revision-Date: 2025-09-16 00:02+0000\n" "Last-Translator: Maciej Olko , 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" " \n" " .\n" " .\n" " .\n" " " msgstr "" "class ClassName:\n" " \n" " .\n" " .\n" " .\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." 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" " \n" " .\n" " .\n" " .\n" " " msgstr "" "class DerivedClassName(BaseClassName):\n" " \n" " .\n" " .\n" " .\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" " \n" " .\n" " .\n" " .\n" " " msgstr "" "class NazwaKlasyPochodnej(Baza1, Baza2, Baza3):\n" " \n" " .\n" " .\n" " .\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 ` for " "details and special cases." msgstr "" "Szczegółowe informacje i przypadki specjalne znajdują się w specyfikacji :" "ref:`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 ` have attributes, too: :" "attr:`m.__self__ ` is the instance object with the method :" "meth:`!m`, and :attr:`m.__func__ ` is the :ref:`function " "object ` corresponding to the method." msgstr "" ":ref:`Obiekty metod instancji ` także mają atrybuty: :attr:" "`m.__self__ ` jest obiektem instancji z metodą :meth:`!m`, " "i :attr:`m.__func__ ` jest :ref:`obiektem funkcji ` 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" "\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 \"\", line 1, in \n" " next(it)\n" "StopIteration" msgstr "" ">>> s = 'abc'\n" ">>> it = iter(s)\n" ">>> it\n" "\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 \"\", line 1, in \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 ` 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 ` 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"