# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

# Maciej Olko <[email protected]>, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-17 14:50+0000\n"

"PO-Revision-Date: 2025-09-16 00:02+0000\n"

"Last-Translator: Maciej Olko <[email protected]>, 2025\n"

"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: pl\n"

"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "

"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "

"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid "Brief Tour of the Standard Library --- Part II"

msgstr "Krótka wycieczka po bibliotece standardowej --- Część II"

msgid ""

"This second tour covers more advanced modules that support professional "

"programming needs. These modules rarely occur in small scripts."

msgstr ""

"Ta druga wycieczka obejmuje bardziej zaawansowane moduł, które wspierają "

"profesjonalne potrzeby programistyczne. Te moduł rzadko występują w małych "

"skryptach."

msgid "Output Formatting"

msgstr "Formatowanie wyjścia"

msgid ""

"The :mod:`reprlib` module provides a version of :func:`repr` customized for "

"abbreviated displays of large or deeply nested containers::"

msgstr ""

":mod:`reprlib` moduł zapewnia wersja z :func:`repr` dostosowany do "

"skróconego wyświetlania dużych lub głęboko zagnieżdżonych kontenerów::"

msgid ""

">>> import reprlib\n"

">>> reprlib.repr(set('supercalifragilisticexpialidocious'))\n"

"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""

msgstr ""

">>> import reprlib\n"

">>> reprlib.repr(set('supercalifragilisticexpialidocious'))\n"

"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""

msgid ""

"The :mod:`pprint` module offers more sophisticated control over printing "

"both built-in and user defined objects in a way that is readable by the "

"interpreter. When the result is longer than one line, the \"pretty printer\" "

"adds line breaks and indentation to more clearly reveal data structure::"

msgstr ""

"Moduł :mod:`pprint` oferuje bardziej wyrafinowaną kontrolę nad drukowaniem "

"zarówno wbudowanej, jak i obiektów zdefiniowanych przez użytkownika w sposób "

"czytelny dla interpretera. Gdy wynik jest dłuższy niż jedna linia, \"ładna "

"drukarka\" dodaje podziały linii i wcięcia, aby wyraźniej ujawnić strukturę "

"danych::"

msgid ""

">>> import pprint\n"

">>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',\n"

"... 'yellow'], 'blue']]]\n"

"...\n"

">>> pprint.pprint(t, width=30)\n"

"[[[['black', 'cyan'],\n"

" 'white',\n"

" ['green', 'red']],\n"

" [['magenta', 'yellow'],\n"

" 'blue']]]"

msgstr ""

">>> import pprint\n"

">>> t = [[[['czarny', 'cyjan'], 'biały', ['zielony', 'czerwony']], "

"[['magenta',\n"

"... 'żółty'], 'niebieski']]]\n"

"...\n"

">>> pprint.pprint(t, width=30)\n"

"[[[['czarny', 'cyjan'],\n"

" 'biały',\n"

" ['zielony', 'czerwony']],\n"

" [['magenta', 'żółty'],\n"

" 'niebieski']]]"

msgid ""

"The :mod:`textwrap` module formats paragraphs of text to fit a given screen "

"width::"

msgstr ""

"Moduł :mod:`textwrap` formatuje akapity tekstu tak, aby pasowały do danej "

"szerokości ekranu::"

msgid ""

">>> import textwrap\n"

">>> doc = \"\"\"The wrap() method is just like fill() except that it "

"returns\n"

"... a list of strings instead of one big string with newlines to separate\n"

"... the wrapped lines.\"\"\"\n"

"...\n"

">>> print(textwrap.fill(doc, width=40))\n"

"The wrap() method is just like fill()\n"

"except that it returns a list of strings\n"

"instead of one big string with newlines\n"

"to separate the wrapped lines."

msgstr ""

">>> import textwrap\n"

">>> doc = \"\"\"Metoda wrap() jest taka sama jak fill() z tą różnicą, że "

"zwracać\n"

"... listę napisow zamiast jednego dużego napisu z nowymi liniami do "

"oddzielenia\n"

"... zawinięte linie.\"\"\"\n"

"...\n"

">>> print(textwrap.fill(doc, width=40))\n"

"Metoda wrap() jest taka sama jak fill()\n"

"z tą różnicą, że zwracać listę napis\n"

"zamiast jednego dużego napisu z nowymi liniami\n"

"aby oddzielić zawinięte linie."

msgid ""

"The :mod:`locale` module accesses a database of culture specific data "

