controlflow.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Bartosz Chmiel <chmielbartosz@gmail.com>, 2021
# Igor Zubrycki <igorzubrycki@gmail.com>, 2021
# Lidia Lipinska-Zubrycka <lidiawandalipinska@gmail.com>, 2021
# haaritsubaki, 2023
# Marysia Olko, 2024
# Maciej Olko <maciej.olko@gmail.com>, 2024
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-04-04 14:18+0000\n"
"PO-Revision-Date: 2021-06-28 01:50+0000\n"
"Last-Translator: Maciej Olko <maciej.olko@gmail.com>, 2024\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 "More Control Flow Tools"
msgstr "Więcej narzędzi kontroli przepływu"

msgid ""
"As well as the :keyword:`while` statement just introduced, Python uses a few "
"more that we will encounter in this chapter."
msgstr ""
"Oprócz właśnie przedstawionego wyrażenia :keyword:`while`, Python używa "
"kilku innych, które napotkamy w tym rozdziale."

msgid ":keyword:`!if` Statements"
msgstr "Instrukcje :keyword:`!if`"

msgid ""
"Perhaps the most well-known statement type is the :keyword:`if` statement.  "
"For example::"
msgstr ""
"Prawdopodobnie najbardziej znanym typem instrukcji jest instrukcja :keyword:"
"`if`. Na przykład::"

msgid ""
">>> x = int(input(\"Please enter an integer: \"))\n"
"Please enter an integer: 42\n"
">>> if x < 0:\n"
"...     x = 0\n"
"...     print('Negative changed to zero')\n"
"... elif x == 0:\n"
"...     print('Zero')\n"
"... elif x == 1:\n"
"...     print('Single')\n"
"... else:\n"
"...     print('More')\n"
"...\n"
"More"
msgstr ""
">>> x = int(input(\"Wprowadź liczbę całkowitą: \"))\n"
"Wprowadź liczbę całkowitą: 42\n"
">>> if x < 0:\n"
"...     x = 0\n"
"...     print('Wartość ujemna zmieniona na zero')\n"
"... elif x == 0:\n"
"...     print('Zero')\n"
"... elif x == 1:\n"
"...     print('Jeden')\n"
"... else:\n"
"...     print('Więcej niż jeden')\n"
"...\n"
"Więcej niż jeden"

msgid ""
"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "
"part is optional.  The keyword ':keyword:`!elif`' is short for 'else if', "
"and is useful to avoid excessive indentation.  An  :keyword:`!if` ... :"
"keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the "
"``switch`` or ``case`` statements found in other languages."
msgstr ""
"Części :keyword:`elif` może być zero lub więcej i część :keyword:`else` jest "
"opcjonalna. Keyword „:keyword:`!elif`” jest skrótem od „else if” i jest "
"przydatny by uniknąć nadmiarowych wcięć. Sekwencja :keyword:`!if` … :keyword:"
"`!elif` … :keyword:`!elif` … jest zamiennikiem instrukcji ``switch`` lub "
"``case`` z innych języków."

msgid ""
"If you're comparing the same value to several constants, or checking for "
"specific types or attributes, you may also find the :keyword:`!match` "
"statement useful. For more details see :ref:`tut-match`."
msgstr ""
"Jeśli porównujesz tę samą wartość z wieloma stałymi lub sprawdzasz "
"poszczególne typy lub atrybuty, może ci się przydać instrukcja :keyword:`!"
"match`. Więcej szczegółów znajdziesz w :ref:`tut-match`."

msgid ":keyword:`!for` Statements"
msgstr "Instrukcje :keyword:`!for`"

msgid ""
"The :keyword:`for` statement in Python differs a bit from what you may be "
"used to in C or Pascal.  Rather than always iterating over an arithmetic "
"progression of numbers (like in Pascal), or giving the user the ability to "
"define both the iteration step and halting condition (as C), Python's :"
"keyword:`!for` statement iterates over the items of any sequence (a list or "
"a string), in the order that they appear in the sequence.  For example (no "
"pun intended):"
msgstr ""
"Instrukcja :keyword:`for` różni się troszeczkę w Pythonie od tego, co "
"używasz w C lub Pascalu. Nie prowadzi się iteracji od liczby do liczby (jak "
"w Pascalu) lub daje się użytkownikowi możliwość definiowania kroku iteracji "
"i warunki zakończenia iteracji (jak w C). Instrukcja :keyword:`!for` w "
"Pythonie powoduje iterację po elementach jakiejkolwiek sekwencji (listy lub "
"łańcucha znaków), w takim porządku, w jakim są one umieszczone w danej "
"sekwencji. Na przykład (gra słów niezamierzona):"

msgid ""
">>> # Measure some strings:\n"
">>> words = ['cat', 'window', 'defenestrate']\n"
">>> for w in words:\n"
"...     print(w, len(w))\n"
"...\n"
"cat 3\n"
"window 6\n"
"defenestrate 12"
msgstr ""
">>> # Zmierz kilka napisów:\n"
">>> words = ['kot', 'okienko', 'defenestracja']\n"
">>> for w in words:\n"
"...     print(w, len(w))\n"
"...\n"
"kot 3\n"
"okienko 7\n"
"defenestracja 13"

msgid ""
"Code that modifies a collection while iterating over that same collection "
"can be tricky to get right.  Instead, it is usually more straight-forward to "
"loop over a copy of the collection or to create a new collection::"
msgstr ""
"Kod, który zmienia kolekcję podczas iterowania po niej, może być trudny. "
"Zamiast tego, zazwyczaj prostsze jest przejść pętlą po kopii kolekcji lub "
"stworzyć nową kolekcję::"

msgid ""
"# Create a sample collection\n"
"users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}\n"
"\n"
"# Strategy:  Iterate over a copy\n"
"for user, status in users.copy().items():\n"
"    if status == 'inactive':\n"
"        del users[user]\n"
"\n"
"# Strategy:  Create a new collection\n"
"active_users = {}\n"
"for user, status in users.items():\n"
"    if status == 'active':\n"
"        active_users[user] = status"
msgstr ""
"# Utwórz próbną kolekcję\n"
"users = {'Hans': 'aktywny', 'Éléonore': 'nieaktywny', '景太郎': 'aktywny'}\n"
"\n"
"# Strategia:  Iteracja po kopii\n"
"for user, status in users.copy().items():\n"
"    if status == 'nieaktywny':\n"
"        del users[user]\n"
"\n"
"# Strategia:  Utwórz nową kolekcję\n"
"active_users = {}\n"
"for user, status in users.items():\n"
"    if status == 'aktywny':\n"
"        active_users[user] = status"

msgid "The :func:`range` Function"
msgstr "Funkcja :func:`range`"

msgid ""
"If you do need to iterate over a sequence of numbers, the built-in function :"
"func:`range` comes in handy.  It generates arithmetic progressions::"
msgstr ""
"Jeśli potrzebujesz iterować po sekwencji liczb, przydatna jest wbudowana "
"funkcja :func:`range`. Generuje ciągi arytmetyczne::"

msgid ""
">>> for i in range(5):\n"
"...     print(i)\n"
"...\n"
"0\n"
"1\n"
"2\n"
"3\n"
"4"
msgstr ""
">>> for i in range(5):\n"
"...     print(i)\n"
"...\n"
"0\n"
"1\n"
"2\n"
"3\n"
"4"

msgid ""
"The given end point is never part of the generated sequence; ``range(10)`` "
"generates 10 values, the legal indices for items of a sequence of length "
"10.  It is possible to let the range start at another number, or to specify "
"a different increment (even negative; sometimes this is called the 'step')::"
msgstr ""
"Podany punkt końcowy nigdy nie jest częścią generowanej sekwencji; "
"``range(10)`` generuje 10 wartości, poprawne indeksy dla elementów sekwencji "
"o długości 10. Możliwe jest zacząć zakres od innej liczby lub podać inne "
"zwiększenie (nawet ujemne; czasem jest to nazywane „krokiem”)::"

msgid ""
">>> list(range(5, 10))\n"
"[5, 6, 7, 8, 9]\n"
"\n"
">>> list(range(0, 10, 3))\n"
"[0, 3, 6, 9]\n"
"\n"
">>> list(range(-10, -100, -30))\n"
"[-10, -40, -70]"
msgstr ""
">>> list(range(5, 10))\n"
"[5, 6, 7, 8, 9]\n"
"\n"
">>> list(range(0, 10, 3))\n"
"[0, 3, 6, 9]\n"
"\n"
">>> list(range(-10, -100, -30))\n"
"[-10, -40, -70]"

msgid ""
"To iterate over the indices of a sequence, you can combine :func:`range` "
"and :func:`len` as follows::"
msgstr ""
"By przeiterować po indeksach sekwencji możesz połączyć :func:`range` i :func:"
"`len` w następujący sposób::"

msgid ""
">>> a = ['Mary', 'had', 'a', 'little', 'lamb']\n"
">>> for i in range(len(a)):\n"
"...     print(i, a[i])\n"
"...\n"
"0 Mary\n"
"1 had\n"
"2 a\n"
"3 little\n"
"4 lamb"
msgstr ""
">>> a = ['Wyszły', 'w', 'pole', 'kurki', 'trzy']\n"
">>> for i in range(len(a)):\n"
"...     print(i, a[i])\n"
"...\n"
"0 Wyszły\n"
"1 w\n"
"2 pole\n"
"3 kurki\n"
"4 trzy"

msgid ""
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
msgstr ""
"Jednak w większości takich przypadków wygodnie jest użyć funkcji :func:"
"`enumerate`, patrz :ref:`tut-loopidioms`."

msgid "A strange thing happens if you just print a range::"
msgstr "Dzieje się dziwna rzecz jeśli po prostu wydrukujesz zakres::"

msgid ""
">>> range(10)\n"
"range(0, 10)"
msgstr ""
">>> range(10)\n"
"range(0, 10)"

msgid ""
"In many ways the object returned by :func:`range` behaves as if it is a "
"list, but in fact it isn't. It is an object which returns the successive "
"items of the desired sequence when you iterate over it, but it doesn't "
"really make the list, thus saving space."
msgstr ""
"Pod wieloma względami obiekt zwracany przez :func:`range` zachowuje się, "
"jakby był listą, ale w rzeczywistości nią nie jest. Jest obiektem, który "
"zwraca kolejne elementy żądanej sekwencji w trakcie twojego iterowania po "
"nim, lecz naprawdę nie tworzy listy, tak więc oszczędza miejsce w pamięci "
"komputera."

msgid ""
"We say such an object is :term:`iterable`, that is, suitable as a target for "
"functions and constructs that expect something from which they can obtain "
"successive items until the supply is exhausted.  We have seen that the :"
"keyword:`for` statement is such a construct, while an example of a function "
"that takes an iterable is :func:`sum`::"
msgstr ""
"Mówimy, że taki obiekt to :term:`iterable`, to znaczy odpowiedni jako cel "
"dla funkcji i konstrukcji, które spodziewają się czegoś, z czego można "
"pobierać kolejne elementy aż do wyczerpania zapasu. Widzieliśmy, że "
"instrukcja :keyword:`for` jest takim konstruktem, podczas gdy przykładem "
"funkcji, która spodziewa się obiektu iterable jest :func:`sum`::"

msgid ""
">>> sum(range(4))  # 0 + 1 + 2 + 3\n"
"6"
msgstr ""
">>> sum(range(4))  # 0 + 1 + 2 + 3\n"
"6"

msgid ""
"Later we will see more functions that return iterables and take iterables as "
"arguments.  In chapter :ref:`tut-structures`, we will discuss in more detail "
"about :func:`list`."
msgstr ""
"Później napotkamy więcej funkcji, które zwracają iterable i biorą iterable "
"jako argumenty. W rozdziale :ref:`tut-structures`, omówimy bardziej "
"szczegółowo :func:`list`."

msgid ":keyword:`!break` and :keyword:`!continue` Statements"
msgstr "Instrukcje :keyword:`!break` oraz :keyword:`!continue`"

