functions.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:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-02-21 14:16+0000\n"
"PO-Revision-Date: 2025-05-08 05:09+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\n"
"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pl\n"
"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "
"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "
"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid "Built-in Functions"
msgstr "Wbudowane funkcje"

msgid ""
"The Python interpreter has a number of functions and types built into it "
"that are always available.  They are listed here in alphabetical order."
msgstr ""
"Interpreter Pythona ma wbudowane wiele funkcji i typów, które zawsze są "
"dostępne. Spisane są tutaj w kolejności alfabetycznej."

msgid "**A**"
msgstr "**A**"

msgid ":func:`abs`"
msgstr ":func:`abs`"

msgid ":func:`aiter`"
msgstr ":func:`aiter`"

msgid ":func:`all`"
msgstr ":func:`all`"

msgid ":func:`anext`"
msgstr ":func:`anext`"

msgid ":func:`any`"
msgstr ":func:`any`"

msgid ":func:`ascii`"
msgstr ":func:`ascii`"

msgid "**B**"
msgstr "**B**"

msgid ":func:`bin`"
msgstr ":func:`bin`"

msgid ":func:`bool`"
msgstr ":func:`bool`"

msgid ":func:`breakpoint`"
msgstr ":func:`breakpoint`"

msgid "|func-bytearray|_"
msgstr "|func-bytearray|_"

msgid "|func-bytes|_"
msgstr "|func-bytes|_"

msgid "**C**"
msgstr "**C**"

msgid ":func:`callable`"
msgstr ":func:`callable`"

msgid ":func:`chr`"
msgstr ":func:`chr`"

msgid ":func:`classmethod`"
msgstr ":func:`classmethod`"

msgid ":func:`compile`"
msgstr ":func:`compile`"

msgid ":func:`complex`"
msgstr ":func:`complex`"

msgid "**D**"
msgstr "**D**"

msgid ":func:`delattr`"
msgstr ":func:`delattr`"

msgid "|func-dict|_"
msgstr "|func-dict|_"

msgid ":func:`dir`"
msgstr ":func:`dir`"

msgid ":func:`divmod`"
msgstr ":func:`divmod`"

msgid "**E**"
msgstr "**E**"

msgid ":func:`enumerate`"
msgstr ":func:`enumerate`"

msgid ":func:`eval`"
msgstr ":func:`eval`"

msgid ":func:`exec`"
msgstr ":func:`exec`"

msgid "**F**"
msgstr "**F**"

msgid ":func:`filter`"
msgstr ":func:`filter`"

msgid ":func:`float`"
msgstr ":func:`float`"

msgid ":func:`format`"
msgstr ":func:`format`"

msgid "|func-frozenset|_"
msgstr "|func-frozenset|_"

msgid "**G**"
msgstr "**G**"

msgid ":func:`getattr`"
msgstr ":func:`getattr`"

msgid ":func:`globals`"
msgstr ":func:`globals`"

msgid "**H**"
msgstr "**H**"

msgid ":func:`hasattr`"
msgstr ":func:`hasattr`"

msgid ":func:`hash`"
msgstr ":func:`hash`"

msgid ":func:`help`"
msgstr ":func:`help`"

msgid ":func:`hex`"
msgstr ":func:`hex`"

msgid "**I**"
msgstr "**I**"

msgid ":func:`id`"
msgstr ":func:`id`"

msgid ":func:`input`"
msgstr ":func:`input`"

msgid ":func:`int`"
msgstr ":func:`int`"

msgid ":func:`isinstance`"
msgstr ":func:`isinstance`"

msgid ":func:`issubclass`"
msgstr ":func:`issubclass`"

msgid ":func:`iter`"
msgstr ":func:`iter`"

msgid "**L**"
msgstr "**L**"

msgid ":func:`len`"
msgstr ":func:`len`"

msgid "|func-list|_"
msgstr "|func-list|_"

msgid ":func:`locals`"
msgstr ":func:`locals`"

msgid "**M**"
msgstr "**M**"

msgid ":func:`map`"
msgstr ":func:`map`"

msgid ":func:`max`"
msgstr ":func:`max`"

msgid "|func-memoryview|_"
msgstr "|func-memoryview|_"

msgid ":func:`min`"
msgstr ":func:`min`"

msgid "**N**"
msgstr "**N**"

msgid ":func:`next`"
msgstr ":func:`next`"

msgid "**O**"
msgstr "**O**"

msgid ":func:`object`"
msgstr ":func:`object`"

msgid ":func:`oct`"
msgstr ":func:`oct`"

msgid ":func:`open`"
msgstr ":func:`open`"

msgid ":func:`ord`"
msgstr ":func:`ord`"

msgid "**P**"
msgstr "**P**"

msgid ":func:`pow`"
msgstr ":func:`pow`"

msgid ":func:`print`"
msgstr ":func:`print`"

msgid ":func:`property`"
msgstr ":func:`property`"

msgid "**R**"
msgstr "**R**"

msgid "|func-range|_"
msgstr "|func-range|_"

msgid ":func:`repr`"
msgstr ":func:`repr`"

msgid ":func:`reversed`"
msgstr ":func:`reversed`"

msgid ":func:`round`"
msgstr ":func:`round`"

msgid "**S**"
msgstr "**S**"

msgid "|func-set|_"
msgstr "|func-set|_"

msgid ":func:`setattr`"
msgstr ":func:`setattr`"

msgid ":func:`slice`"
msgstr ":func:`slice`"

msgid ":func:`sorted`"
msgstr ":func:`sorted`"

msgid ":func:`staticmethod`"
msgstr ":func:`staticmethod`"

msgid "|func-str|_"
msgstr "|func-str|_"

msgid ":func:`sum`"
msgstr ":func:`sum`"

msgid ":func:`super`"
msgstr ":func:`super`"

msgid "**T**"
msgstr "**T**"

msgid "|func-tuple|_"
msgstr "|func-tuple|_"

msgid ":func:`type`"
msgstr ":func:`type`"

msgid "**V**"
msgstr "**V**"

msgid ":func:`vars`"
msgstr ":func:`vars`"

msgid "**Z**"
msgstr "**Z**"

msgid ":func:`zip`"
msgstr ":func:`zip`"

msgid "**_**"
msgstr "**_**"

msgid ":func:`__import__`"
msgstr ":func:`__import__`"

msgid ""
"Return the absolute value of a number.  The argument may be an integer, a "
"floating-point number, or an object implementing :meth:`~object.__abs__`. If "
"the argument is a complex number, its magnitude is returned."
msgstr ""
"Zwraca wartość bezwzględną liczby. Argument może być liczbą całkowitą, "
"zmiennoprzecinkową lub obiektem implementującym :meth:`~object.__abs__`. "
"Jeśli argument jest liczbą zespoloną, zwracany jest jej moduł."

msgid ""
"Return an :term:`asynchronous iterator` for an :term:`asynchronous "
"iterable`. Equivalent to calling ``x.__aiter__()``."
msgstr ""
"Zwraca :term:`asynchroniczny iterator <asynchronous iterator>` dla :term:"
"`asynchronicznego iterable'a <asynchronous iterable>`. Ekwiwalent wywołania "
"``x.__aiter__()``."

msgid "Note: Unlike :func:`iter`, :func:`aiter` has no 2-argument variant."
msgstr ""
"Uwaga: W przeciwieństwie do :func:`iter`, :func:`aiter` nie ma "
"dwuargumentowego wariantu."

msgid ""
"Return ``True`` if all elements of the *iterable* are true (or if the "
"iterable is empty).  Equivalent to::"
msgstr ""
"Zwraca ``True`` jeśli wszystkie elementy *iterable*'a są prawdziwe (lub "
"jeśli iterable jest pusty). Ekwiwalent kodu::"

msgid ""
"def all(iterable):\n"
"    for element in iterable:\n"
"        if not element:\n"
"            return False\n"
"    return True"
msgstr ""
"def all(iterable):\n"
"    for element in iterable:\n"
"        if not element:\n"
"            return False\n"
"    return True"

msgid ""
"When awaited, return the next item from the given :term:`asynchronous "
"iterator`, or *default* if given and the iterator is exhausted."
msgstr ""
"W przypadku oczekiwania zwraca następny element z podanego :term:"
"`asynchronicznego iteratora <asynchronous iterator>` lub wartość *default*, "
"jeżeli jest ona podana, a iterator został wyczerpany."

msgid ""
"This is the async variant of the :func:`next` builtin, and behaves similarly."
msgstr ""
"Jest to asynchroniczny wariant wbudowanej funkcji :func:`next` i zachowuje "
"się podobnie."

msgid ""
"This calls the :meth:`~object.__anext__` method of *async_iterator*, "
"returning an :term:`awaitable`. Awaiting this returns the next value of the "
"iterator. If *default* is given, it is returned if the iterator is "
"exhausted, otherwise :exc:`StopAsyncIteration` is raised."
msgstr ""
"Wywołuje on metodę :meth:`~object.__anext__` *async_iteratora*, zwracając :"
"term:`awaitable`. Oczekiwanie zwraca następną wartość iteratora. Jeśli "
"podano wartość *default*, jest ona zwracana, jeśli iterator zostanie "
"wyczerpany, w przeciwnym razie zostanie podniesiony wyjątek :exc:"
"`StopAsyncIteration`."

msgid ""
"Return ``True`` if any element of the *iterable* is true.  If the iterable "
"is empty, return ``False``.  Equivalent to::"
msgstr ""
"Zwraca ``True`` jeśli jakikolwiek element *iterable*'a jest prawdziwy. Jeśli "
"iterable jest pusty, zwraca ``False``. Ekwiwalent kodu::"

msgid ""
"def any(iterable):\n"
"    for element in iterable:\n"
"        if element:\n"
"            return True\n"
"    return False"
msgstr ""
"def any(iterable):\n"
"    for element in iterable:\n"
"        if element:\n"
"            return True\n"
"    return False"

msgid ""
"As :func:`repr`, return a string containing a printable representation of an "
"object, but escape the non-ASCII characters in the string returned by :func:"
"`repr` using ``\\x``, ``\\u``, or ``\\U`` escapes.  This generates a string "
"similar to that returned by :func:`repr` in Python 2."
msgstr ""
"Tak jak :func:`repr`, zwraca ciąg znaków zawierający reprezentację obiektu, "
"ale wypisuje znaki nie-ASCII w zwracanym przez :func:`repr` ciągu przy "
"użyciu escape'ów ``\\x``, ``\\u`` lub ``\\U``. Generuje ciąg znaków podobny "
"do tego zwracanego przez :func:`repr` w Pythonie 2."

msgid ""
"Convert an integer number to a binary string prefixed with \"0b\". The "
"result is a valid Python expression. If *x* is not a Python :class:`int` "
"object, it has to define an :meth:`~object.__index__` method that returns an "
"integer. Some examples:"
msgstr ""
"Konwertuje liczbę całkowitą do binarnego ciągu znaków z prefiksem „0b”. "
"Wynik jest poprawnym wyrażeniem Pythona. Jeśli *x* nie jest pythonowym "
"obiektem :class:`int`, musi definiować metodę :meth:`~object.__index__`, "
"która zwraca liczbę całkowitą. Kilka przykładów:"

msgid ""
"If the prefix \"0b\" is desired or not, you can use either of the following "
"ways."
msgstr ""
"Jeśli prefiks „0b” nie jest pożądany, możesz użyć któregoś z poniższych "
"sposobów."

msgid "See also :func:`format` for more information."
msgstr "Zobacz też :func:`format` by uzyskać więcej informacji."

msgid ""
"Return a Boolean value, i.e. one of ``True`` or ``False``.  The argument is "
"converted using the standard :ref:`truth testing procedure <truth>`. If the "
"argument is false or omitted, this returns ``False``; otherwise, it returns "
"``True``.  The :class:`bool` class is a subclass of :class:`int` (see :ref:"
"`typesnumeric`). It cannot be subclassed further.  Its only instances are "
"``False`` and ``True`` (see :ref:`typebool`)."
msgstr ""
"Zwraca wartość logiczną, tj. jedno z ``True`` lub ``False``. Wartość "
"argumentu jest konwertowana przy użyciu standardowej procedury testowania :"
"ref:`truth testing procedure<truth>`. Jeśli argument jest fałszywy lub "
"pominięty, zwraca ``False``; w przeciwnym razie, zwraca ``True``.  Klasa :"
"class:`bool` jest podklasą klasy :class:`int` (zobacz :ref:`typesnumeric`). "
"Nie może być dalej podklasowana. Jej jedynymi instancjami są ``False`` i "
"``True`` (zobacz :ref:`typebool`)."

msgid "The parameter is now positional-only."
msgstr "Parametr jest teraz tylko-pozycyjny."

msgid ""
"This function drops you into the debugger at the call site.  Specifically, "
"it calls :func:`sys.breakpointhook`, passing ``args`` and ``kws`` straight "
"through.  By default, ``sys.breakpointhook()`` calls :func:`pdb.set_trace` "
"expecting no arguments.  In this case, it is purely a convenience function "
"so you don't have to explicitly import :mod:`pdb` or type as much code to "
"enter the debugger.  However, :func:`sys.breakpointhook` can be set to some "
"other function and :func:`breakpoint` will automatically call that, allowing "
"you to drop into the debugger of choice. If :func:`sys.breakpointhook` is "
"not accessible, this function will raise :exc:`RuntimeError`."
msgstr ""
"Ta funkcja powoduje przejście do debuggera w miejscu wywołania.  W "
"szczególności wywołuje :func:`sys.breakpointhook`, przekazując do niego "
"bezpośrednio ``args`` i ``kws``. Domyślnie ``sys.breakpointhook()`` wywołuje "
"funkcję :func:`pdb.set_trace` nie oczekującą argumentu. W tym przypadku jest "
"to wyłącznie funkcja dla wygody, aby nie trzeba było jawnie importować :mod:"
"`pdb` ani wpisywać tak dużo kodu, aby wejść do debuggera. Jednakże :func:"
"`sys.breakpointhook` może być ustawiony na inną funkcję i :func:`breakpoint` "
"automatycznie wywoła ją, pozwalając na przejście do wybranego debuggera. "
"Jeśli :func:`sys.breakpointhook` nie jest dostępny, funkcja rzuci :exc:"
"`RuntimeError`."

msgid ""
"By default, the behavior of :func:`breakpoint` can be changed with the :"
"envvar:`PYTHONBREAKPOINT` environment variable. See :func:`sys."
"breakpointhook` for usage details."
msgstr ""
"Domyślnie zachowanie funkcji :func:`breakpoint` można zmienić za pomocą "
"zmiennej środowiskowej :envvar:`PYTHONBREAKPOINT`. Szczegółowe informacje "
"można znaleźć w :func:`sys.breakpointhook`."

msgid ""
"Note that this is not guaranteed if :func:`sys.breakpointhook` has been "
"replaced."
msgstr ""
"Należy pamiętać, że nie jest to gwarantowane, jeśli :func:`sys."
"breakpointhook` został wymieniony."

msgid ""
"Raises an :ref:`auditing event <auditing>` ``builtins.breakpoint`` with "
"argument ``breakpointhook``."
msgstr ""
"Rzuca :ref:`auditing event <auditing>` ``builtins.breakpoint`` z argumentem "
"``breakpointhook``."

msgid ""
"Return a new array of bytes.  The :class:`bytearray` class is a mutable "
"sequence of integers in the range 0 <= x < 256.  It has most of the usual "
"methods of mutable sequences, described in :ref:`typesseq-mutable`, as well "
"as most methods that the :class:`bytes` type has, see :ref:`bytes-methods`."
msgstr ""
"Zwraca nową tablicę bajtów. Klasa :class:`bytearray` jest mutowalną "
"sekwencją liczb całkowitych w zakresie 0 <= x < 256. Ma większość metod "
"mutowalnych sekwencji, opisanych w :ref:`typesseq-mutable`, jak również "
"większość metod, które ma typ :class:`bytes`, patrz :ref:`bytes-methods`."

msgid ""
"The optional *source* parameter can be used to initialize the array in a few "
"different ways:"
msgstr ""
"Opcjonalny parametr *source* może być użyty do inicjalizacji tablicy na "
"kilka różnych sposobów:"

msgid ""
"If it is a *string*, you must also give the *encoding* (and optionally, "
"*errors*) parameters; :func:`bytearray` then converts the string to bytes "
"using :meth:`str.encode`."
msgstr ""
"Jeśli jest *stringiem*, musisz podać również parametr *encoding* (i "
"opcjonalnie *errors*); :func:`bytearray` konwertuje string na bajty "
"używając :meth:`str.encode`."

msgid ""
"If it is an *integer*, the array will have that size and will be initialized "
"with null bytes."
msgstr ""
"Jeśli jest *liczbą całkowitą*, tablica będzie miała taki rozmiar i będzie "
"zainicjowana bajtami zerowymi."

msgid ""
"If it is an object conforming to the :ref:`buffer interface "
"<bufferobjects>`, a read-only buffer of the object will be used to "
"initialize the bytes array."
msgstr ""
"Jeśli jest to obiekt spełniający :ref:`interfejs bufora <bufferobjects>`, "
"bufor tylko-do-odczytu obiektu zostanie użyty do zainicjowania tablicy "
"bajtów."

msgid ""
"If it is an *iterable*, it must be an iterable of integers in the range ``0 "
"<= x < 256``, which are used as the initial contents of the array."
msgstr ""
"Jeśli jest *iterablem*, musi być iterablem składającym się z liczb "
"całkowitych w zakresie ``0 <= x < 256``, które są użyte do zainicjowania "
"tablicy."

msgid "Without an argument, an array of size 0 is created."
msgstr "Bez argumentu tworzona jest tablica o rozmiarze 0."

msgid "See also :ref:`binaryseq` and :ref:`typebytearray`."
msgstr "Zobacz też :ref:`binaryseq` i :ref:`typebytearray`."

msgid ""
"Return a new \"bytes\" object which is an immutable sequence of integers in "
"the range ``0 <= x < 256``.  :class:`bytes` is an immutable version of :"
"class:`bytearray` -- it has the same non-mutating methods and the same "
"indexing and slicing behavior."
msgstr ""
"Zwraca nowy obiekt „bajtów”, który jest niemutowalną sekwencją liczb "
"całkowitych z zakresu ``0 <= x < 256``. :class:`bytes` jest niemutowalną "
"wersją :class:`bytearray` -- ma te same niemutujące metody i to samo "
"zachowanie indeksowania i slice'owania."

msgid ""
"Accordingly, constructor arguments are interpreted as for :func:`bytearray`."
msgstr ""
"Argumenty konstruktora są interpretowane tak jak dla :func:`bytearray`."

msgid "Bytes objects can also be created with literals, see :ref:`strings`."
msgstr ""
"Obiekty bytes mogą być również tworzone z literałami, patrz :ref:`strings`."

msgid "See also :ref:`binaryseq`, :ref:`typebytes`, and :ref:`bytes-methods`."
msgstr "Zobacz też :ref:`binaryseq`, :ref:`typebytes` i :ref:`bytes-methods`."

msgid ""
"Return :const:`True` if the *object* argument appears callable, :const:"
"`False` if not.  If this returns ``True``, it is still possible that a call "
"fails, but if it is ``False``, calling *object* will never succeed. Note "
"that classes are callable (calling a class returns a new instance); "
"instances are callable if their class has a :meth:`~object.__call__` method."
msgstr ""
"Zwraca :const:`True` jeśli argument *object* jest wywoływalny, :const:"
"`False` jeśli nie. Jeśli zwraca ``True``, nadal możliwe jest, że wywołanie "
"nie powiedzie się, ale jeśli zwraca ``False``, wywołanie *object* nigdy się "
"nie powiedzie. Należy pamiętać, że klasy są wywoływalne (wywołanie klasy "
"zwraca nową instancję); instancje są wywoływalne, jeśli ich klasa ma metodę :"
"meth:`~object.__call__`."

msgid ""
"This function was first removed in Python 3.0 and then brought back in "
"Python 3.2."
msgstr ""
"Ta funkcja była wpierw usunięta w Pythonie 3.0 a następnie przywrócona w "
"Pythonie 3.2."

msgid ""
"Return the string representing a character whose Unicode code point is the "
"integer *i*.  For example, ``chr(97)`` returns the string ``'a'``, while "
"``chr(8364)`` returns the string ``'€'``. This is the inverse of :func:`ord`."
msgstr ""
"Zwraca ciąg znaków reprezentujący znak, którego punktem kodowym Unicode jest "
"liczba całkowita *i*. Na przykład ``chr(97)`` zwraca ciąg znaków ``'a'``, a "
"``chr(8364)`` zwraca ciąg ``'€'``. Jest odwrotnością :func:`ord`."

msgid ""
"The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in "
"base 16).  :exc:`ValueError` will be raised if *i* is outside that range."
msgstr ""
"Poprawnym zakresem argumentu są wartości od 0 do 1 114 111 (0x10FFFF w "
"systemie szesnastkowym). Dla *i* poza tym zakresem zostanie rzucony :exc:"
"`ValueError`."

msgid "Transform a method into a class method."
msgstr "Przekształca metodę w metodę klasową."

msgid ""
"A class method receives the class as an implicit first argument, just like "
"an instance method receives the instance. To declare a class method, use "
"this idiom::"
msgstr ""
"Metoda klasowa otrzymuje klasę jako niejawny pierwszy argument, podobnie jak "
"metoda instancji otrzymuje instancję. Aby zadeklarować metodę klasową, użyj "
"tego idiomu::"

msgid ""
"class C:\n"
"    @classmethod\n"
"    def f(cls, arg1, arg2): ..."
msgstr ""
"class C:\n"
"    @classmethod\n"
"    def f(cls, arg1, arg2): ..."

msgid ""
"The ``@classmethod`` form is a function :term:`decorator` -- see :ref:"
"`function` for details."
msgstr ""
"Forma ``@classmethod`` jest :term:`dekoratorem <decorator>` funkcji – "
"szczegóły znajdziesz w :ref:`function`."

msgid ""
"A class method can be called either on the class (such as ``C.f()``) or on "
"an instance (such as ``C().f()``).  The instance is ignored except for its "
"class. If a class method is called for a derived class, the derived class "
"object is passed as the implied first argument."
msgstr ""
"Metoda klasowa może być wywoływana albo na klasie (na przykład ``C.f()``) "
"albo na instancji (na przykład ``C().f()``). Instancja jest ignorowana, "
"brana jest pod uwagę tylko jej klasa. Jeśli metoda klasowa jest wywołana dla "
"klasy dziedziczącej, obiekt klasy dziedziczącej jest przekazywany jako "
"pierwszy argument."

msgid ""
"Class methods are different than C++ or Java static methods. If you want "
"those, see :func:`staticmethod` in this section. For more information on "
"class methods, see :ref:`types`."
msgstr ""
"Metody klasowe różnią się od statycznych metod C++ lub Javy. Jeśli chcesz "
"takie, sprawdź :func:`staticmethod` w tej sekcji. Więcej informacji o "
"metodach klasowych znajdziesz w :ref:`types`."

msgid ""
"Class methods can now wrap other :term:`descriptors <descriptor>` such as :"
"func:`property`."
msgstr ""
"Metody klasowe mogą teraz opakowywać inne :term:`deskryptory <descriptor>`, "
"takie jak :func:`property`."

msgid ""
"Class methods now inherit the method attributes (:attr:`~function."
"__module__`, :attr:`~function.__name__`, :attr:`~function.__qualname__`, :"
"attr:`~function.__doc__` and :attr:`~function.__annotations__`) and have a "
"new ``__wrapped__`` attribute."
msgstr ""
"Metody klasowe dziedziczą teraz atrybuty metod (:attr:`~function."
"__module__`, :attr:`~function.__name__`, :attr:`~function.__qualname__`, :"
"attr:`~function.__doc__` i :attr:`~function.__annotations__`) i mają nowy "
"atrybut ``__wrapped__``."