"formats. The grouping attribute of locale's format function provides a "

"direct way of formatting numbers with group separators::"

msgstr ""

":mod:`locale` moduł uzyskuje dostęp do bazy danych formatów danych "

"specyficznych dla danej kultury. Grupowanie atrybut formatu locale funkcja "

"zapewnia bezpośredni sposób formatowania liczb za pomocą separatorów grup::"

msgid ""

">>> import locale\n"

">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"

"'English_United States.1252'\n"

">>> conv = locale.localeconv() # get a mapping of conventions\n"

">>> x = 1234567.8\n"

">>> locale.format_string(\"%d\", x, grouping=True)\n"

"'1,234,567'\n"

">>> locale.format_string(\"%s%.*f\", (conv['currency_symbol'],\n"

"... conv['frac_digits'], x), grouping=True)\n"

"'$1,234,567.80'"

msgstr ""

">>> import locale\n"

">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"

"'English_United States.1252'\n"

">>> conv = locale.localeconv() # uzyskać mapowanie konwencji\n"

">>> x = 1234567.8\n"

">>> locale.format_string(\"%d\", x, grouping=True)\n"

"'1,234,567'\n"

">>> locale.format_string(\"%s%.*f\", (conv['currency_symbol'],\n"

"... conv['frac_digits'], x), grouping=True)\n"

"'$1,234,567.80'"

msgid "Templating"

msgstr "Szablonowanie"

msgid ""

"The :mod:`string` module includes a versatile :class:`~string.Template` "

"class with a simplified syntax suitable for editing by end-users. This "

"allows users to customize their applications without having to alter the "

"application."

msgstr ""

"Moduł :mod:`string` zawiera wszechstronną klasę :class:`~string.Template` z "

"uproszczoną składnią odpowiednią do edycji przez użytkowników końcowych. "

"Pozwala to użytkownikom na dostosowanie ich aplikacja bez konieczności "

"zmiany aplikacja."

msgid ""

"The format uses placeholder names formed by ``$`` with valid Python "

"identifiers (alphanumeric characters and underscores). Surrounding the "

"placeholder with braces allows it to be followed by more alphanumeric "

"letters with no intervening spaces. Writing ``$$`` creates a single escaped "

"``$``::"

msgstr ""

"Format wykorzystuje nazwy placeholder utworzone przez ``$`` z ważnymi "

"identyfikatorami Python (alfanumeryczne znak i podkreślenia). Otoczenie "

"placeholder nawiasami klamrowymi pozwala na umieszczenie po nim kolejnych "

"liter alfanumerycznych bez spacji. Napisanie ``$$`` tworzy pojedynczy "

"``$``::"

msgid ""

">>> from string import Template\n"

">>> t = Template('${village}folk send $$10 to $cause.')\n"

">>> t.substitute(village='Nottingham', cause='the ditch fund')\n"

"'Nottinghamfolk send $10 to the ditch fund.'"

msgstr ""

">>> from string import Template\n"

">>> t = Template('${village}anie wysyłają $$10 na $cause.')\n"

">>> t.substitute(village='Nottingham', cause='fundusz rowu')\n"

"'Nottinghamanie wysyłają $10 na fundusz rowu.'"

msgid ""

"The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` when "

"a placeholder is not supplied in a dictionary or a keyword argument. For "

"mail-merge style applications, user supplied data may be incomplete and the :"

"meth:`~string.Template.safe_substitute` method may be more appropriate --- "

"it will leave placeholders unchanged if data is missing::"

msgstr ""

"Metoda :meth:`~string.Template.substitute` rzuci :exc:`KeyError`, gdy "

"placeholder nie jest podany w słowniku lub argument nazwany. W przypadku "

"mail-merge aplikacjach, dane dostarczone przez użytkownika mogą być "

"niekompletne, a metoda :meth:`~string.Template.safe_substitute` może być "

"bardziej odpowiednia --- pozostawi placeholder bez zmian, jeśli brakuje "

"danych::"

msgid ""

">>> t = Template('Return the $item to $owner.')\n"

">>> d = dict(item='unladen swallow')\n"

">>> t.substitute(d)\n"

"Traceback (most recent call last):\n"

" ...\n"

"KeyError: 'owner'\n"

">>> t.safe_substitute(d)\n"

"'Return the unladen swallow to $owner.'"

msgstr ""

">>> t = Template('Zwróć $item do $owner.')\n"

">>> d = dict(item='nieobciążoną jaskółkę')\n"