msgid ""
"The :keyword:`break` statement breaks out of the innermost enclosing :"
"keyword:`for` or :keyword:`while` loop::"
msgstr ""
"Instrukcja :keyword:`break` wyłamuje się z najbardziej wewnętrznej pętli :"
"keyword:`for` lub :keyword:`while`::"

msgid ""
">>> for n in range(2, 10):\n"
"...     for x in range(2, n):\n"
"...         if n % x == 0:\n"
"...             print(f\"{n} equals {x} * {n//x}\")\n"
"...             break\n"
"...\n"
"4 equals 2 * 2\n"
"6 equals 2 * 3\n"
"8 equals 2 * 4\n"
"9 equals 3 * 3"
msgstr ""
">>> for n in range(2, 10):\n"
"...     for x in range(2, n):\n"
"...         if n % x == 0:\n"
"...             print(f\"{n} równa się {x} * {n//x}\")\n"
"...             break\n"
"...\n"
"4 równa się 2 * 2\n"
"6 równa się 2 * 3\n"
"8 równa się 2 * 4\n"
"9 równa się 3 * 3"

msgid ""
"The :keyword:`continue` statement continues with the next iteration of the "
"loop::"
msgstr "Instrukcja :keyword:`continue` kontynuuje następną iterację pętli::"

msgid ""
">>> for num in range(2, 10):\n"
"...     if num % 2 == 0:\n"
"...         print(f\"Found an even number {num}\")\n"
"...         continue\n"
"...     print(f\"Found an odd number {num}\")\n"
"...\n"
"Found an even number 2\n"
"Found an odd number 3\n"
"Found an even number 4\n"
"Found an odd number 5\n"
"Found an even number 6\n"
"Found an odd number 7\n"
"Found an even number 8\n"
"Found an odd number 9"
msgstr ""
">>> for num in range(2, 10):\n"
"...     if num % 2 == 0:\n"
"...         print(f\"Znaleziono liczbę parzystą {num}\")\n"
"...         continue\n"
"...     print(f\"Znaleziono liczbę nieparzystą {num}\")\n"
"...\n"
"Znaleziono liczbę parzystą 2\n"
"Znaleziono liczbę nieparzystą 3\n"
"Znaleziono liczbę parzystą 4\n"
"Znaleziono liczbę nieparzystą 5\n"
"Znaleziono liczbę parzystą 6\n"
"Znaleziono liczbę nieparzystą 7\n"
"Znaleziono liczbę parzystą 8\n"
"Znaleziono liczbę nieparzystą 9"

msgid ":keyword:`!else` Clauses on Loops"
msgstr "Klauzule :keyword:`!else` na pętlach"

msgid ""
"In a :keyword:`!for` or :keyword:`!while` loop the :keyword:`!break` "
"statement may be paired with an :keyword:`!else` clause.  If the loop "
"finishes without executing the :keyword:`!break`, the :keyword:`!else` "
"clause executes."
msgstr ""
"W pętli :keyword:`!for` lub :keyword:`!while` instrukcja :keyword:`!break` "
"może być sparowana z klauzulą :keyword:`!else`. Jeśli pętla zakończy się bez "
"wykonania :keyword:`!break`, wykonana zostanie klauzula :keyword:`!else`."

msgid ""
"In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the "
"loop finishes its final iteration, that is, if no break occurred."
msgstr ""
"W pętli :keyword:`for`, klauzula :keyword:`!else` jest wykonywana po tym, "
"jak pętla zakończy swoją ostatnią iterację, czyli jeśli nie nastąpiło "
"przerwanie."

msgid ""
"In a :keyword:`while` loop, it's executed after the loop's condition becomes "
"false."
msgstr ""
"W pętli :keyword:`while`, klauzula wykonuje się ostatni raz po tym, jak "
"warunek pętli staje się fałszywy."

msgid ""
"In either kind of loop, the :keyword:`!else` clause is **not** executed if "
"the loop was terminated by a :keyword:`break`.  Of course, other ways of "
"ending the loop early, such as a :keyword:`return` or a raised exception, "
"will also skip execution of the :keyword:`else` clause."
msgstr ""
"W obu rodzajach pętli, :keyword:`!else` klauzula **nie** jest wykonywana, "
"jeśli pętla została zakończona przez :keyword:`break`. Oczywiście, inne "
"sposoby wcześniejszego zakończenia pętli, takie jak :keyword:`return` lub "
"rzucenie wyjątku, również pominą wykonanie klauzuli :keyword:`else`."

msgid ""
"This is exemplified in the following :keyword:`!for` loop, which searches "
"for prime numbers::"
msgstr ""
"Jest to zilustrowane w poniższej pętli :keyword:`!for`, która szuka liczb "
"pierwszych::"

msgid ""
">>> for n in range(2, 10):\n"
"...     for x in range(2, n):\n"
"...         if n % x == 0:\n"
"...             print(n, 'equals', x, '*', n//x)\n"
"...             break\n"
"...     else:\n"
"...         # loop fell through without finding a factor\n"
"...         print(n, 'is a prime number')\n"
"...\n"
"2 is a prime number\n"
"3 is a prime number\n"
"4 equals 2 * 2\n"
"5 is a prime number\n"
"6 equals 2 * 3\n"
"7 is a prime number\n"
"8 equals 2 * 4\n"
"9 equals 3 * 3"
msgstr ""
">>> for n in range(2, 10):\n"
"...     for x in range(2, n):\n"
"...         if n % x == 0:\n"
"...             print(n, 'równa się', x, '*', n//x)\n"
"...             break\n"
"...     else:\n"
"...         # pętla przeszła całość nie znajdując dzielnika\n"
"...         print(n, 'jest liczbą pierwszą')\n"
"...\n"
"2 jest liczbą pierwszą\n"
"3 jest liczbą pierwszą\n"
"4 równa się 2 * 2\n"
"5 jest liczbą pierwszą\n"
"6 równa się 2 * 3\n"
"7 jest liczbą pierwszą\n"
"8 równa się 2 * 4\n"
"9 równa się 3 * 3"

msgid ""
"(Yes, this is the correct code.  Look closely: the ``else`` clause belongs "
"to the ``for`` loop, **not** the ``if`` statement.)"
msgstr ""
"(Tak, to jest poprawny kod. Przyjrzyjcie się uważnie: klauzula ``else`` "
"należy do pętli ``for``, **nie** do instrukcji ``if``.)"

msgid ""
"One way to think of the else clause is to imagine it paired with the ``if`` "
"inside the loop.  As the loop executes, it will run a sequence like if/if/if/"
"else. The ``if`` is inside the loop, encountered a number of times. If the "
"condition is ever true, a ``break`` will happen. If the condition is never "
"true, the ``else`` clause outside the loop will execute."
msgstr ""
"Jednym ze sposobów myślenia o klauzuli else jest wyobrażenie sobie jej w "
"połączeniu z ``if`` wewnątrz pętli. Podczas wykonywania pętli będzie ona "
"wykonywać sekwencję if/if/if/else. Warunek ``if`` znajduje się wewnątrz "
"pętli, napotykany wiele razy. Jeśli warunek zostanie kiedykolwiek spełniony, "
"nastąpi ``break``. Jeśli warunek nigdy się nie spełni, zostanie wykonana "
"klauzula ``else`` spoza pętli."

msgid ""
"When used with a loop, the ``else`` clause has more in common with the "
"``else`` clause of a :keyword:`try` statement than it does with that of "
"``if`` statements: a ``try`` statement's ``else`` clause runs when no "
"exception occurs, and a loop's ``else`` clause runs when no ``break`` "
"occurs. For more on the ``try`` statement and exceptions, see :ref:`tut-"
"handling`."
msgstr ""
"W przypadku użycia z pętlą, klauzula ``else`` ma więcej wspólnego z klauzulą "
"``else`` instrukcji :keyword:`try` niż z instrukcją ``if``: klauzula "
"``else`` instrukcji ``try`` działa, gdy nie wystąpi wyjątek, a klauzula "
"``else`` pętli działa, gdy nie wystąpi ``break``. Więcej informacji na temat "
"instrukcji ``try`` i wyjątków można znaleźć w rozdziale :ref:`tut-handling`."

msgid ":keyword:`!pass` Statements"
msgstr "Instrukcje :keyword:`!pass`"

msgid ""
"The :keyword:`pass` statement does nothing. It can be used when a statement "
"is required syntactically but the program requires no action. For example::"
msgstr ""
"Instrukcja :keyword:`pass` nie robi nic. Można jej użyć, gdy składnia wymaga "
"instrukcji a program nie wymaga działania. Na przykład::"

msgid ""
">>> while True:\n"
"...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)\n"
"..."
msgstr ""
">>> while True:\n"
"...     pass  # Aktywne oczekiwanie na przerwanie z klawiatury (Ctrl+C)\n"
"..."

msgid "This is commonly used for creating minimal classes::"
msgstr "Często jej się używa do tworzenia minimalnych klas::"

msgid ""
">>> class MyEmptyClass:\n"
"...     pass\n"
"..."
msgstr ""
">>> class MyEmptyClass:\n"
"...     pass\n"
"..."

msgid ""
"Another place :keyword:`pass` can be used is as a place-holder for a "
"function or conditional body when you are working on new code, allowing you "
"to keep thinking at a more abstract level.  The :keyword:`!pass` is silently "
"ignored::"
msgstr ""
"Innym miejscem, w którym można użyć :keyword:`pass` to placeholder dla "
"funkcji lub ciała warunku, kiedy pracujesz nad nowym kodem. Pozwoli ci to "
"myśleć na bardziej abstrakcyjnym poziomie. :keyword:`!pass` jest „po cichu” "
"ignorowane::"

msgid ""
">>> def initlog(*args):\n"
"...     pass   # Remember to implement this!\n"
"..."
msgstr ""
">>> def initlog(*args):\n"
"...     pass   # Pamiętaj, aby to zaimplementować!\n"
"..."

msgid ":keyword:`!match` Statements"
msgstr "Instrukcje :keyword:`!match`"

msgid ""
"A :keyword:`match` statement takes an expression and compares its value to "
"successive patterns given as one or more case blocks.  This is superficially "
"similar to a switch statement in C, Java or JavaScript (and many other "
"languages), but it's more similar to pattern matching in languages like Rust "
"or Haskell. Only the first pattern that matches gets executed and it can "
"also extract components (sequence elements or object attributes) from the "
"value into variables."
msgstr ""
"Instrukcja :keyword:`match` bierze wyrażenie i porównuje jego wartość do "
"kolejnych wzorców podanych jako jeden lub więcej blok case. Jest to "
"powierzchownie podobne do instrukcji switch w C, Javie lub JavaScripcie (i "
"wielu innych językach), ale bardziej jest podobne do pattern matchingu w "
"takich językach jak Rust lub Haskell. Jedynie pierwszy pasujący wzorzec jest "
"zostaje wykonany i może on również wydobywać komponenty (elementy sekwencji "
"lub atrybuty obiektu) z wartości do zmiennych."

msgid ""
"The simplest form compares a subject value against one or more literals::"
msgstr ""
"Najprostsza forma porównuje wartość podmiotu z jednym lub wieloma "
"literałami::"

msgid ""
"def http_error(status):\n"
"    match status:\n"
"        case 400:\n"
"            return \"Bad request\"\n"
"        case 404:\n"
"            return \"Not found\"\n"
"        case 418:\n"
"            return \"I'm a teapot\"\n"
"        case _:\n"
"            return \"Something's wrong with the internet\""
msgstr ""
"def http_error(status):\n"
"    match status:\n"
"        case 400:\n"
"            return \"Niewłaściwe żądanie\"\n"
"        case 404:\n"
"            return \"Nie znaleziono\"\n"
"        case 418:\n"
"            return \"Jestem czajniczkiem\"\n"
"        case _:\n"
"            return \"Coś jest nie tak z internetem\""