msgid ""
"Class methods can no longer wrap other :term:`descriptors <descriptor>` such "
"as :func:`property`."
msgstr ""
"Metody klas nie mogą już opakowywać innych :term:`deskryptorów <descriptor>` "
"takich jak :func:`property`."

msgid ""
"Compile the *source* into a code or AST object.  Code objects can be "
"executed by :func:`exec` or :func:`eval`.  *source* can either be a normal "
"string, a byte string, or an AST object.  Refer to the :mod:`ast` module "
"documentation for information on how to work with AST objects."
msgstr ""
"Kompiluje *source* do obiektu kodu lub obiektu AST. Obiekty kodu mogą wyć "
"wykonywane przy użyciu :func:`exec` lub :func:`eval`. *source* może być "
"zwykłym ciągiem znaków, ciągiem bajtów lub obiektem AST. W dokumentacji "
"modułu :mod:`ast` znajdziesz informacje o tym jak pracować z obiektami AST."

msgid ""
"The *filename* argument should give the file from which the code was read; "
"pass some recognizable value if it wasn't read from a file (``'<string>'`` "
"is commonly used)."
msgstr ""
"Argument *filename* powinien dawać plik, z którego kod został przeczytany; "
"przekaż jakąś rozpoznawalną wartość, jeśli nie został przeczytany z pliku "
"(często używa się ``'<string>'``)."

msgid ""
"The *mode* argument specifies what kind of code must be compiled; it can be "
"``'exec'`` if *source* consists of a sequence of statements, ``'eval'`` if "
"it consists of a single expression, or ``'single'`` if it consists of a "
"single interactive statement (in the latter case, expression statements that "
"evaluate to something other than ``None`` will be printed)."
msgstr ""
"Argument *mode* określa, jaki rodzaj kodu ma zostać skompilowany; może mieć "
"wartość ``'exec'`` jeśli *source* składa się z sekwencji instrukcji, "
"``'eval'`` jeśli składa się z jednego wyrażenia lub ``'single'`` jeśli "
"składa się z jednej interaktywnej instrukcji (w ostatnim przypadku, "
"instrukcje wyrażeń, które ewaluują się do czegoś innego niż ``None``, "
"zostaną wydrukowane na standardowe wyjście)."

msgid ""
"The optional arguments *flags* and *dont_inherit* control which :ref:"
"`compiler options <ast-compiler-flags>` should be activated and which :ref:"
"`future features <future>` should be allowed. If neither is present (or both "
"are zero) the code is compiled with the same flags that affect the code that "
"is calling :func:`compile`. If the *flags* argument is given and "
"*dont_inherit* is not (or is zero) then the compiler options and the future "
"statements specified by the *flags* argument are used in addition to those "
"that would be used anyway. If *dont_inherit* is a non-zero integer then the "
"*flags* argument is it -- the flags (future features and compiler options) "
"in the surrounding code are ignored."
msgstr ""
"Opcjonalne argumenty *flags* i *dont_inherit* kontrolują, które :ref:`opcje "
"kompilatora <ast-compiler-flags>` powinny być aktywowane i które :ref:"
"`przyszłe funkcje <future>` powinne być dozwolone. Jeśli żaden z nich nie "
"jest obecny (lub oba są zerowe), kod jest kompilowany z tymi samymi flagami, "
"które wpływają na kod wywołujący :func:`compile`. Jeśli argument *flags* "
"jest podany, a *dont_inherit* nie jest (lub wynosi zero), to opcje "
"kompilatora i przyszłe instrukcje określone przez argument *flags* są "
"używane w dodatku do tych, które i tak byłyby użyte. Jeśli *dont_inherit* "
"jest niezerową liczbą całkowitą, to argument *flags* jest nim – flagi "
"(przyszłe funkcje i opcje kompilatora) w otaczającym kodzie są ignorowane."

msgid ""
"Compiler options and future statements are specified by bits which can be "
"bitwise ORed together to specify multiple options. The bitfield required to "
"specify a given future feature can be found as the :attr:`~__future__."
"_Feature.compiler_flag` attribute on the :class:`~__future__._Feature` "
"instance in the :mod:`__future__` module. :ref:`Compiler flags <ast-compiler-"
"flags>` can be found in :mod:`ast` module, with ``PyCF_`` prefix."
msgstr ""
"Opcje kompilatora i przyszłe instrukcja są określone przez bity, które mogą "
"być łączone bitowo w celu określenia wielu opcji. Pole bitowe wymagane do "
"określenia danej przyszłej funkcji można znaleźć jako :attr:`~__future__."
"_Feature.compiler_flag` atrybut na instancji :class:`~__future__._Feature` w "
"module :mod:`__future__` . :ref:`Flagi kompilatora <ast-compiler-flags>` "
"można znaleźć w module :mod:`ast` , z prefiksem ``PyCF_``."

msgid ""
"The argument *optimize* specifies the optimization level of the compiler; "
"the default value of ``-1`` selects the optimization level of the "
"interpreter as given by :option:`-O` options.  Explicit levels are ``0`` (no "
"optimization; ``__debug__`` is true), ``1`` (asserts are removed, "
"``__debug__`` is false) or ``2`` (docstrings are removed too)."
msgstr ""
"Wartość argumentu *optimize* określa poziom optymalizacji kompilatora; "
"wartość domyślna ``-1`` wybiera poziom optymalizacji interpretera podany "
"przez opcje :option:`-O`.  Wyraźne poziomy to ``0`` (brak optymalizacji; "
"``__debug__`` to prawda), ``1`` (asercje są usuwane, ``__debug__`` to fałsz) "
"lub ``2`` (docstrings są również usuwane)."

msgid ""
"This function raises :exc:`SyntaxError` if the compiled source is invalid, "
"and :exc:`ValueError` if the source contains null bytes."
msgstr ""
"To funkcja rzuci :exc:`SyntaxError` jeśli skompilowane źródło jest "
"nieprawidłowe, a :exc:`ValueError` jeśli źródło zawiera bajty null."

msgid ""
"If you want to parse Python code into its AST representation, see :func:`ast."
"parse`."
msgstr ""
"Jeśli chcesz przeanalizować kod Python do jego reprezentacji AST, zobacz :"
"func:`ast.parse`."

msgid ""
"Raises an :ref:`auditing event <auditing>` ``compile`` with arguments "
"``source`` and ``filename``. This event may also be raised by implicit "
"compilation."
msgstr ""
"Rzuci zdarzenie :ref:`auditing <auditing>` ``compile`` z argumentem "
"``source`` i ``filename``. To zdarzenie może być również rzucone przez "
"niejawną kompilację."

msgid ""
"When compiling a string with multi-line code in ``'single'`` or ``'eval'`` "
"mode, input must be terminated by at least one newline character.  This is "
"to facilitate detection of incomplete and complete statements in the :mod:"
"`code` module."
msgstr ""
"Podczas kompilacji napisem z kodem wielowierszowym w trybie ``'single'`` lub "
"``'eval'``, dane wejściowe muszą być zakończone co najmniej jedną znak nowej "
"lini.  Ma to na celu ułatwienie wykrywania niekompletnych i kompletnych "
"instrukcja w module :mod:`code` ."

msgid ""
"It is possible to crash the Python interpreter with a sufficiently large/"
"complex string when compiling to an AST object due to stack depth "
"limitations in Python's AST compiler."
msgstr ""
"Możliwe jest zawieszenie interpretera Python z wystarczająco dużym/złożonym "
"napisem podczas kompilacji do obiektu AST z powodu ograniczeń głębokości "
"stosu w kompilatorze AST Python."

msgid ""
"Allowed use of Windows and Mac newlines.  Also, input in ``'exec'`` mode "
"does not have to end in a newline anymore.  Added the *optimize* parameter."
msgstr ""
"Zezwolono na używanie nowej linii w systemach Windows i Mac.  Ponadto "
"wprowadzanie danych w trybie ``'exec'`` nie musi już kończyć się nową "
"linią.  Dodano funkcję *optimize* parametr."

msgid ""
"Previously, :exc:`TypeError` was raised when null bytes were encountered in "
"*source*."
msgstr ""
"Poprzednio, :exc:`TypeError` został rzucony gdy napotkano bajty null w "
"*source*."

msgid ""
"``ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`` can now be passed in flags to enable "
"support for top-level ``await``, ``async for``, and ``async with``."
msgstr ""
"``ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`` można teraz przekazywać we flagach, aby "
"włączyć obsługę najwyższego poziomu ``await``, ``async for`` i ``async "
"with``."

msgid ""
"Convert a single string or number to a complex number, or create a complex "
"number from real and imaginary parts."
msgstr ""
"Konwertowanie pojedynczego napisu lub liczby na liczba zespolona lub "
"tworzenie liczba zespolona z części rzeczywistej i urojonej."

msgid "Examples:"
msgstr "Przykłady:"

msgid ""
">>> complex('+1.23')\n"
"(1.23+0j)\n"
">>> complex('-4.5j')\n"
"-4.5j\n"
">>> complex('-1.23+4.5j')\n"
"(-1.23+4.5j)\n"
">>> complex('\\t( -1.23+4.5J )\\n')\n"
"(-1.23+4.5j)\n"
">>> complex('-Infinity+NaNj')\n"
"(-inf+nanj)\n"
">>> complex(1.23)\n"
"(1.23+0j)\n"
">>> complex(imag=-4.5)\n"
"-4.5j\n"
">>> complex(-1.23, 4.5)\n"
"(-1.23+4.5j)"
msgstr ""
">>> complex('+1.23')\n"
"(1.23+0j)\n"
">>> complex('-4.5j')\n"
"-4.5j\n"
">>> complex('-1.23+4.5j')\n"
"(-1.23+4.5j)\n"
">>> complex('\\t( -1.23+4.5J )\\n')\n"
"(-1.23+4.5j)\n"
">>> complex('-Infinity+NaNj')\n"
"(-inf+nanj)\n"
">>> complex(1.23)\n"
"(1.23+0j)\n"
">>> complex(imag=-4.5)\n"
"-4.5j\n"
">>> complex(-1.23, 4.5)\n"
"(-1.23+4.5j)"

msgid ""
"If the argument is a string, it must contain either a real part (in the same "
"format as for :func:`float`) or an imaginary part (in the same format but "
"with a ``'j'`` or ``'J'`` suffix), or both real and imaginary parts (the "
"sign of the imaginary part is mandatory in this case). The string can "
"optionally be surrounded by whitespaces and the round parentheses ``'('`` "
"and ``')'``, which are ignored. The string must not contain whitespace "
"between ``'+'``, ``'-'``, the ``'j'`` or ``'J'`` suffix, and the decimal "
"number. For example, ``complex('1+2j')`` is fine, but ``complex('1 + 2j')`` "
"raises :exc:`ValueError`. More precisely, the input must conform to the :"
"token:`~float:complexvalue` production rule in the following grammar, after "
"parentheses and leading and trailing whitespace characters are removed:"
msgstr ""
"Jeśli argument jest napisem, musi zawierać albo część rzeczywistą (w tym "
"samym formacie co :func:`float`), albo część urojoną (w tym samym formacie, "
"ale z przyrostkiem ``'j'`` lub ``'J'`` ), albo zarówno część rzeczywistą, "
"jak i urojoną (znak części urojonej jest w tym przypadku obowiązkowy). "
"Wartość napis może być opcjonalnie otoczona białymi znakami i okrągłymi "
"nawiasami ``'('`` i ``')'``, które są ignorowane. napis nie może zawierać "
"białych znaków między ``'+'``, ``'-'``, przyrostkiem ``'j'`` lub ``'J'`` a "
"liczbą dziesiętną. Na przykład, ``complex('1+2j')`` jest w porządku, ale "
"``complex('1 + 2j')`` rzuci :exc:`ValueError` . Dokładniej, dane wejściowe "
"muszą być zgodne z regułą produkcji :token:`~float:complexvalue` w poniższej "
"gramatyce, po usunięciu nawiasów oraz początkowych i końcowych znaków:"

msgid ""
"If the argument is a number, the constructor serves as a numeric conversion "
"like :class:`int` and :class:`float`. For a general Python object ``x``, "
"``complex(x)`` delegates to ``x.__complex__()``. If :meth:`~object."
"__complex__` is not defined then it falls back to :meth:`~object.__float__`. "
"If :meth:`!__float__` is not defined then it falls back to :meth:`~object."
"__index__`."
msgstr ""
"Jeśli argument jest liczbą, konstruktor służy jako konwersja numeryczna, "
"podobnie jak :class:`int` i :class:`float`. Dla ogólnego obiektu Python "
"``x`` , ``complex(x)`` deleguje do ``x.__complex__()``. Jeśli :meth:`~object."
"__complex__` nie jest zdefiniowane, to spada z powrotem do :meth:`~object."
"__float__`. Jeśli :meth:`!__float__` nie jest zdefiniowane, to spada z "
"powrotem do :meth:`~object.__index__`."

msgid ""
"If two arguments are provided or keyword arguments are used, each argument "
"may be any numeric type (including complex). If both arguments are real "
"numbers, return a complex number with the real component *real* and the "
"imaginary component *imag*. If both arguments are complex numbers, return a "
"complex number with the real component ``real.real-imag.imag`` and the "
"imaginary component ``real.imag+imag.real``. If one of arguments is a real "
"number, only its real component is used in the above expressions."
msgstr ""
"Jeśli podano dwa argumenty lub argument nazwany, każdy argument może być "
"dowolnego typu liczbowego (w tym złożonego). Jeśli oba argumenty są liczbami "
"rzeczywistymi, zwraca liczba zespolona ze składnikiem rzeczywistym *real* i "
"składnikiem urojonym *imag*. Jeśli oba argumenty są liczba zespolona, zwraca "
"liczba zespolona ze składnikiem rzeczywistym ``real.real-imag.imag`` i "
"składnikiem urojonym ``real.imag+imag.real``. Jeśli jedna z argumentow jest "
"liczbą rzeczywistą, w powyższych wyrażeniach używany jest tylko jej składnik "
"rzeczywisty."

msgid "If all arguments are omitted, returns ``0j``."
msgstr "Jeśli wszystkie argumenty zostaną pominięte, zwraca ``0j`` ."

msgid "The complex type is described in :ref:`typesnumeric`."
msgstr "Typ Complex został opisany na stronie :ref:`typesnumeric`."

msgid "Grouping digits with underscores as in code literals is allowed."
msgstr ""
"Dozwolone jest grupowanie cyfr za pomocą podkreślników, tak jak w literałach "
"kodu."

msgid ""
"Falls back to :meth:`~object.__index__` if :meth:`~object.__complex__` and :"
"meth:`~object.__float__` are not defined."
msgstr ""
"Powraca do :meth:`~object.__index__`, jeśli :meth:`~object.__complex__` i :"
"meth:`~object.__float__` nie są zdefiniowane."

msgid ""
"This is a relative of :func:`setattr`.  The arguments are an object and a "
"string.  The string must be the name of one of the object's attributes.  The "
"function deletes the named attribute, provided the object allows it.  For "
"example, ``delattr(x, 'foobar')`` is equivalent to ``del x.foobar``. *name* "
"need not be a Python identifier (see :func:`setattr`)."
msgstr ""
"Jest to krewny :func:`setattr`. Argumenty są obiektem i napisem. Napis musi "
"być nazwą jednego z atrybut obiektu. Funkcja usuwa nazwany atrybut, pod "
"warunkiem, że obiekt na to pozwala.  Na przykład, ``delattr(x, 'foobar')`` "
"jest równoważne ``del x.foobar``. *name* nie musi być identyfikatorem Python "
"(zobacz :func:`setattr`)."

msgid ""
"Create a new dictionary.  The :class:`dict` object is the dictionary class. "
"See :class:`dict` and :ref:`typesmapping` for documentation about this class."
msgstr ""
"Utwórz nowy słownik.  Obiekt :class:`dict` jest klasą słownik. Dokumentacja "
"dotycząca tej klasy znajduje się na stronach :class:`dict` i :ref:"
"`typesmapping`."

msgid ""
"For other containers see the built-in :class:`list`, :class:`set`, and :"
"class:`tuple` classes, as well as the :mod:`collections` module."
msgstr ""
"Inne kontenery można znaleźć w klasach wbudowanych :class:`list` , :class:"
"`set` i :class:`tuple`, a także moduł :mod:`collections` ."

msgid ""
"Without arguments, return the list of names in the current local scope.  "
"With an argument, attempt to return a list of valid attributes for that "
"object."
msgstr ""
"Bez argumentow, zwraca listę nazw w bieżącym zakresie lokalnym.  Z "
"argumentów, próba zwraca listy prawidłowych atrybut dla tego obiektu."

msgid ""
"If the object has a method named :meth:`~object.__dir__`, this method will "
"be called and must return the list of attributes. This allows objects that "
"implement a custom :func:`~object.__getattr__` or :func:`~object."
"__getattribute__` function to customize the way :func:`dir` reports their "
"attributes."
msgstr ""
"Jeśli obiekt posiada metodę o nazwie :meth:`~object.__dir__`, metoda ta "
"zostanie wywołana i musi zwracać listę atrybut. Pozwala to obiektom, które "
"implementują niestandardowe :func:`~object.__getattr__` lub :func:`~object."
"__getattribute__` funkcje na dostosowanie sposobu, w jaki :func:`dir` "
"zgłasza ich atrybuty."

msgid ""
"If the object does not provide :meth:`~object.__dir__`, the function tries "
"its best to gather information from the object's :attr:`~object.__dict__` "
"attribute, if defined, and from its type object.  The resulting list is not "
"necessarily complete and may be inaccurate when the object has a custom :"
"func:`~object.__getattr__`."
msgstr ""
"Jeśli obiekt nie udostępnia :meth:`~object.__dir__`, funkcja stara się "
"zebrać informacje z :attr:`~object.__dict__` atrybut obiektu, jeśli jest "
"zdefiniowany, oraz z jego obiektu typu.  Wynikowa lista niekoniecznie jest "
"kompletna i może być niedokładna, jeśli obiekt ma niestandardowy :func:"
"`~object.__getattr__`."

msgid ""
"The default :func:`dir` mechanism behaves differently with different types "
"of objects, as it attempts to produce the most relevant, rather than "
"complete, information:"
msgstr ""
"Mechanizm domyślny :func:`dir` zachowuje się inaczej w przypadku różnych "
"typów obiektów, ponieważ stara się uzyskać najbardziej istotne, a nie "
"kompletne informacje:"

msgid ""
"If the object is a module object, the list contains the names of the "
"module's attributes."
msgstr ""
"Jeśli obiekt jest obiektem moduł, lista zawiera nazwy obiektów moduł "
"atrybutow."

msgid ""
"If the object is a type or class object, the list contains the names of its "
"attributes, and recursively of the attributes of its bases."
msgstr ""
"Jeśli obiekt jest obiektem typu lub klasy, lista zawiera nazwy jego atrybut "
"i rekurencyjnie atrybut jego baz."

msgid ""
"Otherwise, the list contains the object's attributes' names, the names of "
"its class's attributes, and recursively of the attributes of its class's "
"base classes."
msgstr ""
"W przeciwnym razie lista zawiera nazwy atrybut' obiektow, nazwy atrybut jego "
"klasy i rekurencyjnie atrybut klas bazowych jego klasy."

msgid "The resulting list is sorted alphabetically.  For example:"
msgstr "Wynikowa lista jest posortowana alfabetycznie.  Na przykład:"

msgid ""
"Because :func:`dir` is supplied primarily as a convenience for use at an "
"interactive prompt, it tries to supply an interesting set of names more than "
"it tries to supply a rigorously or consistently defined set of names, and "
"its detailed behavior may change across releases.  For example, metaclass "
"attributes are not in the result list when the argument is a class."
msgstr ""
"Ponieważ :func:`dir` jest dostarczany głównie jako udogodnienie do użycia w "
"interaktywnym wierszu polecenia, stara się dostarczyć interesujący zestaw "
"nazw bardziej niż rygorystycznie lub konsekwentnie zdefiniowany zestaw nazw, "
"a jego szczegółowy zachowanie może się zmieniać w różnych wydaniach.  Na "
"przykład, atrybut metaklasy nie znajduje się na liście wyników, gdy argument "
"jest klasą."

msgid ""
"Take two (non-complex) numbers as arguments and return a pair of numbers "
"consisting of their quotient and remainder when using integer division.  "
"With mixed operand types, the rules for binary arithmetic operators apply.  "
"For integers, the result is the same as ``(a // b, a % b)``. For floating-"
"point numbers the result is ``(q, a % b)``, where *q* is usually ``math."
"floor(a / b)`` but may be 1 less than that.  In any case ``q * b + a % b`` "
"is very close to *a*, if ``a % b`` is non-zero it has the same sign as *b*, "
"and ``0 <= abs(a % b) < abs(b)``."
msgstr ""
"Weź dwie (niezłożone) liczby jako argumenty i zwraca parę liczb składającą "
"się z ich ilorazu i reszty, gdy używasz liczba całkowita dzielenia.  W "
"przypadku mieszanych typów operandów obowiązują reguły dla binarnych "
"operatorów arytmetycznych.  Dla liczb całkowitych wynik jest taki sam jak "
"``(a // b, a % b)``. Dla liczb zmiennoprzecinkowych wynikiem jest ``(q, a % "
"b)``, gdzie *q* jest zwykle ``math.floor(a / b)``, ale może być o 1 "
"mniejsze.  W każdym przypadku ``q * b + a % b`` jest bardzo zbliżone do *a*, "
"jeśli ``a % b`` jest niezerowe, to ma taki sam znak jak *b* i ``0 <= abs(a % "
"b) < abs(b)``."

msgid ""
"Return an enumerate object. *iterable* must be a sequence, an :term:"
"`iterator`, or some other object which supports iteration. The :meth:"
"`~iterator.__next__` method of the iterator returned by :func:`enumerate` "
"returns a tuple containing a count (from *start* which defaults to 0) and "
"the values obtained from iterating over *iterable*."
msgstr ""
"Zwraca obiekt wyliczeniowy. *iterable* musi być sekwencją, :term:`iteratorem "
"<iterator>` lub innym obiektem obsługującym iterację. Metoda :meth:"
"`~iterator.__next__` iteratora zwróconego przez :func:`enumerate` zwraca "
"dwukrotkę zawierającą licznik (od *start*, który domyślnie wynosi 0) i "
"wartości uzyskane z iteracji na argumencie *iterable*."

msgid "Equivalent to::"
msgstr "Odpowiednik::"

msgid ""
"def enumerate(iterable, start=0):\n"
"    n = start\n"
"    for elem in iterable:\n"
"        yield n, elem\n"
"        n += 1"
msgstr ""
"def enumerate(iterable, start=0):\n"
"    n = start\n"
"    for elem in iterable:\n"
"        yield n, elem\n"
"        n += 1"

msgid "Parameters"
msgstr "parametry"

msgid "A Python expression."
msgstr "Expresja Python."

msgid "The global namespace (default: ``None``)."
msgstr "Globalna przestrzeń nazw (domyślny: ``None``)."

msgid "The local namespace (default: ``None``)."
msgstr "Lokalna przestrzeń nazw (domyślny: ``None``)."

msgid "Returns"
msgstr "Zwraca"

msgid "The result of the evaluated expression."
msgstr "Wynik obliczonej ekspresji."

msgid "raises"
msgstr "rzuca"