">>> t.substitute(d)\n"

"Traceback (most recent call last):\n"

"...\n"

"KeyError: 'owner'\n"

">>> t.safe_substitute(d)\n"

"'Zwróć nieobciążoną jaskółkę do $owner.'"

msgid ""

"Template subclasses can specify a custom delimiter. For example, a batch "

"renaming utility for a photo browser may elect to use percent signs for "

"placeholders such as the current date, image sequence number, or file "

"format::"

msgstr ""

"Szablon podklas mogą określać niestandardowy separator. Na przykład, "

"narzędzie do wsadowej zmiany nazw dla przeglądarki zdjęć może zdecydować się "

"na użycie znaków procentowych jako placeholder, takich jak bieżące dane, "

"numer sekwencyjny obrazu lub format pliku::"

msgid ""

">>> import time, os.path\n"

">>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"

">>> class BatchRename(Template):\n"

"... delimiter = '%'\n"

"...\n"

">>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format): ')\n"

"Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f\n"

"\n"

">>> t = BatchRename(fmt)\n"

">>> date = time.strftime('%d%b%y')\n"

">>> for i, filename in enumerate(photofiles):\n"

"... base, ext = os.path.splitext(filename)\n"

"... newname = t.substitute(d=date, n=i, f=ext)\n"

"... print('{0} --> {1}'.format(filename, newname))\n"

"\n"

"img_1074.jpg --> Ashley_0.jpg\n"

"img_1076.jpg --> Ashley_1.jpg\n"

"img_1077.jpg --> Ashley_2.jpg"

msgstr ""

">>> import time, os.path\n"

">>> pliki_zdjecia = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"

">>> class ZmienNazwePlikow(Template):\n"

"... delimiter = '%'\n"

"...\n"

">>> format_nazwy = input('Podaj styl zmiany nazwy (-data -numer -format): "

"')\n"

"Podaj styl zmiany nazwy (-data -numer -format): Ashley_\n"

"\n"

">>> zmiana_nazwy = ZmienNazwePlikow(format_nazwy)\n"

">>> data = time.strftime('%b%y')\n"

">>> for i, nazwa_pliku in enumerate(pliki_zdjecia):\n"

"... baza, rozszerzenie = os.path.splitext(nazwa_pliku)\n"

"... nowa_nazwa = zmiana_nazwy.substitute(d=data, n=i, f=rozszerzenie)\n"

"... print('{0} --> {1}'.format(nazwa_pliku, nowa_nazwa))\n"

"...\n"

"img_1074.jpg --> Ashley_0.jpg\n"

"img_1076.jpg --> Ashley_1.jpg\n"

"img_1077.jpg --> Ashley_2.jpg"

msgid ""

"Another application for templating is separating program logic from the "

"details of multiple output formats. This makes it possible to substitute "

"custom templates for XML files, plain text reports, and HTML web reports."

msgstr ""

"Innym aplikacja dla szablonów jest oddzielenie logiki programu od szczegółów "

"wielu formatów wyjściowych. Umożliwia to zastąpienie niestandardowych "

"szablonów plikami XML, raportami tekstowymi i raportami internetowymi HTML."

msgid "Working with Binary Data Record Layouts"

msgstr "Praca z układami rekordów danych binarnych"

msgid ""

"The :mod:`struct` module provides :func:`~struct.pack` and :func:`~struct."

"unpack` functions for working with variable length binary record formats. "

"The following example shows how to loop through header information in a ZIP "

"file without using the :mod:`zipfile` module. Pack codes ``\"H\"`` and "

"``\"I\"`` represent two and four byte unsigned numbers respectively. The "

"``\"<\"`` indicates that they are standard size and in little-endian byte "

"order::"

msgstr ""

"Moduł :mod:`struct` udostępnia :func:`~struct.pack` i :func:`~struct.unpack` "

"funkcje do pracy z formatami rekordów binarnych o zmiennej długości. "

"Poniższy przykład pokazuje, jak zapętlić informacje nagłówka w pliku ZIP bez "

"użycia moduł :mod:`zipfile` . Kody pakietów ``\"H\"`` i ``\"I\"`` "

"reprezentują odpowiednio dwu- i czterobajtowe liczby bez znaku. Oznaczenie "

"``\"<\"`` wskazuje, że mają one standardowy rozmiar i kolejność bajtów "

"little-endian::"

msgid ""

"import struct\n"

"\n"

"with open('myfile.zip', 'rb') as f:\n"