msgid ""
"Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and "
"never fails to match. If no case matches, none of the branches is executed."
msgstr ""
"Zwróć uwagę na ostatni blok: „nazwa zmiennej” ``_`` zachowuje się jak *dzika "
"karta* i zawsze znajduje dopasowanie. Jeśli żaden z case'ów nie będzie "
"dopasowany, żadne z rozgałęzień nie będzie wykonane."

msgid ""
"You can combine several literals in a single pattern using ``|`` (\"or\")::"
msgstr "Możesz łączyć kilka literałów w jeden wzorzec używając ``|`` („or”)::"

msgid ""
"case 401 | 403 | 404:\n"
"    return \"Not allowed\""
msgstr ""
"case 401 | 403 | 404:\n"
"    return \"Niedozwolone\""

msgid ""
"Patterns can look like unpacking assignments, and can be used to bind "
"variables::"
msgstr ""
"Wzorce mogą wyglądać jak przypisania rozpakowujące i można ich używać do "
"powiązywania zmiennych::"

msgid ""
"# point is an (x, y) tuple\n"
"match point:\n"
"    case (0, 0):\n"
"        print(\"Origin\")\n"
"    case (0, y):\n"
"        print(f\"Y={y}\")\n"
"    case (x, 0):\n"
"        print(f\"X={x}\")\n"
"    case (x, y):\n"
"        print(f\"X={x}, Y={y}\")\n"
"    case _:\n"
"        raise ValueError(\"Not a point\")"
msgstr ""
"# punkt to dwukrotka (x, y)\n"
"match point:\n"
"    case (0, 0):\n"
"        print(\"Początek\")\n"
"    case (0, y):\n"
"        print(f\"Y={y}\")\n"
"    case (x, 0):\n"
"        print(f\"X={x}\")\n"
"    case (x, y):\n"
"        print(f\"X={x}, Y={y}\")\n"
"    case _:\n"
"        raise ValueError(\"Nie punkt\")"

msgid ""
"Study that one carefully!  The first pattern has two literals, and can be "
"thought of as an extension of the literal pattern shown above.  But the next "
"two patterns combine a literal and a variable, and the variable *binds* a "
"value from the subject (``point``).  The fourth pattern captures two values, "
"which makes it conceptually similar to the unpacking assignment ``(x, y) = "
"point``."
msgstr ""
"Przyjrzyj się temu uważnie! Pierwszy wzorzec ma dwa literały i można o nim "
"myśleć jako o rozszerzeniu dosłownego wzorca pokazanego wyżej. Ale następne "
"dwa wzorce składają się z literału i zmiennej. Ta zmienna *wiąże* wartość z "
"podmiotu (``point``). Czwarty wzorzec wyłapuje dwie wartości, co czyni go "
"konceptualnie bliższym do przypisania z „rozpakowaniem” ``(x, y) = point``."

msgid ""
"If you are using classes to structure your data you can use the class name "
"followed by an argument list resembling a constructor, but with the ability "
"to capture attributes into variables::"
msgstr ""
"Jeśli używasz klas, aby nadać strukturę swoim danym, możesz użyć nazwę klasy "
"oraz listę argumentów przypominającą konstruktor, ale z możliwością "
"wyłapania atrybutów w zmienne::"

msgid ""
"class Point:\n"
"    def __init__(self, x, y):\n"
"        self.x = x\n"
"        self.y = y\n"
"\n"
"def where_is(point):\n"
"    match point:\n"
"        case Point(x=0, y=0):\n"
"            print(\"Origin\")\n"
"        case Point(x=0, y=y):\n"
"            print(f\"Y={y}\")\n"
"        case Point(x=x, y=0):\n"
"            print(f\"X={x}\")\n"
"        case Point():\n"
"            print(\"Somewhere else\")\n"
"        case _:\n"
"            print(\"Not a point\")"
msgstr ""
"class Point:\n"
"    def __init__(self, x, y):\n"
"        self.x = x\n"
"        self.y = y\n"
"\n"
"def where_is(point):\n"
"    match point:\n"
"        case Point(x=0, y=0):\n"
"            print(\"Początek\")\n"
"        case Point(x=0, y=y):\n"
"            print(f\"Y={y}\")\n"
"        case Point(x=x, y=0):\n"
"            print(f\"X={x}\")\n"
"        case Point():\n"
"            print(\"Gdzieś indziej\")\n"
"        case _:\n"
"            print(\"Nie punkt\")"

msgid ""
"You can use positional parameters with some builtin classes that provide an "
"ordering for their attributes (e.g. dataclasses). You can also define a "
"specific position for attributes in patterns by setting the "
"``__match_args__`` special attribute in your classes. If it's set to (\"x\", "
"\"y\"), the following patterns are all equivalent (and all bind the ``y`` "
"attribute to the ``var`` variable)::"
msgstr ""
"Możesz użyć parametrów pozycyjnych z jakimiś wbudowanymi klasami, które "
"posiadają kolejność dla atrybutów (na przykład dataclasses). Możesz też "
"określić wybrane pozycje dla atrybutów we wzorcach ustawiając specjalny "
"atrybut ``__match_args__`` w twoich klasach. Jeśli jest on ustawiony na "
"(„x”, „y”), wszystkie następujące wzorce są równoważne (i wszystkie "
"powiązują atrybut ``y`` ze zmienną ``var``)::"

msgid ""
"Point(1, var)\n"
"Point(1, y=var)\n"
"Point(x=1, y=var)\n"
"Point(y=var, x=1)"
msgstr ""
"Point(1, var)\n"
"Point(1, y=var)\n"
"Point(x=1, y=var)\n"
"Point(y=var, x=1)"

msgid ""
"A recommended way to read patterns is to look at them as an extended form of "
"what you would put on the left of an assignment, to understand which "
"variables would be set to what. Only the standalone names (like ``var`` "
"above) are assigned to by a match statement. Dotted names (like ``foo."
"bar``), attribute names (the ``x=`` and ``y=`` above) or class names "
"(recognized by the \"(...)\" next to them like ``Point`` above) are never "
"assigned to."
msgstr ""
"Rekomendowanym sposobem na czytanie wzorców jest patrzenie na nie jako na "
"rozszerzoną formę tego, co wstawił(a)byś po lewej stronie przypisania, aby "
"zrozumieć które zmienne będą ustawione na co. Tylko samodzielne nazwy (jak "
"``var`` powyżej) zyskują przypisanie w instrukcji match. Nazwy z kropkami "
"(jak ``foo.bar``), nazwy atrybutów (``x=`` i ``y=`` powyżej) lub nazwy klas "
"(rozpoznawane przez „(…)” przy nich jak ``Point`` powyżej) nie mają nigdy "
"przypisań."

msgid ""
"Patterns can be arbitrarily nested.  For example, if we have a short list of "
"Points, with ``__match_args__`` added, we could match it like this::"
msgstr ""
"Wzory mogą być zagnieżdżane w dowolny sposób. Na przykład, jeśli mamy krótką "
"listę punktów, z dodanym ``__match_args__``, możemy dopasować ją w "
"następujący sposób::"

msgid ""
"class Point:\n"
"    __match_args__ = ('x', 'y')\n"
"    def __init__(self, x, y):\n"
"        self.x = x\n"
"        self.y = y\n"
"\n"
"match points:\n"
"    case []:\n"
"        print(\"No points\")\n"
"    case [Point(0, 0)]:\n"
"        print(\"The origin\")\n"
"    case [Point(x, y)]:\n"
"        print(f\"Single point {x}, {y}\")\n"
"    case [Point(0, y1), Point(0, y2)]:\n"
"        print(f\"Two on the Y axis at {y1}, {y2}\")\n"
"    case _:\n"
"        print(\"Something else\")"
msgstr ""
"class Point:\n"
"    __match_args__ = ('x', 'y')\n"
"    def __init__(self, x, y):\n"
"        self.x = x\n"
"        self.y = y\n"
"\n"
"match points:\n"
"    case []:\n"
"        print(\"Brak punktów\")\n"
"    case [Point(0, 0)]:\n"
"        print(\"Początek\")\n"
"    case [Point(x, y)]:\n"
"        print(f\"Pojedynczy punkt {x}, {y}\")\n"
"    case [Point(0, y1), Point(0, y2)]:\n"
"        print(f\"Dwa na osi Y na {y1}, {y2}\")\n"
"    case _:\n"
"        print(\"Coś innego\")"

msgid ""
"We can add an ``if`` clause to a pattern, known as a \"guard\".  If the "
"guard is false, ``match`` goes on to try the next case block.  Note that "
"value capture happens before the guard is evaluated::"
msgstr ""
"Możemy dodać klauzulę ``if`` do wzorca, nazywaną „guardem”. Jeśli guard jest "
"fałszywy, ``match`` próbuje dopasować następny blok case. Zwróć uwagę, że "
"przechwycenie wartości dzieje się zanim wyliczona jest wartość guarda::"

msgid ""
"match point:\n"
"    case Point(x, y) if x == y:\n"
"        print(f\"Y=X at {x}\")\n"
"    case Point(x, y):\n"
"        print(f\"Not on the diagonal\")"
msgstr ""
"match point:\n"
"    case Point(x, y) if x == y:\n"
"        print(f\"Y=X at {x}\")\n"
"    case Point(x, y):\n"
"        print(f\"Nie na przekątnej\")"

msgid "Several other key features of this statement:"
msgstr "Kilka innych ważnych funkcjonalności tej instrukcji:"

msgid ""
"Like unpacking assignments, tuple and list patterns have exactly the same "
"meaning and actually match arbitrary sequences.  An important exception is "
"that they don't match iterators or strings."
msgstr ""
"Podobnie do przypisań z „rozpakowywaniem”, wzorce z krotkami i listami mają "
"to samo znaczenie i dopasowują się do dowolnych sekwencji. Ważnym wyjątkiem "
"jest to, że nie dopasowują się do iteratorów i ciągów znaków."

msgid ""
"Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, "
"*rest)`` work similar to unpacking assignments.  The name after ``*`` may "
"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items "
"without binding the remaining items."
msgstr ""
"Wzorce sekwencji wspierają rozszerzone rozpakowywanie: ``[x, y, *rest]`` i "
"``(x, y, *rest)`` działają podobnie do przypisań z rozpakowywaniem. Nazwa po "
"``*`` może być również ``_``, aby ``(x, y, *_)`` dopasowywała się do "
"sekwencji o conajmniej dwóch elementach bez powiązywania ze zmienną "
"pozostałych elementów."

msgid ""
"Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the "
"``\"bandwidth\"`` and ``\"latency\"`` values from a dictionary.  Unlike "
"sequence patterns, extra keys are ignored.  An unpacking like ``**rest`` is "
"also supported.  (But ``**_`` would be redundant, so it is not allowed.)"
msgstr ""
"Wzorce mapowania: ``{\"bandwidth\": b, \"latency\": l}`` przechwytuje "
"wartości ``\"bandwidth\"`` i ``\"latency\"`` ze słownika. W przeciwieństwie "
"do wzorców sekwencji, nadmiarowe klucze są ignorowane. Rozpakowywanie typu "
"``**rest`` jest również wspierane. (Ale ``**_`` byłoby nadmierne, więc jest "
"niedozwolone.)"

msgid "Subpatterns may be captured using the ``as`` keyword::"
msgstr "Można przechwytywać podwzorce używając słowa kluczowego ``as``::"

msgid "case (Point(x1, y1), Point(x2, y2) as p2): ..."
msgstr "case (Point(x1, y1), Point(x2, y2) as p2): ..."

msgid ""
"will capture the second element of the input as ``p2`` (as long as the input "
"is a sequence of two points)"
msgstr ""
"przechwyci drugi element wejścia jako ``p2`` (jeśli wejście jest sekwencją "
"dwóch punktów)"

msgid ""
"Most literals are compared by equality, however the singletons ``True``, "
"``False`` and ``None`` are compared by identity."
msgstr ""
"Większość literałów jest porównywanych przez równość, lecz singletony "
"``True``, ``False`` i ``None`` są porównywane przez identyczność."