msgid "Syntax errors are reported as exceptions."
msgstr "Błędy składni są zgłaszane jako wyjątki."

msgid ""
"This function executes arbitrary code. Calling it with user-supplied input "
"may lead to security vulnerabilities."
msgstr ""
"Ta funkcja wykonuje dowolny kod. Wywołanie go z danymi wejściowymi "
"dostarczonymi przez użytkownika może prowadzić do luk w zabezpieczeniach."

msgid ""
"The *expression* argument is parsed and evaluated as a Python expression "
"(technically speaking, a condition list) using the *globals* and *locals* "
"mappings as global and local namespace.  If the *globals* dictionary is "
"present and does not contain a value for the key ``__builtins__``, a "
"reference to the dictionary of the built-in module :mod:`builtins` is "
"inserted under that key before *expression* is parsed.  That way you can "
"control what builtins are available to the executed code by inserting your "
"own ``__builtins__`` dictionary into *globals* before passing it to :func:"
"`eval`.  If the *locals* mapping is omitted it defaults to the *globals* "
"dictionary.  If both mappings are omitted, the expression is executed with "
"the *globals* and *locals* in the environment where :func:`eval` is called.  "
"Note, *eval()* will only have access to the :term:`nested scopes <nested "
"scope>` (non-locals) in the enclosing environment if they are already "
"referenced in the scope that is calling :func:`eval` (e.g. via a :keyword:"
"`nonlocal` statement)."
msgstr ""
"Argument *expression* jest analizowany i ewaluowany jako wyrażenie Python "
"(technicznie rzecz biorąc, lista warunków) przy użyciu mapowań *globals* i "
"*locals* jako globalnej i lokalnej przestrzeni nazw.  Jeśli *globals* "
"słownik jest obecny i nie zawiera wartości dla klucza ``__builtins__``, "
"odwołanie do słownika z wbudowanej moduły :mod:`builtins` jest wstawiane pod "
"tym kluczem, zanim *expression* zostanie przeanalizowane.  W ten sposób "
"można kontrolować, jakie wbudowany są dostępne dla wykonywanego kodu, "
"wstawiając własne ``__builtins__`` słownik do *globals* przed przekazaniem "
"go do :func:`eval`. Jeśli mapowanie *locals* zostanie pominięte, domyślnie "
"będzie to *globals* słownik.  Jeśli oba mapowania są pominięte, wyrażenie "
"jest wykonywane z *globals* i *locals* w środowisku, w którym wywoływane "
"jest :func:`eval`.  Uwaga, *eval()* będzie miał dostęp do :term:"
"`zagnieżdżonych zakresów <nested scope>` (non-locals) w otaczającym "
"środowisku tylko wtedy, gdy są one już przywoływane w zakresie, który "
"wywołuje :func:`eval` (np. poprzez instrukcję :keyword:`nonlocal` )."

msgid "Example:"
msgstr "Przykład:"

msgid ""
"This function can also be used to execute arbitrary code objects (such as "
"those created by :func:`compile`).  In this case, pass a code object instead "
"of a string.  If the code object has been compiled with ``'exec'`` as the "
"*mode* argument, :func:`eval`\\'s return value will be ``None``."
msgstr ""
"Ta funkcja może być również używana do wykonywania dowolnych obiektów kodu "
"(takich jak te utworzone przez :func:`compile`).  W tym przypadku należy "
"przekazać obiekt kodu zamiast napisu. Jeśli obiekt kodu został skompilowany "
"z ``'exec'`` jako *mode* argument, :func:`eval` wartością zwracana będzie "
"``None``."

msgid ""
"Hints: dynamic execution of statements is supported by the :func:`exec` "
"function.  The :func:`globals` and :func:`locals` functions return the "
"current global and local dictionary, respectively, which may be useful to "
"pass around for use by :func:`eval` or :func:`exec`."
msgstr ""
"Wskazówki: dynamiczne wykonywanie instrukcji jest obsługiwane przez :func:"
"`exec` funkcja .  Adresy :func:`globals` i :func:`locals` funkcje zwracaja "
"określaaą odpowiednio bieżący globalny i lokalny adres słownika, który może "
"być przydatny do przekazania do użycia przez adresy :func:`eval` lub :func:"
"`exec`."

msgid ""
"If the given source is a string, then leading and trailing spaces and tabs "
"are stripped."
msgstr ""
"Jeśli podane źródło to napis, początkowe i końcowe spacje i tabulatory są "
"usuwane."

msgid ""
"See :func:`ast.literal_eval` for a function that can safely evaluate strings "
"with expressions containing only literals."
msgstr ""
"Zobacz :func:`ast.literal_eval` dla funkcj, którya może bezpiecznie ocenić "
"napis z wyrażeniami zawierającymi tylko literały."

msgid ""
"Raises an :ref:`auditing event <auditing>` ``exec`` with the code object as "
"the argument. Code compilation events may also be raised."
msgstr ""
"Rzuci zdarzenie :ref:`auditing event <auditing>` ``exec`` z obiektem kodu "
"jako argument. Zdarzenia kompilacji kodu mogą być również rzucone."

msgid "The *globals* and *locals* arguments can now be passed as keywords."
msgstr ""
"Funkcje *globals* i *locals* argumenty mogą być teraz przekazywane jako "
"słowa kluczowe."

msgid ""
"The semantics of the default *locals* namespace have been adjusted as "
"described for the :func:`locals` builtin."
msgstr ""
"Semantyka przestrzeni nazw domyślnych *locals* została dostosowana zgodnie z "
"opisem dla wbudowanej :func:`locals`  ."

msgid ""
"This function supports dynamic execution of Python code. *source* must be "
"either a string or a code object.  If it is a string, the string is parsed "
"as a suite of Python statements which is then executed (unless a syntax "
"error occurs). [#]_ If it is a code object, it is simply executed.  In all "
"cases, the code that's executed is expected to be valid as file input (see "
"the section :ref:`file-input` in the Reference Manual). Be aware that the :"
"keyword:`nonlocal`, :keyword:`yield`,  and :keyword:`return` statements may "
"not be used outside of function definitions even within the context of code "
"passed to the :func:`exec` function. The return value is ``None``."
msgstr ""
"Ta funkcja obsługuje dynamiczne wykonywanie kodu Python. *source* musi być "
"albo napis albo obiektem kodu.  Jeśli jest to napis, napis jest analizowany "
"jako zestaw instrukcji Pythona, które sa następnie wykonywany (chyba że "
"wystąpi błąd składni). [#]_ Jeśli jest to obiekt kodu, jest on po prostu "
"wykonywany.  We wszystkich przypadkach wykonywany kod powinien być "
"prawidłowy jako plik wejściowy (patrz sekcja :ref:`file-input` w Podręczniku "
"referencyjnym). Należy pamiętać, że wartości :keyword:`nonlocal`, :keyword:"
"`yield` i :keyword:`return` instrukcije nie mogą być używane poza "
"definicjami funkcji, nawet w kontekście kodu przekazywanego do :func:"
"`exec` . Wartość zwracana to ``None``."

msgid ""
"In all cases, if the optional parts are omitted, the code is executed in the "
"current scope.  If only *globals* is provided, it must be a dictionary (and "
"not a subclass of dictionary), which will be used for both the global and "
"the local variables.  If *globals* and *locals* are given, they are used for "
"the global and local variables, respectively.  If provided, *locals* can be "
"any mapping object.  Remember that at the module level, globals and locals "
"are the same dictionary."
msgstr ""
"We wszystkich przypadkach, jeśli części opcjonalne są pominięte, kod jest "
"wykonywany w bieżącym zakresie.  Jeśli podano tylko *globals*, musi to być "
"słownik (a nie podklasa z słownikem), który będzie używany zarówno dla "
"zmiennych globalnych, jak i lokalnych.  Jeśli podano *globals* i *locals*, "
"są one używane odpowiednio dla zmiennych globalnych i lokalnych.  Jeśli "
"podano *locals*, może to być dowolny obiekt mapowania.  Należy pamiętać, że "
"na poziomie moduł, globals i locals są tym samym słownikem."

msgid ""
"When ``exec`` gets two separate objects as *globals* and *locals*, the code "
"will be executed as if it were embedded in a class definition. This means "
"functions and classes defined in the executed code will not be able to "
"access variables assigned at the top level (as the \"top level\" variables "
"are treated as class variables in a class definition)."
msgstr ""
"Gdy ``exec`` pobiera dwa oddzielne obiekty jako *globals* i *locals*, kod "
"zostanie wykonany tak, jakby był osadzony w definicja klasy. Oznacza to, że "
"funkcja i klasy zdefiniowane w wykonywanym kodzie nie będą mogły uzyskać "
"dostępu do zmiennych przypisanych na najwyższym poziomie (ponieważ zmienne "
"\"najwyższego poziomu\" są traktowane jako zmienne klasowe w definicja "
"klasy)."

msgid ""
"If the *globals* dictionary does not contain a value for the key "
"``__builtins__``, a reference to the dictionary of the built-in module :mod:"
"`builtins` is inserted under that key.  That way you can control what "
"builtins are available to the executed code by inserting your own "
"``__builtins__`` dictionary into *globals* before passing it to :func:`exec`."
msgstr ""
"Jeśli *globals* słownik nie zawiera wartości dla klucza ``__builtins__``, "
"odwołanie do słownika z wbudowanego modułu :mod:`builtins` jest wstawiane "
"pod tym kluczem.  W ten sposób można kontrolować, które wbudowane są "
"dostępne dla wykonywanego kodu, wstawiając własny ``__builtins__`` słownik "
"do *globals* przed przekazaniem go do :func:`exec`."

msgid ""
"The *closure* argument specifies a closure--a tuple of cellvars. It's only "
"valid when the *object* is a code object containing :term:`free (closure) "
"variables <closure variable>`. The length of the tuple must exactly match "
"the length of the code object's :attr:`~codeobject.co_freevars` attribute."
msgstr ""
"Wyrażenie *closure* określa zamknięcie - krotka zmiennych komórkowych. Jest "
"ważne tylko wtedy, gdy *obiekt* jest obiektem kodu zawierającym :term:`wolne "
"(zamknięcie) zmienne <closure variable>`. Długość krotka musi dokładnie "
"odpowiadać długości :attr:`~codeobject.co_freevars` atrybutem obiektu kodu."

msgid ""
"The built-in functions :func:`globals` and :func:`locals` return the current "
"global and local namespace, respectively, which may be useful to pass around "
"for use as the second and third argument to :func:`exec`."
msgstr ""
"Adresy wbudowane funkcji :func:`globals` i :func:`locals` zwraca to "
"odpowiednio bieżąca globalna i lokalna przestrzeń nazw, które mogą być "
"przydatne do przekazania jako drugi i trzeci argument do :func:`exec`."

msgid ""
"The default *locals* act as described for function :func:`locals` below. "
"Pass an explicit *locals* dictionary if you need to see effects of the code "
"on *locals* after function :func:`exec` returns."
msgstr ""
"Elementy domyślne *locals* działają w sposób opisany dla funkcji :func:"
"`locals` poniżej. Przekaż jawne *locals* słownik jeśli chcesz zobaczyć "
"efekty kodu na *locals* po funkcji :func:`exec`  ."

msgid "Added the *closure* parameter."
msgstr "Dodano parametr *zamknięcie*."

msgid ""
"Construct an iterator from those elements of *iterable* for which *function* "
"is true.  *iterable* may be either a sequence, a container which supports "
"iteration, or an iterator.  If *function* is ``None``, the identity function "
"is assumed, that is, all elements of *iterable* that are false are removed."
msgstr ""
"Konstruuje iterator z tych elementów *iterable*, dla których *funkcja* jest "
"prawdą.  *iterable* może być sekwencją, kontenerem obsługującym iterację lub "
"iterator. Jeśli *funkcja* jest ``None``, zakłada się tożsamość funkcji, to "
"znaczy wszystkie elementy *iterable*, które są fałszywe, są usuwane."

msgid ""
"Note that ``filter(function, iterable)`` is equivalent to the generator "
"expression ``(item for item in iterable if function(item))`` if function is "
"not ``None`` and ``(item for item in iterable if item)`` if function is "
"``None``."
msgstr ""
"Należy zauważyć, że ``filter(function, iterable)`` jest równoważne wyrażeniu "
"generator ``(item for item in iterable if function(item))`` jeśli funkcja "
"nie jest ``None`` i ``(item for item in iterable if item)`` jeśli funkcja "
"jest ``None``."

msgid ""
"See :func:`itertools.filterfalse` for the complementary function that "
"returns elements of *iterable* for which *function* is false."
msgstr ""
"Zobacz :func:`itertools.filterfalse` dla komplementarnych funkci ktore "
"zwracaja elementy *iterable* dla których *funkcja* jest fałszywe."

msgid "Return a floating-point number constructed from a number or a string."
msgstr "Zwraca liczba zmiennoprzecinkowa zbudowana z liczby lub napisu."

msgid ""
">>> float('+1.23')\n"
"1.23\n"
">>> float('   -12345\\n')\n"
"-12345.0\n"
">>> float('1e-003')\n"
"0.001\n"
">>> float('+1E6')\n"
"1000000.0\n"
">>> float('-Infinity')\n"
"-inf"
msgstr ""
">>> float('+1.23')\n"
"1.23\n"
">>> float('   -12345\\n')\n"
"-12345.0\n"
">>> float('1e-003')\n"
"0.001\n"
">>> float('+1E6')\n"
"1000000.0\n"
">>> float('-Infinity')\n"
"-inf"

msgid ""
"If the argument is a string, it should contain a decimal number, optionally "
"preceded by a sign, and optionally embedded in whitespace.  The optional "
"sign may be ``'+'`` or ``'-'``; a ``'+'`` sign has no effect on the value "
"produced.  The argument may also be a string representing a NaN (not-a-"
"number), or positive or negative infinity. More precisely, the input must "
"conform to the :token:`~float:floatvalue` production rule in the following "
"grammar, after leading and trailing whitespace characters are removed:"
msgstr ""
"Jeśli argument jest napisem, powinien zawierać liczbę dziesiętną, "
"opcjonalnie poprzedzoną znakiem i opcjonalnie osadzoną w białych znakach.  "
"Znak opcjonalny może być ``'+'`` lub ``'-'``; znak ``'+'`` nie ma wpływu na "
"otrzymaną wartość.  argument może być również napisem reprezentującym NaN "
"(not-a-number) lub dodatnią lub ujemną nieskończoność. Dokładniej, dane "
"wejściowe muszą być zgodne z regułą produkcji :token:`~float:floatvalue` w "
"poniższej gramatyce, po usunięciu początkowych i końcowych białych znaków "
"znak:"

msgid ""
"Case is not significant, so, for example, \"inf\", \"Inf\", \"INFINITY\", "
"and \"iNfINity\" are all acceptable spellings for positive infinity."
msgstr ""
"Wielkość liter nie ma znaczenia, więc na przykład \"inf\", \"Inf\", "
"\"INFINITY\" i \"iNfINity\" są akceptowalnymi pisowniami dla dodatniej "
"nieskończoności."

msgid ""
"Otherwise, if the argument is an integer or a floating-point number, a "
"floating-point number with the same value (within Python's floating-point "
"precision) is returned.  If the argument is outside the range of a Python "
"float, an :exc:`OverflowError` will be raised."
msgstr ""
"W przeciwnym razie, jeśli argument jest liczba całkowita lub liczbą "
"zmiennoprzecinkową, zwracana jest liczba zmiennoprzecinkowa o tej samej "
"wartości (w zakresie precyzji zmiennoprzecinkowej Python). Rzuci jeśli "
"argument jest poza zakresem liczby zmiennoprzecinkowej Python, zwrócona "
"zostanie :exc:`OverflowError`."

msgid ""
"For a general Python object ``x``, ``float(x)`` delegates to ``x."
"__float__()``.  If :meth:`~object.__float__` is not defined then it falls "
"back to :meth:`~object.__index__`."
msgstr ""
"W przypadku ogólnego obiektu Python ``x`` , ``float(x)`` deleguje do ``x."
"__float__()``. Jeśli :meth:`~object.__float__` nie jest zdefiniowana, to "
"spada z powrotem do :meth:`~object.__index__`."

msgid "If no argument is given, ``0.0`` is returned."
msgstr "Jeśli nie podano argumentu, zwracane jest ``0.0``."

msgid "The float type is described in :ref:`typesnumeric`."
msgstr "Typ float został opisany na stronie :ref:`typesnumeric`."

msgid ""
"Falls back to :meth:`~object.__index__` if :meth:`~object.__float__` is not "
"defined."
msgstr ""
"Powraca do :meth:`~object.__index__`, jeśli :meth:`~object.__float__` nie "
"jest zdefiniowane."

msgid ""
"Convert a *value* to a \"formatted\" representation, as controlled by "
"*format_spec*.  The interpretation of *format_spec* will depend on the type "
"of the *value* argument; however, there is a standard formatting syntax that "
"is used by most built-in types: :ref:`formatspec`."
msgstr ""
"Konwertuje *value* na \"formatted\" reprezentację, kontrolowaną przez "
"*format_spec*.  Interpretacja *format_spec* będzie zależeć od typu *value* "
"argument; jednak istnieje standardowa składnia formatowania, która jest "
"używana przez większość typów wbudowanych: :ref:`formatspec`."

msgid ""
"The default *format_spec* is an empty string which usually gives the same "
"effect as calling :func:`str(value) <str>`."
msgstr ""
"Parametr domyślny *format_spec* jest pustym napisem, co zwykle daje taki sam "
"efekt jak wywołanie :func:`str(value) <str>`."

msgid ""
"A call to ``format(value, format_spec)`` is translated to ``type(value)."
"__format__(value, format_spec)`` which bypasses the instance dictionary when "
"searching for the value's :meth:`~object.__format__` method. A :exc:"
"`TypeError` exception is raised if the method search reaches :mod:`object` "
"and the *format_spec* is non-empty, or if either the *format_spec* or the "
"return value are not strings."
msgstr ""
"Wywołanie ``format(value, format_spec)`` jest tłumaczone na ``type(value)."
"__format__(value, format_spec)``, które omija instancję słownika podczas "
"wyszukiwania metody :meth:`~object.__format__` wartości . Wyjątek :exc:"
"`TypeError` jest rzucony, jeśli wyszukiwanie metody osiągnie :mod:`object` i "
"*format_spec* jest niepusty, lub jeśli *format_spec* lub wartość zwracana "
"nie są napisem."

msgid ""
"``object().__format__(format_spec)`` raises :exc:`TypeError` if "
"*format_spec* is not an empty string."
msgstr ""
"``object().__format__(format_spec)`` rzuci :exc:`TypeError` jeśli "
"*format_spec* nie jest pustym napisem."

msgid ""
"Return a new :class:`frozenset` object, optionally with elements taken from "
"*iterable*.  ``frozenset`` is a built-in class.  See :class:`frozenset` and :"
"ref:`types-set` for documentation about this class."
msgstr ""
"Zwraca nowy obiekt :class:`frozenset`, opcjonalnie z elementami pobranymi z "
"*iterable*. ``frozenset`` jest klasą wbudowaną.  Dokumentacja dotycząca tej "
"klasy znajduje się na stronach :class:`frozenset` i :ref:`types-set`."

msgid ""
"For other containers see the built-in :class:`set`, :class:`list`, :class:"
"`tuple`, and :class:`dict` classes, as well as the :mod:`collections` module."
msgstr ""
"Dla innych kontenerów zobacz klasy wbudowane :class:`set` , :class:`list`, :"
"class:`tuple` i :class:`dict`, jak również moduł  :mod:`collections` ."

msgid ""
"Return the value of the named attribute of *object*.  *name* must be a "
"string. If the string is the name of one of the object's attributes, the "
"result is the value of that attribute.  For example, ``getattr(x, "
"'foobar')`` is equivalent to ``x.foobar``.  If the named attribute does not "
"exist, *default* is returned if provided, otherwise :exc:`AttributeError` is "
"raised. *name* need not be a Python identifier (see :func:`setattr`)."
msgstr ""
"Zwraca wartość nazwanego atrybut obiektu *object*.  *name* musi być napisem. "
"Jeśli napis jest nazwą jednego z atrybut obiektu, wynikiem jest wartość tego "
"atrybutu.  Na przykład, ``getattr(x, 'foobar')`` jest równoważne ``x."
"foobar``. Jeśli nazwany atrybut nie istnieje, *default* jest zwracany, jeśli "
"został podany, w przeciwnym razie :exc:`AttributeError` jest rzucony. *name* "
"nie musi być identyfikatorem Pythona (Zobacz :func:`setattr`)."

msgid ""
"Since :ref:`private name mangling <private-name-mangling>` happens at "
"compilation time, one must manually mangle a private attribute's (attributes "
"with two leading underscores) name in order to retrieve it with :func:"
"`getattr`."
msgstr ""
"Ponieważ :ref:`manipulowanie nazwami prywatnymi <private-name-mangling>` "
"odbywa się w czasie kompilacji, należy ręcznie zmanipulować nazwę prywatną "
"atrybutu (atrybuty z dwoma wiodącymi podkreśleniami), aby pobrać ją za "
"pomocą :func:`getattr`."

msgid ""
"Return the dictionary implementing the current module namespace. For code "
"within functions, this is set when the function is defined and remains the "
"same regardless of where the function is called."
msgstr ""
"Zwraca słownik implementującą bieżącą przestrzeń nazw moduł. W przypadku "
"kodu w funkcja, jest on ustawiany, gdy funkcja jest zdefiniowana i pozostaje "
"taki sam niezależnie od tego, gdzie wywoływana jest funkcja."

msgid ""
"The arguments are an object and a string.  The result is ``True`` if the "
"string is the name of one of the object's attributes, ``False`` if not. "
"(This is implemented by calling ``getattr(object, name)`` and seeing whether "
"it raises an :exc:`AttributeError` or not.)"
msgstr ""
"Argumenty to obiekt i napis. Wynikiem jest ``True`` jeśli napis jest nazwą "
"jednego z obiektów atrybut, ``False`` jeśli nie. (Jest to zaimplementowane "
"poprzez wywołanie ``getattr(object, name)`` i sprawdzenie, czy rzucone jest :"
"exc:`AttributeError` )."

msgid ""
"Return the hash value of the object (if it has one).  Hash values are "
"integers.  They are used to quickly compare dictionary keys during a "
"dictionary lookup.  Numeric values that compare equal have the same hash "
"value (even if they are of different types, as is the case for 1 and 1.0)."
msgstr ""
"Zwraca wartość skrótu obiektu (jeśli taki posiada).  Wartości skrótu są "
"liczbami całkowitymi.  Są one używane do szybkiego porównywania kluczy "
"słownika podczas wyszukiwania słownika.  Wartości numeryczne, które są "
"równe, mają tę samą wartość skrótu (nawet jeśli są różnych typów, jak w "
"przypadku 1 i 1.0)."

msgid ""
"For objects with custom :meth:`~object.__hash__` methods, note that :func:"
"`hash` truncates the return value based on the bit width of the host machine."
msgstr ""
"W przypadku obiektów z niestandardowymi metodami :meth:`~object.__hash__` "
"należy pamiętać, że :func:`hash` obcina wartość zwracaną w oparciu o "
"szerokość bitową maszyny hosta."