" data = f.read()\n"

"\n"

"start = 0\n"

"for i in range(3): # show the first 3 file headers\n"

" start += 14\n"

" fields = struct.unpack('<IIIHH', data[start:start+16])\n"

" crc32, comp_size, uncomp_size, filenamesize, extra_size = fields\n"

"\n"

" start += 16\n"

" filename = data[start:start+filenamesize]\n"

" start += filenamesize\n"

" extra = data[start:start+extra_size]\n"

" print(filename, hex(crc32), comp_size, uncomp_size)\n"

"\n"

" start += extra_size + comp_size # skip to the next header"

msgstr ""

"import struct\n"

"\n"

"with open('myfile.zip', 'rb') as f:\n"

" data = f.read()\n"

"\n"

"start = 0\n"

"for i in range(3): # pokaż pierwsze 3 nagłówki pliku\n"

" start += 14\n"

" fields = struct.unpack('<IIIHH', data[start:start+16])\n"

" crc32, comp_size, uncomp_size, filenamesize, extra_size = fields\n"

"\n"

" start += 16\n"

" filename = data[start:start+filenamesize]\n"

" start += filenamesize\n"

" extra = data[start:start+extra_size]\n"

" print(filename, hex(crc32), comp_size, uncomp_size)\n"

"\n"

" start += extra_size + comp_size # przeskocz do następnego nagłówka"

msgid "Multi-threading"

msgstr "Wielowątkowość"

msgid ""

"Threading is a technique for decoupling tasks which are not sequentially "

"dependent. Threads can be used to improve the responsiveness of "

"applications that accept user input while other tasks run in the "

"background. A related use case is running I/O in parallel with computations "

"in another thread."

msgstr ""

"Wątkowanie jest techniką oddzielania zadań, które nie są sekwencyjnie "

"zależne. Wątek może być używany do poprawy szybkości reakcji aplikacji, "

"które akceptują dane wejściowe użytkownika, podczas gdy inne zadania "

"działają w tle. Powiązanym przypadkiem użycia jest równoległe wykonywanie "

"operacji wejścia/wyjścia z obliczeniami w innym wątku."

msgid ""

"The following code shows how the high level :mod:`threading` module can run "

"tasks in background while the main program continues to run::"

msgstr ""

"Poniższy kod pokazuje, w jaki sposób wysokopoziomowy :mod:`threading` moduł "

"może uruchamiać zadania w tle, podczas gdy główny program nadal działa::"

msgid ""

"import threading, zipfile\n"

"\n"

"class AsyncZip(threading.Thread):\n"

" def __init__(self, infile, outfile):\n"

" threading.Thread.__init__(self)\n"

" self.infile = infile\n"

" self.outfile = outfile\n"

"\n"

" def run(self):\n"

" f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)\n"

" f.write(self.infile)\n"

" f.close()\n"

" print('Finished background zip of:', self.infile)\n"

"\n"

"background = AsyncZip('mydata.txt', 'myarchive.zip')\n"

"background.start()\n"

"print('The main program continues to run in foreground.')\n"

"\n"

"background.join() # Wait for the background task to finish\n"

"print('Main program waited until background was done.')"

msgstr ""

"import threading, zipfile\n"

"\n"

"class AsyncZip(threading.Thread):\n"

" def __init__(self, infile, outfile):\n"

" threading.Thread.__init__(self)\n"

" self.infile = infile\n"

" self.outfile = outfile\n"

"\n"

" def run(self):\n"

" f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)\n"

" f.write(self.infile)\n"

" f.close()\n"

" print('Zakończono zipowanie w tle pliku:', self.infile)\n"

"\n"

"background = AsyncZip('mydata.txt', 'myarchive.zip')\n"

"background.start()\n"

"print('Główny program nadal działa.')\n"

"\n"

"background.join() # Poczekaj na zakończenie zadania w tle\n"

"print('Główny program czekał, aż tło zostanie wykonane.')"

msgid ""

"The principal challenge of multi-threaded applications is coordinating "

"threads that share data or other resources. To that end, the threading "

"module provides a number of synchronization primitives including locks, "

"events, condition variables, and semaphores."

msgstr ""

"Głównym wyzwaniem wielowątkowej aplikacji jest koordynacja wątkow, które "

"współdzielą dane lub inne zasoby. W tym celu wątkowanie moduł zapewnia "

"szereg prymitywów synchronizacji, w tym blokady, zdarzenia, zmienne "

