# 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.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-08-21 14:26+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=0 && n%10=5 && "
"n%10=12 && n%100>> 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 moemy zrobi z obiektami instancji? Jedynymi operacjami rozumianymi "
"przez obiekty instancji s odniesienia do atrybutw. Istniej dwa rodzaje "
"poprawnych nazw atrybutw: 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 "
"skadowym w C++. Atrybuty danych nie musz by deklarowane; podobnie jak "
"zmienna lokalna, powstaj, gdy zostan po raz pierwszy przypisane. Na "
"przykad, jeli ``x`` jest instancj :class:`!MyClass` utworzonej powyej, "
"nastpujcy 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, ktra naley 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 ""
"Prawidowe nazwy metod obiektu instancji zale od jego klasy. Z definicji "
"wszystkie atrybuty klasy, ktre s obiektami funkcji definiuj odpowiednie "
"metody jej instancji. Tak wic w naszym przykadzie, ``x.f`` jest poprawnym "
"odwoaniem 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 wywoywana zaraz po jej powizaniu::"
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 ""
"Jeli ``x = MyClass()``, jak powyej, powysze zwrci napis ``'hello "
"world'`` . Nie jest jednak konieczne wywoywanie metody od razu: ``x.f`` "
"jest obiektem metody i moe by przechowywany i wywoywany pniej. Na "
"przykad::"
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 "bdzie drukowa ``witaj wiecie`` do koca 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 dokadnie dzieje si, gdy wywoywana jest metoda? By moe zauwaye(-"
"a), e powyej ``x.f()`` zostaa wywoana bez argumentu, mimo e definicja "
"funkcji dla :meth:`!f` okrelaa argument. Co si stao z argumentem? Z "
"pewnoci Python rzuca wyjtek, gdy funkcja, ktry wymaga argumentu jest "
"wywoywana bez adnego --- nawet jeli argument nie jest faktycznie uywany"
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 ""
"Waciwie, by moe zgade(-a) odpowied: szczegln rzecz w metodach "
"jest to, e obiekt instancji jest przekazywany jako pierwszy argument "
"funkcji. W naszym przykadzie wywoanie ``x.f()`` jest dokadnie rwnowane "
"wywoaniu ``MyClass.f(x)``. Oglnie rzecz biorc, wywoanie metody z list "
"*n* argumentw jest rwnowane wywoaniu odpowiedniej funkcji z list "
"argumentw, ktra 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 ""
"Oglnie rzecz biorc, metody dziaaj w nastpujcy sposb. Gdy odwoywane "
"jest nie-dane atrybut instancji, wyszukiwana jest klasa instancji. Jeli "
"nazwa wskazuje na prawidow klas atrybut, ktra jest obiektem funkcja, "
"odwoania zarwno do obiektu instancji, jak i obiektu funkcja s pakowane do "
"obiektu metody. Gdy obiekt metody jest wywoywany z list argument, nowa "
"lista argument jest konstruowana z instancji obiektu i listy argument, a "
"obiekt funkcja jest wywoywany 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 ""
"Oglnie rzecz biorc, zmienne instancji s dla danych unikalnych dla kadej "
"instancji, a zmienne klasy s dla atrybutw i metod wspdzielonych 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 wspdzielona przez wszystkie instancje\n"
"\n"
" def __init__(self, name):\n"
" self.name = name # zmienna instancji unikalna dla kadej instancji\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Zito')\n"
">>> d.kind # wspdzielona przez wszystkie psy\n"
"'pies'\n"
">>> e.kind # wspdzielona 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 omwiono w :ref:`tut-object`, wspdzielone dane mog mie zaskakujce "
"efekty z udziaem :term:`mutable` obiektw takich jak listy i sownik. Na "
"przykad, lista *tricks* w poniszym kodzie nie powinna by uywana jako "
"zmienna klasowa, poniewa tylko jedna lista byaby wspdzielona 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 = [] # bdne uycie 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 wspdzielone przez wszystkie "
"psy\n"
"['przewr si', 'udawaj martwego']"
msgid "Correct design of the class should use an instance variable instead::"
msgstr ""
"Prawidowy projekt klasy powinien zamiast tego uywa 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 kadego 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 ""
"Jeli ten sam atrybut wystpuje zarwno w instancji, jak i w klasie, wwczas "
"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 = 'zachd'\n"
"...\n"
">>> m1 = Magazyn()\n"
">>> print(m1.cel, m1.region)\n"
"przechowywanie zachd\n"
">>> m2 = Magazyn()\n"
">>> m2.region = 'wschd'\n"
">>> print(m2.cel, m2.region)\n"
"przechowywanie wschd"
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 odwoywa si zarwno metody, jak i zwykli "
"uytkownicy (\"klienci\") obiektu. Innymi sowy, klasy nie nadaj si do "
"implementacji czysto abstrakcyjnych typw danych. W rzeczywistoci nic w "
"Python nie umoliwia wymuszenia ukrywania danych --- wszystko opiera si na "
"konwencji. (Z drugiej strony, implementacja Python, napisana w C, moe "
"cakowicie ukry szczegy implementacji i kontrolowa dostp do obiektu, "
"jeli to konieczne; moe 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 uywa danych atrybut z ostronoci --- klienci mog zepsu "
"niezmienniki utrzymywane przez metody poprzez stemplowanie ich danych "
"atrybut. Naley pamita, e klienci mog dodawa wasne dane atrybut do "
"obiektu instancji bez wpywu na wano metod, o ile unika si konfliktw "
"nazw --- ponownie, konwencja nazewnictwa moe tutaj zaoszczdzi 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 skrtu do odwoywania si do danych atrybut (lub innych metod!) z "
"poziomu metod. Uwaam, e w rzeczywistoci zwiksza to czytelno metod: "
"nie ma szans na pomylenie zmiennych lokalnych i zmiennych instancji podczas "
"przegldania 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 ""
"Czsto pierwsza argument metody jest nazywana ``self``. Jest to nic wicej "
"ni konwencja: nazwa ``self`` nie ma absolutnie adnego specjalnego "
"znaczenia dla Python. Naley jednak pamita, e nieprzestrzeganie tej "
"konwencji moe sprawi, e kod bdzie mniej czytelny dla innych programistw "
"Python, a take moliwe jest napisanie programu *przegldarki klas*, ktry "
"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 ""
"Kady obiekt funkcja bdcy klas atrybut definiuje metod dla instancji tej "
"klasy. Nie jest konieczne, aby definicja funkcja bya tekstowo zawarta w "
"definicja klasy: przypisanie obiektu funkcja do zmiennej lokalnej w klasie "
"jest rwnie w porzdku. Na przykad::"
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`, ktre "
"odnosz si do obiektw funkcja, a w konsekwencji wszystkie s metodami "
"instancji :class:`!C` --- ``h`` jest dokadnie rwnowane ``g``. Zauwa, e "
"ta praktyka zwykle suy jedynie do zmylenia czytelnika programu."
msgid ""
"Methods may call other methods by using method attributes of the ``self`` "
"argument::"
msgstr ""
"Metody mog wywoywa inne metody przy uyciu 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 odwoywa si do nazw globalnych w taki sam sposb jak zwyke "
"funkcje. Zakres globalny powizany z metod to modu zawierajcy jej "
"definicj. (Klasa nigdy nie jest uywana jako zakres globalny.) Podczas gdy "
"rzadko mona napotka dobry powd do uywania danych globalnych w metodzie, "
"istnieje wiele uzasadnionych zastosowa zakresu globalnego: po pierwsze, "
"funkcja i modu importowane do zakresu globalnego mog by uywane przez "
"metody, a take funkcja i klasy w nim zdefiniowane. Zazwyczaj klasa "
"zawierajca metod sama jest zdefiniowana w tym globalnym zakresie, a w "
"nastpnej sekcji znajdziemy kilka dobrych powodw, dla ktrych metoda "
"chciaaby odwoywa si do wasnej klasy."
msgid ""
"Each value is an object, and therefore has a *class* (also called its "
"*type*). It is stored as ``object.__class__``."
msgstr ""
"Kada warto jest obiektem, a zatem ma *klas* (zwan rwnie *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 ""
"Oczywicie funkcja jzykowa nie byaby godna nazwy \"klasa\" bez obsugi "
"dziedziczenia. Skadnia pochodnej definicja klasy wyglda 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 "
"dostpnej z zakresu zawierajcego pochodn definicja klasy. Zamiast nazwy "
"klasa bazowa dozwolone s rwnie inne dowolne wyraenia. Moe to by "
"przydatne, na przykad, 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, zapamitywany jest klasa "
"bazowa. Jest to wykorzystywane do rozwizywania referencji atrybut: jeli "
"dany atrybut nie zostanie znaleziony w klasie, wyszukiwanie jest "
"kontynuowane w klasie bazowej. Ta regua jest stosowana rekurencyjnie, jeli "
"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 "
"rozwizywane w nastpujcy sposb: odpowiednia klasa atrybut jest "
"przeszukiwana, w razie potrzeby schodzc w d acucha klas bazowych, a "
"odniesienie do metody jest wane, jeli 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 przywilejw podczas wywoywania innych metod tego "
"samego obiektu, metoda klasa bazowa, ktra wywouje inn metod zdefiniowan "
"w tym samym klasa bazowa moe skoczy si wywoaniem metody klasy "
"pochodnej, ktra j nadpisuje. (Dla programistw 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 nadrzdna w klasie pochodnej moe w rzeczywistoci chcie rozszerzy, "
"a nie tylko zastpi metod klasa bazowa o tej samej nazwie. Istnieje prosty "
"sposb na bezporednie wywoanie metody klasa bazowa: wystarczy wywoa "
"``BaseClassName.methodname(self, arguments)``. Jest to czasami przydatne "
"rwnie dla klientw. (Naley pamita, e dziaa to tylko wtedy, gdy klasa "
"bazowa jest dostpna jako ``BaseClassName`` w zakresie globalnym)."
msgid "Python has two built-in functions that work with inheritance:"
msgstr "Python ma dwa wbudowane funkcje, ktre 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 ""
"Uyj :func:`isinstance` do sprawdzenia typu instancji: ``isinstance(obj, "
"int)`` bdzie ``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 ""
"Uyj :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 obsuguje rwnie dziedziczenie wielokrotne. Strona definicja klasy "
"z wieloma klasami bazowymi wyglda 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 wikszoci celw, w najprostszych przypadkach, mona myle o "
"wyszukiwaniu atrybut odziedziczonym po klasie nadrzdnej jako o wyszukiwaniu "
"w gb, od lewej do prawej, nie szukajc dwa razy w tej samej klasie, gdy "
"hierarchia si pokrywa. Tak wic, jeli atrybut nie zostanie znaleziony w :"
"class:`!DerivedClassName`, jest szukany w :class:`!Base1`, a nastpnie "
"(rekurencyjnie) w klasach bazowych :class:`!Base1`, a jeli 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 rzeczywistoci jest to nieco bardziej skomplikowane; kolejno "
"rozwizywania metod zmienia si dynamicznie, aby wspiera kooperacyjne "
"wywoania :func:`super`. Podejcie to jest znane w niektrych innych "
"jzykach wielokrotnego dziedziczenia jako call-next-method i jest bardziej "
"wydajne ni super wywoanie wystpujce w jzykach 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 porzdkowanie jest konieczne, poniewa wszystkie przypadki "
"wielokrotnego dziedziczenia wykazuj jedn lub wicej relacji diamentowych "
"(w ktrych co najmniej jedna z klas nadrzdnych moe by dostpna poprzez "
"wiele cieek z najniszej klasy). Na przykad, wszystkie klasy dziedzicz "
"z :class:`object`, wic kady przypadek wielokrotnego dziedziczenia zapewnia "
"wicej ni jedn ciek dostpu do :class:`object`. Aby zapobiec "
"wielokrotnemu dostpowi do klas bazowych, algorytm dynamiczny linearyzuje "
"kolejno wyszukiwania w sposb, ktry zachowuje kolejno od lewej do "
"prawej okrelon w kadej klasie, ktra wywouje kadego rodzica tylko raz i "
"ktra jest monotoniczna (co oznacza, e klasa moe by podklasowana bez "
"wpywu na kolejno pierwszestwa jej rodzicw). cznie waciwoci te "
"umoliwiaj projektowanie niezawodnych i rozszerzalnych klas z wielokrotnym "
"dziedziczeniem. Wicej szczegw mona znale na stronie :ref:"
"`python_2.3_mro`."
msgid ""
"In some cases multiple inheritance is not allowed; see :ref:`multiple-"
"inheritance` for details."
msgstr ""
"W niektrych przypadkach wielokrotne dziedziczenie nie jest dozwolone; "
"szczegowe informacje w :ref:`multiple-inheritance`."
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 ktrych nie mona uzyska dostpu inaczej "
"ni z wntrza obiektu, nie istniej w Python. Istnieje jednak konwencja, "
"ktrej przestrzega wikszo kodu Python: nazwa poprzedzona podkreleniem "
"(np. ``_spam``) powinna by traktowana jako niepubliczna cz API "
"(niezalenie od tego, czy jest to funkcja, metoda czy czonek danych). "
"Naley j traktowa jako szczeg implementacji i moe 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 uycia dla czonkw klasy-prywatnej "
"(mianowicie, aby unikn kolizji nazw z nazwami zdefiniowanymi przez "
"podklasa), istnieje ograniczone wsparcie dla takiego mechanizmu, zwanego :"
"dfn:`name mangling`. Kady identyfikator w postaci ``__spam`` (co najmniej "
"dwa pocztkowe podkrelenia, co najwyej jedno kocowe podkrelenie) jest "
"tekstowo zastpowany przez ``_classname__spam``, gdzie ``classname`` jest "
"biec nazw klasy z usunitymi pocztkowymi podkreleniami. Zamiana ta "
"jest wykonywana bez wzgldu na pozycj skadniow identyfikatora, o ile "
"wystpuje on w definicji klasy."
msgid ""
"The :ref:`private name mangling specifications ` for "
"details and special cases."
msgstr ""
"Szczegowe 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 umoliwieniu podklasa nadpisywania "
"metod bez przerywania wywoa metod wewntrzklasowych. Na przykad::"
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 ""
"Powyszy przykad zadziaa nawet wtedy, gdy ``MappingSubclass`` wprowadzi "
"identyfikator ``__update``, poniewa zostanie on zastpiony 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 ""
"Naley pamita, e reguy mieszania zostay zaprojektowane gwnie w celu "
"uniknicia wypadkw; nadal moliwy jest dostp lub modyfikacja zmiennej, "
"ktra jest uwaana za prywatn. Moe to by nawet przydatne w szczeglnych "
"okolicznociach, 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 uwaa nazwy klasy "
"wywoujcej za biec klas; jest to podobne do efektu ``global`` "
"instrukcja , ktrego efekt jest rwnie ograniczony do kodu, ktry jest "
"kompilowany bajtowo. To samo ograniczenie dotyczy ``getattr()``, "
"``setattr()`` i ``delattr()``, a take bezporedniego odwoywania 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, czcego kilka nazwanych elementw danych. "
"Idiomatycznym podejciem jest uycie 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, ktry oczekuje okrelonego abstrakcyjnego typu danych, "
"moe czsto zosta przekazany klasie, ktra emuluje metody tego typu "
"danych. Na przykad, jeli masz klas funkcja, ktra formatuje pewne dane z "
"obiektu pliku, moesz zdefiniowa klas z metodami :meth:`~io.TextIOBase."
"read` i :meth:`~io.TextIOBase.readline`, ktre 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 ` take maj atrybuty: :attr:"
"`m.__self__ ` jest obiektem instancji z metod :meth:`!m`, "
"i :attr:`m.__func__ ` jest :ref:`obiektem funkcji ` odpowiadajcym 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 zauwaye ju, e wikszo obiektw kontenera mona "
"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 dostpu jest jasny, zwizy i wygodny. Uycie iterators przenika i "
"ujednolica Python. Za kulisami, :keyword:`for` instrukcja wywouje :func:"
"`iter` na obiekcie kontenera. Obiekt funkcja zwraca i iterator definiuj "
"metod :meth:`~iterator.__next__`, ktra uzyskuje dostp do elementw w "
"kontenerze jeden po drugim. Gdy nie ma wicej elementw, :meth:`~iterator."
"__next__` rzuci wyjtek :exc:`StopIteration`, ktry informuje ptl :"
"keyword:`!for` o zakoczeniu. Metod :meth:`~iterator.__next__` mona "
"wywoa za pomoc :func:`next` wbudowanej funkcja; ten przykad pokazuje, "
"jak to wszystko dziaa::"
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 stojc za protokoem iterator, atwo jest "
"doda iterator zachowanie do swoich klas. Zdefiniuj metod :meth:"
"`~container.__iter__`, ktra zwraca obiekt z metod :meth:`~iterator."
"__next__`. Jeli klasa definiuje :meth:`!__next__`, to :meth:`!__iter__` "
"moe 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 zaptlania 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"
"\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"
"\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 potnym narzdziem do tworzenia "
"iteratorw. S one pisane jak zwyke funkcje, ale uywaj instrukcji :"
"keyword:`yield` za kadym razem, gdy chc zwraca dane. Za kadym razem, "
"gdy :func:`next` jest na nim wywoywany, generator wznawia dziaanie od "
"miejsca, w ktrym zostao przerwane (pamita wszystkie wartoci danych i "
"ktre instrukcje byo ostatnio wykonywane). Przykad pokazuje, e tworzenie "
"generatorw moe 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 mona zrobi za pomoc generatorw, mona rwnie zrobi za "
"pomoc iteratorw opartych na klasach, jak opisano w poprzedniej sekcji. "
"Kompaktowo generatorw 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 midzy wywoaniami. Sprawia to, e funkcja jest "
"atwiejszy do napisania i znacznie bardziej przejrzysty ni podejcie "
"wykorzystujce 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 ""
"Oprcz automatycznego tworzenia metod i zapisywania stanu programu, po "
"zakoczeniu generatory automatycznie rzuci :exc:`StopIteration` . W "
"poczeniu, funkcje te uatwiaj tworzenie iteratorw bez wikszego wysiku "
"ni napisanie zwykego funkcja."
msgid "Generator Expressions"
msgstr "generator wyraenia"
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 ""
"Niektre proste generatory mog by kodowane w zwizy sposb jako wyraenia "
"przy uyciu skadni podobnej do list comprehensions, ale z nawiasami zamiast "
"nawiasw kwadratowych. Wyraenia te s przeznaczone do sytuacji, w ktrych "
"generator jest uywane od razu przez otaczajc je funkcja. Wyraenia "
"generator s bardziej zwize, ale mniej wszechstronne ni pene definicje "
"generator i zwykle s bardziej przyjazne dla pamici ni rwnowane "
"wyraenia listowe."
msgid "Examples::"
msgstr "Przykady::"
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']\n"
"\n"
">>> x = [[1,2,3], [], [4, 5]]\n"
">>> g = (*i for i in x)\n"
">>> list(g)\n"
"[1, 2, 3, 4, 5]"
msgstr ""
">>> sum(i*i for i in range(10)) # suma kwadratw\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']\n"
">>> x = [[1,2,3], [], [4, 5]]\n"
">>> g = (*i for i in x)\n"
">>> list(g)\n"
"[1, 2, 3, 4, 5]"
msgid ""
"In most cases, generator expressions must be wrapped in parentheses. As a "
"special case, however, when provided as the sole argument to a function (as "
"in the examples involving ``sum``, ``set``, ``max``, and ``list`` above), "
"the generator expression does not need to be wrapped in an additional set of "
"parentheses. That is to say, the following two pieces of code are "
"semantically equivalent::"
msgstr ""
"W wikszoci przypadkw wyraenia generatorw musz by ujte w nawiasy. "
"Jednak w szczeglnym przypadku, gdy podane jako jedyny argument funkcji (jak "
"w przykadach z ``sum``, ``set``, ``max`` i ``list`` powyej), wyraenie "
"generatora nie musi by ujte w dodatkowy zestaw nawiasw. Oznacza to, e "
"nastpujce dwa fragmenty kodu s semantycznie rwnowane::"
msgid ""
">>> f(x for x in y)\n"
">>> f((x for x in y))"
msgstr ""
">>> f(x for x in y)\n"
">>> f((x for x in y))"
msgid "as are the following::"
msgstr "podobnie jak nastpujce::"
msgid ""
">>> f(*x for x in y)\n"
">>> f((*x for x in y))"
msgstr ""
">>> f(*x for x in y)\n"
">>> f((*x for x in y))"
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 wyjtkiem jednej rzeczy. Obiekty modu maj tajn tylko do odczytu atrybut "
"o nazwie :attr:`~object.__dict__`, ktra zwraca sownik suy do "
"implementacji przestrzeni nazw modu; nazwa ``__dict__`` jest atrybut, ale "
"nie jest nazw globaln. Oczywicie 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"