msgid ""
"Invoke the built-in help system.  (This function is intended for interactive "
"use.)  If no argument is given, the interactive help system starts on the "
"interpreter console.  If the argument is a string, then the string is looked "
"up as the name of a module, function, class, method, keyword, or "
"documentation topic, and a help page is printed on the console.  If the "
"argument is any other kind of object, a help page on the object is generated."
msgstr ""
"Wywołuje system pomocy wbudowany.  (Ta funkcja jest przeznaczona do użytku "
"interaktywnego.) Jeśli nie podano argumentu, interaktywny system pomocy "
"uruchamia się na konsoli interpretera.  Jeśli argument jest napisem, to "
"napis jest wyszukiwany jako nazwa modułu, funkcja, klasa, metoda, słowo "
"kluczowe lub temat dokumentacji, a strona pomocy jest drukowana na konsoli.  "
"Jeśli argument jest jakimkolwiek innym rodzajem obiektu, generowana jest "
"strona pomocy dotycząca tego obiektu."

msgid ""
"Note that if a slash(/) appears in the parameter list of a function when "
"invoking :func:`help`, it means that the parameters prior to the slash are "
"positional-only. For more info, see :ref:`the FAQ entry on positional-only "
"parameters <faq-positional-only-arguments>`."
msgstr ""
"Zauważ, że jeśli ukośnik (/) pojawia się na liście parametrów w funkcji "
"podczas wywoływania :func:`help`, oznacza to, że parametry przed ukośnikiem "
"są tylko-pozycyjne. Aby uzyskać więcej informacji, zobacz :ref:`wpis FAQ na "
"temat parametrów tylko-pozycyjnych <faq-positional-only-arguments>` ."

msgid ""
"This function is added to the built-in namespace by the :mod:`site` module."
msgstr ""
"Ta funkcja jest dodawana do przestrzeni nazw wbudowanych przez moduł :mod:"
"`site` ."

msgid ""
"Changes to :mod:`pydoc` and :mod:`inspect` mean that the reported signatures "
"for callables are now more comprehensive and consistent."
msgstr ""
"Zmiany do :mod:`pydoc` i :mod:`inspect` oznaczają, że zgłoszone sygnatury "
"dla callables są teraz bardziej kompleksowe i spójne."

msgid ""
"Convert an integer number to a lowercase hexadecimal string prefixed with "
"\"0x\". If *x* is not a Python :class:`int` object, it has to define an :"
"meth:`~object.__index__` method that returns an integer. Some examples:"
msgstr ""
"Konwertuje liczbę liczba całkowita na zapis szesnastkowy z małymi literami "
"napis poprzedzony \"0x\". Jeśli *x* nie jest obiektem Python :class:`int` , "
"musi zdefiniować metodę :meth:`~object.__index__`, która zwraca liczbe "
"całkowita. Kilka przykładów:"

msgid ""
"If you want to convert an integer number to an uppercase or lower "
"hexadecimal string with prefix or not, you can use either of the following "
"ways:"
msgstr ""
"Jeśli chcesz przekonwertować liczbe całkowita na wielką lub małą liczbę "
"szesnastkową napis z prefiksem lub bez, możesz użyć jednego z poniższych "
"sposobów:"

msgid ""
"See also :func:`int` for converting a hexadecimal string to an integer using "
"a base of 16."
msgstr ""
"Zobacz także :func:`int`, aby przekonwertować szesnastkowy napis na liczba "
"całkowita przy użyciu podstawy 16."

msgid ""
"To obtain a hexadecimal string representation for a float, use the :meth:"
"`float.hex` method."
msgstr ""
"Aby uzyskać napis szesnastkowej reprezentacj dla zmiennoprzecinkowej, należy "
"użyć metody :meth:`float.hex`."

msgid ""
"Return the \"identity\" of an object.  This is an integer which is "
"guaranteed to be unique and constant for this object during its lifetime. "
"Two objects with non-overlapping lifetimes may have the same :func:`id` "
"value."
msgstr ""
"Zwraca \"tożsamość\" obiektu.  Jest to liczba całkowita, która jest "
"gwarantowana jako unikalny i stały dla tego obiektu przez cały okres jego "
"życia. Dwa obiekty o nienakładających się okresach życia mogą mieć tę samą "
"wartość :func:`id`."

msgid "This is the address of the object in memory."
msgstr "Jest to adres obiektu w pamięci."

msgid ""
"Raises an :ref:`auditing event <auditing>` ``builtins.id`` with argument "
"``id``."
msgstr ""
"Rzuci  :ref:`auditing event <auditing>` ``builtins.id`` bez argumentu "
"``id`` ."

msgid ""
"If the *prompt* argument is present, it is written to standard output "
"without a trailing newline.  The function then reads a line from input, "
"converts it to a string (stripping a trailing newline), and returns that.  "
"When EOF is read, :exc:`EOFError` is raised.  Example::"
msgstr ""
"Jeśli *prompt* argument jest obecny, jest on zapisywany na standardowe "
"wyjście bez końcowej nowej linii.  Następnie funkcja odczytuje linię z "
"wejścia, konwertuje ją na napis (usuwając końcową nową linię) i zwraca.  Po "
"odczytaniu EOF, :exc:`EOFError` jest rzucone.  Przykład::"

msgid ""
">>> s = input('--> ')\n"
"--> Monty Python's Flying Circus\n"
">>> s\n"
"\"Monty Python's Flying Circus\""
msgstr ""
">>> s = input('--> ')\n"
"--> Monty Python's Flying Circus\n"
">>> s\n"
"\"Monty Python's Flying Circus\""

msgid ""
"If the :mod:`readline` module was loaded, then :func:`input` will use it to "
"provide elaborate line editing and history features."
msgstr ""
"Jeśli załadowano moduł :mod:`readline` , to :func:`input` użyje go do "
"zapewnienia rozbudowanych funkcji edycji wierszy i historii."

msgid ""
"Raises an :ref:`auditing event <auditing>` ``builtins.input`` with argument "
"``prompt`` before reading input"
msgstr ""
"Rzuca :ref:`auditing event <auditing>` ``builtins.input`` z argumentem "
"``prompt`` przed odczytaniem wpisu"

msgid ""
"Raises an :ref:`auditing event <auditing>` ``builtins.input/result`` with "
"the result after successfully reading input."
msgstr ""
"Rzuca zdarzenie :ref:`auditing <auditing>` ``builtins.input/result`` z "
"wynikiem po pomyślnym odczytaniu danych wejściowych."

msgid ""
"Return an integer object constructed from a number or a string, or return "
"``0`` if no arguments are given."
msgstr ""
"Zwraca obiekt liczba całkowita zbudowana z liczby lub napisu, lub zwraca "
"``0`` jeśli nie podano argumentu."

msgid ""
">>> int(123.45)\n"
"123\n"
">>> int('123')\n"
"123\n"
">>> int('   -12_345\\n')\n"
"-12345\n"
">>> int('FACE', 16)\n"
"64206\n"
">>> int('0xface', 0)\n"
"64206\n"
">>> int('01110011', base=2)\n"
"115"
msgstr ""
">>> int(123.45)\n"
"123\n"
">>> int('123')\n"
"123\n"
">>> int('   -12_345\\n')\n"
"-12345\n"
">>> int('FACE', 16)\n"
"64206\n"
">>> int('0xface', 0)\n"
"64206\n"
">>> int('01110011', base=2)\n"
"115"

msgid ""
"If the argument defines :meth:`~object.__int__`, ``int(x)`` returns ``x."
"__int__()``.  If the argument defines :meth:`~object.__index__`, it returns "
"``x.__index__()``.  If the argument defines :meth:`~object.__trunc__`, it "
"returns ``x.__trunc__()``. For floating-point numbers, this truncates "
"towards zero."
msgstr ""
"Jeśli argument definiuje :meth:`~object.__int__`, ``int(x)`` zwraca ``x."
"__int__()`` .  Jeśli argument definiuje :meth:`~object.__index__`, to zwraca "
"``x.__index__()`` .  Jeśli argument definiuje :meth:`~object.__trunc__`, to "
"zwraca ``x.__trunc__()`` . W przypadku liczb zmiennoprzecinkowych jest ona "
"obcinana w kierunku zera."

msgid ""
"If the argument is not a number or if *base* is given, then it must be a "
"string, :class:`bytes`, or :class:`bytearray` instance representing an "
"integer in radix *base*.  Optionally, the string can be preceded by ``+`` or "
"``-`` (with no space in between), have leading zeros, be surrounded by "
"whitespace, and have single underscores interspersed between digits."
msgstr ""
"Jeśli argument nie jest liczbą lub jeśli podano *base*, musi to być "
"instancja napisu, :class:`bytes` lub :class:`bytearray` reprezentująca "
"liczba całkowita w radix *base*.  Opcjonalnie, napis może być poprzedzony "
"przez ``+`` lub ``-`` (bez spacji pomiędzy nimi), mieć początkowe zera, być "
"otoczone białymi znakami i mieć pojedyncze podkreślenia pomiędzy cyframi."

msgid ""
"A base-n integer string contains digits, each representing a value from 0 to "
"n-1. The values 0--9 can be represented by any Unicode decimal digit. The "
"values 10--35 can be represented by ``a`` to ``z`` (or ``A`` to ``Z``). The "
"default *base* is 10. The allowed bases are 0 and 2--36. Base-2, -8, and -16 "
"strings can be optionally prefixed with ``0b``/``0B``, ``0o``/``0O``, or "
"``0x``/``0X``, as with integer literals in code.  For base 0, the string is "
"interpreted in a similar way to an :ref:`integer literal in code "
"<integers>`, in that the actual base is 2, 8, 10, or 16 as determined by the "
"prefix. Base 0 also disallows leading zeros: ``int('010', 0)`` is not legal, "
"while ``int('010')`` and ``int('010', 8)`` are."
msgstr ""
"Baza-n liczba całkowita napis zawiera cyfry, z których każda reprezentuje "
"wartość od 0 do n-1. Wartości 0--9 mogą być reprezentowane przez dowolną "
"cyfrę dziesiętną Unicode. Wartości 10-35 mogą być reprezentowane przez ``a`` "
"do ``z`` (lub ``A`` do ``Z``). Domyślna baza jest 10. Dozwolone wartości "
"bazowe to 0 i 2--36. Podstawy 2, -8 i -16 napis mogą być opcjonalnie "
"poprzedzone przedrostkiem ``0b``/``0B``, ``0o``/``0O``, lub ``0x``/``0X``, "
"tak jak w przypadku literałów liczba całkowita w kodzie.  Dla podstawy 0, "
"napis jest interpretowane w podobny sposób jak :ref:`liczba całkowita w "
"kodzie <integers>`, w którym rzeczywista podstawa wynosi 2, 8, 10 lub 16, "
"zgodnie z przedrostkiem. Podstawa 0 również nie zezwala na zera wiodące: "
"``int('010', 0)`` nie jest legalne, podczas gdy ``int('010')`` i "
"``int('010', 8)`` są."

msgid "The integer type is described in :ref:`typesnumeric`."
msgstr "Typ liczba całkowita (integer) został opisany w :ref:`typesnumeric`."

msgid ""
"If *base* is not an instance of :class:`int` and the *base* object has a :"
"meth:`base.__index__ <object.__index__>` method, that method is called to "
"obtain an integer for the base.  Previous versions used :meth:`base.__int__ "
"<object.__int__>` instead of :meth:`base.__index__ <object.__index__>`."
msgstr ""
"Jeśli *base* nie jest instancją :class:`int` i obiekt *base* posiada metodę :"
"meth:`base.__index__ <object.__index__>`, metoda ta jest wywoływana w celu "
"uzyskania liczba całkowitych dla bazy.  Poprzednie wersje używały :meth:"
"`base.__int__ <object.__int__>` zamiast :meth:`base.__index__ <object."
"__index__>`."

msgid "The first parameter is now positional-only."
msgstr "Pierwszy parametr jest teraz tylko pozycyjny."

msgid ""
"Falls back to :meth:`~object.__index__` if :meth:`~object.__int__` is not "
"defined."
msgstr ""
"Powraca do :meth:`~object.__index__`, jeśli :meth:`~object.__int__` nie jest "
"zdefiniowane."

msgid "The delegation to :meth:`~object.__trunc__` is deprecated."
msgstr "Delegacja do :meth:`~object.__trunc__` jest zdezaprobowana."

msgid ""
":class:`int` string inputs and string representations can be limited to help "
"avoid denial of service attacks. A :exc:`ValueError` is raised when the "
"limit is exceeded while converting a string to an :class:`int` or when "
"converting an :class:`int` into a string would exceed the limit. See the :"
"ref:`integer string conversion length limitation <int_max_str_digits>` "
"documentation."
msgstr ""
":class:`int` napis wejścia i reprezentacje napisa mogą być ograniczone, aby "
"pomóc uniknąć ataków typu \"odmowa usługi\". :exc:`ValueError` jest rzucone, "
"gdy limit zostanie przekroczony podczas konwersji napisa na :class:`int` lub "
"gdy konwersja :class:`int` na napis przekroczy limit. Zobacz dokumentację :"
"ref:`liczba całkowita napis ograniczenia długości konwersji "
"<int_max_str_digits>`."

msgid ""
"Return ``True`` if the *object* argument is an instance of the *classinfo* "
"argument, or of a (direct, indirect, or :term:`virtual <abstract base "
"class>`) subclass thereof.  If *object* is not an object of the given type, "
"the function always returns ``False``. If *classinfo* is a tuple of type "
"objects (or recursively, other such tuples) or a :ref:`types-union` of "
"multiple types, return ``True`` if *object* is an instance of any of the "
"types. If *classinfo* is not a type or tuple of types and such tuples, a :"
"exc:`TypeError` exception is raised. :exc:`TypeError` may not be raised for "
"an invalid type if an earlier check succeeds."
msgstr ""
"Zwraca ``True`` jeśli argument *object* jest instancją argumentu "
"*classinfo*, lub jego (bezpośrednią, pośrednią lub :term:`wirtualną "
"<abstrakcyjna klasa bazowa>`) podklasą.  Jeśli *object* nie jest obiektem "
"danego typu, funkcja zawsze zwraca ``False``. Jeśli *classinfo* jest krotką "
"obiektów typu (lub rekurencyjnie, innych takich krotek) lub :ref:`types-"
"union` wielu typów, zwraca ``True`` jeśli *obiekt* jest instancją "
"któregokolwiek z typów. Jeśli *classinfo* nie jest typem lub krotką typów i "
"takich krotek, rzucany jest wyjątek :exc:`TypeError`. :exc:`TypeError` może "
"nie być rzucony dla nieprawidłowego typu, jeśli wcześniejsze sprawdzenie "
"powiedzie się."

msgid "*classinfo* can be a :ref:`types-union`."
msgstr "*classinfo* może być :ref:`types-union`."

msgid ""
"Return ``True`` if *class* is a subclass (direct, indirect, or :term:"
"`virtual <abstract base class>`) of *classinfo*.  A class is considered a "
"subclass of itself. *classinfo* may be a tuple of class objects (or "
"recursively, other such tuples) or a :ref:`types-union`, in which case "
"return ``True`` if *class* is a subclass of any entry in *classinfo*.  In "
"any other case, a :exc:`TypeError` exception is raised."
msgstr ""
"Zwraca ``True`` jeśli *class* jest podklasą (bezpośrednią, pośrednią lub :"
"term:`wirtualną <abstrakcyjna klasa bazowa>`) *classinfo*.  Klasa jest "
"uważana za podklasę samej siebie. *classinfo* może być krotką obiektów klasy "
"(lub rekurencyjnie, innych takich krotek) lub :ref:`types-union`, w którym "
"to przypadku zwraca ``True`` jeśli *class* jest podklasą dowolnego wpisu w "
"*classinfo*.  W każdym innym przypadku rzucany jest wyjątek :exc:`TypeError`."

msgid ""
"Return an :term:`iterator` object.  The first argument is interpreted very "
"differently depending on the presence of the second argument. Without a "
"second argument, *object* must be a collection object which supports the :"
"term:`iterable` protocol (the :meth:`~object.__iter__` method), or it must "
"support the sequence protocol (the :meth:`~object.__getitem__` method with "
"integer arguments starting at ``0``).  If it does not support either of "
"those protocols, :exc:`TypeError` is raised. If the second argument, "
"*sentinel*, is given, then *object* must be a callable object.  The iterator "
"created in this case will call *object* with no arguments for each call to "
"its :meth:`~iterator.__next__` method; if the value returned is equal to "
"*sentinel*, :exc:`StopIteration` will be raised, otherwise the value will be "
"returned."
msgstr ""
"Zwraca obiekt :term:`iteratora <iterator>`.  Pierwszy argument jest "
"interpretowany bardzo różnie w zależności od obecności drugiego argumentu. "
"Bez drugiego argumentu, *object* musi być obiektem kolekcji, która obsługuje "
"protokół :term:`iterable` (metoda :meth:`~object.__iter__` ), lub musi "
"obsługiwać protokół sekwencji (metoda :meth:`~object.__getitem__` z "
"argumentami liczb całkowitych zaczynających się od ``0``). Jeśli nie "
"obsługuje żadnego z tych protokołów, zostanie rzucony :exc:`TypeError`. "
"Jeśli podano drugi argument, *sentinel*, to *object* musi być obiektem "
"wywoływalnym. Utworzony w tym przypadku iterator będzie wywoływał *object* "
"bez argumentu dla każdego wywołania jego metody :meth:`~iterator.__next__`; "
"jeśli zwrócona wartość jest równa *sentinel*, zostanie rzucone :exc:"
"`StopIteration`, w przeciwnym razie zostanie zwrócona wartość."

msgid "See also :ref:`typeiter`."
msgstr "Zobacz także :ref:`typeiter`."

msgid ""
"One useful application of the second form of :func:`iter` is to build a "
"block-reader. For example, reading fixed-width blocks from a binary database "
"file until the end of file is reached::"
msgstr ""
"Jednym z przydatnych aplikacji drugiej formy :func:`iter` jest zbudowanie "
"blok czytnika. Na przykład, odczytywanie stałej szerokości bloku z binarnego "
"pliku bazy danych aż do osiągnięcia końca pliku::"

msgid ""
"from functools import partial\n"
"with open('mydata.db', 'rb') as f:\n"
"    for block in iter(partial(f.read, 64), b''):\n"
"        process_block(block)"
msgstr ""
"from functools import partial\n"
"with open('mojedane.db', 'rb') as f:\n"
"    for block in iter(partial(f.read, 64), b''):\n"
"        process_block(block)"

msgid ""
"Return the length (the number of items) of an object.  The argument may be a "
"sequence (such as a string, bytes, tuple, list, or range) or a collection "
"(such as a dictionary, set, or frozen set)."
msgstr ""
"Zwraca długość (liczba elementów) obiektu.  Obiekt argument może być "
"sekwencją (taką jak napis, bajty, krotka, lista lub zakres) lub kolekcją "
"(taką jak słownik, zbiór lub zbiór zamrożony)."

msgid ""
"``len`` raises :exc:`OverflowError` on lengths larger than :data:`sys."
"maxsize`, such as :class:`range(2 ** 100) <range>`."
msgstr ""
"``len`` rzuca :exc:`OverflowError` dla długości większych niż :data:`sys."
"maxsize`, takich jak :class:`range(2 ** 100) <range>`."

msgid ""
"Rather than being a function, :class:`list` is actually a mutable sequence "
"type, as documented in :ref:`typesseq-list` and :ref:`typesseq`."
msgstr ""
"Zamiast być funkcją, :class:`list` jest w rzeczywistości typem mutowalnej "
"(zmiennej) sekwencji, jak udokumentowano w :ref:`typesseq-list` i :ref:"
"`typesseq`."

msgid ""
"Return a mapping object representing the current local symbol table, with "
"variable names as the keys, and their currently bound references as the "
"values."
msgstr ""
"Zwraca obiekt mapowania reprezentujący bieżącą lokalną tablicę symboli, z "
"nazwami zmiennych jako kluczami i ich aktualnie powiązanymi referencjami "
"jako wartościami."

msgid ""
"At module scope, as well as when using :func:`exec` or :func:`eval` with a "
"single namespace, this function returns the same namespace as :func:"
"`globals`."
msgstr ""
"W zakresie moduł, a także podczas korzystania z :func:`exec` lub :func:"
"`eval` z pojedynczą przestrzenią nazw, ta funkcja zwraca ta sama przestrzeń "
"nazw co :func:`globals`."

msgid ""
"At class scope, it returns the namespace that will be passed to the "
"metaclass constructor."
msgstr ""
"W zakresie klasy, zwraca przestrzeń nazw, która zostanie przekazana do "
"konstruktora metaklasy."

msgid ""
"When using ``exec()`` or ``eval()`` with separate local and global "
"arguments, it returns the local namespace passed in to the function call."
msgstr ""
"W przypadku korzystania z ``exec()`` lub ``eval()`` z oddzielnymi lokalnymi "
"i globalnymi argumentami, zwraca lokalną przestrzeń nazw przekazaną do "
"wywołania funkcji."

msgid ""
"In all of the above cases, each call to ``locals()`` in a given frame of "
"execution will return the *same* mapping object. Changes made through the "
"mapping object returned from ``locals()`` will be visible as assigned, "
"reassigned, or deleted local variables, and assigning, reassigning, or "
"deleting local variables will immediately affect the contents of the "
"returned mapping object."
msgstr ""
"We wszystkich powyższych przypadkach każde wywołanie ``locals()`` w danej "
"ramce wykonania spowoduje zwracanie *tego samego* obiektu mapowania. Zmiany "
"dokonane za pośrednictwem obiektu mapowania zwróconego z ``locals()`` będą "
"widoczne jako przypisane, ponownie przypisane lub usunięte zmienne lokalne, "
"a przypisanie, ponowne przypisanie lub usunięcie zmiennych lokalnych "
"natychmiast wpłynie na zawartość zwróconego obiektu mapowania."

msgid ""
"In an :term:`optimized scope` (including functions, generators, and "
"coroutines), each call to ``locals()`` instead returns a fresh dictionary "
"containing the current bindings of the function's local variables and any "
"nonlocal cell references. In this case, name binding changes made via the "
"returned dict are *not* written back to the corresponding local variables or "
"nonlocal cell references, and assigning, reassigning, or deleting local "
"variables and nonlocal cell references does *not* affect the contents of "
"previously returned dictionaries."
msgstr ""
"W :term:`optimized scope` (włączając w to funkcja, generatory i coroutines), "
"każde wywołanie ``locals()`` zamiast zwracania świeżego słownika zawierający "
"aktualne wiązania zmiennych lokalnych funkcji i wszelkie nielokalne "
"odwołania do komórek. W tym przypadku zmiany powiązań nazw dokonane za "
"pośrednictwem zwróconego dict *nie* są zapisywane z powrotem do odpowiednich "
"zmiennych lokalnych lub nielokalnych odwołań do komórek, a przypisywanie, "
"ponowne przypisywanie lub usuwanie zmiennych lokalnych i nielokalnych "
"odwołań do komórek *nie* wpływa na zawartość wcześniej zwróconego słownika."

msgid ""
"Calling ``locals()`` as part of a comprehension in a function, generator, or "
"coroutine is equivalent to calling it in the containing scope, except that "
"the comprehension's initialised iteration variables will be included. In "
"other scopes, it behaves as if the comprehension were running as a nested "
"function."
msgstr ""
"Wywołanie ``locals()`` jako części rozumienia w funkcji, generator lub "
"coroutine jest równoważne wywołaniu go w zakresie zawierającym, z wyjątkiem "
"tego, że zainicjowane zmienne iteracyjne rozumienia zostaną uwzględnione. W "
"innych zakresach zachowuje się tak, jakby rozumienie działało jako "
"zagnieżdżone funkcja."

msgid ""
"Calling ``locals()`` as part of a generator expression is equivalent to "
"calling it in a nested generator function."
msgstr ""
"Wywołanie ``locals()`` jako części wyrażenia generator jest równoważne "
"wywołaniu go w zagnieżdżonym generatorze funkcji ."