msgid ""
"Patterns may use named constants.  These must be dotted names to prevent "
"them from being interpreted as capture variable::"
msgstr ""
"Wzorce mogą używać nazwanych stałych. Trzeba je podawać po kropce, aby "
"uniknąć interpretacji przechwycenia jako zwykłej zmiennej::"

msgid ""
"from enum import Enum\n"
"class Color(Enum):\n"
"    RED = 'red'\n"
"    GREEN = 'green'\n"
"    BLUE = 'blue'\n"
"\n"
"color = Color(input(\"Enter your choice of 'red', 'blue' or 'green': \"))\n"
"\n"
"match color:\n"
"    case Color.RED:\n"
"        print(\"I see red!\")\n"
"    case Color.GREEN:\n"
"        print(\"Grass is green\")\n"
"    case Color.BLUE:\n"
"        print(\"I'm feeling the blues :(\")"
msgstr ""
"from enum import Enum\n"
"class Color(Enum):\n"
"    RED = 'red'\n"
"    GREEN = 'green'\n"
"    BLUE = 'blue'\n"
"\n"
"color = Color(input(\"Wprowadź swój wybór spośród 'red', 'blue' lub 'green': "
"\"))\n"
"\n"
"match color:\n"
"    case Color.RED:\n"
"        print(\"Widzę czerwone!\")\n"
"    case Color.GREEN:\n"
"        print(\"Zielono mi\")\n"
"    case Color.BLUE:\n"
"        print(\"Niebo jest niebieskie\")"

msgid ""
"For a more detailed explanation and additional examples, you can look into :"
"pep:`636` which is written in a tutorial format."
msgstr ""
"Bardziej szczegółowe wyjaśnienie i dodatkowe przykłady możesz znaleźć w :pep:"
"`636`, który jest napisany w formie tutoriala."

msgid "Defining Functions"
msgstr "Definiowanie funkcji"

msgid ""
"We can create a function that writes the Fibonacci series to an arbitrary "
"boundary::"
msgstr ""
"Możemy stworzyć funkcję, która wypisuje ciąg Fibonacciego do wskazanej "
"granicy::"

msgid ""
">>> def fib(n):    # write Fibonacci series less than n\n"
"...     \"\"\"Print a Fibonacci series less than n.\"\"\"\n"
"...     a, b = 0, 1\n"
"...     while a < n:\n"
"...         print(a, end=' ')\n"
"...         a, b = b, a+b\n"
"...     print()\n"
"...\n"
">>> # Now call the function we just defined:\n"
">>> fib(2000)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597"
msgstr ""
">>> def fib(n):    # wypisz ciąg Fibonacciego mniejszy niż n\n"
"...     \"\"\"Wypisz elementy ciągu Fibonacciego mniejsze niż n.\"\"\"\n"
"...     a, b = 0, 1\n"
"...     while a < n:\n"
"...         print(a, end=' ')\n"
"...         a, b = b, a+b\n"
"...     print()\n"
"...\n"
">>> # Teraz wywołaj funkcję, którą właśnie zdefiniowaliśmy:\n"
">>> fib(2000)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597"

msgid ""
"The keyword :keyword:`def` introduces a function *definition*.  It must be "
"followed by the function name and the parenthesized list of formal "
"parameters. The statements that form the body of the function start at the "
"next line, and must be indented."
msgstr ""
"Słowo kluczowe :keyword:`def` oznacza *definicję* funkcji. Po nim musi "
"następować nazwa funkcji oraz lista formalnych parametrów otoczona "
"nawiasami. Instrukcje, które stanowią ciało funkcji zaczynają się w "
"następnej linii i muszą być wcięte."

msgid ""
"The first statement of the function body can optionally be a string literal; "
"this string literal is the function's documentation string, or :dfn:"
"`docstring`. (More about docstrings can be found in the section :ref:`tut-"
"docstrings`.) There are tools which use docstrings to automatically produce "
"online or printed documentation, or to let the user interactively browse "
"through code; it's good practice to include docstrings in code that you "
"write, so make a habit of it."
msgstr ""
"Opcjonalnie, pierwszy wiersz ciała funkcji może być gołym napisem "
"(literałem): jest to tzw. napis dokumentujący lub inaczej :dfn:`docstring`. "
"(Więcej o docstringach znajdziesz w sekcji :ref:`tut-docstrings`.) Istnieją "
"pewne narzędzia, które używają docstringów do automatycznego tworzenia "
"drukowanej lub dostępnej online dokumentacji albo pozwalają użytkownikowi na "
"interaktywne przeglądanie kodu. Dobrym zwyczajem jest pisane napisów "
"dokumentacyjnych w czasie pisania programu: spróbuj się do tego przyzwyczaić."

msgid ""
"The *execution* of a function introduces a new symbol table used for the "
"local variables of the function.  More precisely, all variable assignments "
"in a function store the value in the local symbol table; whereas variable "
"references first look in the local symbol table, then in the local symbol "
"tables of enclosing functions, then in the global symbol table, and finally "
"in the table of built-in names. Thus, global variables and variables of "
"enclosing functions cannot be directly assigned a value within a function "
"(unless, for global variables, named in a :keyword:`global` statement, or, "
"for variables of enclosing functions, named in a :keyword:`nonlocal` "
"statement), although they may be referenced."
msgstr ""
"*Wykonanie* funkcji powoduje stworzenie nowej tablicy symboli lokalnych "
"używanych w tej funkcji. Mówiąc precyzyjniej: wszystkie przypisania do "
"zmiennych lokalnych funkcji powodują umieszczenie tych wartości w lokalnej "
"tablicy symboli. Odniesienia do zmiennych najpierw szukają swych wartości w "
"lokalnej tablicy symboli, potem w lokalnych tablicach symboli funkcji "
"otaczających, potem w globalnej, a dopiero na końcu w tablicy nazw "
"wbudowanych w interpreter. Tak więc, zmiennym globalnym ani zmiennym w "
"otaczających funkcjach nie można wprost przypisać wartości w ciele funkcji "
"(chyba, że zostaną wymienione w niej za pomocą instrukcji :keyword:`global` "
"lub dla zmiennych w otaczających funkcjach, wymienionych w instrukcji :"
"keyword:`nonlocal`), aczkolwiek mogą w niej być używane (czytane)."

msgid ""
"The actual parameters (arguments) to a function call are introduced in the "
"local symbol table of the called function when it is called; thus, arguments "
"are passed using *call by value* (where the *value* is always an object "
"*reference*, not the value of the object). [#]_ When a function calls "
"another function, or calls itself recursively, a new local symbol table is "
"created for that call."
msgstr ""
"Parametry (argumenty) wywołania funkcji wprowadzane są do lokalnej tablicy "
"symboli w momencie wywołania funkcji. Tak więc, argumenty przekazywane są "
"jej przez wartość (gdzie *wartość* jest zawsze *odniesieniem* do obiektu, a "
"nie samym obiektem). [#]_ Nowa tablica symboli tworzona jest również w "
"przypadku, gdy funkcja wywołuje inną funkcję lub wywołuje się przez rekursję."

msgid ""
"A function definition associates the function name with the function object "
"in the current symbol table.  The interpreter recognizes the object pointed "
"to by that name as a user-defined function.  Other names can also point to "
"that same function object and can also be used to access the function::"
msgstr ""
"Definicja funkcji powiązuje nazwę funkcji z obiektem funkcji w aktualnej "
"tablicy symboli. Interpreter rozpoznaje obiekt wskazany tą nazwą jako "
"funkcję zdefiniowaną przez użytkownika. Inne nazwy też mogą wskazywać na ten "
"sam obiekt funkcji i mogą być używane, aby dostać się do funkcji::"

msgid ""
">>> fib\n"
"<function fib at 10042ed0>\n"
">>> f = fib\n"
">>> f(100)\n"
"0 1 1 2 3 5 8 13 21 34 55 89"
msgstr ""
">>> fib\n"
"<function fib at 10042ed0>\n"
">>> f = fib\n"
">>> f(100)\n"
"0 1 1 2 3 5 8 13 21 34 55 89"

msgid ""
"Coming from other languages, you might object that ``fib`` is not a function "
"but a procedure since it doesn't return a value.  In fact, even functions "
"without a :keyword:`return` statement do return a value, albeit a rather "
"boring one.  This value is called ``None`` (it's a built-in name).  Writing "
"the value ``None`` is normally suppressed by the interpreter if it would be "
"the only value written. You can see it if you really want to using :func:"
"`print`::"
msgstr ""
"Przychodząc z innych języków, mógłbyś oponować, że ``fib`` nie jest funkcją, "
"ale procedurą, jako że nie zwraca wartości. Tak naprawdę nawet funkcje bez "
"instrukcji :keyword:`return` zwracają wartość, chociaż dość nudną. Tę "
"wartość nazywamy ``None`` (to wbudowana nazwa). Wypisywanie wartości "
"``None`` jest normalnie pomijane przez interpreter, jeśli miałaby to jedyna "
"wypisywana wartość. Możesz ją zobaczyć, jeśli bardzo chcesz, używając :func:"
"`print`::"

msgid ""
">>> fib(0)\n"
">>> print(fib(0))\n"
"None"
msgstr ""
">>> fib(0)\n"
">>> print(fib(0))\n"
"None"

msgid ""
"It is simple to write a function that returns a list of the numbers of the "
"Fibonacci series, instead of printing it::"
msgstr ""
"Prosto można napisać funkcję, która zwraca listę numerów ciągu Fibonnaciego "
"zamiast go wyświetlać::"

msgid ""
">>> def fib2(n):  # return Fibonacci series up to n\n"
"...     \"\"\"Return a list containing the Fibonacci series up to n.\"\"\"\n"
"...     result = []\n"
"...     a, b = 0, 1\n"
"...     while a < n:\n"
"...         result.append(a)    # see below\n"
"...         a, b = b, a+b\n"
"...     return result\n"
"...\n"
">>> f100 = fib2(100)    # call it\n"
">>> f100                # write the result\n"
"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]"
msgstr ""
">>> def fib2(n):  # Zwróć ciąg Fibonacciego do n\n"
"...     \"\"\"Zwróć listę zawierającą ciąg Fibonacciego do n.\"\"\"\n"
"...     result = []\n"
"...     a, b = 0, 1\n"
"...     while a < n:\n"
"...         result.append(a)    # Zobacz poniżej\n"
"...         a, b = b, a+b\n"
"...     return result\n"
"...\n"
">>> f100 = fib2(100)    # Wywołaj\n"
">>> f100                # Wypisz wynik\n"
"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]"

msgid "This example, as usual, demonstrates some new Python features:"
msgstr "Ten przykład, jak zazwyczaj, prezentuje nowe cechy Pythona:"

msgid ""
"The :keyword:`return` statement returns with a value from a function. :"
"keyword:`!return` without an expression argument returns ``None``. Falling "
"off the end of a function also returns ``None``."
msgstr ""
"Instrukcja :keyword:`return` zwraca wartość funkcji. :keyword:`!return` bez "
"wyrażenia podanego jako argument zwraca ``None``. Dojście do końca funkcji "
"również zwraca ``None``."

