Update translation from Transifex

GitHub Action's update-translation job · GitHub Action's update-translation job · commit 02e7550014f4 · 2024-11-26T12:50:10.000Z
diff --git a/README.md b/README.md
@@ -15,8 +15,8 @@ f'''![build](https://github.com/python/python-docs-pl/workflows/.github/workflow
 ![{translators} tłumaczy](https://img.shields.io/badge/tłumaczy-{translators}-0.svg)''')
 ]]] -->
 ![build](https://github.com/python/python-docs-pl/workflows/.github/workflows/update-lint-and-build.yml/badge.svg)
-![71.00% przełącznika języków](https://img.shields.io/badge/przełącznik_języków-71.00%25-0.svg)
-![postęp tłumaczenia całości dokumentacji](https://img.shields.io/badge/całość-3.78%25-0.svg)
+![73.32% przełącznika języków](https://img.shields.io/badge/przełącznik_języków-73.32%25-0.svg)
+![postęp tłumaczenia całości dokumentacji](https://img.shields.io/badge/całość-3.87%25-0.svg)
 ![24 tłumaczy](https://img.shields.io/badge/tłumaczy-24-0.svg)
 <!-- [[[end]]] -->
 
diff --git a/tutorial/classes.po b/tutorial/classes.po
@@ -823,6 +823,24 @@ msgid ""
 ">>> e.name                  # unique to e\n"
 "'Buddy'"
 msgstr ""
+"class Pies:\n"
+"\n"
+"  gatunek = 'pies' # zmienna klasowa współdzielona przez wszystkie "
+"instancje\n"
+"\n"
+"  def __init__(self, imie):\n"
+"    self.imie = imie # zmienna instancji unikalna dla każdej instancji\n"
+"\n"
+">>> d = Pies('Fido')\n"
+">>> e = Pies('Zito')\n"
+">>> d.gatunek # współdzielona przez wszystkie psy\n"
+"'pies'\n"
+">>> e.gatunek # współdzielona przez wszystkie psy\n"
+"'pies'\n"
+">>> d.imie # unikalna dla d\n"
+"'Fido'\n"
+">>> e.imie # unikalna dla e\n"
+"'Zito'"
 
 msgid ""
 "As discussed in :ref:`tut-object`, shared data can have possibly surprising "
@@ -831,6 +849,11 @@ msgid ""
 "not be used as a class variable because just a single list would be shared "
 "by all *Dog* instances::"
 msgstr ""
+"Jak omówiono w :ref:`tut-object`, współdzielone dane mogą mieć zaskakujące "
+"efekty z udziałem :term:`mutable` obiektów takich jak listy i słownik. Na "
+"przykład, lista *sztuczki* w poniższym kodzie nie powinna być używana jako "
+"zmienna klasowa, ponieważ tylko jedna lista byłaby współdzielona przez "
+"wszystkie instancje *Pies*::"
 
 msgid ""
 "class Dog:\n"
@@ -890,6 +913,23 @@ msgid ""
 ">>> e.tricks\n"
 "['play dead']"
 msgstr ""
+"class Pies:\n"
+"\n"
+"def __init__(self, imie):\n"
+"self.imie = imie\n"
+"self.sztuczki = [] # tworzy nową pustą listę dla każdego psa\n"
+"\n"
+"def dodaj_sztuczke(self, sztuczka):\n"
+"self.sztuczki.append(sztuczka)\n"
+"\n"
+">>> d = Pies('Fido')\n"
+">>> e = Pies('Zito')\n"
+">>> d.dodaj_sztuczke('przewróć się')\n"
+">>> e.dodaj_sztuczke('udawaj martwego')\n"
+">>> d.sztuczki\n"
+"['przewróć się']\n"
+">>> e.sztuczki\n"
+"['udawaj martwego']"
 
 msgid "Random Remarks"
 msgstr "Uwagi losowe"
@@ -914,6 +954,17 @@ msgid ""
 ">>> 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 "
@@ -967,6 +1018,10 @@ msgid ""
 "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"
@@ -999,6 +1054,10 @@ msgid ""
 "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`` "
@@ -1041,11 +1100,23 @@ msgid ""
 "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"
@@ -1079,6 +1150,10 @@ msgid ""
 "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):"
@@ -1125,13 +1200,20 @@ msgid ""
 "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"
@@ -1196,6 +1278,20 @@ msgid ""
 "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"
@@ -1254,20 +1350,46 @@ msgid ""
 "        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 "
@@ -1286,6 +1408,9 @@ msgid ""
 "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"
@@ -1296,6 +1421,13 @@ msgid ""
 "    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"
@@ -1304,6 +1436,11 @@ msgid ""
 ">>> 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 "
@@ -1320,9 +1457,9 @@ msgid ""
 "meth:`!m`, and :attr:`m.__func__ <method.__func__>` is the :ref:`function "
 "object <user-defined-funcs>` corresponding to the method."
 msgstr ""
-":ref:` Obiekty metod instancji <instance-methods>` mają atrybut, także: :"
+":ref:` Instance method objects <instance-methods>` mają atrybut, także: :"
 "attr:`m.__self__ <method.__self__>` jest obiektem instancji z metodą :meth:`!"
-"m`, i :attr:`m.__func__ <method.__func__>` jest :ref:`funkcja obiektem ` "
+"m`, i :attr:`m.__func__ <method.__func__>` jest :ref:`function object` "
 "odpowiadającym metodzie."
 
 msgid "Iterators"
@@ -1387,6 +1524,21 @@ msgid ""
 "    next(it)\n"
 "StopIteration"
 msgstr ""
+">>> s = 'abc'\n"
+">>> it = iter(s)\n"
+">>> it\n"
+"<str_iterator object at 0x10c90e650>\n"
+">>> next(it)\n"
+"'a'\n"
+">>> next(it)\n"
+"'b'\n"
+">>> next(it)\n"
+"'c'\n"
+">>> next(it)\n"
+"Traceback (most recent call last):\n"
+"  File \"<stdin>\", line 1, in <module>\n"
+"    next(it)\n"
+"StopIteration"
 
 msgid ""
 "Having seen the mechanics behind the iterator protocol, it is easy to add "
@@ -1395,6 +1547,11 @@ msgid ""
 "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"
@@ -1412,6 +1569,20 @@ msgid ""
 "        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"
@@ -1480,20 +1651,32 @@ msgid ""
 "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"
@@ -1528,6 +1711,22 @@ msgid ""
 ">>> 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"