msgid ""
"The behaviour of ``locals()`` in a comprehension has been updated as "
"described in :pep:`709`."
msgstr ""
"Zachowanie  ``locals()`` w zrozumieniu została zaktualizowana zgodnie z "
"opisem w :pep:`709`."

msgid ""
"As part of :pep:`667`, the semantics of mutating the mapping objects "
"returned from this function are now defined. The behavior in :term:"
"`optimized scopes <optimized scope>` is now as described above. Aside from "
"being defined, the behaviour in other scopes remains unchanged from previous "
"versions."
msgstr ""
"Jako część :pep:`667`, semantyka mutowania obiektów mapowania zwróconych z "
"tej funkcji jest teraz zdefiniowana. Zachowanie w :term:`zoptymalizowanych "
"zakresach <optimized scope>` jest teraz opisane powyżej. Poza "
"zdefiniowaniem, zachowanie w innych zakresach pozostaje niezmienione w "
"stosunku do poprzednich wersji."

msgid ""
"Return an iterator that applies *function* to every item of *iterable*, "
"yielding the results.  If additional *iterables* arguments are passed, "
"*function* must take that many arguments and is applied to the items from "
"all iterables in parallel.  With multiple iterables, the iterator stops when "
"the shortest iterable is exhausted.  For cases where the function inputs are "
"already arranged into argument tuples, see :func:`itertools.starmap`\\."
msgstr ""
"Zwraca iterator , który stosuje *funkcje* do każdego elementu *iterable*, "
"dając wyniki.  Jeśli przekazane zostaną dodatkowe *iterable* argumenty, "
"*funkcja* musi przyjąć taką liczbę argumentow i jest stosowana do elementów "
"ze wszystkich iterable równolegle.  W przypadku wielu iterables, iterator "
"zatrzymuje się, gdy najkrótszy iterable zostanie wyczerpany.  Dla "
"przypadków, w których wejścia funkcji są już ułożone w argumentach krotka , "
"zobacz :func:`itertools.starmap` ."

msgid ""
"Return the largest item in an iterable or the largest of two or more "
"arguments."
msgstr ""
"Zwraca największy element w iterable lub największy z dwóch lub więcej "
"argumentow."

msgid ""
"If one positional argument is provided, it should be an :term:`iterable`. "
"The largest item in the iterable is returned.  If two or more positional "
"arguments are provided, the largest of the positional arguments is returned."
msgstr ""
"Jeśli podano jeden pozycjny argument, powinien to być :term:`iterable`. "
"Zwracany jest największy element w iterable.  Jeśli podano dwa lub więcej "
"pozycyjne argumenty, zwracany jest największy z pozycyjnych argumentow."

msgid ""
"There are two optional keyword-only arguments. The *key* argument specifies "
"a one-argument ordering function like that used for :meth:`list.sort`. The "
"*default* argument specifies an object to return if the provided iterable is "
"empty. If the iterable is empty and *default* is not provided, a :exc:"
"`ValueError` is raised."
msgstr ""
"Istnieją dwa opcjonalne tylko ze słowem kluczowym argument. *Kluczowy* "
"argument określa jedno-argumentowy uporządkowanie funkcji jak to używane "
"dla :meth:`list.sort`. *Domyślny* argument określa obiekt do zwracania, "
"jeśli podany iterable jest pusty. Jeśli iterable jest pusty i *domyślny* nie "
"jest podany, :exc:`ValueError` jest rzucony."

msgid ""
"If multiple items are maximal, the function returns the first one "
"encountered.  This is consistent with other sort-stability preserving tools "
"such as ``sorted(iterable, key=keyfunc, reverse=True)[0]`` and ``heapq."
"nlargest(1, iterable, key=keyfunc)``."
msgstr ""
"Jeśli wiele elementów jest maksymalnych, funkcja zwraca pierwszy napotkany "
"element.  Jest to zgodne z innymi narzędziami zachowującymi stabilność "
"sortowania, takimi jak ``sorted(iterable, key=keyfunc, reverse=True)[0]`` i "
"``heapq.nlargest(1, iterable, key=keyfunc)``."

msgid "Added the *default* keyword-only parameter."
msgstr "Dodano *default* tylko słowo kluczowe parametr."

msgid "The *key* can be ``None``."
msgstr "*Kluczem* może być ``None``."

msgid ""
"Return a \"memory view\" object created from the given argument.  See :ref:"
"`typememoryview` for more information."
msgstr ""
"Zwraca obiekt \"memory view\" utworzony z podanego argumentu.  Więcej "
"informacji można znaleźć na stronie :ref:`typememoryview`."

msgid ""
"Return the smallest item in an iterable or the smallest of two or more "
"arguments."
msgstr ""
"Zwraca najmniejszy element w iterable lub najmniejszy z dwóch lub więcej "
"argumentow."

msgid ""
"If one positional argument is provided, it should be an :term:`iterable`. "
"The smallest item in the iterable is returned.  If two or more positional "
"arguments are provided, the smallest of the positional arguments is returned."
msgstr ""
"Jeśli podano jeden pozycjny argument, powinien to być :term:`iterable`. "
"Zwracany jest najmniejszy element w iterable.  Jeśli podano dwa lub więcej "
"pozycyjne argumenty, zwracany jest najmniejszy z pozycyjnych argumentow."

msgid ""
"If multiple items are minimal, the function returns the first one "
"encountered.  This is consistent with other sort-stability preserving tools "
"such as ``sorted(iterable, key=keyfunc)[0]`` and ``heapq.nsmallest(1, "
"iterable, key=keyfunc)``."
msgstr ""
"Jeśli wiele elementów jest minimalnych, funkcja zwraca pierwszy napotkany.  "
"Jest to zgodne z innymi narzędziami zachowującymi stabilność sortowania, "
"takimi jak ``sorted(iterable, key=keyfunc)[0]`` i ``heapq.nsmallest(1, "
"iterable, key=keyfunc)``."

msgid ""
"Retrieve the next item from the :term:`iterator` by calling its :meth:"
"`~iterator.__next__` method.  If *default* is given, it is returned if the "
"iterator is exhausted, otherwise :exc:`StopIteration` is raised."
msgstr ""
"Pobiera następny element z :term:`iterator` poprzez wywołanie jego metody :"
"meth:`~iterator.__next__`.  Jeśli *domyślny* jest podany, jest zwracany, "
"jeśli iterator jest wyczerpany, w przeciwnym razie :exc:`StopIteration` jest "
"rzucony."

msgid ""
"This is the ultimate base class of all other classes. It has methods that "
"are common to all instances of Python classes. When the constructor is "
"called, it returns a new featureless object. The constructor does not accept "
"any arguments."
msgstr ""
"Jest to ostateczna klasa bazowa wszystkich innych klas. Posiada metody, "
"które są wspólne dla wszystkich instancji klas Pythona. Kiedy konstruktor "
"jest wywoływany, zwraca nowy obiekt bez funkcji. Klasa konstruktor nie "
"akceptuje żadnych argumentow."

msgid ""
":class:`object` instances do *not* have :attr:`~object.__dict__` attributes, "
"so you can't assign arbitrary attributes to an instance of :class:`object`."
msgstr ""
":class:`object` instancje *nie* mają :attr:`~object.__dict__` atrybut , więc "
"nie można przypisać dowolnego atrybuta do instancji :class:`object`."

msgid ""
"Convert an integer number to an octal string prefixed with \"0o\".  The "
"result is a valid Python expression. If *x* is not a Python :class:`int` "
"object, it has to define an :meth:`~object.__index__` method that returns an "
"integer. For example:"
msgstr ""
"Konwertuje liczbę liczba całkowita na ósemkowy napis z prefiksem \"0o\".  "
"Wynikiem jest poprawne wyrażenie Python. Jeśli *x* nie jest obiektem "
"Pythona :class:`int` , musi definiować metodę :meth:`~object.__index__`, "
"która zwraca liczbe całkowita. Na przykład:"

msgid ""
"If you want to convert an integer number to an octal string either with the "
"prefix \"0o\" or not, you can use either of the following ways."
msgstr ""
"Jeśli chcesz przekonwertować liczbę całkowita na ósemkowy napis z "
"przedrostkiem \"0o\" lub bez, możesz użyć jednego z poniższych sposobów."

msgid ""
"Open *file* and return a corresponding :term:`file object`.  If the file "
"cannot be opened, an :exc:`OSError` is raised. See :ref:`tut-files` for more "
"examples of how to use this function."
msgstr ""
"Otwiera *file* i zwraca odpowiedni :term:`obiekt pliku <file object>`.  "
"Jeśli pliku nie da się otworzyć, rzucany jest :exc:`OSError`. Więcej "
"przykładów użycia tej funkcji można znaleźć w :ref:`tut-files`."

msgid ""
"*file* is a :term:`path-like object` giving the pathname (absolute or "
"relative to the current working directory) of the file to be opened or an "
"integer file descriptor of the file to be wrapped.  (If a file descriptor is "
"given, it is closed when the returned I/O object is closed unless *closefd* "
"is set to ``False``.)"
msgstr ""
"*file* jest :term:`obiektem path-like <path-like object>` podającym nazwę "
"ścieżki (bezwzględną lub względną do bieżącego katalogu roboczego) pliku, "
"który ma zostać otwarty, lub liczbą całkowitą deskryptora pliku, który ma "
"zostać opakowany.  (Jeśli podano deskryptor pliku, jest on zamykany, gdy "
"zwrócony obiekt I/O jest zamykany, chyba że *closefd* jest ustawione na "
"``False``.)"

msgid ""
"*mode* is an optional string that specifies the mode in which the file is "
"opened.  It defaults to ``'r'`` which means open for reading in text mode. "
"Other common values are ``'w'`` for writing (truncating the file if it "
"already exists), ``'x'`` for exclusive creation, and ``'a'`` for appending "
"(which on *some* Unix systems, means that *all* writes append to the end of "
"the file regardless of the current seek position).  In text mode, if "
"*encoding* is not specified the encoding used is platform-dependent: :func:"
"`locale.getencoding` is called to get the current locale encoding. (For "
"reading and writing raw bytes use binary mode and leave *encoding* "
"unspecified.)  The available modes are:"
msgstr ""
"*mode* to opcjonalny napis , który określa tryb, w którym plik jest "
"otwierany.  Domyślnie jest to ``'r'``, co oznacza otwarcie do odczytu w "
"trybie tekstowym. Inne popularne wartości to ``'w'`` dla zapisu (obcinanie "
"pliku, jeśli już istnieje), ``'x'`` dla wyłącznego tworzenia i ``'a'`` dla "
"dołączania (co w *niektórych* systemach Unix oznacza, że *wszystkie* zapisy "
"są dołączane do końca pliku niezależnie od bieżącej pozycji wyszukiwania).  "
"W trybie tekstowym, jeśli nie podano *encoding*, używane kodowanie jest "
"zależne od platformy: :func:`locale.getencoding` jest wywoływane w celu "
"uzyskania bieżącego kodowania locale. (Do odczytu i zapisu nieprzetworzonych "
"bajtów należy użyć trybu binarnego i pozostawić *encoding* nieokreślone).  "
"Dostępne tryby to:"

msgid "Character"
msgstr "Znak"

msgid "Meaning"
msgstr "Znaczenie"

msgid "``'r'``"
msgstr "``'r'``"

msgid "open for reading (default)"
msgstr "otwarte do czytania (domyślny)"

msgid "``'w'``"
msgstr "``'w'``"

msgid "open for writing, truncating the file first"
msgstr "otworzyć do zapisu, najpierw obcinając plik"

msgid "``'x'``"
msgstr "``'x'``"

msgid "open for exclusive creation, failing if the file already exists"
msgstr ""
"otwarcie do wyłącznego utworzenia, niepowodzenie, jeśli plik już istnieje"

msgid "``'a'``"
msgstr "``'a'``"

msgid "open for writing, appending to the end of file if it exists"
msgstr "otwarte do zapisu, dołączenie do końca pliku, jeśli istnieje"

msgid "``'b'``"
msgstr "``'b'``"

msgid "binary mode"
msgstr "tryb binarny"

msgid "``'t'``"
msgstr "``'t'``"

msgid "text mode (default)"
msgstr "tryb tekstowy (domyślny)"

msgid "``'+'``"
msgstr "``'+'``"

msgid "open for updating (reading and writing)"
msgstr "otwarte na aktualizację (odczyt i zapis)"

msgid ""
"The default mode is ``'r'`` (open for reading text, a synonym of ``'rt'``). "
"Modes ``'w+'`` and ``'w+b'`` open and truncate the file.  Modes ``'r+'`` and "
"``'r+b'`` open the file with no truncation."
msgstr ""
"Tryb domyślny to ``'r'`` (otwarty do odczytu tekstu, synonim ``'rt'``). "
"Tryby ``'w+'`` i ``'w+b'`` otwierają i obcinają plik.  Tryby ``'r+'`` i "
"``'r+b'`` otwierają plik bez obcinania."

msgid ""
"As mentioned in the :ref:`io-overview`, Python distinguishes between binary "
"and text I/O.  Files opened in binary mode (including ``'b'`` in the *mode* "
"argument) return contents as :class:`bytes` objects without any decoding.  "
"In text mode (the default, or when ``'t'`` is included in the *mode* "
"argument), the contents of the file are returned as :class:`str`, the bytes "
"having been first decoded using a platform-dependent encoding or using the "
"specified *encoding* if given."
msgstr ""
"Jak wspomniano w :ref:`io-overview`, Python rozróżnia binarne i tekstowe I/"
"O.  Pliki otwierane w trybie binarnym (w tym ``'b'`` w *mode* argument) "
"zwracają zawartość jako obiekty :class:`bytes` bez żadnego dekodowania.  W "
"trybie tekstowym ( domyślny, lub gdy ``'t'`` jest zawarte w *mode* "
"argument), zawartość pliku jest zwracana jako :class:`str`, bajty zostały "
"najpierw zdekodowane przy użyciu kodowania zależnego od platformy lub przy "
"użyciu określonego *kodowania*, jeśli zostało podane."

msgid ""
"Python doesn't depend on the underlying operating system's notion of text "
"files; all the processing is done by Python itself, and is therefore "
"platform-independent."
msgstr ""
"Python nie zależy od pojęcia plików tekstowych w systemie operacyjnym; całe "
"przetwarzanie jest wykonywane przez Pythoan i dlatego jest niezależne od "
"platformy."

msgid ""
"*buffering* is an optional integer used to set the buffering policy.  Pass 0 "
"to switch buffering off (only allowed in binary mode), 1 to select line "
"buffering (only usable when writing in text mode), and an integer > 1 to "
"indicate the size in bytes of a fixed-size chunk buffer. Note that "
"specifying a buffer size this way applies for binary buffered I/O, but "
"``TextIOWrapper`` (i.e., files opened with ``mode='r+'``) would have another "
"buffering. To disable buffering in ``TextIOWrapper``, consider using the "
"``write_through`` flag for :func:`io.TextIOWrapper.reconfigure`. When no "
"*buffering* argument is given, the default buffering policy works as follows:"
msgstr ""
"*buffering* to opcjonalna liczba całkowita używana do ustawiania polityki "
"buforowania.  Przekaż 0, aby wyłączyć buforowanie (dozwolone tylko w trybie "
"binarnym), 1, aby wybrać buforowanie liniowe (używane tylko podczas pisania "
"w trybie tekstowym) i liczba całkowita > 1, aby wskazać rozmiar w bajtach "
"bufora o stałym rozmiarze. Należy zauważyć, że określenie rozmiaru bufora w "
"ten sposób dotyczy binarnie buforowanego wejścia/wyjścia, ale "
"``TextIOWrapper`` (tj. pliki otwierane za pomocą ``mode='r+'``) będą miały "
"inne buforowanie. Aby wyłączyć buforowanie w ``TextIOWrapper``, należy "
"rozważyć użycie flagi ``write_through`` dla :func:`io.TextIOWrapper."
"reconfigure`. Gdy nie podano *buforowania* argument, polityka buforowania "
"domyślny działa w następujący sposób:"

msgid ""
"Binary files are buffered in fixed-size chunks; the size of the buffer is "
"chosen using a heuristic trying to determine the underlying device's \"block "
"size\" and falling back on :const:`io.DEFAULT_BUFFER_SIZE`.  On many "
"systems, the buffer will typically be 4096 or 8192 bytes long."
msgstr ""
"Pliki binarne są buforowane w kawałkach o stałym rozmiarze; rozmiar bufora "
"jest wybierany przy użyciu heurystyki próbującej określić \"rozmiar "
"urządzenia bazowego\" i powracając do :const:`io.DEFAULT_BUFFER_SIZE`.  W "
"wielu systemach bufor ma długość 4096 lub 8192 bajtów."

msgid ""
"\"Interactive\" text files (files for which :meth:`~io.IOBase.isatty` "
"returns ``True``) use line buffering.  Other text files use the policy "
"described above for binary files."
msgstr ""
"\"Interaktywne\" pliki tekstowe (pliki, dla których :meth:`~io.IOBase."
"isatty` zwraca ``True`` ) używają buforowania linii.  Inne pliki tekstowe "
"używają zasad opisanych powyżej dla plików binarnych."

msgid ""
"*encoding* is the name of the encoding used to decode or encode the file. "
"This should only be used in text mode.  The default encoding is platform "
"dependent (whatever :func:`locale.getencoding` returns), but any :term:`text "
"encoding` supported by Python can be used. See the :mod:`codecs` module for "
"the list of supported encodings."
msgstr ""
"*encoding* to nazwa kodowania używanego do dekodowania lub kodowania pliku. "
"Powinno być używane tylko w trybie tekstowym.  Kodowanie domyślne jest "
"zależne od platformy (cokolwiek :func:`locale.getencoding` zwraca ), ale "
"można użyć dowolnego :term:`kodowanie tekstu` obsługiwanego przez Python. "
"Lista obsługiwanych kodowań znajduje się na stronie :mod:`codecs` modułu ."

msgid ""
"*errors* is an optional string that specifies how encoding and decoding "
"errors are to be handled—this cannot be used in binary mode. A variety of "
"standard error handlers are available (listed under :ref:`error-handlers`), "
"though any error handling name that has been registered with :func:`codecs."
"register_error` is also valid.  The standard names include:"
msgstr ""
"*errors* to opcjonalny napis, który określa sposób obsługi błędów kodowania "
"i dekodowania - nie może być używany w trybie binarnym. Dostępnych jest "
"wiele standardowych programów obsługi błędów (wymienionych w :ref:`error-"
"handlers`), choć każda nazwa obsługi błędów zarejestrowana w :func:`codecs."
"register_error` jest również ważna.  Standardowe nazwy obejmują:"

msgid ""
"``'strict'`` to raise a :exc:`ValueError` exception if there is an encoding "
"error.  The default value of ``None`` has the same effect."
msgstr ""
"``'strict'`` do rzucenja wyjątek :exc:`ValueError`, jeśli wystąpi błąd "
"kodowania.  Wartość domyślna z ``None`` ma ten sam efekt."

msgid ""
"``'ignore'`` ignores errors.  Note that ignoring encoding errors can lead to "
"data loss."
msgstr ""
"``'ignore'`` ignoruje błędy.  Należy pamiętać, że ignorowanie błędów "
"kodowania może prowadzić do utraty danych."

msgid ""
"``'replace'`` causes a replacement marker (such as ``'?'``) to be inserted "
"where there is malformed data."
msgstr ""
"``'replace'`` powoduje wstawienie znacznika zastępczego (takiego jak "
"``'?'``) tam, gdzie występują zniekształcone dane."

msgid ""
"``'surrogateescape'`` will represent any incorrect bytes as low surrogate "
"code units ranging from U+DC80 to U+DCFF. These surrogate code units will "
"then be turned back into the same bytes when the ``surrogateescape`` error "
"handler is used when writing data.  This is useful for processing files in "
"an unknown encoding."
msgstr ""
"``'surrogateescape'`` będzie reprezentować wszelkie nieprawidłowe bajty jako "
"niskie jednostki kodu zastępczego w zakresie od U+DC80 do U+DCFF. Te "
"jednostki kodu zastępczego zostaną następnie przekształcone z powrotem w te "
"same bajty, gdy podczas zapisu danych zostanie użyta obsługa błędów "
"``surrogateescape``.  Jest to przydatne do przetwarzania plików w nieznanym "
"kodowaniu."

msgid ""
"``'xmlcharrefreplace'`` is only supported when writing to a file. Characters "
"not supported by the encoding are replaced with the appropriate XML "
"character reference :samp:`&#{nnn};`."
msgstr ""
"``'xmlcharrefreplace'`` jest obsługiwany tylko podczas zapisu do pliku. Znak "
"nieobsługiwany przez kodowanie jest zastępowany odpowiednim odniesieniem XML "
"znak :samp:`&#{nnn};` ."

msgid ""
"``'backslashreplace'`` replaces malformed data by Python's backslashed "
"escape sequences."
msgstr ""
"``'backslashreplace'`` zastępuje zniekształcone dane przez sekwencje "
"specjalne Python'z ukośnikiem wstecznym."

msgid ""
"``'namereplace'`` (also only supported when writing) replaces unsupported "
"characters with ``\\N{...}`` escape sequences."
msgstr ""
"``'namereplace'`` (również obsługiwane tylko podczas zapisu) zastępuje "
"nieobsługiwane znak sekwencjami ucieczki ``\\N{...}``."

msgid ""
"*newline* determines how to parse newline characters from the stream. It can "
"be ``None``, ``''``, ``'\\n'``, ``'\\r'``, and ``'\\r\\n'``.  It works as "
"follows:"
msgstr ""
"*newline* określa sposób analizowania nowej linii znak ze strumienia. Może "
"to być ``None``, ``''``, ``'\\n'``, ``'\\r'`` i ``'\\r\\n'``. Działa to w "
"następujący sposób:"

msgid ""
"When reading input from the stream, if *newline* is ``None``, universal "
"newlines mode is enabled.  Lines in the input can end in ``'\\n'``, "
"``'\\r'``, or ``'\\r\\n'``, and these are translated into ``'\\n'`` before "
"being returned to the caller.  If it is ``''``, universal newlines mode is "
"enabled, but line endings are returned to the caller untranslated.  If it "
"has any of the other legal values, input lines are only terminated by the "
"given string, and the line ending is returned to the caller untranslated."
msgstr ""
"Podczas odczytu danych wejściowych ze strumienia, jeśli *newline* to "
"``None``, włączony jest uniwersalny tryb nowych linii.  Linie na wejściu "
"mogą kończyć się na ``'\\n'``, ``'\\r'``, lub ``'\\r\\n'``, które są "
"tłumaczone na ``'\\n'`` przed zwróceniem do wywołującego.  Jeśli jest to "
"``''``, włączony jest uniwersalny tryb nowych linii, ale zakończenia linii "
"są zwracane do wywołującego bez tłumaczenia.  Jeśli ma dowolną z pozostałych "
"legalnych wartości, linie wejściowe są kończone tylko przez podany napis, a "
"zakończenie linii jest zwracane bez tłumaczenia."

msgid ""
"When writing output to the stream, if *newline* is ``None``, any ``'\\n'`` "
"characters written are translated to the system default line separator, :"
"data:`os.linesep`.  If *newline* is ``''`` or ``'\\n'``, no translation "
"takes place.  If *newline* is any of the other legal values, any ``'\\n'`` "
"characters written are translated to the given string."
msgstr ""
"Podczas zapisywania danych wyjściowych do strumienia, jeśli *newline* ma "
"wartość ``None``, wszelkie zapisane ``'\\n'`` znaki są tłumaczone na "
"systemowy domyślny separator linii, :data:`os.linesep`.  Jeśli *newline* ma "
"wartość ``''`` lub ``'\\n'``, tłumaczenie nie jest wykonywane.  Jeśli "
"*newline* jest dowolną z pozostałych legalnych wartości, wszelkie zapisane "
"``'\\n'`` znaki są tłumaczone na podany napis."