msgid ""
"The statement ``result.append(a)`` calls a *method* of the list object "
"``result``.  A method is a function that 'belongs' to an object and is named "
"``obj.methodname``, where ``obj`` is some object (this may be an "
"expression), and ``methodname`` is the name of a method that is defined by "
"the object's type. Different types define different methods.  Methods of "
"different types may have the same name without causing ambiguity.  (It is "
"possible to define your own object types and methods, using *classes*, see :"
"ref:`tut-classes`) The method :meth:`!append` shown in the example is "
"defined for list objects; it adds a new element at the end of the list.  In "
"this example it is equivalent to ``result = result + [a]``, but more "
"efficient."
msgstr ""
"Instrukcja ``result.append(a)`` wywołuje *metodę* listy obiektów ``result``. "
"Metoda to funkcja, która „należy” do obiektu i jest nazwana ``obj."
"methodname``, gdzie ``obj`` jest jakimś obiektem (może też być wyrażeniem) a "
"``methodname`` jest nazwą metody, które jest zdefiniowana przez typ obiektu. "
"Różne typy definiują różne metody. Metody różnych typów mogą mieć te same "
"nazwy bez powodowania dwuznaczności. (Da się definiować własne typy obiektów "
"i metody, używając *klas*, patrz :ref:`tut-classes`.) Metoda :meth:`!append` "
"pokazana w przykładzie jest zdefiniowana dla listy obiektów; dodaje nowy "
"element na końcu listy. W tym przykładzie jest równoważna ``result = result "
"+ [a]``, ale bardziej wydajna."

msgid "More on Defining Functions"
msgstr "Więcej o definiowaniu funkcji"

msgid ""
"It is also possible to define functions with a variable number of arguments. "
"There are three forms, which can be combined."
msgstr ""
"Można też definiować funkcje ze zmienną liczbą argumentów. Są trzy sposoby, "
"które można łączyć."

msgid "Default Argument Values"
msgstr "Domyślne wartości argumentów"

msgid ""
"The most useful form is to specify a default value for one or more "
"arguments. This creates a function that can be called with fewer arguments "
"than it is defined to allow.  For example::"
msgstr ""
"Najbardziej przydatnym sposobem jest podanie domyślnej wartości dla jednego "
"lub więcej argumentów. Tworzy to funkcję, która może zostać wywołana z "
"mniejszą liczbą argumentów, niż jest podane w jej definicji. Na przykład::"

msgid ""
"def ask_ok(prompt, retries=4, reminder='Please try again!'):\n"
"    while True:\n"
"        reply = input(prompt)\n"
"        if reply in {'y', 'ye', 'yes'}:\n"
"            return True\n"
"        if reply in {'n', 'no', 'nop', 'nope'}:\n"
"            return False\n"
"        retries = retries - 1\n"
"        if retries < 0:\n"
"            raise ValueError('invalid user response')\n"
"        print(reminder)"
msgstr ""
"def ask_ok(prompt, retries=4, reminder='Spróbuj ponownie!'):\n"
"    while True:\n"
"        reply = input(prompt)\n"
"        if reply in {'t', 'ta', 'tak'}:\n"
"            return True\n"
"        if reply in {'n', 'ni', 'nie'}:\n"
"            return False\n"
"        retries = retries - 1\n"
"        if retries < 0:\n"
"            raise ValueError('Niepoprawna odpowiedź użytkownika')\n"
"        print(reminder)"

msgid "This function can be called in several ways:"
msgstr "Tę funkcję można wywołać na kilka sposobów:"

msgid ""
"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"
msgstr ""
"podając tylko wymagany argument: ``ask_ok('Czy na pewno chcesz wyjść?')``"

msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"2)``"
msgstr ""
"podając jeden z opcjonalnych argumentów: ``ask_ok('OK nadpisać plik?', 2)``"

msgid ""
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "
"on, only yes or no!')``"
msgstr ""
"lub podając wszystkie argumenty: ``ask_ok('OK nadpisać plik?', 2, 'No coś "
"ty, tylko tak lub nie!')``"

msgid ""
"This example also introduces the :keyword:`in` keyword. This tests whether "
"or not a sequence contains a certain value."
msgstr ""
"Ten przykład wprowadza słowo kluczowe :keyword:`in`. Sprawdza ono, czy "
"sekwencja zawiera szczególną wartość."

msgid ""
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
msgstr ""
"Wartości domyślne są ewaluowane w momencie definiowania funkcji w scopie "
"*defining*, więc ::"

msgid ""
"i = 5\n"
"\n"
"def f(arg=i):\n"
"    print(arg)\n"
"\n"
"i = 6\n"
"f()"
msgstr ""
"i = 5\n"
"\n"
"def f(arg=i):\n"
"    print(arg)\n"
"\n"
"i = 6\n"
"f()"

msgid "will print ``5``."
msgstr "wyświetli ``5``."

msgid ""
"**Important warning:**  The default value is evaluated only once. This makes "
"a difference when the default is a mutable object such as a list, "
"dictionary, or instances of most classes.  For example, the following "
"function accumulates the arguments passed to it on subsequent calls::"
msgstr ""
"**Ważna uwaga**: Wartość domyślna jest wyliczana tylko raz. Ma to znaczenie, "
"gdy domyślna wartość jest obiektem mutowalnym takim jak lista, słownik lub "
"instancje większości klas. Na przykład następująca funkcja akumuluje "
"argumenty przekazane do niej w kolejnych wywołaniach::"

msgid ""
"def f(a, L=[]):\n"
"    L.append(a)\n"
"    return L\n"
"\n"
"print(f(1))\n"
"print(f(2))\n"
"print(f(3))"
msgstr ""
"def f(a, L=[]):\n"
"    L.append(a)\n"
"    return L\n"
"\n"
"print(f(1))\n"
"print(f(2))\n"
"print(f(3))"

msgid "This will print ::"
msgstr "To wyświetli ::"

msgid ""
"[1]\n"
"[1, 2]\n"
"[1, 2, 3]"
msgstr ""
"[1]\n"
"[1, 2]\n"
"[1, 2, 3]"

msgid ""
"If you don't want the default to be shared between subsequent calls, you can "
"write the function like this instead::"
msgstr ""
"Jeśli nie chcesz, żeby domyślna wartość była współdzielona pomiędzy "
"kolejnymi wywołaniami, możesz napisać funkcję w ten sposób::"

msgid ""
"def f(a, L=None):\n"
"    if L is None:\n"
"        L = []\n"
"    L.append(a)\n"
"    return L"
msgstr ""
"def f(a, L=None):\n"
"    if L is None:\n"
"        L = []\n"
"    L.append(a)\n"
"    return L"

msgid "Keyword Arguments"
msgstr "Argumenty nazwane"

msgid ""
"Functions can also be called using :term:`keyword arguments <keyword "
"argument>` of the form ``kwarg=value``.  For instance, the following "
"function::"
msgstr ""
"Funkcje mogą być również wywoływane przy użyciu :term:`argumentów nazwanych "
"<keyword argument>` w formie ``kwarg=value``. Na przykład poniższa funkcja::"

msgid ""
"def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n"
"    print(\"-- This parrot wouldn't\", action, end=' ')\n"
"    print(\"if you put\", voltage, \"volts through it.\")\n"
"    print(\"-- Lovely plumage, the\", type)\n"
"    print(\"-- It's\", state, \"!\")"
msgstr ""
"def parrot(voltage, state='jest sztywna', action='fru', type='norweska "
"błękitna'):\n"
"    print(\"-- Ta papuga nie zrobi\", action, end=' ')\n"
"    print(\"nawet jeśli podłączę ją do\", voltage, \"woltów.\")\n"
"    print(\"-- Śliczne upierzenie,\", type)\n"
"    print(\"-- Ona\", state, \"!\")"

msgid ""
"accepts one required argument (``voltage``) and three optional arguments "
"(``state``, ``action``, and ``type``).  This function can be called in any "
"of the following ways::"
msgstr ""
"akceptuje jeden wymagany argument (``voltage``) i trzy opcjonalne argumenty "
"(``state``, ``action`` i ``type``). Funkcja może być wywołana w dowolny z "
"poniższych sposobów::"

msgid ""
"parrot(1000)                                          # 1 positional "
"argument\n"
"parrot(voltage=1000)                                  # 1 keyword argument\n"
"parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments\n"
"parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments\n"
"parrot('a million', 'bereft of life', 'jump')         # 3 positional "
"arguments\n"
"parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 "
"keyword"
msgstr ""
"parrot(1000)                                          # 1 argument "
"pozycyjny\n"
"parrot(voltage=1000)                                  # 1 argument nazwany\n"
"parrot(voltage=1000000, action='FRUUUUU')             # 2 argumenty nazwane\n"
"parrot(action='FRUUUUU', voltage=1000000)             # 2 argumenty nazwane\n"
"parrot('miliona', 'wyzionęła ducha', 'hop')         # 3 argumenty pozycyjne\n"
"parrot('tysiąca', state='wącha kwiatki')  # 1 pozycyjny, 1 nazwany"

msgid "but all the following calls would be invalid::"
msgstr "ale wszystkie poniższe wywołania byłyby niepoprawne::"

msgid ""
"parrot()                     # required argument missing\n"
"parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword "
"argument\n"
"parrot(110, voltage=220)     # duplicate value for the same argument\n"
"parrot(actor='John Cleese')  # unknown keyword argument"
msgstr ""
"parrot()                     # brakuje wymaganego argumentu\n"
"parrot(voltage=5.0, 'zdechła')  # argument nie-nazwany za argumentem "
"nazwanym\n"
"parrot(110, voltage=220)     # zduplikowana wartość dla tego samego "
"argumentu\n"
"parrot(actor='John Cleese')  # nieznany argument nazwany"

msgid ""
"In a function call, keyword arguments must follow positional arguments. All "
"the keyword arguments passed must match one of the arguments accepted by the "
"function (e.g. ``actor`` is not a valid argument for the ``parrot`` "
"function), and their order is not important.  This also includes non-"
"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument "
"may receive a value more than once. Here's an example that fails due to this "
"restriction::"
msgstr ""
"W wywołaniu funkcji argumenty nazwane muszą znajdować się za argumentami "
"pozycyjnymi. Wszystkie przekazane argumenty nazwane muszą pasować do jednego "
"argumentu akceptowanego przez funkcję (na przykład ``actor`` nie jest "
"poprawnym argumentem dla funkcji ``parrot``) a ich kolejność nie ma "
"znaczenia. Dotyczy to również nie-opcjonalnych argumentów (na przykład "
"``parrot(voltage=1000)`` też jest poprawne). Żaden argument nie może "
"otrzymać wartości więcej niż raz. Tutaj jest przykład, który się nie "
"powiedzie z powodu tego ograniczenia::"

msgid ""
">>> def function(a):\n"
"...     pass\n"
"...\n"
">>> function(0, a=0)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: function() got multiple values for argument 'a'"
msgstr ""
">>> def function(a):\n"
"...     pass\n"
"...\n"
">>> function(0, a=0)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: function() got multiple values for argument 'a'"

msgid ""
"When a final formal parameter of the form ``**name`` is present, it receives "
"a dictionary (see :ref:`typesmapping`) containing all keyword arguments "
"except for those corresponding to a formal parameter.  This may be combined "
"with a formal parameter of the form ``*name`` (described in the next "
"subsection) which receives a :ref:`tuple <tut-tuples>` containing the "
"positional arguments beyond the formal parameter list.  (``*name`` must "
"occur before ``**name``.) For example, if we define a function like this::"
msgstr ""
"Kiedy ostatni formalny parametr ma postać ``**nazwa``, to otrzymuje on "
"słownik (zobacz :ref:`typesmapping`) zawierający wszystkie argumenty "
"kluczowe oprócz tych które odpowiadają formalnym parametrom. Może to być "
"połączone z formalnym parametrem o postaci ``*nazwa`` (opisanym w następnej "
"subsekcji) który otrzymuje  :ref:`krotkę <tut-tuples>` zawierającą argumenty "
"pozycyjne z poza listy formalnych parametrów.  (``*nazwa`` musi występować "
"przed ``**nazwa``.) Dla przykładu możemy zdefiniować funkcję tak::"

msgid ""
"def cheeseshop(kind, *arguments, **keywords):\n"
"    print(\"-- Do you have any\", kind, \"?\")\n"
"    print(\"-- I'm sorry, we're all out of\", kind)\n"
"    for arg in arguments:\n"
"        print(arg)\n"
"    print(\"-\" * 40)\n"
"    for kw in keywords:\n"
"        print(kw, \":\", keywords[kw])"
msgstr ""
"def cheeseshop(kind, *arguments, **keywords):\n"
"    print(\"-- Czy jest może\", kind, \"?\")\n"
"    print(\"-- Przykro mi, nie mamy już sera\", kind)\n"
"    for arg in arguments:\n"
"        print(arg)\n"
"    print(\"-\" * 40)\n"
"    for kw in keywords:\n"
"        print(kw, \":\", keywords[kw])"

