# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

# Maciej Olko <[email protected]>, 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 <[email protected]>, 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 <floor division>` 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 \"<stdin>\", line 1, in <module>\n"

"NameError: name 'n' is not defined"

msgstr ""

">>> n # próba dostępu do niezdefiniowanej zmiennej\n"

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

" File \"<stdin>\", line 1, in <module>\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 "

"<typesnumeric>`, 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 <typesnumeric>` 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 <faq-programming-"

"raw-string-backslash>` 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 "

"<faq-programming-raw-string-backslash>`, 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 \"<stdin>\", line 1\n"

" prefix 'thon'\n"

" ^^^^^^\n"

"SyntaxError: invalid syntax\n"

">>> ('un' * 3) 'ium'\n"

" File \"<stdin>\", 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 \"<stdin>\", line 1\n"

" prefix 'thon'\n"

" ^^^^^^\n"

"SyntaxError: invalid syntax\n"

">>> ('un' * 3) 'ium'\n"

" File \"<stdin>\", 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 \"<stdin>\", line 1, in <module>\n"

"IndexError: string index out of range"

msgstr ""

">>> word[42] # word ma tylko 6 znaków\n"

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

" File \"<stdin>\", line 1, in <module>\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 "

"<immutable>`. 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 \"<stdin>\", line 1, in <module>\n"

"TypeError: 'str' object does not support item assignment\n"

">>> word[2:] = 'py'\n"

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

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

"TypeError: 'str' object does not support item assignment"

msgstr ""

">>> word[0] = 'J'\n"

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

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

"TypeError: 'str' object does not support item assignment\n"

">>> word[2:] = 'py'\n"

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

" File \"<stdin>\", line 1, in <module>\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 "

"<sequence>`), 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 "

"<immutable>`, listy są typem :term:`mutowalnym <mutable>`, 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 "

"<shallow_vs_deep_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ę "

"<shallow_vs_deep_copy>` 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"

"[]"