msgid ""
"If *closefd* is ``False`` and a file descriptor rather than a filename was "
"given, the underlying file descriptor will be kept open when the file is "
"closed.  If a filename is given *closefd* must be ``True`` (the default); "
"otherwise, an error will be raised."
msgstr ""
"Jeśli *closefd* ma wartość ``False`` i podano deskryptor pliku, a nie nazwę "
"pliku, to bazowy deskryptor pliku pozostanie otwarty po zamknięciu pliku.  "
"Jeśli podano nazwę pliku, *closefd* musi mieć wartość ``True`` ( domyślny); "
"w przeciwnym razie wystąpi błąd."

msgid ""
"A custom opener can be used by passing a callable as *opener*. The "
"underlying file descriptor for the file object is then obtained by calling "
"*opener* with (*file*, *flags*). *opener* must return an open file "
"descriptor (passing :mod:`os.open` as *opener* results in functionality "
"similar to passing ``None``)."
msgstr ""
"Niestandardowy otwieracz może być użyty poprzez przekazanie wywołania jako "
"*opener*. Podstawowy deskryptor pliku dla obiektu pliku jest następnie "
"uzyskiwany przez wywołanie *opener* z (*file*, *flags*). *opener* musi "
"zwracać otwarty deskryptor pliku (przekazanie :mod:`os.open` jako *opener* "
"skutkuje funkcjonalnością podobną do przekazania ``None``)."

msgid "The newly created file is :ref:`non-inheritable <fd_inheritance>`."
msgstr "Nowo utworzony plik jest :ref:`non-inheritable <fd_inheritance>`."

msgid ""
"The following example uses the :ref:`dir_fd <dir_fd>` parameter of the :func:"
"`os.open` function to open a file relative to a given directory::"
msgstr ""
"Poniższy przykład używa :ref:`dir_fd <dir_fd>`  parametr z :func:`os.open` "
"funkcji do otwarcia pliku względem danego katalogu::"

msgid ""
">>> import os\n"
">>> dir_fd = os.open('somedir', os.O_RDONLY)\n"
">>> def opener(path, flags):\n"
"...     return os.open(path, flags, dir_fd=dir_fd)\n"
"...\n"
">>> with open('spamspam.txt', 'w', opener=opener) as f:\n"
"...     print('This will be written to somedir/spamspam.txt', file=f)\n"
"...\n"
">>> os.close(dir_fd)  # don't leak a file descriptor"
msgstr ""
">>> import os\n"
">>> dir_fd = os.open('somedir', os.O_RDONLY)\n"
">>> def opener(path, flags):\n"
"...     return os.open(path, flags, dir_fd=dir_fd)\n"
"...\n"
">>> with open('spamspam.txt', 'w', opener=opener) as f:\n"
"...     print('To zostanie zapisane  w somedir/spamspam.txt', file=f)\n"
"...\n"
">>> os.close(dir_fd)  # nie ujawniaj deskryptora pliku"

msgid ""
"The type of :term:`file object` returned by the :func:`open` function "
"depends on the mode.  When :func:`open` is used to open a file in a text "
"mode (``'w'``, ``'r'``, ``'wt'``, ``'rt'``, etc.), it returns a subclass of :"
"class:`io.TextIOBase` (specifically :class:`io.TextIOWrapper`).  When used "
"to open a file in a binary mode with buffering, the returned class is a "
"subclass of :class:`io.BufferedIOBase`.  The exact class varies: in read "
"binary mode, it returns an :class:`io.BufferedReader`; in write binary and "
"append binary modes, it returns an :class:`io.BufferedWriter`, and in read/"
"write mode, it returns an :class:`io.BufferedRandom`.  When buffering is "
"disabled, the raw stream, a subclass of :class:`io.RawIOBase`, :class:`io."
"FileIO`, is returned."
msgstr ""
"Typ :term:`file object` zwracany przez :func:`open` zależy od trybu.  Gdy :"
"func:`open` jest używany do otwarcia pliku w trybie tekstowym (``'w'``, "
"``'r'``, ``'wt'``, ``'rt'``, itd.), to zwracana jest podklasa klasy :class:"
"`io.TextIOBase` (w szczególności :class:`io.TextIOWrapper`).  W przypadku "
"użycia do otwarcia pliku w trybie binarnym z buforowaniem, zwracana klasą "
"jest podklasa z :class:`io.BufferedIOBase`. Dokładna klasa różni się: w "
"trybie odczytu binarnego, jest to zwracane z :class:`io.BufferedReader`; w "
"trybach zapisu binarnego i dołączania binarnego, jest to zwracane z :class:"
"`io.BufferedWriter`, a w trybie odczytu/zapisu, jest to zwracane z :class:"
"`io.BufferedRandom`. Gdy buforowanie jest wyłączone, zwracany jest "
"nieprzetworzony strumień, podklasa z :class:`io.RawIOBase`, :class:`io."
"FileIO`."

msgid ""
"See also the file handling modules, such as :mod:`fileinput`, :mod:`io` "
"(where :func:`open` is declared), :mod:`os`, :mod:`os.path`, :mod:"
"`tempfile`, and :mod:`shutil`."
msgstr ""
"Zobacz także moduły obsługę plików, takich jak :mod:`fileinput`, :mod:`io` "
"(gdzie zadeklarowano :func:`open` ), :mod:`os`, :mod:`os.path`, :mod:"
"`tempfile` i :mod:`shutil`."

msgid ""
"Raises an :ref:`auditing event <auditing>` ``open`` with arguments ``path``, "
"``mode``, ``flags``."
msgstr ""
"Rzuca :ref:`auditing event <auditing>` ``open`` z argumentami ``path`` , "
"``mode``, ``flags``."

msgid ""
"The ``mode`` and ``flags`` arguments may have been modified or inferred from "
"the original call."
msgstr ""
"Adresy ``mode`` i ``flags`` argumenty mogły zostać zmodyfikowane lub "
"wywnioskowane z oryginalnego połączenia."

msgid "The *opener* parameter was added."
msgstr "Dodano *opener* parametr."

msgid "The ``'x'`` mode was added."
msgstr "Dodano tryb ``'x'``."

msgid ":exc:`IOError` used to be raised, it is now an alias of :exc:`OSError`."
msgstr ":exc:`IOError` kiedyś był rzucony, teraz jest alias z :exc:`OSError`."

msgid ""
":exc:`FileExistsError` is now raised if the file opened in exclusive "
"creation mode (``'x'``) already exists."
msgstr ""
":exc:`FileExistsError` jest teraz rzucane, jeśli plik otwarty w trybie "
"wyłącznego tworzenia (``'x'``) już istnieje."

msgid "The file is now non-inheritable."
msgstr "Plik nie jest teraz dziedziczony."

msgid ""
"If the system call is interrupted and the signal handler does not raise an "
"exception, the function now retries the system call instead of raising an :"
"exc:`InterruptedError` exception (see :pep:`475` for the rationale)."
msgstr ""
"Jeśli wywołanie systemowe zostanie przerwane, a program obsługi sygnału nie "
"rzuci wyjątku, funkcji ponawia teraz wywołanie systemowe zamiast rzucenja "
"wyjątku :exc:`InterruptedError` (zobacz :pep:`475` dla uzasadnienia)."

msgid "The ``'namereplace'`` error handler was added."
msgstr "Dodano obsługę błędów ``'namereplace'``."

msgid "Support added to accept objects implementing :class:`os.PathLike`."
msgstr ""
"Dodano obsługę akceptowania obiektów implementujących :class:`os.PathLike`."

msgid ""
"On Windows, opening a console buffer may return a subclass of :class:`io."
"RawIOBase` other than :class:`io.FileIO`."
msgstr ""
"W systemie Windows, otwarcie bufora konsoli może zwracać podklasa z :class:"
"`io.RawIOBase` innego niż :class:`io.FileIO`."

msgid "The ``'U'`` mode has been removed."
msgstr "Tryb ``'U'`` został usunięty."

msgid ""
"Given a string representing one Unicode character, return an integer "
"representing the Unicode code point of that character.  For example, "
"``ord('a')`` returns the integer ``97`` and ``ord('€')`` (Euro sign) returns "
"``8364``.  This is the inverse of :func:`chr`."
msgstr ""
"Biorąc pod uwagę napis reprezentujący jeden punkt kodowy Unicode znak, "
"zwracać i liczba całkowita reprezentujący punkt kodowy Unicode tego znaka.  "
"Na przykład, ``ord('a')`` zwraca liczbe całkowita ``97`` i ``ord('€')`` "
"(znak euro) zwraca ``8364`` .  Jest to odwrotność :func:`chr`."

msgid ""
"Return *base* to the power *exp*; if *mod* is present, return *base* to the "
"power *exp*, modulo *mod* (computed more efficiently than ``pow(base, exp) % "
"mod``). The two-argument form ``pow(base, exp)`` is equivalent to using the "
"power operator: ``base**exp``."
msgstr ""
"Zwraca *base* do potęgi *exp*; jeśli *mod* jest obecny, zwraca *base* do "
"potęgi *exp*, modulo *mod* (obliczane bardziej efektywnie niż ``pow(base, "
"exp) % mod``). Forma dwóchargumentow ``pow(base, exp)`` jest równoważna "
"użyciu operatora potęgi: ``base**exp``."

msgid ""
"The arguments must have numeric types.  With mixed operand types, the "
"coercion rules for binary arithmetic operators apply.  For :class:`int` "
"operands, the result has the same type as the operands (after coercion) "
"unless the second argument is negative; in that case, all arguments are "
"converted to float and a float result is delivered.  For example, ``pow(10, "
"2)`` returns ``100``, but ``pow(10, -2)`` returns ``0.01``.  For a negative "
"base of type :class:`int` or :class:`float` and a non-integral exponent, a "
"complex result is delivered.  For example, ``pow(-9, 0.5)`` returns a value "
"close to ``3j``. Whereas, for a negative base of type :class:`int` or :class:"
"`float` with an integral exponent, a float result is delivered. For example, "
"``pow(-9, 2.0)`` returns ``81.0``."
msgstr ""
"Operatory argumentów muszą mieć typy numeryczne.  W przypadku mieszanych "
"typów operandów obowiązują zasady koercji dla binarnych operatorów "
"arytmetycznych.  Dla operandów :class:`int` wynik ma ten sam typ co operandy "
"(po koercji), chyba że drugi argument jest ujemny; w takim przypadku "
"wszystkie argument są konwertowane na float i dostarczany jest wynik float.  "
"Na przykład, ``pow(10, 2)`` zwracać ``100`` , ale ``pow(10, -2)`` zwracać "
"``0.01`` .  W przypadku ujemnej podstawy typu :class:`int` lub :class:"
"`float` i wykładnika niecałkowitego dostarczany jest wynik złożony.  Na "
"przykład, ``pow(-9, 0.5)`` zwraca wartość zbliżona do ``3j``. Natomiast dla "
"ujemnej podstawy typu :class:`int` lub :class:`float` z wykładnikiem "
"całkowitym, dostarczany jest wynik zmiennoprzecinkowy. Na przykład ``pow(-9, "
"2.0)`` zwraca ``81.0`` ."

msgid ""
"For :class:`int` operands *base* and *exp*, if *mod* is present, *mod* must "
"also be of integer type and *mod* must be nonzero. If *mod* is present and "
"*exp* is negative, *base* must be relatively prime to *mod*. In that case, "
"``pow(inv_base, -exp, mod)`` is returned, where *inv_base* is an inverse to "
"*base* modulo *mod*."
msgstr ""
"Dla operandów :class:`int` *base* i *exp*, jeśli *mod* jest obecny, *mod* "
"musi być również typu liczba całkowita i *mod* musi być niezerowy. Jeśli "
"*mod* jest obecny, a *exp* jest ujemny, *base* musi być względnie pierwsze "
"do *mod*. W takim przypadku zwracana jest wartość ``pow(inv_base, -exp, "
"mod)``, gdzie *inv_base* jest odwrotnością *base* modulo *mod*."

msgid "Here's an example of computing an inverse for ``38`` modulo ``97``::"
msgstr "Oto przykład obliczania odwrotności dla ``38`` modulo ``97``::"

msgid ""
">>> pow(38, -1, mod=97)\n"
"23\n"
">>> 23 * 38 % 97 == 1\n"
"True"
msgstr ""
">>> pow(38, -1, mod=97)\n"
"23\n"
">>> 23 * 38 % 97 == 1\n"
"True"

msgid ""
"For :class:`int` operands, the three-argument form of ``pow`` now allows the "
"second argument to be negative, permitting computation of modular inverses."
msgstr ""
"W przypadku operandów :class:`int`, trzy-argumenty formy ``pow`` pozwala "
"teraz, aby drugi argument był ujemny, umożliwiając obliczanie odwrotności "
"modularnych."

msgid ""
"Allow keyword arguments.  Formerly, only positional arguments were supported."
msgstr ""
"Zezwalaj na argument nazwany.  Wcześniej obsługiwane były tylko pozycyjne "
"argument."

msgid ""
"Print *objects* to the text stream *file*, separated by *sep* and followed "
"by *end*.  *sep*, *end*, *file*, and *flush*, if present, must be given as "
"keyword arguments."
msgstr ""
"Wypisuje *obiekty* do strumienia tekstowego *file*, oddzielone *sep* i "
"zakończone *end*.  *sep*, *end*, *file* i *flush*, jeśli występują, muszą "
"być podane jako argument nazwany."

msgid ""
"All non-keyword arguments are converted to strings like :func:`str` does and "
"written to the stream, separated by *sep* and followed by *end*.  Both *sep* "
"and *end* must be strings; they can also be ``None``, which means to use the "
"default values.  If no *objects* are given, :func:`print` will just write "
"*end*."
msgstr ""
"Wszystkie non-argumenty nazwane są konwertowane na napis tak jak :func:`str` "
"i zapisywane do strumienia, oddzielone *sep* i *end*.  Zarówno *sep* jak i "
"*end* muszą być napisem; mogą być również ``None``, co oznacza użycie "
"wartości domyślne.  Jeśli nie podano *objects*, :func:`print` po prostu "
"zapisze *end*."

msgid ""
"The *file* argument must be an object with a ``write(string)`` method; if it "
"is not present or ``None``, :data:`sys.stdout` will be used.  Since printed "
"arguments are converted to text strings, :func:`print` cannot be used with "
"binary mode file objects.  For these, use ``file.write(...)`` instead."
msgstr ""
"*Plik* argument musi być obiektem z metodą ``write(string)``; jeśli nie jest "
"obecny lub ``None``, zostanie użyty :data:`sys.stdout`.  Ponieważ drukowane "
"argument są konwertowane na tekst napis, :func:`print` nie może być używany "
"z obiektami plików w trybie binarnym.  Zamiast tego należy uży ``file."
"write(...)``."

msgid ""
"Output buffering is usually determined by *file*. However, if *flush* is "
"true, the stream is forcibly flushed."
msgstr ""
"Buforowanie wyjścia jest zwykle określane przez *file*. Jednakże, jeśli "
"*flush* jest prawdą, strumień jest przymusowo opróżniany."

msgid "Added the *flush* keyword argument."
msgstr "Dodano *flush* argument nazwany."

msgid "Return a property attribute."
msgstr "Zwraca atrybut właściwośći."

msgid ""
"*fget* is a function for getting an attribute value.  *fset* is a function "
"for setting an attribute value. *fdel* is a function for deleting an "
"attribute value.  And *doc* creates a docstring for the attribute."
msgstr ""
"*fget* to funkcja do pobierania wartości atrybut.  *fset* to funkcja do "
"ustawiania wartości atrybut. *fdel* to funkcja do usuwania wartości "
"atrybut.  Z kolei *doc* tworzy docstring dla atrybut."

msgid "A typical use is to define a managed attribute ``x``::"
msgstr ""
"Typowym zastosowaniem jest zdefiniowanie zarządzanego atrybutu ``x`` ::"

msgid ""
"class C:\n"
"    def __init__(self):\n"
"        self._x = None\n"
"\n"
"    def getx(self):\n"
"        return self._x\n"
"\n"
"    def setx(self, value):\n"
"        self._x = value\n"
"\n"
"    def delx(self):\n"
"        del self._x\n"
"\n"
"    x = property(getx, setx, delx, \"I'm the 'x' property.\")"
msgstr ""
"class C:\n"
"    def __init__(self):\n"
"        self._x = None\n"
"\n"
"    def getx(self):\n"
"        return self._x\n"
"\n"
"    def setx(self, value):\n"
"        self._x = value\n"
"\n"
"    def delx(self):\n"
"        del self._x\n"
"\n"
"    x = property(getx, setx, delx, \"I'm the 'x' property.\")"

msgid ""
"If *c* is an instance of *C*, ``c.x`` will invoke the getter, ``c.x = "
"value`` will invoke the setter, and ``del c.x`` the deleter."
msgstr ""
"Jeśli *c* jest instancją *C*, ``c.x`` wywoła getter, ``c.x = value`` wywoła "
"setter, a ``del c.x`` deleter."

msgid ""
"If given, *doc* will be the docstring of the property attribute. Otherwise, "
"the property will copy *fget*'s docstring (if it exists).  This makes it "
"possible to create read-only properties easily using :func:`property` as a :"
"term:`decorator`::"
msgstr ""
"Jeśli zostanie podana, *doc* będzie docstringiem właściwości atrybut. W "
"przeciwnym razie właściwość skopiuje docstring *fget* (jeśli istnieje).  "
"Umożliwia to łatwe tworzenie właściwości tylko do odczytu przy użyciu :func:"
"`property` jako :term:`dekorator`::"

msgid ""
"class Parrot:\n"
"    def __init__(self):\n"
"        self._voltage = 100000\n"
"\n"
"    @property\n"
"    def voltage(self):\n"
"        \"\"\"Get the current voltage.\"\"\"\n"
"        return self._voltage"
msgstr ""
"class Parrot:\n"
"    def __init__(self):\n"
"        self._voltage = 100000\n"
"\n"
"    @property\n"
"    def voltage(self):\n"
"        \"\"\"Uzyska aktualne napięcie.\"\"\n"
"        return self._voltage"

msgid ""
"The ``@property`` decorator turns the :meth:`!voltage` method into a "
"\"getter\" for a read-only attribute with the same name, and it sets the "
"docstring for *voltage* to \"Get the current voltage.\""
msgstr ""
"``@property`` dekorator zamienia metodę :meth:`!voltage` w \"getter\" dla "
"tylko do odczytu atrybut o tej samej nazwie i ustawia docstring dla "
"*voltage* na \"Get the current voltage\"."

msgid ""
"A property object has ``getter``, ``setter``, and ``deleter`` methods usable "
"as decorators that create a copy of the property with the corresponding "
"accessor function set to the decorated function.  This is best explained "
"with an example:"
msgstr ""
"Obiekt właściwości ma metody ``getter``, ``setter`` i ``deleter`` używane "
"jako dekorator, które tworzą kopię właściwości z odpowiednim akcesorem "
"funkcji ustawionym na dekorowany funkcja.  Najlepiej wyjaśnić to na "
"przykładzie:"

msgid ""
"class C:\n"
"    def __init__(self):\n"
"        self._x = None\n"
"\n"
"    @property\n"
"    def x(self):\n"
"        \"\"\"I'm the 'x' property.\"\"\"\n"
"        return self._x\n"
"\n"
"    @x.setter\n"
"    def x(self, value):\n"
"        self._x = value\n"
"\n"
"    @x.deleter\n"
"    def x(self):\n"
"        del self._x"
msgstr ""
"class C:\n"
"    def __init__(self):\n"
"        self._x = None\n"
"\n"
"    @property\n"
"    def x(self):\n"
"        \"\"\"I'm the 'x' property.\"\"\"\n"
"        return self._x\n"
"\n"
"    @x.setter\n"
"    def x(self, value):\n"
"        self._x = value\n"
"\n"
"    @x.deleter\n"
"    def x(self):\n"
"        del self._x"

msgid ""
"This code is exactly equivalent to the first example.  Be sure to give the "
"additional functions the same name as the original property (``x`` in this "
"case.)"
msgstr ""
"Ten kod jest dokładnie taki sam jak w pierwszym przykładzie. Pamiętaj, aby "
"nadać dodatkowym funkcjom takie same nazwy jak oryginalnej właściwości (w "
"tym przypadku ``x``)."

msgid ""
"The returned property object also has the attributes ``fget``, ``fset``, and "
"``fdel`` corresponding to the constructor arguments."
msgstr ""
"Zwrócony obiekt właściwości ma również atrybutow ``fget`` , ``fset`` i "
"``fdel`` odpowiadające konstruktor argumentu."

msgid "The docstrings of property objects are now writeable."
msgstr "Dokumentacja obiektów właściwości sa teraz zapisywalne."

msgid ""
"Attribute holding the name of the property. The name of the property can be "
"changed at runtime."
msgstr ""
"Atrybut przechowująca nazwę właściwości. Nazwa właściwości może zostać "
"zmieniona w czasie wykonywania."

msgid ""
"Rather than being a function, :class:`range` is actually an immutable "
"sequence type, as documented in :ref:`typesseq-range` and :ref:`typesseq`."
msgstr ""
"Zamiast być funkcja, :class:`range` jest w rzeczywistości niezmiennym typem "
"sekwencji, jak udokumentowano w :ref:`typesseq-range` i :ref:`typesseq`."

msgid ""
"Return a string containing a printable representation of an object.  For "
"many types, this function makes an attempt to return a string that would "
"yield an object with the same value when passed to :func:`eval`; otherwise, "
"the representation is a string enclosed in angle brackets that contains the "
"name of the type of the object together with additional information often "
"including the name and address of the object.  A class can control what this "
"function returns for its instances by defining a :meth:`~object.__repr__` "
"method. If :func:`sys.displayhook` is not accessible, this function will "
"raise :exc:`RuntimeError`."
msgstr ""
"Zwraca napis zawierający nadającą się do druku reprezentację obiektu.  W "
"przypadku wielu typów, ta funkcja podejmuje próbę zwracanja napisu, która "
"dałaby obiekt o tej samej wartości po przekazaniu do :func:`eval`; w "
"przeciwnym razie reprezentacja jest napisem ujęta w nawiasy kątowe, które "
"zawierają nazwę typu obiektu wraz z dodatkowymi informacjami, często "
"zawierającymi nazwę i adres obiektu.  Klasa może kontrolować co funkcja "
"zwraca dla swoich instancji, definiując metodę :meth:`~object.__repr__`. "
"Jeśli :func:`sys.displayhook` nie jest dostępna, ta funkcja będzie rzucona :"
"exc:`RuntimeError` ."

msgid "This class has a custom representation that can be evaluated::"
msgstr "Ta klasa ma niestandardową reprezentację, którą można ocenić::"

msgid ""
"class Person:\n"
"   def __init__(self, name, age):\n"
"      self.name = name\n"
"      self.age = age\n"
"\n"
"   def __repr__(self):\n"
"      return f\"Person('{self.name}', {self.age})\""
msgstr ""
"class Osoba:\n"
"   def __init__(self, imie, wiek):\n"
"      self.imie = imie\n"
"      self.wiek = wiek\n"
"\n"
"   def __repr__(self):\n"
"      zwracać f \"Person('{self.imie}', {self.wiek})\"."