msgid "It could be called like this::"
msgstr "Można ją wywołać w ten sposób::"

msgid ""
"cheeseshop(\"Limburger\", \"It's very runny, sir.\",\n"
"           \"It's really very, VERY runny, sir.\",\n"
"           shopkeeper=\"Michael Palin\",\n"
"           client=\"John Cleese\",\n"
"           sketch=\"Cheese Shop Sketch\")"
msgstr ""
"cheeseshop(\"limburger\", \"Jest bardzo płynny, proszę pana.\",\n"
"           \"Naprawdę jest bardzo, BARDZO płynny, proszę pana.\",\n"
"           shopkeeper=\"Michael Palin\",\n"
"           client=\"John Cleese\",\n"
"           sketch=\"Sklep z serami\")"

msgid "and of course it would print:"
msgstr "i oczywiście wyświetli się nam:"

msgid ""
"-- Do you have any Limburger ?\n"
"-- I'm sorry, we're all out of Limburger\n"
"It's very runny, sir.\n"
"It's really very, VERY runny, sir.\n"
"----------------------------------------\n"
"shopkeeper : Michael Palin\n"
"client : John Cleese\n"
"sketch : Cheese Shop Sketch"
msgstr ""
"-- Czy jest może limburger ?\n"
"-- Przykro mi, nie mamy już sera limburger\n"
"Jest bardzo płynny, proszę pana.\n"
"Naprawdę jest bardzo, BARDZO płynny, proszę pana.\n"
"----------------------------------------\n"
"shopkeeper : Michael Palin\n"
"client : John Cleese\n"
"sketch : Sklep z serami"

msgid ""
"Note that the order in which the keyword arguments are printed is guaranteed "
"to match the order in which they were provided in the function call."
msgstr ""
"Zwróć uwagę, że kolejność w jakim argumenty kluczowe są wyświetlane "
"dokładnie odpowiada kolejności w jakim zostały one podane w wywołaniu "
"funkcji."

msgid "Special parameters"
msgstr "Parametry specjalne"

msgid ""
"By default, arguments may be passed to a Python function either by position "
"or explicitly by keyword. For readability and performance, it makes sense to "
"restrict the way arguments can be passed so that a developer need only look "
"at the function definition to determine if items are passed by position, by "
"position or keyword, or by keyword."
msgstr ""
"Domyślnie, argumenty mogą być przekazywane do funkcji Pythona albo poprzez "
"swoje umiejscowienie (pozycję)  albo wprost poprzez słowo kluczowe. Dla "
"czytelności oraz wydajności, ma sens aby ograniczyć sposób w jaki argumenty "
"mogą być przekazywane tak aby deweloper musiał tylko spojrzeć na definicję "
"funkcji aby zrozumieć czy argumenty są przekazywane poprzez pozycję, pozycję "
"i słowa kluczowe czy same słowa kluczowe."

msgid "A function definition may look like:"
msgstr "Definicja funkcji może wyglądać w ten sposób:"

msgid ""
"def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):\n"
"      -----------    ----------     ----------\n"
"        |             |                  |\n"
"        |        Positional or keyword   |\n"
"        |                                - Keyword only\n"
"         -- Positional only"
msgstr ""
"def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):\n"
"      -----------    ----------     ----------\n"
"        |             |                  |\n"
"        |        pozycyjny lub nazwany   |\n"
"        |                                - tylko nazwany\n"
"         -- tylko pozycyjne"

msgid ""
"where ``/`` and ``*`` are optional. If used, these symbols indicate the kind "
"of parameter by how the arguments may be passed to the function: positional-"
"only, positional-or-keyword, and keyword-only. Keyword parameters are also "
"referred to as named parameters."
msgstr ""
"gdzie ``/`` i ``*`` są opcjonalne. Jeśli są używane, te symbole wskazują "
"rodzaj parametru poprzez sposób przekazywania argumentów do funkcji: tylko "
"pozycyjne, pozycyjne lub słowo kluczowe i tylko słowo kluczowe. Parametry "
"słów kluczowych są również nazywane parametrami nazwanymi."

msgid "Positional-or-Keyword Arguments"
msgstr "Argumenty pozycyjne-lub-nazwane"

msgid ""
"If ``/`` and ``*`` are not present in the function definition, arguments may "
"be passed to a function by position or by keyword."
msgstr ""
"Jeśli ``/`` czy ``*`` nie są obecne w definicji funkcji, argumenty mogą być "
"przekazywane i poprzez pozycje i przez słowa kluczowe."

msgid "Positional-Only Parameters"
msgstr "Parametry tylko-pozycyjne (positional-only)"

msgid ""
"Looking at this in a bit more detail, it is possible to mark certain "
"parameters as *positional-only*. If *positional-only*, the parameters' order "
"matters, and the parameters cannot be passed by keyword. Positional-only "
"parameters are placed before a ``/`` (forward-slash). The ``/`` is used to "
"logically separate the positional-only parameters from the rest of the "
"parameters. If there is no ``/`` in the function definition, there are no "
"positional-only parameters."
msgstr ""
"Wchodząc w szegóły, można oznaczyć pewne parametry jako *tylko-pozycyjne*. "
"Jeśli argument jest *tylko pozycyjny*, ma znaczenie kolejność parametrów a "
"parametry te nie mogą być przekazywane przez słowa kluczowe. Argumenty tylko-"
"pozycyjne są umieszczane przed ``/`` (forward-slash).  ``/`` rozdziela "
"parametry tylko-pozycyjne od reszty parametrów. Jeśli w definicji funkcji "
"nie ma ``/`` , nie ma parametrów tylko pozycyjnych."

msgid ""
"Parameters following the ``/`` may be *positional-or-keyword* or *keyword-"
"only*."
msgstr ""
"Argumenty po ``/`` mogą mieć charakter *pozycja-lub-słowo-kluczowe* lub "
"*tylko-kluczowe*."

msgid "Keyword-Only Arguments"
msgstr "Argumenty tylko-nazwane (keyword-only)"

msgid ""
"To mark parameters as *keyword-only*, indicating the parameters must be "
"passed by keyword argument, place an ``*`` in the arguments list just before "
"the first *keyword-only* parameter."
msgstr ""
"Aby oznaczyć parametry jako *tylko słowa kluczowe* (*keyword-only*), to "
"znaczy wskazać, że parametry muszą być przekazywane przez argument słowa "
"kluczowego, umieść ``*``  na liście argumentów tuż przed pierwszym "
"parametrem, który ma być przekazywany tylko przez słowo kluczowe."

msgid "Function Examples"
msgstr "Przykłady funkcji"

msgid ""
"Consider the following example function definitions paying close attention "
"to the markers ``/`` and ``*``::"
msgstr ""
"Rozważ następujące przykłady definicji funkcji, przykładając szczególną "
"uwagę do oznaczeń  ``/`` oraz ``*``::"

msgid ""
">>> def standard_arg(arg):\n"
"...     print(arg)\n"
"...\n"
">>> def pos_only_arg(arg, /):\n"
"...     print(arg)\n"
"...\n"
">>> def kwd_only_arg(*, arg):\n"
"...     print(arg)\n"
"...\n"
">>> def combined_example(pos_only, /, standard, *, kwd_only):\n"
"...     print(pos_only, standard, kwd_only)"
msgstr ""
">>> def standard_arg(arg):\n"
"...     print(arg)\n"
"...\n"
">>> def pos_only_arg(arg, /):\n"
"...     print(arg)\n"
"...\n"
">>> def kwd_only_arg(*, arg):\n"
"...     print(arg)\n"
"...\n"
">>> def combined_example(pos_only, /, standard, *, kwd_only):\n"
"...     print(pos_only, standard, kwd_only)"

msgid ""
"The first function definition, ``standard_arg``, the most familiar form, "
"places no restrictions on the calling convention and arguments may be passed "
"by position or keyword::"
msgstr ""
"Pierwsza z definicji, ``standard_arg``, mająca najbardziej znaną formę, nie "
"wprowadza ograniczeń na sposób wywoływania, argumenty mogą być przekazywane "
"poprzez pozycję lub słowo kluczowe::"

msgid ""
">>> standard_arg(2)\n"
"2\n"
"\n"
">>> standard_arg(arg=2)\n"
"2"
msgstr ""
">>> standard_arg(2)\n"
"2\n"
"\n"
">>> standard_arg(arg=2)\n"
"2"

msgid ""
"The second function ``pos_only_arg`` is restricted to only use positional "
"parameters as there is a ``/`` in the function definition::"
msgstr ""
"Druga z funkcji ``pos_only_arg`` jest ograniczona do wykorzystywania tylko "
"argumentów pozycyjnych jako, że posiada ``/`` w swojej definicji::"

msgid ""
">>> pos_only_arg(1)\n"
"1\n"
"\n"
">>> pos_only_arg(arg=1)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: pos_only_arg() got some positional-only arguments passed as "
"keyword arguments: 'arg'"
msgstr ""
">>> pos_only_arg(1)\n"
"1\n"
"\n"
">>> pos_only_arg(arg=1)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: pos_only_arg() got some positional-only arguments passed as "
"keyword arguments: 'arg'"

msgid ""
"The third function ``kwd_only_arg`` only allows keyword arguments as "
"indicated by a ``*`` in the function definition::"
msgstr ""
"Trzecia funkcja ``kwd_only_arg`` zezwala tylko na argumenty nazwane jak "
"wskazuje ``*`` w definicji funkcji::"

msgid ""
">>> kwd_only_arg(3)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given\n"
"\n"
">>> kwd_only_arg(arg=3)\n"
"3"
msgstr ""
">>> kwd_only_arg(3)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given\n"
"\n"
">>> kwd_only_arg(arg=3)\n"
"3"

msgid ""
"And the last uses all three calling conventions in the same function "
"definition::"
msgstr ""
"Ostatnia z funkcji wykorzystuje wszystkie trzy konwencje w swojej definicji::"

msgid ""
">>> combined_example(1, 2, 3)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: combined_example() takes 2 positional arguments but 3 were given\n"
"\n"
">>> combined_example(1, 2, kwd_only=3)\n"
"1 2 3\n"
"\n"
">>> combined_example(1, standard=2, kwd_only=3)\n"
"1 2 3\n"
"\n"
">>> combined_example(pos_only=1, standard=2, kwd_only=3)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: combined_example() got some positional-only arguments passed as "
"keyword arguments: 'pos_only'"
msgstr ""
">>> combined_example(1, 2, 3)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: combined_example() takes 2 positional arguments but 3 were given\n"
"\n"
">>> combined_example(1, 2, kwd_only=3)\n"
"1 2 3\n"
"\n"
">>> combined_example(1, standard=2, kwd_only=3)\n"
"1 2 3\n"
"\n"
">>> combined_example(pos_only=1, standard=2, kwd_only=3)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: combined_example() got some positional-only arguments passed as "
"keyword arguments: 'pos_only'"

msgid ""
"Finally, consider this function definition which has a potential collision "
"between the positional argument ``name``  and ``**kwds`` which has ``name`` "
"as a key::"
msgstr ""
"Na koniec, przyjrzyj się definicji funkcji, która ma potencjalną kolizję "
"pomiędzy pozycyjnym argumentem ``name``  a ``**kwds`` gdzie ``name`` jest "
"kluczem::"

msgid ""
"def foo(name, **kwds):\n"
"    return 'name' in kwds"
msgstr ""
"def foo(name, **kwds):\n"
"    return 'name' in kwds"

