# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001 Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # # Translators: # python-doc bot, 2025 # Maciej Olko , 2026 # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.14\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2026-04-19 14:37+0000\n" "PO-Revision-Date: 2025-09-16 00:02+0000\n" "Last-Translator: Maciej Olko , 2026\n" "Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Language: pl\n" "Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && " "(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && " "n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n" msgid "An Informal Introduction to Python" msgstr "Nieformalne wprowadzenie do Pythona" msgid "" "In the following examples, input and output are distinguished by the " "presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the " "example, you must type everything after the prompt, when the prompt appears; " "lines that do not begin with a prompt are output from the interpreter. Note " "that a secondary prompt on a line by itself in an example means you must " "type a blank line; this is used to end a multi-line command." msgstr "" "W nadchodzących przykładach wejście i wyjście są rozróżniane przez obecność " "lub nieobecność promptów (:term:`>>>` i :term:`...`): aby powtórzyć " "przykład, musisz wpisać wszystko po prompcie, kiedy prompt jest widoczny; " "linie, które nie zaczynają się promptem są wyjściem z interpretera. Zwróć " "uwagę, że prompt drugiego rzędu z pustą linią w przykładzie oznacza, że " "musisz wpisać pustą linię; używa się tego do zakończenia wielo-liniowej " "komendy." msgid "" "You can use the \"Copy\" button (it appears in the upper-right corner when " "hovering over or tapping a code example), which strips prompts and omits " "output, to copy and paste the input lines into your interpreter." msgstr "" "Możesz użyć przycisku „Copy” (pojawia się w prawym górnym rogu po najechaniu " "kursorem lub dotknięciu przykładu kodu), który usuwa prompty i pomija dane " "wyjściowe, aby skopiować i wkleić linie wejściowe do swojego interpretera." msgid "" "Many of the examples in this manual, even those entered at the interactive " "prompt, include comments. Comments in Python start with the hash character, " "``#``, and extend to the end of the physical line. A comment may appear at " "the start of a line or following whitespace or code, but not within a string " "literal. A hash character within a string literal is just a hash character. " "Since comments are to clarify code and are not interpreted by Python, they " "may be omitted when typing in examples." msgstr "" "Wiele przykładów w tej instrukcji, także tych wpisywanych w konsoli " "interaktywnej, zawiera komentarze. Komentarze w Pythonie zaczynają się " "znakiem hash ``#`` i ciągną się do końca fizycznej linii. Komentarz może " "pojawić się na początku linii, po wiodących spacjach lub kodzie, lecz nie " "może być zawarty w literale ciągu znaków. Znak hash w ciągu znaków jest po " "prostu znakiem hash. Jako że komentarze mają wyjaśniać kod i nie są " "interpretowane przez Pythona, można je ominąć przy wpisywaniu przykładów." msgid "Some examples::" msgstr "Trochę przykładów::" msgid "" "# this is the first comment\n" "spam = 1 # and this is the second comment\n" " # ... and now a third!\n" "text = \"# This is not a comment because it's inside quotes.\"" msgstr "" "# to jest pierwszy komentarz\n" "spam = 1 # a to jest drugi komentarz\n" " # … i teraz trzeci!\n" "text = \"# To nie jest komentarz, bo jest w cudzysłowie.\"" msgid "Using Python as a Calculator" msgstr "Używanie Pythona jako kalkulatora" msgid "" "Let's try some simple Python commands. Start the interpreter and wait for " "the primary prompt, ``>>>``. (It shouldn't take long.)" msgstr "" "Wypróbujmy parę prostych poleceń Pythona. Uruchom interpreter i poczekaj na " "pojawienie się pierwszego znaku zachęty ``>>>``. (Nie powinno to zająć dużo " "czasu.)" msgid "Numbers" msgstr "Liczby" msgid "" "The interpreter acts as a simple calculator: you can type an expression into " "it and it will write the value. Expression syntax is straightforward: the " "operators ``+``, ``-``, ``*`` and ``/`` can be used to perform arithmetic; " "parentheses (``()``) can be used for grouping. For example::" msgstr "" "Interpreter działa jak prosty kalkulator: można wpisać do niego wyrażenie, a " "on wypisze jego wartość. Składnia wyrażenia jest prosta: operatory ``+``, ``-" "``, ``*`` i ``/`` można użyć do arytmetyki; nawiasy (``()``) można użyć do " "grupowania. Na przykład::" msgid "" ">>> 2 + 2\n" "4\n" ">>> 50 - 5*6\n" "20\n" ">>> (50 - 5*6) / 4\n" "5.0\n" ">>> 8 / 5 # division always returns a floating-point number\n" "1.6" msgstr "" ">>> 2 + 2\n" "4\n" ">>> 50 - 5*6\n" "20\n" ">>> (50 - 5*6) / 4\n" "5.0\n" ">>> 8 / 5 # dzielenie zawsze zwraca liczbę zmiennoprzecinkową\n" "1.6" msgid "" "The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the " "ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:" "`float`. We will see more about numeric types later in the tutorial." msgstr "" "Liczby całkowite (np. ``2``, ``4``, ``20``) są typu :class:`int`, te z " "częścią ułamkową (np. ``5.0``, ``1.6``) są typu :class:`float`. Więcej o " "typach numerycznych dowiemy się więcej później w tym tutorialu." msgid "" "Division (``/``) always returns a float. To do :term:`floor division` and " "get an integer result you can use the ``//`` operator; to calculate the " "remainder you can use ``%``::" msgstr "" "Dzielenie (``/``) zawsze zwraca liczbę zmiennoprzecinkową. Aby zrobić :term:" "`dzielenie całkowite ` i uzyskać wynik całkowity możesz użyć " "operatora ``//``; aby obliczyć resztę możesz użyć ``%``::" msgid "" ">>> 17 / 3 # classic division returns a float\n" "5.666666666666667\n" ">>>\n" ">>> 17 // 3 # floor division discards the fractional part\n" "5\n" ">>> 17 % 3 # the % operator returns the remainder of the division\n" "2\n" ">>> 5 * 3 + 2 # floored quotient * divisor + remainder\n" "17" msgstr "" ">>> 17 / 3 # klasyczne dzielenie zwraca liczbę zmiennoprzecinkową\n" "5.666666666666667\n" ">>>\n" ">>> 17 // 3 # dzielenie całkowite pomija część ułamkową\n" "5\n" ">>> 17 % 3 # operator % zwraca resztę z dzielenia\n" "2\n" ">>> 5 * 3 + 2 # iloraz całkowity * dzielnik + reszta\n" "17" msgid "" "With Python, it is possible to use the ``**`` operator to calculate powers " "[#]_::" msgstr "" "W Pythonie możesz użyć operatora ``**``, do obliczania potęgowania [#]_::" msgid "" ">>> 5 ** 2 # 5 squared\n" "25\n" ">>> 2 ** 7 # 2 to the power of 7\n" "128" msgstr "" ">>> 5 ** 2 # 5 do kwadratu\n" "25\n" ">>> 2 ** 7 # 2 do potęgi 7.\n" "128" msgid "" "The equal sign (``=``) is used to assign a value to a variable. Afterwards, " "no result is displayed before the next interactive prompt::" msgstr "" "Znak równości (``=``) jest używany do przypisania wartości do zmiennej. " "Przypisanie do zmiennej nie jest wypisywane przez interpreter::" msgid "" ">>> width = 20\n" ">>> height = 5 * 9\n" ">>> width * height\n" "900" msgstr "" ">>> width = 20\n" ">>> height = 5 * 9\n" ">>> width * height\n" "900" msgid "" "If a variable is not \"defined\" (assigned a value), trying to use it will " "give you an error::" msgstr "" "Jeśli zmienna nie jest „zdefiniowana” (nie ma przypisanej wartości), próba " "jej użycia spowoduje błąd::" msgid "" ">>> n # try to access an undefined variable\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "NameError: name 'n' is not defined" msgstr "" ">>> n # próba dostępu do niezdefiniowanej zmiennej\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "NameError: name 'n' is not defined" msgid "" "There is full support for floating point; operators with mixed type operands " "convert the integer operand to floating point::" msgstr "" "Python implementuje w pełni arytmetykę zmiennoprzecinkową; operatory z " "operandami typów mieszanych przekształcają operandy całkowite w " "zmiennoprzecinkowe::" msgid "" ">>> 4 * 3.75 - 1\n" "14.0" msgstr "" ">>> 4 * 3.75 - 1\n" "14.0" msgid "" "In interactive mode, the last printed expression is assigned to the variable " "``_``. This means that when you are using Python as a desk calculator, it " "is somewhat easier to continue calculations, for example::" msgstr "" "W trybie interaktywnym ostatnie wyświetlone wyrażenie jest przypisywane do " "zmiennej ``_``. Dzięki temu kiedy używasz Pythona jako biurkowego " "kalkulatora, jest nieco prościej kontynuować obliczenia, na przykład::" msgid "" ">>> tax = 12.5 / 100\n" ">>> price = 100.50\n" ">>> price * tax\n" "12.5625\n" ">>> price + _\n" "113.0625\n" ">>> round(_, 2)\n" "113.06" msgstr "" ">>> tax = 12.5 / 100\n" ">>> price = 100.50\n" ">>> price * tax\n" "12.5625\n" ">>> price + _\n" "113.0625\n" ">>> round(_, 2)\n" "113.06" msgid "" "This variable should be treated as read-only by the user. Don't explicitly " "assign a value to it --- you would create an independent local variable with " "the same name masking the built-in variable with its magic behavior." msgstr "" "Ta zmienna powinna być traktowana przez użytkownika jako tylko-do-odczytu. " "Nie przypisuj wprost do niej wartości --- stworzyłbyś niezależną zmienną " "lokalną o tej samej nazwie maskując wbudowaną zmienną z jej magicznym " "zachowaniem." msgid "" "In addition to :class:`int` and :class:`float`, Python supports other types " "of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions." "Fraction`. Python also has built-in support for :ref:`complex numbers " "`, and uses the ``j`` or ``J`` suffix to indicate the " "imaginary part (e.g. ``3+5j``)." msgstr "" "Oprócz :class:`int` i :class:`float`, Python wspiera inne typy liczb, takie " "jak :class:`~decimal.Decimal` i :class:`~fractions.Fraction`. Python ma też " "wbudowane wsparcie dla :ref:`liczb zespolonych ` i używa " "sufiksów ``j`` lub ``J`` do wskazania części urojonej (np. ``3+5j``)." msgid "Text" msgstr "Tekst" msgid "" "Python can manipulate text (represented by type :class:`str`, so-called " "\"strings\") as well as numbers. This includes characters \"``!``\", words " "\"``rabbit``\", names \"``Paris``\", sentences \"``Got your back.``\", etc. " "\"``Yay! :)``\". They can be enclosed in single quotes (``'...'``) or double " "quotes (``\"...\"``) with the same result [#]_." msgstr "" "Python umożliwia manipulację tekstem (reprezentowanym przez typ :class:" "`str`, tzw. „ciąg znaków” lub „string”) oraz liczbami. Obejmuje to znaki „``!" "``”, słowa „``królik``”, nazwy „``Paryż``”, zdania „``Możesz na mnie liczyć." "``”, itp. „``Hurra! :)``”. Mogą być one umieszczone w pojedynczych " "cudzysłowach (``'...'``) lub podwójnych cudzysłowach (``\"...\"``) z takim " "samym wynikiem [#]_." msgid "" ">>> 'spam eggs' # single quotes\n" "'spam eggs'\n" ">>> \"Paris rabbit got your back :)! Yay!\" # double quotes\n" "'Paris rabbit got your back :)! Yay!'\n" ">>> '1975' # digits and numerals enclosed in quotes are also strings\n" "'1975'" msgstr "" ">>> 'spam eggs' # pojedynczy cudzysłów\n" "'spam eggs'\n" ">>> \"Paris rabbit got your back :)! Yay!\" # podwójny cudzysłów\n" "'Paris rabbit got your back :)! Yay!'\n" ">>> '1975' # cyfry i liczby ujęte w cudzysłów są również ciągami znaków\n" "'1975'" msgid "" "To quote a quote, we need to \"escape\" it, by preceding it with ``\\``. " "Alternatively, we can use the other type of quotation marks::" msgstr "" "Aby umieścić znak cudzysłowu, musimy go oznaczyć znakiem \"ucieczki\", " "poprzedzając znakiem ``\\``. Alternatywnie, możemy użyć innego rodzaju " "znaków do oznaczenia cudzysłowu::" msgid "" ">>> 'doesn\\'t' # use \\' to escape the single quote...\n" "\"doesn't\"\n" ">>> \"doesn't\" # ...or use double quotes instead\n" "\"doesn't\"\n" ">>> '\"Yes,\" they said.'\n" "'\"Yes,\" they said.'\n" ">>> \"\\\"Yes,\\\" they said.\"\n" "'\"Yes,\" they said.'\n" ">>> '\"Isn\\'t,\" they said.'\n" "'\"Isn\\'t,\" they said.'" msgstr "" ">>> 'Oni powiedzieli \\'tak\\'.' # użyj \\' jako znaku ucieczki da " "pojedynczego cudzysłowu…\n" "\"Oni powiedzieli 'tak'.\"\n" ">>> \"Oni powiedzieli 'tak'.\" # …lub użyj podwójnego cudzysłowu\n" "\"Oni powiedzieli 'tak'.\"\n" ">>> 'Oni powiedzieli \"tak\".'\n" "'Oni powiedzieli \"tak\".'\n" ">>> \"Oni powiedzieli \\\"tak\\\".\"\n" "'Oni powiedzieli \"tak\".'\n" ">>> 'Oni powiedzieli \"tamci powiedzieli \\'tak\\'\".'\n" "'Oni powiedzieli \"tamci powiedzieli \\'tak\\'\".'" msgid "" "In the Python shell, the string definition and output string can look " "different. The :func:`print` function produces a more readable output, by " "omitting the enclosing quotes and by printing escaped and special " "characters::" msgstr "" "W interaktywnej powłoce Pythona definicja ciągu znaków i wyjściowy ciąg " "znaków mogą wyglądać inaczej. Funkcja :func:`print` wytwarza czytelne " "wyjście, poprzez pominięcie otaczających cudzysłowów, pominięcie znaków " "ucieczki i wypisanie znaków specjalnych::" msgid "" ">>> s = 'First line.\\nSecond line.' # \\n means newline\n" ">>> s # without print(), special characters are included in the string\n" "'First line.\\nSecond line.'\n" ">>> print(s) # with print(), special characters are interpreted, so \\n " "produces new line\n" "First line.\n" "Second line." msgstr "" ">>> s = 'Pierwsza linia.\\nDruga linia.' # \\n oznacza nową linię\n" ">>> s # bez print(), znaki specjalne są zawarte w ciągu znaków\n" "'Pierwsza linia.\\nDruga linia.'\n" ">>> print(s) # z print(), znaki specjalne są interpretowane, więc \\n " "tworzy nową linię\n" "Pierwsza linia.\n" "Druga linia." msgid "" "If you don't want characters prefaced by ``\\`` to be interpreted as special " "characters, you can use *raw strings* by adding an ``r`` before the first " "quote::" msgstr "" "Jeśli nie chcesz, aby znaki poprzedzone ``\\`` były interpretowane jako " "znaki specjalne, możesz użyć *surowych ciągów znaków* (ang. *raw strings*) " "dodając ``r`` przed pierwszym cudzysłowem::" msgid "" ">>> print('C:\\this\\name') # here \\t means tab, \\n means newline\n" "C: his\n" "ame\n" ">>> print(r'C:\\this\\name') # note the r before the quote\n" "C:\\this\\name" msgstr "" ">>> print('C:\\taka\\nazwa') # tutaj \\t oznacza tabulator, \\n oznacza " "nową linię\n" "C: aka\n" "azwa\n" ">>> print(r'C:\\taka\\nazwa') # zwróć uwagę na r przed cudzysłowem\n" "C:\\taka\\nazwa" msgid "" "There is one subtle aspect to raw strings: a raw string may not end in an " "odd number of ``\\`` characters; see :ref:`the FAQ entry ` for more information and workarounds." msgstr "" "Istnieje jeden subtelny aspekt surowych ciągów znaków: surowy ciąg znaków " "nie może kończyć się nieparzystą liczbą znaków ``\\``; zobacz :ref:`wpis FAQ " "`, aby uzyskać więcej informacji i " "sposobów obejścia tego problemu." msgid "" "String literals can span multiple lines. One way is using triple-quotes: " "``\"\"\"...\"\"\"`` or ``'''...'''``. End-of-line characters are " "automatically included in the string, but it's possible to prevent this by " "adding a ``\\`` at the end of the line. In the following example, the " "initial newline is not included::" msgstr "" "Literał ciągu znaków może obejmować wiele linii. Jednym ze sposobów jest " "użycie potrójnych cudzysłowów: ``\"\"\"...\"\"\"`` lub ``'''...'''``. Znaki " "końca linii są automatycznie dołączane do napisów, ale można temu zapobiec, " "dodając ``\\`` na końcu linii. W poniższym przykładzie początkowy znak nowej " "linii nie jest uwzględniony::" msgid "" ">>> print(\"\"\"\\\n" "... Usage: thingy [OPTIONS]\n" "... -h Display this usage message\n" "... -H hostname Hostname to connect to\n" "... \"\"\")\n" "Usage: thingy [OPTIONS]\n" " -h Display this usage message\n" " -H hostname Hostname to connect to\n" "\n" ">>>" msgstr "" ">>> print(\"\"\"\\\n" "... Użycie: cosiek [OPCJE]\n" "... -h Wyświetl tą wiadomość użycia\n" "... -H hostname Nazwa hosta do połączenia\n" "... \"\"\")\n" "Użycie: cosiek [OPCJE]\n" " -h Wyświetl tą wiadomość użycia\n" " -H hostname Nazwa hosta do połączenia\n" "\n" ">>>" msgid "" "Strings can be concatenated (glued together) with the ``+`` operator, and " "repeated with ``*``::" msgstr "" "Ciągi mogą być łączone operatorem ``+`` i powtarzane przy użyciu ``*``::" msgid "" ">>> # 3 times 'un', followed by 'ium'\n" ">>> 3 * 'un' + 'ium'\n" "'unununium'" msgstr "" ">>> # 3 razy 'un', a następnie 'ium'\n" ">>> 3 * 'un' + 'ium'\n" "'unununium'" msgid "" "Two or more *string literals* (i.e. the ones enclosed between quotes) next " "to each other are automatically concatenated. ::" msgstr "" "Dwa lub więcej *literały ciągu znaków* (czyli te zawarte w cudzysłowach) " "obok siebie są automatycznie łączone. ::" msgid "" ">>> 'Py' 'thon'\n" "'Python'" msgstr "" ">>> 'Py' 'thon'\n" "'Python'" msgid "" "This feature is particularly useful when you want to break long strings::" msgstr "" "To zachowanie jest szczególnie przydatne, gdy chcesz dzielić długie ciągi::" msgid "" ">>> text = ('Put several strings within parentheses '\n" "... 'to have them joined together.')\n" ">>> text\n" "'Put several strings within parentheses to have them joined together.'" msgstr "" ">>> text = ('Umieść kilka ciągów znaków w nawiasach '\n" "... 'aby je połączyć.')\n" ">>> text\n" "'Umieść kilka ciągów znaków w nawiasach aby je połączyć'." msgid "" "This only works with two literals though, not with variables or expressions::" msgstr "Jednak działa tylko dla literałów, nie dla zmiennych lub wyrażeń::" msgid "" ">>> prefix = 'Py'\n" ">>> prefix 'thon' # can't concatenate a variable and a string literal\n" " File \"\", line 1\n" " prefix 'thon'\n" " ^^^^^^\n" "SyntaxError: invalid syntax\n" ">>> ('un' * 3) 'ium'\n" " File \"\", line 1\n" " ('un' * 3) 'ium'\n" " ^^^^^\n" "SyntaxError: invalid syntax" msgstr "" ">>> prefix = 'Py'\n" ">>> prefiks 'thon' # nie można łączyć zmiennej i literału ciagu znaków\n" " File \"\", line 1\n" " prefix 'thon'\n" " ^^^^^^\n" "SyntaxError: invalid syntax\n" ">>> ('un' * 3) 'ium'\n" " File \"\", line 1\n" " ('un' * 3) 'ium'\n" " ^^^^^\n" "SyntaxError: invalid syntax" msgid "" "If you want to concatenate variables or a variable and a literal, use ``+``::" msgstr "Jeśli chcesz połączyć zmienne lub zmienną i literał, użyj ``+``::" msgid "" ">>> prefix + 'thon'\n" "'Python'" msgstr "" ">>> prefix + 'thon'\n" "'Python'" msgid "" "Strings can be *indexed* (subscripted), with the first character having " "index 0. There is no separate character type; a character is simply a string " "of size one::" msgstr "" "Ciągi znaków mogą być *indeksowane*. Pierwszy znak ma indeks 0. Nie ma " "osobnego typu znakowego; znak jest po prostu ciągiem znaków o długości " "jeden::" msgid "" ">>> word = 'Python'\n" ">>> word[0] # character in position 0\n" "'P'\n" ">>> word[5] # character in position 5\n" "'n'" msgstr "" ">>> word = 'Python'\n" ">>> word[0] # znak na pozycji 0\n" "'P'\n" ">>> word[5] # znak na pozycji 5\n" "'n'" msgid "" "Indices may also be negative numbers, to start counting from the right::" msgstr "" "Indeksy mogą być też liczbami ujemnymi, aby zacząć odliczać od prawej::" msgid "" ">>> word[-1] # last character\n" "'n'\n" ">>> word[-2] # second-last character\n" "'o'\n" ">>> word[-6]\n" "'P'" msgstr "" ">>> word[-1] # ostatni znak\n" "'n'\n" ">>> word[-2] # przedostatni znak\n" "'o'\n" ">>> word[-6]\n" "'P'" msgid "Note that since -0 is the same as 0, negative indices start from -1." msgstr "" "Zwróć uwagę, że jako -0 to to samo co 0, ujemne indeksy zaczynają się od -1." msgid "" "In addition to indexing, *slicing* is also supported. While indexing is " "used to obtain individual characters, *slicing* allows you to obtain a " "substring::" msgstr "" "Dodatkowo do indeksowania, obsługiwany jest również *podział*. Podczas gdy " "indeksowanie służy do uzyskiwania pojedynczych znaków, *podział* pozwala na " "uzyskanie podciągu znaków::" msgid "" ">>> word[0:2] # characters from position 0 (included) to 2 (excluded)\n" "'Py'\n" ">>> word[2:5] # characters from position 2 (included) to 5 (excluded)\n" "'tho'" msgstr "" ">>> word[0:2] # znaki od pozycji 0 (włącznie) do 2 (wyłącznie)\n" "'Py'\n" ">>> word[2:5] # znaki od pozycji 2 (włącznie) do 5 (wyłącznie)\n" "'tho'" msgid "" "Slice indices have useful defaults; an omitted first index defaults to zero, " "an omitted second index defaults to the size of the string being sliced. ::" msgstr "" "Indeksy podzielonych fragmentów mają przydatne wartości domyślne; pominięty " "pierwszy indeks domyślnie jest zerem, pominięty drugi indeks domyślnie ma " "wartość długości dzielonego stringa. ::" msgid "" ">>> word[:2] # character from the beginning to position 2 (excluded)\n" "'Py'\n" ">>> word[4:] # characters from position 4 (included) to the end\n" "'on'\n" ">>> word[-2:] # characters from the second-last (included) to the end\n" "'on'" msgstr "" ">>> word[:2] # znak od początku do pozycji 2 (wyłącznie)\n" "'Py'\n" ">>> word[4:] # znak od pozycji 4 (włącznie) do końca\n" "'on'\n" ">>> word[-2:] # znak od przedostatniego (włącznie) do końca\n" "'on'" msgid "" "Note how the start is always included, and the end always excluded. This " "makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::" msgstr "" "Zwróć uwagę, że początkowy indeks wchodzi w skład podciągu, a końcowy nie. W " "ten sposób ``s[:i] + s[i:]`` jest zawsze równe ``s``::" msgid "" ">>> word[:2] + word[2:]\n" "'Python'\n" ">>> word[:4] + word[4:]\n" "'Python'" msgstr "" ">>> word[:2] + word[2:]\n" "'Python'\n" ">>> word[:4] + word[4:]\n" "'Python'" msgid "" "One way to remember how slices work is to think of the indices as pointing " "*between* characters, with the left edge of the first character numbered 0. " "Then the right edge of the last character of a string of *n* characters has " "index *n*, for example::" msgstr "" "Jednym ze sposobów na zapamiętanie, jak działa podział, to myślenie o " "indeksach wskazujących *pomiędzy* znakami, z lewą krawędzią pierwszego znaku " "numerowaną 0. Wtedy prawa krawędź ostatniego znaku ciągu o długości *n* ma " "indeks *n*, na przykład::" msgid "" " +---+---+---+---+---+---+\n" " | P | y | t | h | o | n |\n" " +---+---+---+---+---+---+\n" " 0 1 2 3 4 5 6\n" "-6 -5 -4 -3 -2 -1" msgstr "" " +---+---+---+---+---+---+\n" " | P | y | t | h | o | n |\n" " +---+---+---+---+---+---+\n" " 0 1 2 3 4 5 6\n" "-6 -5 -4 -3 -2 -1" msgid "" "The first row of numbers gives the position of the indices 0...6 in the " "string; the second row gives the corresponding negative indices. The slice " "from *i* to *j* consists of all characters between the edges labeled *i* and " "*j*, respectively." msgstr "" "W pierwszym wierszu liczb są pozycje indeksów od 0 do 6 w ciągu. W drugim " "wierszu odpowiadające im indeksy ujemne. Fragment od *i* do *j* składa się " "ze wszystkich znaków pomiędzy krawędziami oznaczonymi kolejno *i* i *j*." msgid "" "For non-negative indices, the length of a slice is the difference of the " "indices, if both are within bounds. For example, the length of " "``word[1:3]`` is 2." msgstr "" "Dla nieujemnych indeksów długość wydzielonego fragmentu to różnica indeksów, " "jeśli oba mieszczą się w zakresie. Na przykład długość ``word[1:3]`` to 2." msgid "Attempting to use an index that is too large will result in an error::" msgstr "Próba użycia za dużego indeksu skończy się błędem::" msgid "" ">>> word[42] # the word only has 6 characters\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "IndexError: string index out of range" msgstr "" ">>> word[42] # word ma tylko 6 znaków\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "IndexError: string index out of range" msgid "" "However, out of range slice indexes are handled gracefully when used for " "slicing::" msgstr "" "Jednak indeksy podzielonych fragmentów poza zakresem są obsłużone " "bezpiecznie przy podziale::" msgid "" ">>> word[4:42]\n" "'on'\n" ">>> word[42:]\n" "''" msgstr "" ">>> word[4:42]\n" "'on'\n" ">>> word[42:]\n" "''" msgid "" "Python strings cannot be changed --- they are :term:`immutable`. Therefore, " "assigning to an indexed position in the string results in an error::" msgstr "" "Ciągi znaków Pythona nie mogą być zmieniane — są :term:`niemutowalne " "`. W związku z tym przypisywanie wartości do indeksowanej pozycji " "w ciągu spowoduje błąd::" msgid "" ">>> word[0] = 'J'\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "TypeError: 'str' object does not support item assignment\n" ">>> word[2:] = 'py'\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "TypeError: 'str' object does not support item assignment" msgstr "" ">>> word[0] = 'J'\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "TypeError: 'str' object does not support item assignment\n" ">>> word[2:] = 'py'\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "TypeError: 'str' object does not support item assignment" msgid "If you need a different string, you should create a new one::" msgstr "" "Jeśli potrzebujesz innego ciągu znaków, powinieneś(-nnaś) stworzyć nowy::" msgid "" ">>> 'J' + word[1:]\n" "'Jython'\n" ">>> word[:2] + 'py'\n" "'Pypy'" msgstr "" ">>> 'J' + word[1:]\n" "'Jython'\n" ">>> word[:2] + 'py'\n" "'Pypy'" msgid "The built-in function :func:`len` returns the length of a string::" msgstr "Wbudowana funkcja :func:`len` zwraca długość ciągu::" msgid "" ">>> s = 'supercalifragilisticexpialidocious'\n" ">>> len(s)\n" "34" msgstr "" ">>> s = 'superkalifradalistodekspialitycznie'\n" ">>> len(s)\n" "35" msgid ":ref:`textseq`" msgstr ":ref:`textseq`" msgid "" "Strings are examples of *sequence types*, and support the common operations " "supported by such types." msgstr "" "Ciągi znaków są przykładami *typów sekwencyjnych* i obsługują wspólne " "operacje wspierane przez takie typy." msgid ":ref:`string-methods`" msgstr ":ref:`string-methods`" msgid "" "Strings support a large number of methods for basic transformations and " "searching." msgstr "" "Ciągi znaków wspierają dużą liczbę metod do podstawowych przekształceń i " "wyszukiwania." msgid ":ref:`f-strings`" msgstr ":ref:`f-strings`" msgid "String literals that have embedded expressions." msgstr "Literały ciągów znaków z osadzonymi wyrażeniami." msgid ":ref:`formatstrings`" msgstr ":ref:`formatstrings`" msgid "Information about string formatting with :meth:`str.format`." msgstr "" "Informacje o formatowaniu ciągów znaków przy użyciu :meth:`str.format`." msgid ":ref:`old-string-formatting`" msgstr ":ref:`old-string-formatting`" msgid "" "The old formatting operations invoked when strings are the left operand of " "the ``%`` operator are described in more detail here." msgstr "" "Stare operacje formatowania, wywoływane gdy ciągi znaków są lewymi " "operandami operatora ``%`` są opisane tutaj bardziej szczegółowo." msgid "Lists" msgstr "Listy" msgid "" "Python knows a number of *compound* data types, used to group together other " "values. The most versatile is the *list*, which can be written as a list of " "comma-separated values (items) between square brackets. Lists might contain " "items of different types, but usually the items all have the same type. ::" msgstr "" "Python ma kilka *złożonych* typów danych, używanych do grupowania różnych " "wartości. Najbardziej wszechstronnym jest *lista*, która może zostać " "zapisana jako lista wartości (elementów) rozdzielonych przecinkami ujęta w " "nawiasy kwadratowe. Listy mogą zawierać elementy różnych typów, ale " "zazwyczaj wszystkie elementy mają ten sam typ. ::" msgid "" ">>> squares = [1, 4, 9, 16, 25]\n" ">>> squares\n" "[1, 4, 9, 16, 25]" msgstr "" ">>> squares = [1, 4, 9, 16, 25]\n" ">>> squares\n" "[1, 4, 9, 16, 25]" msgid "" "Like strings (and all other built-in :term:`sequence` types), lists can be " "indexed and sliced::" msgstr "" "Tak jak ciągi znaków (i wszystkie inne wbudowane typy :term:`sekwencyjne " "`), do elementów list można odwoływać się przez indeksy oraz można " "z nich „wydzielać”::" msgid "" ">>> squares[0] # indexing returns the item\n" "1\n" ">>> squares[-1]\n" "25\n" ">>> squares[-3:] # slicing returns a new list\n" "[9, 16, 25]" msgstr "" ">>> squares[0] # indeksowanie zwraca element\n" "1\n" ">>> squares[-1]\n" "25\n" ">>> squares[-3:] # slicing zwraca nową listę\n" "[9, 16, 25]" msgid "Lists also support operations like concatenation::" msgstr "Listy wspierają też operacje takie jak łączenie::" msgid "" ">>> squares + [36, 49, 64, 81, 100]\n" "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" msgstr "" ">>> squares + [36, 49, 64, 81, 100]\n" "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" msgid "" "Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` " "type, i.e. it is possible to change their content::" msgstr "" "W przeciwieństwie do ciągów znaków, które są :term:`niemutowalne " "`, listy są typem :term:`mutowalnym `, w szczególności " "można zmieniać ich treść::" msgid "" ">>> cubes = [1, 8, 27, 65, 125] # something's wrong here\n" ">>> 4 ** 3 # the cube of 4 is 64, not 65!\n" "64\n" ">>> cubes[3] = 64 # replace the wrong value\n" ">>> cubes\n" "[1, 8, 27, 64, 125]" msgstr "" ">>> cubes = [1, 8, 27, 65, 125] # coś tu jest nie tak\n" ">>> 4 ** 3 # sześcian 4 to 64, a nie 65!\n" "64\n" ">>> cubes[3] = 64 # zastąp nieprawidłową wartość\n" ">>> cubes\n" "[1, 8, 27, 64, 125]" msgid "" "You can also add new items at the end of the list, by using the :meth:`list." "append` *method* (we will see more about methods later)::" msgstr "" "Można również dodawać nowe elementy na końcu listy, przez użycie *metody* " "(dowiemy się więcej o metodach później) :meth:`list.append`::" msgid "" ">>> cubes.append(216) # add the cube of 6\n" ">>> cubes.append(7 ** 3) # and the cube of 7\n" ">>> cubes\n" "[1, 8, 27, 64, 125, 216, 343]" msgstr "" ">>> cubes.append(216) # dodaj sześcian 6\n" ">>> cubes.append(7 ** 3) # i sześcian 7\n" ">>> cubes\n" "[1, 8, 27, 64, 125, 216, 343]" msgid "" "Simple assignment in Python never copies data. When you assign a list to a " "variable, the variable refers to the *existing list*. Any changes you make " "to the list through one variable will be seen through all other variables " "that refer to it.::" msgstr "" "Proste przypisanie w Pythonie nigdy nie kopiuje danych. Kiedy przypisujesz " "listę do zmiennej, zmienna odnosi się do *istniejącej listy*. Wszystkie " "zmiany dokonane na liście przez jedną zmienną będą widoczne przez wszystkie " "inne zmienne, które się do niej odwołują.::" msgid "" ">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n" ">>> rgba = rgb\n" ">>> id(rgb) == id(rgba) # they reference the same object\n" "True\n" ">>> rgba.append(\"Alph\")\n" ">>> rgb\n" "[\"Red\", \"Green\", \"Blue\", \"Alph\"]" msgstr "" ">>> rgb = [\"czerwony\", \"zielony\", \"niebieski\"]\n" ">>> rgba = rgb\n" ">>> id(rgb) == id(rgba) # odwołują się do tego samego obiektu\n" "True\n" ">>> rgba.append(\"alfa\")\n" ">>> rgb\n" "[\"czerwony\", \"zielony\", \"niebieski\", \"alfa\"]" msgid "" "All slice operations return a new list containing the requested elements. " "This means that the following slice returns a :ref:`shallow copy " "` of the list::" msgstr "" "Wszystkie operacje wykrawania zwracają nową listę zawierającą żądane " "elementy. Następujący slice więc zwraca :ref:`płytką kopię " "` listy::" msgid "" ">>> correct_rgba = rgba[:]\n" ">>> correct_rgba[-1] = \"Alpha\"\n" ">>> correct_rgba\n" "[\"Red\", \"Green\", \"Blue\", \"Alpha\"]\n" ">>> rgba\n" "[\"Red\", \"Green\", \"Blue\", \"Alph\"]" msgstr "" ">>> correct_rgba = rgba[:]\n" ">>> correct_rgba[-1] = \"alfa\"\n" ">>> correct_rgba\n" "[\"czerwony\", \"zielony\", \"niebieski\", \"alfa\"]\n" ">>> rgba\n" "[\"czerwony\", \"zielony\", \"niebieski\", \"alfa\"]" msgid "" "Assignment to slices is also possible, and this can even change the size of " "the list or clear it entirely::" msgstr "" "Możliwe jest również przypisywanie do slice'ów. Może to zmienić rozmiar " "listy lub zupełnie ją wyczyścić::" msgid "" ">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n" ">>> letters\n" "['a', 'b', 'c', 'd', 'e', 'f', 'g']\n" ">>> # replace some values\n" ">>> letters[2:5] = ['C', 'D', 'E']\n" ">>> letters\n" "['a', 'b', 'C', 'D', 'E', 'f', 'g']\n" ">>> # now remove them\n" ">>> letters[2:5] = []\n" ">>> letters\n" "['a', 'b', 'f', 'g']\n" ">>> # clear the list by replacing all the elements with an empty list\n" ">>> letters[:] = []\n" ">>> letters\n" "[]" msgstr "" ">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n" ">>> litery\n" "['a', 'b', 'c', 'd', 'e', 'f', 'g']\n" ">>> # zastąp niektóre wartości\n" ">>> letters[2:5] = ['C', 'D', 'E']\n" ">>> litery\n" "['a', 'b', 'C', 'D', 'E', 'f', 'g']\n" ">>> # teraz je usuń\n" ">>> letters[2:5] = []\n" ">>> letters\n" "['a', 'b', 'f', 'g']\n" ">>> # wyczyść listę zastępując wszystkie elementy pustą listą\n" ">>> letters[:] = []\n" ">>> letters[:]\n" "[]" msgid "The built-in function :func:`len` also applies to lists::" msgstr "Wbudowana funkcja :func:`len` ma również zastosowanie do list::" msgid "" ">>> letters = ['a', 'b', 'c', 'd']\n" ">>> len(letters)\n" "4" msgstr "" ">>> letters = ['a', 'b', 'c', 'd']\n" ">>> len(letters)\n" "4" msgid "" "It is possible to nest lists (create lists containing other lists), for " "example::" msgstr "" "Można zagnieżdżać listy (tworzyć listy zawierające inne listy), na przykład::" msgid "" ">>> a = ['a', 'b', 'c']\n" ">>> n = [1, 2, 3]\n" ">>> x = [a, n]\n" ">>> x\n" "[['a', 'b', 'c'], [1, 2, 3]]\n" ">>> x[0]\n" "['a', 'b', 'c']\n" ">>> x[0][1]\n" "'b'" msgstr "" ">>> a = ['a', 'b', 'c']\n" ">>> n = [1, 2, 3]\n" ">>> x = [a, n]\n" ">>> x\n" "[['a', 'b', 'c'], [1, 2, 3]]\n" ">>> x[0]\n" "['a', 'b', 'c']\n" ">>> x[0][1]\n" "'b'" msgid "First Steps Towards Programming" msgstr "Pierwsze kroki do programowania" msgid "" "Of course, we can use Python for more complicated tasks than adding two and " "two together. For instance, we can write an initial sub-sequence of the " "`Fibonacci series `_ as " "follows::" msgstr "" "Oczywiście możemy używać Pythona do zadań bardziej skomplikowanych niż " "dodawanie dwóch do dwóch. Na przykład możemy napisać początkowy podciąg " "`ciągu Fibonacciego `_ " "następująco::" msgid "" ">>> # Fibonacci series:\n" ">>> # the sum of two elements defines the next\n" ">>> a, b = 0, 1\n" ">>> while a < 10:\n" "... print(a)\n" "... a, b = b, a+b\n" "...\n" "0\n" "1\n" "1\n" "2\n" "3\n" "5\n" "8" msgstr "" ">>> # ciąg Fibonacciego:\n" ">>> # suma dwóch elementów określa następny\n" ">>> a, b = 0, 1\n" ">>> while a < 10:\n" "... print(a)\n" "... a, b = b, a+b\n" "...\n" "0\n" "1\n" "1\n" "2\n" "3\n" "5\n" "8" msgid "This example introduces several new features." msgstr "Ten przykład wprowadza kilka nowych funkcji." msgid "" "The first line contains a *multiple assignment*: the variables ``a`` and " "``b`` simultaneously get the new values 0 and 1. On the last line this is " "used again, demonstrating that the expressions on the right-hand side are " "all evaluated first before any of the assignments take place. The right-" "hand side expressions are evaluated from the left to the right." msgstr "" "Pierwsza linia zawiera *wielokrotne przypisanie*: zmienne ``a`` i ``b`` " "jednocześnie dostają nowe wartości 0 i 1. W ostatniej linii jest ponownie " "wykorzystane, demonstrując, że wyrażenia po prawej stronie są ewaluowane " "wcześniej, zanim którekolwiek z przypisań ma miejsce. Wyrażenia po prawej " "stronie są ewaluowane od lewej do prawej." msgid "" "The :keyword:`while` loop executes as long as the condition (here: ``a < " "10``) remains true. In Python, like in C, any non-zero integer value is " "true; zero is false. The condition may also be a string or list value, in " "fact any sequence; anything with a non-zero length is true, empty sequences " "are false. The test used in the example is a simple comparison. The " "standard comparison operators are written the same as in C: ``<`` (less " "than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal " "to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)." msgstr "" "Pętla :keyword:`while` wykonuje się dopóki warunek (tutaj: ``a < 10``) " "pozostaje prawdziwy. W Pythonie, tak jak w C, każda niezerowa liczba " "całkowita jest prawdziwa; zero jest fałszywe. Warunek może być również " "ciągiem znaków lub listą, tak naprawdę jakąkolwiek sekwencją; cokolwiek o " "niezerowej długości jest prawdziwe, puste sekwencje są fałszywe. Warunek " "użyty w przykładzie jest prostym porównaniem. Standardowe operatory porównań " "pisane są tak samo jak w C: ``<`` (mniejsze niż), ``>`` (większe niż), " "``==`` (równe), ``<=`` (mniejsze lub równe), ``>=`` (większe lub równe) i ``!" "=`` (różne)." msgid "" "The *body* of the loop is *indented*: indentation is Python's way of " "grouping statements. At the interactive prompt, you have to type a tab or " "space(s) for each indented line. In practice you will prepare more " "complicated input for Python with a text editor; all decent text editors " "have an auto-indent facility. When a compound statement is entered " "interactively, it must be followed by a blank line to indicate completion " "(since the parser cannot guess when you have typed the last line). Note " "that each line within a basic block must be indented by the same amount." msgstr "" "*Ciało* pętli jest *wcięte*: indentacja (wcięcia) jest sposobem na " "grupowanie instrukcji. W trybie interaktywnym trzeba wprowadzić znak(i) " "spacji lub tabulacji, aby wciąć wiersz. W praktyce będziesz przygotowywać " "bardziej skomplikowane dane wejściowe dla Pythona za pomocą edytora tekstu; " "wszystkie przyzwoite edytory tekstu mają funkcję automatycznych wcięć. W " "chwili, gdy wprowadza się jakąś instrukcję złożoną w czasie sesji " "interpretera Pythona, trzeba zakończyć ją pustym wierszem (bowiem " "interpreter nie wie, czy ostatni wprowadzony wiersz jest ostatnim z tej " "instrukcji). Ważne jest, aby każdy wiersz należący do tej samej grupy " "instrukcji, był wcięty o taką samą liczbę spacji lub znaków tabulacji." msgid "" "The :func:`print` function writes the value of the argument(s) it is given. " "It differs from just writing the expression you want to write (as we did " "earlier in the calculator examples) in the way it handles multiple " "arguments, floating-point quantities, and strings. Strings are printed " "without quotes, and a space is inserted between items, so you can format " "things nicely, like this::" msgstr "" "Funkcja :func:`print` wypisuje wartość argumentu(-ów), które jej podano. " "Różnica pomiędzy tą instrukcją, a zwykłym zapisem wyrażenia, które chce się " "wypisać (tak jak robiliśmy to w przykładzie z kalkulatorem) występuje w " "sposobie obsługi wielu wyrażeń i napisów. Łańcuchy znaków wypisywane są bez " "cudzysłowów, a pomiędzy nimi zapisywane są spacje, tak aby można było ładnie " "sformatować pojawiający się napis, na przykład::" msgid "" ">>> i = 256*256\n" ">>> print('The value of i is', i)\n" "The value of i is 65536" msgstr "" ">>> i = 256*256\n" ">>> print('Wartość i wynosi', i)\n" "Wartość i wynosi 65536" msgid "" "The keyword argument *end* can be used to avoid the newline after the " "output, or end the output with a different string::" msgstr "" "Keyword argument *end* można wykorzystać, aby uniknąć znaku nowej linii po " "wypisaniu lub aby zakończyć wypisanie innym ciągiem znaków::" msgid "" ">>> a, b = 0, 1\n" ">>> while a < 1000:\n" "... print(a, end=',')\n" "... a, b = b, a+b\n" "...\n" "0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987," msgstr "" ">>> a, b = 0, 1\n" ">>> while a < 1000:\n" "... print(a, end=',')\n" "... a, b = b, a+b\n" "...\n" "0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987," msgid "Footnotes" msgstr "Przypisy" msgid "" "Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted " "as ``-(3**2)`` and thus result in ``-9``. To avoid this and get ``9``, you " "can use ``(-3)**2``." msgstr "" "Jako że ``**`` ma wyższą precedencję niż ``-``, ``-3**2`` zostanie " "zinterpretowane jako ``-(3**2)`` i zwróci ``-9``. Aby tego uniknąć i " "otrzymać ``9``, możesz użyć ``(-3)**2``." msgid "" "Unlike other languages, special characters such as ``\\n`` have the same " "meaning with both single (``'...'``) and double (``\"...\"``) quotes. The " "only difference between the two is that within single quotes you don't need " "to escape ``\"`` (but you have to escape ``\\'``) and vice versa." msgstr "" "W przeciwieństwie do innych języków, znaki specjalne takie jak ``\\n`` mają " "to samo znaczenie zarówno z pojedynczym (``'…'``) jak i podwójnym (``\"…" "\"``) cudzysłowem. Jedyną różnicą między nimi jest to, że wewnątrz " "pojedynczego cudzysłowu nie musisz używać znaku ucieczki dla ``\"`` (lecz " "musisz użyć znaku ucieczki ``\\'``) i vice versa." msgid "# (hash)" msgstr "# (hash)" msgid "comment" msgstr "komentarz"