msgid ""
"Return a reverse :term:`iterator`.  *seq* must be an object which has a :"
"meth:`~object.__reversed__` method or supports the sequence protocol (the :"
"meth:`~object.__len__` method and the :meth:`~object.__getitem__` method "
"with integer arguments starting at ``0``)."
msgstr ""
"Zwraca a reverse :term:`iterator`.  *seq* musi być obiektem, który ma "
"metodę :meth:`~object.__reversed__` lub obsługuje protokół sekwencji "
"(metoda :meth:`~object.__len__` i metoda :meth:`~object.__getitem__` z "
"liczba całkowita argument począwszy od ``0``)."

msgid ""
"Return *number* rounded to *ndigits* precision after the decimal point.  If "
"*ndigits* is omitted or is ``None``, it returns the nearest integer to its "
"input."
msgstr ""
"Zwraca *liczba* zaokrąglona do *cyfr* po przecinku dziesiętnym.  Jeśli "
"*ndigits* zostanie pominięte lub będzie ``None``, to zwraca najbliższa "
"liczbe całkowita wartości wejściowej."

msgid ""
"For the built-in types supporting :func:`round`, values are rounded to the "
"closest multiple of 10 to the power minus *ndigits*; if two multiples are "
"equally close, rounding is done toward the even choice (so, for example, "
"both ``round(0.5)`` and ``round(-0.5)`` are ``0``, and ``round(1.5)`` is "
"``2``).  Any integer value is valid for *ndigits* (positive, zero, or "
"negative).  The return value is an integer if *ndigits* is omitted or "
"``None``. Otherwise, the return value has the same type as *number*."
msgstr ""
"Dla typów wbudowanych wspierających :func:`round`, wartości są zaokrąglane "
"do najbliższej wielokrotności 10 do potęgi minus *ndigits*; jeśli dwie "
"wielokrotności są równie bliskie, zaokrąglanie jest wykonywane w kierunku "
"parzystego wyboru (więc, na przykład, zarówno ``round(0.5)`` jak i "
"``round(-0.5)`` są ``0``, a ``round(1.5)`` jest ``2``).  Każda wartość "
"liczby całkowitej jest ważna dla *cyfr* (dodatnich, zerowych lub ujemnych).  "
"zwracana wartość jest liczba całkowita jeśli *ndigits* jest pominięte lub "
"``None``. W przeciwnym razie zwracana wartość ma ten sam typ co *number*."

msgid ""
"For a general Python object ``number``, ``round`` delegates to ``number."
"__round__``."
msgstr ""
"Dla ogólnego obiektu Python ``number`` , ``round`` deleguje do ``number."
"__round__``."

msgid ""
"The behavior of :func:`round` for floats can be surprising: for example, "
"``round(2.675, 2)`` gives ``2.67`` instead of the expected ``2.68``. This is "
"not a bug: it's a result of the fact that most decimal fractions can't be "
"represented exactly as a float.  See :ref:`tut-fp-issues` for more "
"information."
msgstr ""
"Zachowanie :func:`round` dla zmiennoprzecinkowych może być zaskakujący: na "
"przykład, ``round(2.675, 2)`` daje ``2.67`` zamiast oczekiwanego ``2.68``. "
"Nie jest to błąd: wynika to z faktu, że większość ułamków dziesiętnych nie "
"może być reprezentowana dokładnie jako liczba zmiennoprzecinkowa.  Więcej "
"informacji można znaleźć na stronie :ref:`tut-fp-issues`."

msgid ""
"Return a new :class:`set` object, optionally with elements taken from "
"*iterable*.  ``set`` is a built-in class.  See :class:`set` and :ref:`types-"
"set` for documentation about this class."
msgstr ""
"Zwraca nowy obiekt :class:`set`, opcjonalnie z elementami pobranymi z "
"*iterable*. ``set`` jest klasą wbudowana.  Dokumentacja dotycząca tej klasy "
"znajduje się na stronach :class:`set` i :ref:`types-set`."

msgid ""
"For other containers see the built-in :class:`frozenset`, :class:`list`, :"
"class:`tuple`, and :class:`dict` classes, as well as the :mod:`collections` "
"module."
msgstr ""
"Dla innych kontenerów zobacz klasy wbudowane :class:`frozenset` , :class:"
"`list`, :class:`tuple` i :class:`dict`, jak również :mod:`collections` "
"moduł ."

msgid ""
"This is the counterpart of :func:`getattr`.  The arguments are an object, a "
"string, and an arbitrary value.  The string may name an existing attribute "
"or a new attribute.  The function assigns the value to the attribute, "
"provided the object allows it.  For example, ``setattr(x, 'foobar', 123)`` "
"is equivalent to ``x.foobar = 123``."
msgstr ""
"Jest to odpowiednik :func:`getattr`. Argumenty to obiekt, napis i dowolna "
"wartość.  Napis może nazywać istniejący atrybut lub nowy atrybut.  Funkcja "
"przypisuje wartość do atrybut, pod warunkiem, że obiekt na to pozwala.  Na "
"przykład, ``setattr(x, 'foobar', 123)`` jest równoważne ``x.foobar = 123``."

msgid ""
"*name* need not be a Python identifier as defined in :ref:`identifiers` "
"unless the object chooses to enforce that, for example in a custom :meth:"
"`~object.__getattribute__` or via :attr:`~object.__slots__`. An attribute "
"whose name is not an identifier will not be accessible using the dot "
"notation, but is accessible through :func:`getattr` etc.."
msgstr ""
"*name* nie musi być identyfikatorem Pythona zdefiniowanym w :ref:"
"`identifiers`, chyba że obiekt zdecyduje się to wymusić, na przykład w "
"niestandardowym :meth:`~object.__getattribute__` lub poprzez :attr:`~object."
"__slots__`. Obiekt atrybut, którego nazwa nie jest identyfikatorem, nie "
"będzie dostępny przy użyciu notacji kropkowej, ale będzie dostępny za "
"pośrednictwem :func:`getattr` itd."

msgid ""
"Since :ref:`private name mangling <private-name-mangling>` happens at "
"compilation time, one must manually mangle a private attribute's (attributes "
"with two leading underscores) name in order to set it with :func:`setattr`."
msgstr ""
"Ponieważ :ref:`mangling nazwy prywatnej <private-name-mangling>` ma miejsce "
"w czasie kompilacji, należy ręcznie zmienić nazwę prywatnego atrybutu "
"(atrybut z dwoma wiodącymi podkreśleniami), aby ustawić ją z :func:`setattr`."

msgid ""
"Return a :term:`slice` object representing the set of indices specified by "
"``range(start, stop, step)``.  The *start* and *step* arguments default to "
"``None``."
msgstr ""
"Zwraca obiekt :term:`slice` reprezentujący zbiór indeksów określonych przez "
"``range(start, stop, step)``.  *start* i *step* argumenty domyślne do "
"``None``."

msgid ""
"Slice objects have read-only data attributes :attr:`!start`, :attr:`!stop`, "
"and :attr:`!step` which merely return the argument values (or their "
"default).  They have no other explicit functionality; however, they are used "
"by NumPy and other third-party packages."
msgstr ""
"Obiekty slice mają dane tylko do odczytu atrybut :attr:`!start` , :attr:`!"
"stop` i :attr:`!step`, które jedynie zwracać wartości argument (lub ich "
"domyślny).  Nie mają one żadnej innej wyraźnej funkcjonalności; są jednak "
"używane przez NumPy i inne pakiety innych firm."

msgid ""
"Slice objects are also generated when extended indexing syntax is used.  For "
"example: ``a[start:stop:step]`` or ``a[start:stop, i]``.  See :func:"
"`itertools.islice` for an alternate version that returns an :term:`iterator`."
msgstr ""
"Obiekty Slice są również generowane, gdy używana jest rozszerzona składnia "
"indeksowania.  Na przykład: ``a[start:stop:step]`` lub ``a[start:stop, i]``. "
"Zobacz :func:`itertools.islice` dla alternatywy, która zwraca :term:"
"`iterator`."

msgid ""
"Slice objects are now :term:`hashable` (provided :attr:`~slice.start`, :attr:"
"`~slice.stop`, and :attr:`~slice.step` are hashable)."
msgstr ""
"Obiekty Slice są teraz :term:`hashable` (pod warunkiem, że :attr:`~slice."
"start`, :attr:`~slice.stop` i :attr:`~slice.step` są hashable)."

msgid "Return a new sorted list from the items in *iterable*."
msgstr "Zwraca nową posortowaną listę z elementów w *iterable*."

msgid ""
"Has two optional arguments which must be specified as keyword arguments."
msgstr ""
"Posiada dwa opcjonalne argumenty, które muszą być określone jako argument "
"nazwany."

msgid ""
"*key* specifies a function of one argument that is used to extract a "
"comparison key from each element in *iterable* (for example, ``key=str."
"lower``).  The default value is ``None`` (compare the elements directly)."
msgstr ""
"*key* określa funkcje jednego argumentu, który jest używany do wyodrębnienia "
"klucza porównania z każdego elementu w *iterable* (na przykład ``key=str."
"lower``).  Wartość domyślna to ``None`` (bezpośrednie porównanie elementów)."

msgid ""
"*reverse* is a boolean value.  If set to ``True``, then the list elements "
"are sorted as if each comparison were reversed."
msgstr ""
"*reverse* jest wartością logiczną.  Jeśli jest ustawiona na ``True``, "
"elementy listy są sortowane tak, jakby każde porównanie było odwrócone."

msgid ""
"Use :func:`functools.cmp_to_key` to convert an old-style *cmp* function to a "
"*key* function."
msgstr ""
"Użyj :func:`functools.cmp_to_key` do konwersji starego stylu *cmp* funkcja "
"na *key* funkcja."

msgid ""
"The built-in :func:`sorted` function is guaranteed to be stable. A sort is "
"stable if it guarantees not to change the relative order of elements that "
"compare equal --- this is helpful for sorting in multiple passes (for "
"example, sort by department, then by salary grade)."
msgstr ""
"Wbudowana :func:`sorted` funkcja ma gwarancję stabilności. Sortowanie jest "
"stabilne, jeśli gwarantuje, że nie zmieni względnej kolejności elementów, "
"które porównują równe --- jest to pomocne przy sortowaniu w wielu "
"przejściach (na przykład sortowanie według działu, a następnie według "
"kategorii wynagrodzenia)."

msgid ""
"The sort algorithm uses only ``<`` comparisons between items.  While "
"defining an :meth:`~object.__lt__` method will suffice for sorting, :PEP:`8` "
"recommends that all six :ref:`rich comparisons <comparisons>` be "
"implemented.  This will help avoid bugs when using the same data with other "
"ordering tools such as :func:`max` that rely on a different underlying "
"method.  Implementing all six comparisons also helps avoid confusion for "
"mixed type comparisons which can call reflected the :meth:`~object.__gt__` "
"method."
msgstr ""
"Algorytm sortowania używa tylko porównań ``<`` między elementami. Podczas "
"gdy zdefiniowanie metoda :meth:`~object.__lt__` wystarczy do sortowania, :"
"PEP:`8` zaleca zaimplementowanie wszystkich sześciu :ref:`bogatych porównań "
"<comparisons>`. Pomoże to uniknąć błędów podczas korzystania z tych samych "
"danych z innymi narzędziami porządkującymi, takimi jak :func:`max`, które "
"opierają się na innej metodzie bazowej. Zaimplementowanie wszystkich sześciu "
"porównań pomaga również uniknąć nieporozumień w przypadku porównań typów "
"mieszanych, które mogą wywoływać metodę :meth:`~object.__gt__`."

msgid ""
"For sorting examples and a brief sorting tutorial, see :ref:`sortinghowto`."
msgstr ""
"Przykłady sortowania i krótki samouczek sortowania można znaleźć na stronie :"
"ref:`sortinghowto`."

msgid "Transform a method into a static method."
msgstr "Przekształcenie metody w metodę statyczną."

msgid ""
"A static method does not receive an implicit first argument. To declare a "
"static method, use this idiom::"
msgstr ""
"Metoda statyczna nie otrzymuje niejawnego pierwszego argumentu. Aby "
"zadeklarować metodę statyczną, użyj tego idiomu::"

msgid ""
"class C:\n"
"    @staticmethod\n"
"    def f(arg1, arg2, argN): ..."
msgstr ""
"class C:\n"
"    @staticmethod\n"
"    def f(arg1, arg2, argN): ..."

msgid ""
"The ``@staticmethod`` form is a function :term:`decorator` -- see :ref:"
"`function` for details."
msgstr ""
"Forma ``@staticmethod`` to :term:`dekorator` funkcji -- zobacz :ref:"
"`function` po szczegóły."

msgid ""
"A static method can be called either on the class (such as ``C.f()``) or on "
"an instance (such as ``C().f()``). Moreover, the static method :term:"
"`descriptor` is also callable, so it can be used in the class definition "
"(such as ``f()``)."
msgstr ""
"Metoda statyczna może być wywołana na klasie (np. ``C.f()``) lub na "
"instancji (np. ``C().f()``). Co więcej, metoda statyczna :term:`descriptor` "
"jest również wywoływalna, więc może być użyta w definicja klasy (np. "
"``f()``)."

msgid ""
"Static methods in Python are similar to those found in Java or C++. Also, "
"see :func:`classmethod` for a variant that is useful for creating alternate "
"class constructors."
msgstr ""
"Metody statyczne w Python są podobne do tych, które można znaleźć w Java lub "
"C++. Zobacz także :func:`classmethod`, aby zapoznać się z wariantem, który "
"jest przydatny do tworzenia alternatywnych konstruktorów klas."

msgid ""
"Like all decorators, it is also possible to call ``staticmethod`` as a "
"regular function and do something with its result.  This is needed in some "
"cases where you need a reference to a function from a class body and you "
"want to avoid the automatic transformation to instance method.  For these "
"cases, use this idiom::"
msgstr ""
"Podobnie jak wszystkie dekoratory, możliwe jest również wywołanie "
"``staticmethod`` jako zwykłoł funkcje i zrobienie czegoś z jego wynikiem.  "
"Jest to potrzebne w niektórych przypadkach, gdy potrzebujesz odniesienia do "
"funkcji z ciałej klasy i chcesz uniknąć automatycznej transformacji do "
"metody instancji.  W takich przypadkach należy użyć tego idiomu::"

msgid ""
"def regular_function():\n"
"    ...\n"
"\n"
"class C:\n"
"    method = staticmethod(regular_function)"
msgstr ""
"def standardowa_funkcja():\n"
"    ...\n"
"\n"
"class C:\n"
"    methoda = staticmethod(standardowa_funkcja)"

msgid "For more information on static methods, see :ref:`types`."
msgstr ""
"Więcej informacji na temat metod statycznych można znaleźć na stronie :ref:"
"`types`."

msgid ""
"Static methods now inherit the method attributes (:attr:`~function."
"__module__`, :attr:`~function.__name__`, :attr:`~function.__qualname__`, :"
"attr:`~function.__doc__` and :attr:`~function.__annotations__`), have a new "
"``__wrapped__`` attribute, and are now callable as regular functions."
msgstr ""
"Metody statyczne dziedziczą teraz metodę atrybut (:attr:`~function."
"__module__`, :attr:`~function.__name__`, :attr:`~function.__qualname__`, :"
"attr:`~function.__doc__` i :attr:`~function.__annotations__`), mają nową "
"``__wrapped__`` atrybut i są teraz wywoływane jako zwykła funkcja."

msgid ""
"Return a :class:`str` version of *object*.  See :func:`str` for details."
msgstr ""
"Zwraca :class:`str` wersja of *object*.  Szczegółowe informacje można "
"znaleźć na stronie :func:`str`."

msgid ""
"``str`` is the built-in string :term:`class`.  For general information about "
"strings, see :ref:`textseq`."
msgstr ""
"``str`` jest wbudowanem napisem :term:`class`.  Aby uzyskać ogólne "
"informacje na temat napisow, zobacz :ref:`textseq`."

msgid ""
"Sums *start* and the items of an *iterable* from left to right and returns "
"the total.  The *iterable*'s items are normally numbers, and the start value "
"is not allowed to be a string."
msgstr ""
"Sumuje *start* i elementy *iterable* od lewej do prawej i zwraca sumę.  "
"Elementy *iterable* są zwykle liczbami, a wartością początkową nie może być "
"napisem."

msgid ""
"For some use cases, there are good alternatives to :func:`sum`. The "
"preferred, fast way to concatenate a sequence of strings is by calling ``''."
"join(sequence)``.  To add floating-point values with extended precision, "
"see :func:`math.fsum`\\.  To concatenate a series of iterables, consider "
"using :func:`itertools.chain`."
msgstr ""
"W niektórych przypadkach istnieją dobra alternatywa dla :func:`sum`. "
"Preferowanym, szybkim sposobem na łączyć sekwencji napisów jest wywołanie "
"``''.join(sequence)``.  Aby dodać wartości zmiennoprzecinkowe z rozszerzoną "
"precyzją, zobacz :func:`math.fsum`\\.  Aby łączyć serię iterable, należy "
"rozważyć użycie :func:`itertools.chain`."

msgid "The *start* parameter can be specified as a keyword argument."
msgstr "Parametr  *start* można określić jako argument nazwany."

msgid ""
"Summation of floats switched to an algorithm that gives higher accuracy and "
"better commutativity on most builds."
msgstr ""
"Sumowanie zmiennoprzecinkowe zostało przełączone na algorytm, który zapewnia "
"większą dokładność i lepszą przemienność w większości kompilacji."

msgid ""
"Return a proxy object that delegates method calls to a parent or sibling "
"class of *type*.  This is useful for accessing inherited methods that have "
"been overridden in a class."
msgstr ""
"Zwraca obiekt proxy, który deleguje wywołania metod do klasy nadrzędnej lub "
"rodzeństwa *type*.  Jest to przydatne do uzyskiwania dostępu do "
"odziedziczonych metod, które zostały przesłonięte w klasie."

msgid ""
"The *object_or_type* determines the :term:`method resolution order` to be "
"searched.  The search starts from the class right after the *type*."
msgstr ""
"*object_or_type* określa :term:`method resolution order` do przeszukania.  "
"Wyszukiwanie rozpoczyna się od klasy zaraz po *type*."

msgid ""
"For example, if :attr:`~type.__mro__` of *object_or_type* is ``D -> B -> C -"
"> A -> object`` and the value of *type* is ``B``, then :func:`super` "
"searches ``C -> A -> object``."
msgstr ""
"Na przykład, jeśli :attr:`~type.__mro__` z *object_or_type* jest ``D -> B -> "
"C -> A -> object`` i wartość *type* jest ``B``, to :func:`super` wyszukuje "
"``C -> A -> object``."

msgid ""
"The :attr:`~type.__mro__` attribute of the class corresponding to "
"*object_or_type* lists the method resolution search order used by both :func:"
"`getattr` and :func:`super`.  The attribute is dynamic and can change "
"whenever the inheritance hierarchy is updated."
msgstr ""
":attr:`~type.__mro__` atrybut klasy odpowiadającej *object_or_type* wymienia "
"kolejność wyszukiwania metod używaną zarówno przez :func:`getattr` jak i :"
"func:`super`.  Adres atrybut jest dynamiczny i może ulec zmianie przy każdej "
"aktualizacji hierarchii dziedziczenia."

msgid ""
"If the second argument is omitted, the super object returned is unbound.  If "
"the second argument is an object, ``isinstance(obj, type)`` must be true.  "
"If the second argument is a type, ``issubclass(type2, type)`` must be true "
"(this is useful for classmethods)."
msgstr ""
"Jeśli drugi argument zostanie pominięty, zwrócony superobiekt jest "
"niezwiązany.  Jeśli drugi argument jest obiektem, ``isinstance(obj, type)`` "
"musi być prawda.  Jeśli drugi argument jest typem, ``issubclass(type2, "
"type)`` musi być prawda (jest to przydatne dla metod klasowych)."

msgid ""
"When called directly within an ordinary method of a class, both arguments "
"may be omitted (\"zero-argument :func:`!super`\"). In this case, *type* will "
"be the enclosing class, and *obj* will be the first argument of the "
"immediately enclosing function (typically ``self``). (This means that zero-"
"argument :func:`!super` will not work as expected within nested functions, "
"including generator expressions, which implicitly create nested functions.)"
msgstr ""
"W przypadku wywołania bezpośrednio w zwykłej metodzie klasy, obie argument "
"mogą zostać pominięte (\"zero-argument :func:`!super` \"). W takim przypadku "
"*type* będzie klasą otaczającą, a *obj* będzie pierwszym argumentem "
"bezpośrednio otaczającego funkcje (zazwyczaj ``self``). (Oznacza to, że zero-"
"argument :func:`!super` nie będzie działać zgodnie z oczekiwaniami wewnątrz "
"zagnieżdżonych funkci, w tym wyrażeń generator, które domyślnie tworzą "
"zagnieżdżone funkcje)."

msgid ""
"There are two typical use cases for *super*.  In a class hierarchy with "
"single inheritance, *super* can be used to refer to parent classes without "
"naming them explicitly, thus making the code more maintainable.  This use "
"closely parallels the use of *super* in other programming languages."
msgstr ""
"Istnieją dwa typowe przypadki użycia *super*.  W hierarchii klas z "
"pojedynczym dziedziczeniem, *super* może być używany do odwoływania się do "
"klas nadrzędnych bez ich jawnego nazywania, dzięki czemu kod jest łatwiejszy "
"w utrzymaniu.  To zastosowanie jest bardzo podobne do użycia *super* w "
"innych językach programowania."

msgid ""
"The second use case is to support cooperative multiple inheritance in a "
"dynamic execution environment.  This use case is unique to Python and is not "
"found in statically compiled languages or languages that only support single "
"inheritance.  This makes it possible to implement \"diamond diagrams\" where "
"multiple base classes implement the same method.  Good design dictates that "
"such implementations have the same calling signature in every case (because "
"the order of calls is determined at runtime, because that order adapts to "
"changes in the class hierarchy, and because that order can include sibling "
"classes that are unknown prior to runtime)."
msgstr ""
"Drugim przypadkiem użycia jest obsługa kooperatywnego dziedziczenia "
"wielokrotnego w dynamicznym środowisku wykonawczym.  Ten przypadek użycia "
"jest unikalny dla Python i nie występuje w statycznie kompilowanych językach "
"lub językach, które obsługują tylko pojedyncze dziedziczenie.  Umożliwia to "
"implementację \"diagramów diamentowych\", w których wiele klas bazowych "
"implementuje tę samą metodę.  Dobry projekt nakazuje, aby takie "
"implementacje miały tę samą sygnaturę wywołania w każdym przypadku (ponieważ "
"kolejność wywołań jest określana w czasie wykonywania, ponieważ kolejność ta "
"dostosowuje się do zmian w hierarchii klas i ponieważ kolejność ta może "
"obejmować klasy rodzeństwa, które są nieznane przed uruchomieniem)."

msgid "For both use cases, a typical superclass call looks like this::"
msgstr "W obu przypadkach typowe wywołanie superklasy wygląda następująco::"

msgid ""
"class C(B):\n"
"    def method(self, arg):\n"
"        super().method(arg)    # This does the same thing as:\n"
"                               # super(C, self).method(arg)"
msgstr ""
"class C(B):\n"
"    def methoda(self, arg):\n"
"        super().methoda(arg) # To robi to samo co:\n"
"                               # super(C, self).methoda(arg)"