msgid ""
"There is no possible call that will make it return ``True`` as the keyword "
"``'name'`` will always bind to the first parameter. For example::"
msgstr ""
"Nie jesteśmy w stanie sprawić, aby ta funkcja zwróciła ``True``, jako że "
"słowo kluczowe ``'name'`` zawsze powiązane będzie z pierwszym parametrem. "
"Dla przykładu::"

msgid ""
">>> foo(1, **{'name': 2})\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: foo() got multiple values for argument 'name'\n"
">>>"
msgstr ""
">>> foo(1, **{'name': 2})\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: foo() got multiple values for argument 'name'\n"
">>>"

msgid ""
"But using ``/`` (positional only arguments), it is possible since it allows "
"``name`` as a positional argument and ``'name'`` as a key in the keyword "
"arguments::"
msgstr ""
"Korzystając z ``/`` (argumentów tylko-pozycyjnych), da się to zrobić "
"ponieważ pozwala ono na ``name`` jako argument pozycyjny i  ``'name'`` jako "
"klucz w argumentach kluczowych::"

msgid ""
">>> def foo(name, /, **kwds):\n"
"...     return 'name' in kwds\n"
"...\n"
">>> foo(1, **{'name': 2})\n"
"True"
msgstr ""
">>> def foo(name, /, **kwds):\n"
"...     return 'name' in kwds\n"
"...\n"
">>> foo(1, **{'name': 2})\n"
"True"

msgid ""
"In other words, the names of positional-only parameters can be used in "
"``**kwds`` without ambiguity."
msgstr ""
"Innymi słowy, nazwy w argumentach pozycyjnych mogą być bez dwuznaczności "
"wykorzystywane jako klucze w ``**kwds``."

msgid "Recap"
msgstr "Podsumowanie"

msgid ""
"The use case will determine which parameters to use in the function "
"definition::"
msgstr ""
"Przypadki użycia determinują, jakich typów parametrów kiedy w definicji "
"funkcji::"

msgid "def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):"
msgstr "def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):"

msgid "As guidance:"
msgstr "Kieruj się następującym:"

msgid ""
"Use positional-only if you want the name of the parameters to not be "
"available to the user. This is useful when parameter names have no real "
"meaning, if you want to enforce the order of the arguments when the function "
"is called or if you need to take some positional parameters and arbitrary "
"keywords."
msgstr ""
"Wykorzystuj argumenty tylko-pozycyjne gdy chcesz aby nazwa parametrów nie "
"była dostepna dla użytkownika. To może być pomocne gdy nazwy parametów nie "
"mają specjalnego znaczenia a ty chcesz wymusić określoną kolejność "
"argumentów gdy funkcja jest wywoływana. Ewentualnie gdy chcesz aby część "
"argumentów była pozycyjna a część była jakimiś słowami kluczowymi."

msgid ""
"Use keyword-only when names have meaning and the function definition is more "
"understandable by being explicit with names or you want to prevent users "
"relying on the position of the argument being passed."
msgstr ""
"Wykorzystuj argumenty tylko-kluczowe gdy nazwy mają znaczenie i definicja "
"funkcji jest łatwiejsza do zrozumienia poprzez wprost podawanie nazw, lub "
"jeśli nie chcesz aby użytkownicy polegali na kolejności argumentów."

msgid ""
"For an API, use positional-only to prevent breaking API changes if the "
"parameter's name is modified in the future."
msgstr ""
"W przypadku budowania API, wykorzystanie argumentów tylko-pozycyjnych "
"pozwoli w przyszłości uniknąć problemów, gdy nazwa parametru jest zmieniona."

msgid "Arbitrary Argument Lists"
msgstr "Arbitralne listy argumentów"

msgid ""
"Finally, the least frequently used option is to specify that a function can "
"be called with an arbitrary number of arguments.  These arguments will be "
"wrapped up in a tuple (see :ref:`tut-tuples`).  Before the variable number "
"of arguments, zero or more normal arguments may occur. ::"
msgstr ""
"Najmniej często wykorzystywaną opcją jest specyfikowanie, że funkcja może "
"być wywoływana z arbitralną liczbą argumentów. Takie argumenty zostaną "
"opakowane w krotkę (zobacz :ref:`krotki <tut-tuples>`). Przed zmienną liczbą "
"argumentów, można wymusić jeden lub więcej argumentów. ::"

msgid ""
"def write_multiple_items(file, separator, *args):\n"
"    file.write(separator.join(args))"
msgstr ""
"def write_multiple_items(file, separator, *args):\n"
"    file.write(separator.join(args))"

msgid ""
"Normally, these *variadic* arguments will be last in the list of formal "
"parameters, because they scoop up all remaining input arguments that are "
"passed to the function. Any formal parameters which occur after the "
"``*args`` parameter are 'keyword-only' arguments, meaning that they can only "
"be used as keywords rather than positional arguments. ::"
msgstr ""
"Zazwyczaj takie argumenty będą ostatnie na liście formalnych parametrów, "
"ponieważ zbierają one wszystkie pozostałe argumenty przekazane funkcji. "
"Każdy formalny argument po parametrze ``*args`` może być  'tylko-kluczowy', "
"to znaczy da się go wprowadzić tylko poprzez słowo kluczowe a nie przez "
"pozycję. ::"

msgid ""
">>> def concat(*args, sep=\"/\"):\n"
"...     return sep.join(args)\n"
"...\n"
">>> concat(\"earth\", \"mars\", \"venus\")\n"
"'earth/mars/venus'\n"
">>> concat(\"earth\", \"mars\", \"venus\", sep=\".\")\n"
"'earth.mars.venus'"
msgstr ""
">>> def concat(*args, sep=\"/\"):\n"
"...     return sep.join(args)\n"
"...\n"
">>> concat(\"ziemia\", \"mars\", \"wenus\")\n"
"'ziemia/mars/wenus'\n"
">>> concat(\"ziemia\", \"mars\", \"wenus\", sep=\".\")\n"
"'ziemia.mars.wenus'"

msgid "Unpacking Argument Lists"
msgstr "Rozpakowywanie listy argumentów"

msgid ""
"The reverse situation occurs when the arguments are already in a list or "
"tuple but need to be unpacked for a function call requiring separate "
"positional arguments.  For instance, the built-in :func:`range` function "
"expects separate *start* and *stop* arguments.  If they are not available "
"separately, write the function call with the  ``*``\\ -operator to unpack "
"the arguments out of a list or tuple::"
msgstr ""
"Odwrotna sytuacja wystąpi, gdy argumenty już są listą albo krotką a muszą "
"być rozpakowane gdyż funkcja wymaga argumentów przekazanych pozycyjnie, "
"jeden po drugim .  Dla przykładu, wbudowana funkcja :func:`range` oczekuje "
"oddzielnych argumentów *start* oraz *stop*. Jeśli nie są dostępne "
"oddzielnie, wywołaj funkcją z operatorem  ``*`` aby wypakować argumenty z "
"listy lub krotki::"

msgid ""
">>> list(range(3, 6))            # normal call with separate arguments\n"
"[3, 4, 5]\n"
">>> args = [3, 6]\n"
">>> list(range(*args))            # call with arguments unpacked from a "
"list\n"
"[3, 4, 5]"
msgstr ""
">>> list(range(3, 6))            # zwykłe wywołanie z osobnymi argumentami\n"
"[3, 4, 5]\n"
">>> args = [3, 6]\n"
">>> list(range(*args))            # wywołanie z argumentami rozpakowanymi z "
"listy\n"
"[3, 4, 5]"

msgid ""
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**``\\ -operator::"
msgstr ""
"W podobny sposób, słowniki moga dostarczać argumentów kluczowych poprzez "
"operator ``**``::"

msgid ""
">>> def parrot(voltage, state='a stiff', action='voom'):\n"
"...     print(\"-- This parrot wouldn't\", action, end=' ')\n"
"...     print(\"if you put\", voltage, \"volts through it.\", end=' ')\n"
"...     print(\"E's\", state, \"!\")\n"
"...\n"
">>> d = {\"voltage\": \"four million\", \"state\": \"bleedin' demised\", "
"\"action\": \"VOOM\"}\n"
">>> parrot(**d)\n"
"-- This parrot wouldn't VOOM if you put four million volts through it. E's "
"bleedin' demised !"
msgstr ""
">>> def parrot(voltage, state='sztywna', action='fru'):\n"
"...     print(\"-- Ta papuga nie zrobi\", action, end=' ')\n"
"...     print(\"nawet jeśli podłączę ją do\", voltage, \"woltów.\", end=' "
"')\n"
"...     print(\"Jest\", state, \"!\")\n"
"...\n"
">>> d = {\"voltage\": \"czterech milionów\", \"state\": \"sztywna jak "
"kłoda\", \"action\": \"FRUU\"}\n"
">>> parrot(**d)\n"
"-- Ta papuga nie zrobi FRUU nawet jeśli podłączę ją do czterech milionów "
"woltów. Jest sztywna jak kłoda !"

msgid "Lambda Expressions"
msgstr "Wyrażenia Lambda"

msgid ""
"Small anonymous functions can be created with the :keyword:`lambda` keyword. "
"This function returns the sum of its two arguments: ``lambda a, b: a+b``. "
"Lambda functions can be used wherever function objects are required.  They "
"are syntactically restricted to a single expression.  Semantically, they are "
"just syntactic sugar for a normal function definition.  Like nested function "
"definitions, lambda functions can reference variables from the containing "
"scope::"
msgstr ""
"Niewielkie anonimowe funkcje mogą byś tworzone z wykorzystaniem słowa "
"kluczowego  :keyword:`lambda`. Wykorzystując tą notację: ``lambda a, b: "
"a+b`` powstanie funkcja sumująca podane argumenty. Funkcje lambda mogą być "
"wykorzystywane zawsze wtedy gdy potrzebne są objekty funkcji. Są "
"synaktycznie ograniczone do jednego wyrażenia. Semantycznie, jest to tylko "
"lukier składniowy normalnej definicji funkcji. Podobnie jak funkcje "
"zagnieżdżone funkcje lambda mogą odwoływać się do zmiennych z otaczającego "
"zakresu ::"

msgid ""
">>> def make_incrementor(n):\n"
"...     return lambda x: x + n\n"
"...\n"
">>> f = make_incrementor(42)\n"
">>> f(0)\n"
"42\n"
">>> f(1)\n"
"43"
msgstr ""
">>> def make_incrementor(n):\n"
"...     return lambda x: x + n\n"
"...\n"
">>> f = make_incrementor(42)\n"
">>> f(0)\n"
"42\n"
">>> f(1)\n"
"43"

msgid ""
"The above example uses a lambda expression to return a function.  Another "
"use is to pass a small function as an argument::"
msgstr ""
"Powyższy przykład wykorzystuje ekspresję lambda aby zwrócić funkcję. Inne "
"wykorzystanie to przekazanie małej funkcji jako argumentu::"

msgid ""
">>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]\n"
">>> pairs.sort(key=lambda pair: pair[1])\n"
">>> pairs\n"
"[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]"
msgstr ""
">>> pairs = [(1, 'jeden'), (2, 'dwa'), (3, 'trzy'), (4, 'cztery')]\n"
">>> pairs.sort(key=lambda pair: pair[1])\n"
">>> pairs\n"
"[(4, 'cztery'), (2, 'dwa'), (1, 'jeden'), (3, 'trzy')]"

msgid "Documentation Strings"
msgstr "Napisy dokumentujące (docstringi)"

msgid ""
"Here are some conventions about the content and formatting of documentation "
"strings."
msgstr "Oto kilka konwencji dotyczących zawartości i formatowania docstringów."

msgid ""
"The first line should always be a short, concise summary of the object's "
"purpose.  For brevity, it should not explicitly state the object's name or "
"type, since these are available by other means (except if the name happens "
"to be a verb describing a function's operation).  This line should begin "
"with a capital letter and end with a period."
msgstr ""
"Pierwsza linijka powinna zawierać zwięzłe streszczenie sensu jaki stoi za "
"obiektem. Nie powinna wprost zawierać nazwy obiektu ani typu, gdyż te są "
"dostępne w inny sposób (chyba, że nazwa jest czasownikiem opisujęcym "
"działanie funkcji). Ta linijka powinna zaczynać się z dużej litery i kończyć "
"kropką."