"warunkowe i semafory."

msgid ""

"While those tools are powerful, minor design errors can result in problems "

"that are difficult to reproduce. So, the preferred approach to task "

"coordination is to concentrate all access to a resource in a single thread "

"and then use the :mod:`queue` module to feed that thread with requests from "

"other threads. Applications using :class:`~queue.Queue` objects for inter-"

"thread communication and coordination are easier to design, more readable, "

"and more reliable."

msgstr ""

"Chociaż narzędzia te są potężne, drobne błędy projektowe mogą skutkować "

"trudnymi do odtworzenia problemami. Dlatego preferowanym podejściem do "

"koordynacji zadań jest skoncentrowanie całego dostępu do zasobu w jednym "

"wąteku, a następnie wykorzystanie moduł :mod:`queue` do zasilania tego "

"wąteka żądaniami z innych wątekow. Aplikacja wykorzystuje obiekty :class:"

"`~queue.Queue` do komunikacji i koordynacji międzywątekowych są łatwiejsze "

"do zaprojektowania, bardziej czytelne i niezawodne."

msgid "Logging"

msgstr "Logowanie"

msgid ""

"The :mod:`logging` module offers a full featured and flexible logging "

"system. At its simplest, log messages are sent to a file or to ``sys."

"stderr``::"

msgstr ""

"Moduł :mod:`logging` oferuje w pełni funkcjonalny i elastyczny system "

"logowania. W najprostszym przypadku komunikaty dziennika są wysyłane do "

"pliku lub na adres ``sys.stderr``::"

msgid ""

"import logging\n"

"logging.debug('Debugging information')\n"

"logging.info('Informational message')\n"

"logging.warning('Warning:config file %s not found', 'server.conf')\n"

"logging.error('Error occurred')\n"

"logging.critical('Critical error -- shutting down')"

msgstr ""

"import logging\n"

"logging.debug('Informacje o debugowaniuwarning')\n"

"logging.info('Komunikat informacyjny')\n"

"logging.warning('ostrzeżenie: nie znaleziono pliku konfiguracyjnego %s ', "

"'server.conf')\n"

"logging.error('Wystąpił błąd')\n"

"logging.critical('Błąd krytyczny -- wyłączenie')"

msgid "This produces the following output:"

msgstr "Daje to taki wyniki:"

msgid ""

"WARNING:root:Warning:config file server.conf not found\n"

"ERROR:root:Error occurred\n"

"CRITICAL:root:Critical error -- shutting down"

msgstr ""

"WARNING:root:Warning:config file server.conf not found\n"

"ERROR:root:Error occurred\n"

"CRITICAL:root:Critical error -- shutting down"

msgid ""

"By default, informational and debugging messages are suppressed and the "

"output is sent to standard error. Other output options include routing "

"messages through email, datagrams, sockets, or to an HTTP Server. New "

"filters can select different routing based on message priority: :const:"

"`~logging.DEBUG`, :const:`~logging.INFO`, :const:`~logging.WARNING`, :const:"

"`~logging.ERROR`, and :const:`~logging.CRITICAL`."

msgstr ""

"Domyślnie, komunikaty informacyjne i debugowanie są tłumione, a dane "

"wyjściowe są wysyłane do standardowego błędu. Inne opcje wyjściowe obejmują "

"kierowanie wiadomości przez e-mail, datagramy, gniazda lub do serwera HTTP. "

"Nowe filtry mogą wybierać różne trasy na podstawie priorytetu wiadomości: :"

"const:`~logging.DEBUG`, :const:`~logging.INFO`, :const:`~logging.WARNING`, :"

"const:`~logging.ERROR` i :const:`~logging.CRITICAL`."

msgid ""

"The logging system can be configured directly from Python or can be loaded "

"from a user editable configuration file for customized logging without "

"altering the application."

msgstr ""

"System logowania może być skonfigurowany bezpośrednio z poziomu Pythona lub "

"może być załadowany z edytowalnego przez użytkownika pliku konfiguracyjnego "

"w celu dostosowania rejestrowania bez zmiany aplikacji."

msgid "Weak References"

msgstr "Wsparcie słabych odniesień"

msgid ""

"Python does automatic memory management (reference counting for most objects "

"and :term:`garbage collection` to eliminate cycles). The memory is freed "

"shortly after the last reference to it has been eliminated."

msgstr ""

"Python wykonuje automatyczne zarządzanie pamięcią (liczenie referencji dla "