msgid ""
"In addition to method lookups, :func:`super` also works for attribute "
"lookups.  One possible use case for this is calling :term:`descriptors "
"<descriptor>` in a parent or sibling class."
msgstr ""
"Oprócz wyszukiwania metod, :func:`super` działa również dla wyszukiwania "
"atrybut.  Jednym z możliwych przypadków użycia jest wywołanie :term:"
"`descriptors <descriptor>` w klasie nadrzędnej lub podrzędnej."

msgid ""
"Note that :func:`super` is implemented as part of the binding process for "
"explicit dotted attribute lookups such as ``super().__getitem__(name)``. It "
"does so by implementing its own :meth:`~object.__getattribute__` method for "
"searching classes in a predictable order that supports cooperative multiple "
"inheritance. Accordingly, :func:`super` is undefined for implicit lookups "
"using statements or operators such as ``super()[name]``."
msgstr ""
"Należy zauważyć, że :func:`super` jest zaimplementowany jako część wiązania "
"przetwarzanie/proces dla jawnego wyszukiwania kropkowego atrybut, takiego "
"jak ``super().__getitem__(name)``. Czyni to poprzez implementację własnej "
"metody :meth:`~object.__getattribute__` do wyszukiwania klas w "
"przewidywalnej kolejności, która obsługuje wielokrotne dziedziczenie oparte "
"na współpracy. Odpowiednio, :func:`super` jest niezdefiniowany dla "
"niejawnych wyszukiwań przy użyciu instrukcja lub operatorów takich jak "
"``super()[name]``."

msgid ""
"Also note that, aside from the zero argument form, :func:`super` is not "
"limited to use inside methods.  The two argument form specifies the "
"arguments exactly and makes the appropriate references.  The zero argument "
"form only works inside a class definition, as the compiler fills in the "
"necessary details to correctly retrieve the class being defined, as well as "
"accessing the current instance for ordinary methods."
msgstr ""
"Należy również pamiętać, że poza formą zero argument, :func:`super` nie jest "
"ograniczona do użycia wewnątrz metod.  Dwie formy argumentów dokładnie "
"określają argumenty i tworzą odpowiednie odniesienia.  Forma zero argumentów "
"działa tylko wewnątrz definicja klasy, ponieważ kompilator wypełnia "
"niezbędne szczegóły, aby poprawnie pobrać definiowaną klasę, a także uzyskać "
"dostęp do bieżącej instancji dla zwykłych metod."

msgid ""
"For practical suggestions on how to design cooperative classes using :func:"
"`super`, see `guide to using super() <https://rhettinger.wordpress."
"com/2011/05/26/super-considered-super/>`_."
msgstr ""
"Praktyczne sugestie dotyczące projektowania klas współpracujących przy "
"użyciu :func:`super` można znaleźć w `poradniku korzystania z super() "
"<https://rhettinger.wordpress.com/2011/05/26/super-considered-super/>`_."

msgid ""
"Rather than being a function, :class:`tuple` is actually an immutable "
"sequence type, as documented in :ref:`typesseq-tuple` and :ref:`typesseq`."
msgstr ""
"Zamiast być funkcja, :class:`tuple` jest w rzeczywistości niezmiennym typem "
"sekwencji, jak udokumentowano w :ref:`typesseq-tuple` i :ref:`typesseq`."

msgid ""
"With one argument, return the type of an *object*.  The return value is a "
"type object and generally the same object as returned by :attr:`object."
"__class__`."
msgstr ""
"Z jednym argumentem, zwraca typ *obiektu*.  Typ zwracanej wartość jest "
"obiektem typu i generalnie jest to ten sam obiekt, który został zwrócony "
"przez :attr:`object.__class__`."

msgid ""
"The :func:`isinstance` built-in function is recommended for testing the type "
"of an object, because it takes subclasses into account."
msgstr ""
"Funckja wbudowana  :func:`isinstance` jest zalecana do testowania typu "
"obiektu, ponieważ uwzględnia podklasa."

msgid ""
"With three arguments, return a new type object.  This is essentially a "
"dynamic form of the :keyword:`class` statement. The *name* string is the "
"class name and becomes the :attr:`~type.__name__` attribute. The *bases* "
"tuple contains the base classes and becomes the :attr:`~type.__bases__` "
"attribute; if empty, :class:`object`, the ultimate base of all classes, is "
"added.  The *dict* dictionary contains attribute and method definitions for "
"the class body; it may be copied or wrapped before becoming the :attr:`~type."
"__dict__` attribute. The following two statements create identical :class:`!"
"type` objects:"
msgstr ""
"Z trzema argumentamy, zwracać nowy typ obiektu.  Jest to zasadniczo "
"dynamiczna forma :keyword:`class` instrukcja . *name* napis jest nazwą klasy "
"i staje się :attr:`~type.__name__` atrybut . *bases* krotka zawiera klasy "
"bazowe i staje się :attr:`~type.__bases__` atrybut ; jeśli jest pusta, "
"dodawana jest :class:`object`, ostateczna baza wszystkich klas.  The *dict* "
"słownik zawiera atrybut i definicje metod dla ciało klasy; może być "
"kopiowany lub zawijany zanim stanie się :attr:`~type.__dict__` atrybut . "
"Następujące dwa instrukcja tworzą identyczne :class:`!type` obiekty:"

msgid "See also:"
msgstr "Zobacz także:"

msgid ""
":ref:`Documentation on attributes and methods on classes <class-attrs-and-"
"methods>`."
msgstr ""
":ref:`Dokumentacja atrybutow i metod na klasach <class-attrs-and-methods>`."

msgid ":ref:`bltin-type-objects`"
msgstr ":ref:`bltin-type-objects`"

msgid ""
"Keyword arguments provided to the three argument form are passed to the "
"appropriate metaclass machinery (usually :meth:`~object.__init_subclass__`) "
"in the same way that keywords in a class definition (besides *metaclass*) "
"would."
msgstr ""
"Argument nazwane dostarczone do trzech formularzy argumenty są przekazywane "
"do odpowiedniego mechanizmu metaklas (zwykle :meth:`~object."
"__init_subclass__`) w taki sam sposób, jak słowa kluczowe w definicja klasy "
"(poza *metaclass*)."

msgid "See also :ref:`class-customization`."
msgstr "Zobacz także :ref:`class-customization`."

msgid ""
"Subclasses of :class:`!type` which don't override ``type.__new__`` may no "
"longer use the one-argument form to get the type of an object."
msgstr ""
"Podklasy z :class:`!type`, które nie nadpisują ``type.__new__`` nie mogą już "
"używać formy jednego-argumentu do uzyskania typu obiektu."

msgid ""
"Return the :attr:`~object.__dict__` attribute for a module, class, instance, "
"or any other object with a :attr:`!__dict__` attribute."
msgstr ""
"Zwraca atrybut  :attr:`~object.__dict__` dla moduł, klas, instancji lub "
"dowolnego innego obiektu z :attr:`!__dict__` atrybut ."

msgid ""
"Objects such as modules and instances have an updateable :attr:`~object."
"__dict__` attribute; however, other objects may have write restrictions on "
"their :attr:`!__dict__` attributes (for example, classes use a :class:`types."
"MappingProxyType` to prevent direct dictionary updates)."
msgstr ""
"Obiekty takie jak moduł i instancje mają możliwość aktualizacji :attr:"
"`~object.__dict__` atrybut; jednak inne obiekty mogą mieć ograniczenia "
"zapisu na ich :attr:`!__dict__` atrybut (na przykład klasy używają :class:"
"`types.MappingProxyType`, aby zapobiec bezpośrednim aktualizacjom słownika)."

msgid "Without an argument, :func:`vars` acts like :func:`locals`."
msgstr "Bez argumenta, :func:`vars` działa jak :func:`locals`."

msgid ""
"A :exc:`TypeError` exception is raised if an object is specified but it "
"doesn't have a :attr:`~object.__dict__` attribute (for example, if its class "
"defines the :attr:`~object.__slots__` attribute)."
msgstr ""
"Wyjątek :exc:`TypeError` jest rzucony, jeśli obiekt jest określony, ale nie "
"ma :attr:`~object.__dict__` atrybut (na przykład, jeśli jego klasa "
"definiuje :attr:`~object.__slots__` atrybut )."

msgid ""
"The result of calling this function without an argument has been updated as "
"described for the :func:`locals` builtin."
msgstr ""
"Wynik wywołania tej funkcji bez argumentow został zaktualizowany zgodnie z "
"opisem dla wbudowanej   :func:`locals` ."

msgid ""
"Iterate over several iterables in parallel, producing tuples with an item "
"from each one."
msgstr ""
"Iteruje równolegle po kilku iterables, tworząc krotke z elementem z każdej z "
"nich."

msgid "Example::"
msgstr "Przykład::"

msgid ""
">>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):\n"
"...     print(item)\n"
"...\n"
"(1, 'sugar')\n"
"(2, 'spice')\n"
"(3, 'everything nice')"
msgstr ""
">>> for item in zip([1, 2, 3], ['cukier', 'przyprawa', 'wszystko fajnie']):\n"
"... print(item)\n"
"...\n"
"(1, 'cukier')\n"
"(2, \"przyprawa\")\n"
"(3, \"wszystko fajnie\")"

msgid ""
"More formally: :func:`zip` returns an iterator of tuples, where the *i*-th "
"tuple contains the *i*-th element from each of the argument iterables."
msgstr ""
"Bardziej formalnie: :func:`zip` zwraca i iterator z krotka, gdzie *i*-ty "
"krotka zawiera *i*-ty element z każdego z argument iterable ."

msgid ""
"Another way to think of :func:`zip` is that it turns rows into columns, and "
"columns into rows.  This is similar to `transposing a matrix <https://en."
"wikipedia.org/wiki/Transpose>`_."
msgstr ""
"Innym sposobem myślenia o :func:`zip` jest to, że zamienia wiersze w "
"kolumny, a kolumny w wiersze.  Jest to podobne do `przekształcania macierzy "
"<https://en.wikipedia.org/wiki/Transpose>`_."

msgid ""
":func:`zip` is lazy: The elements won't be processed until the iterable is "
"iterated on, e.g. by a :keyword:`!for` loop or by wrapping in a :class:"
"`list`."
msgstr ""
":func:`zip` jest leniwy: Elementy nie będą przetwarzane, dopóki iterable nie "
"zostanie poddany iteracji, np. przez pętlę :keyword:`!for` lub przez "
"zawinięcie w :class:`list`."

msgid ""
"One thing to consider is that the iterables passed to :func:`zip` could have "
"different lengths; sometimes by design, and sometimes because of a bug in "
"the code that prepared these iterables.  Python offers three different "
"approaches to dealing with this issue:"
msgstr ""
"Jedną rzeczą, którą należy wziąć pod uwagę, jest to, że iterable "
"przekazywane do :func:`zip` mogą mieć różne długości; czasami z założenia, a "
"czasami z powodu błędu w kodzie, który przygotował te iterable. Python "
"oferuje trzy różne podejścia do radzenia sobie z tym problemem:"

msgid ""
"By default, :func:`zip` stops when the shortest iterable is exhausted. It "
"will ignore the remaining items in the longer iterables, cutting off the "
"result to the length of the shortest iterable::"
msgstr ""
"Przez domyślny, :func:`zip` zatrzymuje się, gdy najkrótszy iterable jest "
"wyczerpany. Zignoruje pozostałe elementy w dłuższym iterable, obcinając "
"wynik do długości najkrótszego iterable::"

msgid ""
">>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))\n"
"[(0, 'fee'), (1, 'fi'), (2, 'fo')]"
msgstr ""
">>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))\n"
"[(0, 'fee'), (1, 'fi'), (2, 'fo')]"

msgid ""
":func:`zip` is often used in cases where the iterables are assumed to be of "
"equal length.  In such cases, it's recommended to use the ``strict=True`` "
"option. Its output is the same as regular :func:`zip`::"
msgstr ""
":func:`zip` jest często używana w przypadkach, gdy zakłada się, że iterable "
"są równej długości.  W takich przypadkach zaleca się użycie opcji "
"``strict=True``. Jej wynik jest taki sam jak zwykłego :func:`zip`::"

msgid ""
">>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))\n"
"[('a', 1), ('b', 2), ('c', 3)]"
msgstr ""
">>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))\n"
"[('a', 1), ('b', 2), ('c', 3)]"

msgid ""
"Unlike the default behavior, it raises a :exc:`ValueError` if one iterable "
"is exhausted before the others:"
msgstr ""
"W przeciwieństwie do domyślnego zachowania , rzuci  :exc:`ValueError`, jeśli "
"jeden iterable zostanie wyczerpany przed innymi:"

msgid ""
"Without the ``strict=True`` argument, any bug that results in iterables of "
"different lengths will be silenced, possibly manifesting as a hard-to-find "
"bug in another part of the program."
msgstr ""
"Bez ``strict=True`` argumentu, każdy błąd, który skutkuje iterable o różnych "
"długościach zostanie wyciszony, prawdopodobnie objawiając się jako trudny do "
"znalezienia błąd w innej części programu."

msgid ""
"Shorter iterables can be padded with a constant value to make all the "
"iterables have the same length.  This is done by :func:`itertools."
"zip_longest`."
msgstr ""
"Krótsze iterable mogą być uzupełnione stałą wartością, aby wszystkie "
"iterable miały taką samą długość.  Odbywa się to poprzez :func:`itertools."
"zip_longest`."

msgid ""
"Edge cases: With a single iterable argument, :func:`zip` returns an iterator "
"of 1-tuples.  With no arguments, it returns an empty iterator."
msgstr ""
"Przypadki brzegowe: Z pojedynczym iterable argument, :func:`zip` zwraca "
"iterator z 1-krotka.  Bez argumentu, to zwraca pusty iterator."

msgid "Tips and tricks:"
msgstr "Wskazówki i porady:"

msgid ""
"The left-to-right evaluation order of the iterables is guaranteed. This "
"makes possible an idiom for clustering a data series into n-length groups "
"using ``zip(*[iter(s)]*n, strict=True)``.  This repeats the *same* iterator "
"``n`` times so that each output tuple has the result of ``n`` calls to the "
"iterator. This has the effect of dividing the input into n-length chunks."
msgstr ""
"Kolejność oceny od lewej do prawej strony iterable jest gwarantowana. "
"Umożliwia to idiom grupowania serii danych w grupy o długości n przy użyciu "
"``zip(*[iter(s)]*n, strict=True)``.  Powtarza to *tę samą* iterator ``n`` "
"razy, tak że każde wyjście krotka ma wynik wywołań ``n`` do iteratora. "
"Powoduje to podzielenie danych wejściowych na fragmenty o długości n."

msgid ""
":func:`zip` in conjunction with the ``*`` operator can be used to unzip a "
"list::"
msgstr ""
":func:`zip` w połączeniu z operatorem ``*`` może być użyty do rozpakowania "
"listy::"

msgid ""
">>> x = [1, 2, 3]\n"
">>> y = [4, 5, 6]\n"
">>> list(zip(x, y))\n"
"[(1, 4), (2, 5), (3, 6)]\n"
">>> x2, y2 = zip(*zip(x, y))\n"
">>> x == list(x2) and y == list(y2)\n"
"True"
msgstr ""
">>> x = [1, 2, 3]\n"
">>> y = [4, 5, 6]\n"
">>> list(zip(x, y))\n"
"[(1, 4), (2, 5), (3, 6)]\n"
">>> x2, y2 = zip(*zip(x, y))\n"
">>> x == list(x2) and y == list(y2)\n"
"True"

msgid "Added the ``strict`` argument."
msgstr "Dodano argument ``strict`` ."

msgid ""
"This is an advanced function that is not needed in everyday Python "
"programming, unlike :func:`importlib.import_module`."
msgstr ""
"Jest to zaawansowana funkcja, która nie jest potrzebna w codziennym "
"programowaniu Pythona, w przeciwieństwie do :func:`importlib.import_module`."

msgid ""
"This function is invoked by the :keyword:`import` statement.  It can be "
"replaced (by importing the :mod:`builtins` module and assigning to "
"``builtins.__import__``) in order to change semantics of the :keyword:`!"
"import` statement, but doing so is **strongly** discouraged as it is usually "
"simpler to use import hooks (see :pep:`302`) to attain the same goals and "
"does not cause issues with code which assumes the default import "
"implementation is in use.  Direct use of :func:`__import__` is also "
"discouraged in favor of :func:`importlib.import_module`."
msgstr ""
"Ten funkcja jest wywoływany przez :keyword:`import` instrukcja .  Można go "
"zastąpić (importując :mod:`builtins` moduł i przypisując do ``builtins."
"__import__``) w celu zmiany semantyki :keyword:`!import` instrukcja , ale "
"jest to **bardżo** odradzane, ponieważ zwykle prostsze jest użycie haków "
"importu (zobacz :pep:`302`), aby osiągnąć te same cele i nie powoduje "
"problemów z kodem, który zakłada, że implementacja importu domyślny jest w "
"użyciu.  Bezpośrednie użycie :func:`__import__` jest również odradzane na "
"korzyść :func:`importlib.import_module`."

msgid ""
"The function imports the module *name*, potentially using the given "
"*globals* and *locals* to determine how to interpret the name in a package "
"context. The *fromlist* gives the names of objects or submodules that should "
"be imported from the module given by *name*.  The standard implementation "
"does not use its *locals* argument at all and uses its *globals* only to "
"determine the package context of the :keyword:`import` statement."
msgstr ""
"Funkcja importuje moduł *name*, potencjalnie używając podanych *globals* i "
"*locals* do określenia, jak interpretować nazwę w kontekście pakietu. "
"*fromlist* podaje nazwy obiektów lub submodułów, które powinny zostać "
"zaimportowane z moduł podanego przez *name*.  Standardowa implementacja nie "
"używa *locals* argumentu w ogóle i używa *globals* tylko do określenia "
"kontekstu pakietu :keyword:`import` instrukcja ."

msgid ""
"*level* specifies whether to use absolute or relative imports. ``0`` (the "
"default) means only perform absolute imports.  Positive values for *level* "
"indicate the number of parent directories to search relative to the "
"directory of the module calling :func:`__import__` (see :pep:`328` for the "
"details)."
msgstr ""
"*level* określa, czy ma być używany import bezwzględny czy względny. ``0`` "
"(domyślnie) oznacza tylko import bezwzględny.  Dodatnie wartości dla *level* "
"wskazują liczbę katalogów nadrzędnych do przeszukania względem katalogu "
"moduł wywołującego :func:`__import__` (zobacz :pep:`328` dla szczegółów)."

msgid ""
"When the *name* variable is of the form ``package.module``, normally, the "
"top-level package (the name up till the first dot) is returned, *not* the "
"module named by *name*.  However, when a non-empty *fromlist* argument is "
"given, the module named by *name* is returned."
msgstr ""
"Gdy zmienna *name* ma postać ``package.module``, zwykle zwracany jest pakiet "
"najwyższego poziomu (nazwa do pierwszej kropki), *nie* moduł nazwany przez "
"*name*.  Jednakże, gdy podana jest niepusta *fromlist* argument, zwracany "
"jest moduł nazwany przez *name*."

msgid ""
"For example, the statement ``import spam`` results in bytecode resembling "
"the following code::"
msgstr ""
"Na przykład, instrukcja ``import spam`` skutkuje kodem bajtowym "
"przypominającym następujący kod::"

msgid "spam = __import__('spam', globals(), locals(), [], 0)"
msgstr "spam = __import__('spam', globals(), locals(), [], 0)"

msgid "The statement ``import spam.ham`` results in this call::"
msgstr "Instrukcja ``import spam.ham`` skutkuje następującym połączeniem::"

msgid "spam = __import__('spam.ham', globals(), locals(), [], 0)"
msgstr "spam = __import__('spam.ham', globals(), locals(), [], 0)"

msgid ""
"Note how :func:`__import__` returns the toplevel module here because this is "
"the object that is bound to a name by the :keyword:`import` statement."
msgstr ""
"Zauważ, że :func:`__import__` zwraca toplevel moduł tutaj, ponieważ jest to "
"obiekt, który jest powiązany z nazwą przez :keyword:`import` instrukcje ."

msgid ""
"On the other hand, the statement ``from spam.ham import eggs, sausage as "
"saus`` results in ::"
msgstr ""
"Z drugiej strony, instrukcja ``from spam.ham import eggs, sausage as saus`` "
"skutkuje ::"

msgid ""
"_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)\n"
"eggs = _temp.eggs\n"
"saus = _temp.sausage"
msgstr ""
"_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)\n"
"eggs = _temp.eggs\n"
"saus = _temp.sausage"

msgid ""
"Here, the ``spam.ham`` module is returned from :func:`__import__`.  From "
"this object, the names to import are retrieved and assigned to their "
"respective names."
msgstr ""
"Tutaj obiekt ``spam.ham`` jest zwracany z :func:`__import__`.  Z tego "
"obiektu pobierane są nazwy do zaimportowania i przypisywane do odpowiednich "
"nazw."

msgid ""
"If you simply want to import a module (potentially within a package) by "
"name, use :func:`importlib.import_module`."
msgstr ""
"Jeśli chcesz po prostu zaimportować moduł (potencjalnie w ramach pakietu) "
"według nazwy, użyj :func:`importlib.import_module`."

msgid ""
"Negative values for *level* are no longer supported (which also changes the "
"default value to 0)."
msgstr ""
"Ujemne wartości dla *level* nie są już obsługiwane (co również zmienia "
"wartość domyślny na 0)."

msgid ""
"When the command line options :option:`-E` or :option:`-I` are being used, "
"the environment variable :envvar:`PYTHONCASEOK` is now ignored."
msgstr ""
"Gdy używane są opcje wiersza poleceń :option:`-E` lub :option:`-I`, opcja "
"zmienna środowiskowa :envvar:`PYTHONCASEOK` jest teraz ignorowana."

msgid "Footnotes"
msgstr "Przypisy"

msgid ""
"Note that the parser only accepts the Unix-style end of line convention. If "
"you are reading the code from a file, make sure to use newline conversion "
"mode to convert Windows or Mac-style newlines."
msgstr ""
"Zwróć uwagę, że parser akceptuje tylko Unixowy styl końca linii. Jeśli "
"wczytujesz kod z pliku, wykorzystaj konwersję linii aby przekonwertować "
"style końca linii Winows albo Mac."

msgid "Boolean"
msgstr "Wartość logiczna"

msgid "type"
msgstr "typ"

msgid "built-in function"
msgstr "funkcja wbudowana"

msgid "exec"
msgstr "exec"

msgid "NaN"
msgstr "NaN"

msgid "Infinity"
msgstr "Nieskończoność"

msgid "__format__"
msgstr "__format__"

msgid "string"
msgstr "ciąg znaków"

msgid "format() (built-in function)"
msgstr "format() (wbudowana funkcja)"

msgid "file object"
msgstr "obiekt plik"

msgid "open() built-in function"
msgstr "open() wbudowana funkcja"

msgid "file"
msgstr "plik"

msgid "modes"
msgstr "tryby"

msgid "universal newlines"
msgstr "uniwersalne nowe linie"

msgid "line-buffered I/O"
msgstr "Buforowane liniowo I/O"

msgid "unbuffered I/O"
msgstr "niebuforowane I/O"

msgid "buffer size, I/O"
msgstr "rozmiar bufora, I/O"

msgid "I/O control"
msgstr "Kontrola I/O"

msgid "buffering"
msgstr "buforowanie"

msgid "text mode"
msgstr "tryb tekstowy"

msgid "module"
msgstr "moduł"

msgid "sys"
msgstr "sys"

msgid "str() (built-in function)"
msgstr "str() (wbudowana funkcja)"

msgid "object"
msgstr "obiekt"

msgid "statement"
msgstr "instrukcja"

msgid "import"
msgstr "import"

msgid "builtins"
msgstr "builtins"