msgid ""
"If there are more lines in the documentation string, the second line should "
"be blank, visually separating the summary from the rest of the description.  "
"The following lines should be one or more paragraphs describing the object's "
"calling conventions, its side effects, etc."
msgstr ""
"Jeśli w docstringu jest więcej niż jedna linijka, druga linijka powinna być "
"pusta, aby rozdzielić ją od reszty opisu. Następne linijki powinny zawierać "
"konwencje nazewnicze, efekty uboczne itd."

msgid ""
"The Python parser does not strip indentation from multi-line string literals "
"in Python, so tools that process documentation have to strip indentation if "
"desired.  This is done using the following convention. The first non-blank "
"line *after* the first line of the string determines the amount of "
"indentation for the entire documentation string.  (We can't use the first "
"line since it is generally adjacent to the string's opening quotes so its "
"indentation is not apparent in the string literal.)  Whitespace "
"\"equivalent\" to this indentation is then stripped from the start of all "
"lines of the string.  Lines that are indented less should not occur, but if "
"they occur all their leading whitespace should be stripped.  Equivalence of "
"whitespace should be tested after expansion of tabs (to 8 spaces, normally)."
msgstr ""
"Parser Pythona nie usuwa wcięć z literału stringu wielolinijkowego, więc "
"jeśli to jest pożądane, to narzędzia obrabiające dokumentację powinny usuwać "
"wcięcia. Robi się to, wykorzystując następujące. Pierwsza nie-pusta linijka "
"*po* pierwszej określa jak dużo wcięcia jest w całym docstringu. (Nie można "
"do tego wykorzystać pierwszej linijki, ponieważ ta zazwyczaj przylega do "
"cudzysłowów, więc sposób wcięcia jest nieoczywisty.) \"Ilość wcięcia\" z tej "
"linijki jest następnie usuwana z tej i wszystkich następnych linijek. W "
"kolejnych linijkach nie powinno być mniej wcięć ale jeśli tak będzie to "
"całość wcięcia powinna być usunięta. Ilość wcięcia powinna być usuwana po "
"zamianie tabulatorów na spacje (zazwyczaj na 8 spacji)."

msgid "Here is an example of a multi-line docstring::"
msgstr "Poniżej przykład wielolinijkowego docstringu::"

msgid ""
">>> def my_function():\n"
"...     \"\"\"Do nothing, but document it.\n"
"...\n"
"...     No, really, it doesn't do anything.\n"
"...     \"\"\"\n"
"...     pass\n"
"...\n"
">>> print(my_function.__doc__)\n"
"Do nothing, but document it.\n"
"\n"
"    No, really, it doesn't do anything."
msgstr ""
">>> def my_function():\n"
"...     \"\"\"Nie robi nic, ale dokumentuje to.\n"
"...\n"
"...     Nie, naprawdę, ona nic nie robi.\n"
"...     \"\"\"\n"
"... pass\n"
"...\n"
">>> print(my_function.__doc__)\n"
"Nie robi nic, ale dokumentuje to.\n"
"\n"
"    Nie, naprawdę, ona nic nie robi."

msgid "Function Annotations"
msgstr "Adnotacje funkcji"

msgid ""
":ref:`Function annotations <function>` are completely optional metadata "
"information about the types used by user-defined functions (see :pep:`3107` "
"and :pep:`484` for more information)."
msgstr ""
":ref:`Adnotacje funkcji <function>` to całkowicie opcjonalne metadane dające "
"informacje o funkcjach zdefiniowanych przez użytkowników (zobacz :pep:`3107` "
"oraz :pep:`484` aby uzyskać więcej informacji)."

msgid ""
":term:`Annotations <function annotation>` are stored in the :attr:`!"
"__annotations__` attribute of the function as a dictionary and have no "
"effect on any other part of the function.  Parameter annotations are defined "
"by a colon after the parameter name, followed by an expression evaluating to "
"the value of the annotation.  Return annotations are defined by a literal ``-"
">``, followed by an expression, between the parameter list and the colon "
"denoting the end of the :keyword:`def` statement.  The following example has "
"a required argument, an optional argument, and the return value annotated::"
msgstr ""
":term:`Adnotacje <function annotation>` przechowywane są w atrybucie :attr:`!"
"__annotations__` funkcji jako słownik i nie mają oprócz żadnego innego "
"wpływu na nią.  Adnotacje parametrów są definiowane po nazwie parametru i "
"dwukropku, jako wyrażenie sprawdzające wartość argumentu.  Adonotacje do "
"zwracanego wyniku  definiuje się pomiędzy nawiasem z listą parametrów a "
"drukropkiem kończącym instrukcję :keyword:`def` , poprzez literał ``->``, z "
"następującym po nim wyrażeniem.  Poniższy przykład ma adnotację dotyczącą "
"argumentu wymaganego, argumentu opcjonalnego oraz adnotację zwracanego "
"wyniku::"

msgid ""
">>> def f(ham: str, eggs: str = 'eggs') -> str:\n"
"...     print(\"Annotations:\", f.__annotations__)\n"
"...     print(\"Arguments:\", ham, eggs)\n"
"...     return ham + ' and ' + eggs\n"
"...\n"
">>> f('spam')\n"
"Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class "
"'str'>}\n"
"Arguments: spam eggs\n"
"'spam and eggs'"
msgstr ""
">>> def f(ham: str, eggs: str = 'jajka') -> str:\n"
"...     print(\"adnotacje:\", f.__annotations__)\n"
"...     print(\"argumenty:\", ham, eggs)\n"
"...     return ham + ' i ' + eggs\n"
"...\n"
">>> f('szynka')\n"
"adnotacje: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class "
"'str'>}\n"
"argumenty: szynka jajka\n"
"'szynka i jajka'"

msgid "Intermezzo: Coding Style"
msgstr "Intermezzo: Styl kodowania"

msgid ""
"Now that you are about to write longer, more complex pieces of Python, it is "
"a good time to talk about *coding style*.  Most languages can be written (or "
"more concise, *formatted*) in different styles; some are more readable than "
"others. Making it easy for others to read your code is always a good idea, "
"and adopting a nice coding style helps tremendously for that."
msgstr ""
"Teraz, kiedy już jesteś gotowa(-wy) aby pisać dłuższe, bardziej złożone "
"pythonowe dzieła, dobrze żebyśmy porozmawiali o *stylu kodowania*. Większość "
"języków może być pisana (a mówiąc precyzyjniej, *formatowana*) w różnym "
"stylu; bardziej lub mniej czytelnym. Zawsze dobrze jest dążyć, aby twój kod "
"był łatwy do czytania przez innych a w tym bardzo pomaga stosowanie fajnego "
"stylu kodowania."

msgid ""
"For Python, :pep:`8` has emerged as the style guide that most projects "
"adhere to; it promotes a very readable and eye-pleasing coding style.  Every "
"Python developer should read it at some point; here are the most important "
"points extracted for you:"
msgstr ""
"Dla Pythona :pep:`8` stał się wzorcem stylu, którego trzyma się większość "
"projektów; szerzy czytelny i miły dla oka styl kodowania. W którymś "
"momencie, powinien go przeczytać każdy developer Pythona, poniżej "
"przedstawiliśmy jego najistotniejsze elementy:"

msgid "Use 4-space indentation, and no tabs."
msgstr "Jako wcięcie, wykorzystuj cztery spacje, nie tabulator."

msgid ""
"4 spaces are a good compromise between small indentation (allows greater "
"nesting depth) and large indentation (easier to read).  Tabs introduce "
"confusion, and are best left out."
msgstr ""
"Cztery spacje są dobrym kompromisem pomiędzy płytkim wcięciem (pozwala na "
"więcej kroków zagnieżdżania ) a głębokim wcięciem (jest łatwiejsze do "
"przeczytania). Tabulatorów najlepiej nie używać, wprowadzają zamiesznie."

msgid "Wrap lines so that they don't exceed 79 characters."
msgstr "Zawijaj linie tak, aby nie ich długość nie przekraczała 79 znaków."

msgid ""
"This helps users with small displays and makes it possible to have several "
"code files side-by-side on larger displays."
msgstr ""
"To pomoże użytkownikom z małymi wyświetlaczami a na większych ekranach "
"pozwoli mieć kilka plików obok siebie na ekranie."

msgid ""
"Use blank lines to separate functions and classes, and larger blocks of code "
"inside functions."
msgstr ""
"Wstawiaj puste linie aby oddzielić od siebie funkcje, klasy lub większe "
"bloki kodu wewnątrz funkcji."

msgid "When possible, put comments on a line of their own."
msgstr "Jeśli jest to możliwe, wstawiaj komentarze w oddzielnej linii."

msgid "Use docstrings."
msgstr "Wykorzystuj docstringi"

msgid ""
"Use spaces around operators and after commas, but not directly inside "
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
msgstr ""
"Korzystaj ze spacji naokoło operatorów oraz za przecinkami, ale nie przy "
"nawiasach:   ``a = f(1, 2) + g(3, 4)``."

msgid ""
"Name your classes and functions consistently; the convention is to use "
"``UpperCamelCase`` for classes and ``lowercase_with_underscores`` for "
"functions and methods.  Always use ``self`` as the name for the first method "
"argument (see :ref:`tut-firstclasses` for more on classes and methods)."
msgstr ""
"Nazywaj klasy i funkcje w konsekwentny sposób. Preferowaną konwencją jest "
"\"UpperCamelCase\" dla nazw klas i \"lowercase_with_underscores\" dla "
"funkcji i metod. Zawsze wykorzystuj \"self\" jako nazwę dla pierwszego "
"argumentu metody (zobacz :ref:`tut-firstclasses` aby dowiedzieć się więcej o "
"klasach i metodach)."

msgid ""
"Don't use fancy encodings if your code is meant to be used in international "
"environments.  Python's default, UTF-8, or even plain ASCII work best in any "
"case."
msgstr ""
"Nie wykorzystuj wymyślnych zestawów znaków jeśli twój kod będzie "
"wykorzystywany międzynarodowo. Najlepiej trzymać się domyślnych w Pythonie: "
"UTF-8 lub nawet ASCII."

msgid ""
"Likewise, don't use non-ASCII characters in identifiers if there is only the "
"slightest chance people speaking a different language will read or maintain "
"the code."
msgstr ""
"Podobnie, nie korzystaj ze znaków innych niż ASCII jako identyfikatorów, "
"jeśli jest chociaż szansa, że osoby mówiące innym językiem będą czytać lub "
"rozwijać Twój kod."

msgid "Footnotes"
msgstr "Przypisy"

msgid ""
"Actually, *call by object reference* would be a better description, since if "
"a mutable object is passed, the caller will see any changes the callee makes "
"to it (items inserted into a list)."
msgstr ""
"Tak właściwie, *wywołanie przez referencję do obiektu* byłoby lepszym "
"opisem, jako że jeśli mutowalny obiekt jest przekazany, wszystkie zmiany "
"które wywoływany robi (elementy wstawiane na listę) będą widziane przez "
"wywołującego."

msgid "statement"
msgstr "instrukcja"

msgid "for"
msgstr "for"

msgid "documentation strings"
msgstr "documentation strings"

msgid "docstrings"
msgstr "docstringi"

msgid "strings, documentation"
msgstr "strings, documentation"

msgid "* (asterisk)"
msgstr "* (asterysk)"

msgid "in function calls"
msgstr "in function calls"

msgid "**"
msgstr "**"

msgid "function"
msgstr "funkcja"

msgid "annotations"
msgstr "adnotacje typów"

msgid "->"
msgstr "->"

msgid "function annotations"
msgstr "adnotacje typów funkcji"

msgid ": (colon)"
msgstr ": (dwukropek)"

msgid "coding"
msgstr "kodowanie"

msgid "style"
msgstr "styl"