"większości obiektów i :term:`garbage collection` w celu wyeliminowania "

"cykli). Pamięć jest zwalniana wkrótce po usunięciu ostatniego odniesienia "

"do niej."

msgid ""

"This approach works fine for most applications but occasionally there is a "

"need to track objects only as long as they are being used by something else. "

"Unfortunately, just tracking them creates a reference that makes them "

"permanent. The :mod:`weakref` module provides tools for tracking objects "

"without creating a reference. When the object is no longer needed, it is "

"automatically removed from a weakref table and a callback is triggered for "

"weakref objects. Typical applications include caching objects that are "

"expensive to create::"

msgstr ""

"Takie podejście sprawdza się w większości przypadków aplikacji, ale czasami "

"istnieje potrzeba śledzenia obiektów tylko tak długo, jak są one używane "

"przez coś innego. Niestety, samo ich śledzenie tworzy odniesienie, które "

"czyni je trwałymi. :mod:`weakref` moduł zapewnia narzędzia do śledzenia "

"obiektów bez tworzenia odniesienia. Gdy obiekt nie jest już potrzebny, jest "

"automatycznie usuwany z tabeli weakref i uruchamiane jest wywołanie zwrotne "

"dla obiektów weakref. Typowe aplikacja obejmują buforowanie obiektów, "

"których utworzenie jest kosztowne::"

msgid ""

">>> import weakref, gc\n"

">>> class A:\n"

"... def __init__(self, value):\n"

"... self.value = value\n"

"... def __repr__(self):\n"

"... return str(self.value)\n"

"...\n"

">>> a = A(10) # create a reference\n"

">>> d = weakref.WeakValueDictionary()\n"

">>> d['primary'] = a # does not create a reference\n"

">>> d['primary'] # fetch the object if it is still alive\n"

"10\n"

">>> del a # remove the one reference\n"

">>> gc.collect() # run garbage collection right away\n"

"0\n"

">>> d['primary'] # entry was automatically removed\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" d['primary'] # entry was automatically removed\n"

" File \"C:/python314/lib/weakref.py\", line 46, in __getitem__\n"

" o = self.data[key]()\n"

"KeyError: 'primary'"

msgstr ""

">>> import weakref, gc\n"

">>> class A:\n"

"... def __init__(self, value):\n"

"... self.value = value\n"

"... def __repr__(self):\n"

"... return str(self.value)\n"

"...\n"

">>> a = A(10) # utwórz odniesienie\n"

">>> d = weakref.WeakValueDictionary()\n"

">>> d['primary'] = a # nie tworzy odniesienia\n"

">>> d['primary'] # pobierz obiekt, jeśli nadal istnieje\n"

"10\n"

">>> del a # usuń jedyne odniesienie\n"

">>> gc.collect() # wymuś natychmiastowe uruchomienie garbage collection\n"

"0\n"

">>> d['primary'] # wpis został automatycznie usunięty\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" d['primary'] # wpis został automatycznie usunięty\n"

" File \"C:/python314/lib/weakref.py\", line 46, in __getitem__\n"

" o = self.data[key]()\n"

"KeyError: 'primary'"

msgid "Tools for Working with Lists"

msgstr "Narzędzia do pracy z listami"

msgid ""

"Many data structure needs can be met with the built-in list type. However, "

"sometimes there is a need for alternative implementations with different "

"performance trade-offs."

msgstr ""

"Wiele potrzeb związanych ze strukturami danych można zaspokoić za pomocą "

"listy wbudowanej. Czasami jednak istnieje potrzeba alternatywnych "

"implementacji z różnymi kompromisami w zakresie wydajności."

msgid ""

"The :mod:`array` module provides an :class:`~array.array` object that is "

"like a list that stores only homogeneous data and stores it more compactly. "

"The following example shows an array of numbers stored as two byte unsigned "

"binary numbers (typecode ``\"H\"``) rather than the usual 16 bytes per entry "

"for regular lists of Python int objects::"

msgstr ""

"Moduł :mod:`array` udostępnia obiekt :class:`~array.array`, który jest jak "

"lista, przechowuje tylko jednorodne dane i przechowuje je w bardziej "

"kompaktowy sposób. Poniższy przykład pokazuje tablica liczb przechowywanych "

"jako dwubajtowe liczby binarne bez znaku (kod typowy ``\"H\"``) zamiast "

"zwykłych 16 bajtów na wpis dla zwykłych list obiektów Python int::"

msgid ""

">>> from array import array\n"

">>> a = array('H', [4000, 10, 700, 22222])\n"

">>> sum(a)\n"

"26932\n"

">>> a[1:3]\n"

"array('H', [10, 700])"

msgstr ""

">>> from array import array\n"

">>> a = array('H', [4000, 10, 700, 22222])\n"

">>> sum(a)\n"

"26932\n"

">>> a[1:3]\n"

"array('H', [10, 700])"

msgid ""

"The :mod:`collections` module provides a :class:`~collections.deque` object "

"that is like a list with faster appends and pops from the left side but "

"slower lookups in the middle. These objects are well suited for implementing "

"queues and breadth first tree searches::"

msgstr ""

"Moduł :mod:`collections` udostępnia obiekt :class:`~collections.deque`, "

"który jest jak lista z szybszym dołączaniem i wyskakiwaniem z lewej strony, "

"ale wolniejszym wyszukiwaniem w środku. Obiekty te dobrze nadają się do "

"implementacji kolejek i przeszukiwania drzewa w pierwszej kolejności:"

msgid ""

">>> from collections import deque\n"

">>> d = deque([\"task1\", \"task2\", \"task3\"])\n"

">>> d.append(\"task4\")\n"

">>> print(\"Handling\", d.popleft())\n"

"Handling task1"

msgstr ""

">>> from collections import deque\n"

">>> d = deque([\"zadanie1\", \"zadanie2\", \"zadanie3\"])\n"

">>> d.append(\"zadanie4\")\n"

">>> print(\"Obsługiwanie\", d.popleft())\n"

"Obsługiwanie zadanie1"

msgid ""

"unsearched = deque([starting_node])\n"

"def breadth_first_search(unsearched):\n"

" node = unsearched.popleft()\n"

" for m in gen_moves(node):\n"

" if is_goal(m):\n"

" return m\n"

" unsearched.append(m)"

msgstr ""

"unsearched = deque([starting_node])\n"

"def breadth_first_search(unsearched):\n"

" node = unsearched.popleft()\n"

" for m in gen_moves(node):\n"

" if is_goal(m):\n"

" return m\n"

" unsearched.append(m)"

msgid ""

"In addition to alternative list implementations, the library also offers "

"other tools such as the :mod:`bisect` module with functions for manipulating "

"sorted lists::"

msgstr ""

"Oprócz alternatywnych implementacji list, biblioteka oferuje również inne "

"narzędzia, takie jak :mod:`bisect` moduł z funkcja do manipulowania "

"posortowanymi listami::"

msgid ""

">>> import bisect\n"

">>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]\n"

">>> bisect.insort(scores, (300, 'ruby'))\n"

">>> scores\n"

"[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]"

msgstr ""

">>> import bisect\n"

">>> wyniki = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]\n"

">>> bisect.insort(wyniki, (300, 'ruby'))\n"

">>> wyniki\n"

"[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]"

msgid ""

"The :mod:`heapq` module provides functions for implementing heaps based on "

"regular lists. The lowest valued entry is always kept at position zero. "

"This is useful for applications which repeatedly access the smallest element "

"but do not want to run a full list sort::"

msgstr ""

"Moduł :mod:`heapq` udostępnia funkcje do implementacji stert opartych na "

"listach regularnych. Wpis o najniższej wartości jest zawsze przechowywany "

"na pozycji zero. Jest to przydatne dla aplikacji, które wielokrotnie "

"uzyskują dostęp do najmniejszego elementu, ale nie chcą uruchamiać pełnego "

"sortowania listy::"

msgid ""

">>> from heapq import heapify, heappop, heappush\n"

">>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"

">>> heapify(data) # rearrange the list into heap order\n"

">>> heappush(data, -5) # add a new entry\n"

">>> [heappop(data) for i in range(3)] # fetch the three smallest entries\n"

"[-5, 0, 1]"

msgstr ""

">>> from heapq import heapify, heappop, heappush\n"

">>> dane = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"

">>> heapify(dane) # uporządkuj listę w kolejności na stercie\n"

">>> heappush(dane, -5) # dodanie nowego wpisu\n"

">>> [heappop(dane) for i in range(3)] # pobranie trzech najmniejszych "

"wpisów\n"

"[-5, 0, 1]"

msgid "Decimal Floating-Point Arithmetic"

msgstr "Dziesiętna arytmetyka zmiennoprzecinkowa"

msgid ""

"The :mod:`decimal` module offers a :class:`~decimal.Decimal` datatype for "

"decimal floating-point arithmetic. Compared to the built-in :class:`float` "

"implementation of binary floating point, the class is especially helpful for"

msgstr ""

"Klasa moduł :mod:`decimal` oferuje typ danych :class:`~decimal.Decimal` dla "

"dziesiętnej arytmetyki zmiennoprzecinkowej. W porównaniu do wbudowanej :"

"class:`float` implementacji binarnej liczby zmiennoprzecinkowej, klasa ta "

"jest szczególnie pomocna dla"

msgid ""

"financial applications and other uses which require exact decimal "

"representation,"

msgstr ""

"finansowe aplikacja i inne zastosowania wymagające dokładnej reprezentacji "

"dziesiętnej,"

msgid "control over precision,"

msgstr "kontrola nad precyzją,"

msgid "control over rounding to meet legal or regulatory requirements,"

msgstr ""

"kontrolę nad zaokrągleniami w celu spełnienia wymogów prawnych lub "

"regulacyjnych,"

msgid "tracking of significant decimal places, or"

msgstr "śledzenie znaczących miejsc po przecinku, lub"

msgid ""

"applications where the user expects the results to match calculations done "

"by hand."

msgstr ""

"aplikacja gdzie użytkownik oczekuje, że wyniki będą zgodne z obliczeniami "

"wykonanymi ręcznie."

msgid ""

"For example, calculating a 5% tax on a 70 cent phone charge gives different "

"results in decimal floating point and binary floating point. The difference "

"becomes significant if the results are rounded to the nearest cent::"

msgstr ""

"Na przykład, obliczenie 5% podatku od 70 centów opłaty telefonicznej daje "

"różne wyniki w dziesiętnej zmiennoprzecinkowej i binarnej "

"zmiennoprzecinkowej. Różnica staje się znacząca, jeśli wyniki zostaną "

"zaokrąglone do najbliższego centa::"

msgid ""

">>> from decimal import *\n"

">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"

"Decimal('0.74')\n"

">>> round(.70 * 1.05, 2)\n"

"0.73"

msgstr ""

">>> from decimal import *\n"

">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"

"Decimal('0.74')\n"

">>> round(.70 * 1.05, 2)\n"

"0.73"

msgid ""

"The :class:`~decimal.Decimal` result keeps a trailing zero, automatically "

"inferring four place significance from multiplicands with two place "

"significance. Decimal reproduces mathematics as done by hand and avoids "

"issues that can arise when binary floating point cannot exactly represent "

"decimal quantities."

msgstr ""

"Wynik :class:`~decimal.Decimal` zachowuje końcowe zero, automatycznie "

"wywnioskowując znaczenie czterech miejsc z mnożników o znaczeniu dwóch "

"miejsc. Decimal odtwarza matematykę wykonaną ręcznie i unika problemów, "

"które mogą powstać, gdy binarna liczba zmiennoprzecinkowa nie może dokładnie "

"reprezentować wielkości dziesiętnych."

msgid ""

"Exact representation enables the :class:`~decimal.Decimal` class to perform "

"modulo calculations and equality tests that are unsuitable for binary "

"floating point::"

msgstr ""

"Dokładna reprezentacja umożliwia klasie :class:`~decimal.Decimal` "

"wykonywanie obliczeń modulo i testów równości, które nie są odpowiednie dla "

"binarnych liczb zmiennoprzecinkowych:"

msgid ""

">>> Decimal('1.00') % Decimal('.10')\n"

"Decimal('0.00')\n"

">>> 1.00 % 0.10\n"

"0.09999999999999995\n"

"\n"

">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"

"True\n"

">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"

"False"

msgstr ""

">>> Decimal('1.00') % Decimal('.10')\n"

"Decimal('0.00')\n"

">>> 1.00 % 0.10\n"

"0.09999999999999995\n"

"\n"

">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"

"True\n"

">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"

"False"

msgid ""

"The :mod:`decimal` module provides arithmetic with as much precision as "

"needed::"

msgstr ""

"Moduł :mod:`decimal` zapewnia arytmetykę z taką precyzją, jaka jest "

"potrzebna::"

msgid ""

">>> getcontext().prec = 36\n"

">>> Decimal(1) / Decimal(7)\n"

"Decimal('0.142857142857142857142857142857142857')"

msgstr ""

">>> getcontext().prec = 36\n"

">>> Decimal(1) / Decimal(7)\n"

"Decimal('0.142857142857142857142857142857142857')"