modules.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Ciarbin Ciarbin <mrciarbin@gmail.com>, 2021
# Maciej Olko <maciej.olko@gmail.com>, 2022
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 05:02+0000\n"
"PO-Revision-Date: 2017-02-16 23:41+0000\n"
"Last-Translator: Maciej Olko <maciej.olko@gmail.com>, 2022\n"
"Language-Team: Polish (https://www.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 "Modules"
msgstr "Moduły"

msgid ""
"If you quit from the Python interpreter and enter it again, the definitions "
"you have made (functions and variables) are lost. Therefore, if you want to "
"write a somewhat longer program, you are better off using a text editor to "
"prepare the input for the interpreter and running it with that file as input "
"instead.  This is known as creating a *script*.  As your program gets "
"longer, you may want to split it into several files for easier maintenance.  "
"You may also want to use a handy function that you've written in several "
"programs without copying its definition into each program."
msgstr ""
"Jeśli wyjdziesz z interpretera Pythona i wejdziesz do niego z powrotem, "
"zauważysz, że straciłeś(-łaś) definicje, które zrobiłeś(-łaś) (funkcje i "
"zmienne). Z tego powodu, jeśli chcesz napisać nieco dłuższy program, lepiej "
"będzie użyć edytora tekstu, aby przygotować wejście dla interpretera i "
"uruchomić go z tym plikiem jako wejściem. Znane jest to jako tworzenie "
"„skryptu”. Kiedy twój program staje się dłuższy, możesz podzielić go na "
"kilka plików dla łatwiejszego utrzymania. Możesz chcieć też użyć przydatnej "
"funkcji, którą napisałeś, w kilku programach, bez kopiowania jej definicji "
"do każdego programu."

msgid ""
"To support this, Python has a way to put definitions in a file and use them "
"in a script or in an interactive instance of the interpreter. Such a file is "
"called a *module*; definitions from a module can be *imported* into other "
"modules or into the *main* module (the collection of variables that you have "
"access to in a script executed at the top level and in calculator mode)."
msgstr ""
"By to zapewnić, Python ma możliwość umieszczania definicji w pliku i "
"używania ich w skrypcie lub w interaktywnej instancji interpretera. Taki "
"plik nazywa się *modułem*; definicje z modułu mogą być *importowane* do "
"innych modułów lub do modułu *main* (zbiór zmiennych, do których masz dostęp "
"w skrypcie wykonywanym na najwyższym poziomie i w trybie kalkulatora)."

msgid ""
"A module is a file containing Python definitions and statements.  The file "
"name is the module name with the suffix :file:`.py` appended.  Within a "
"module, the module's name (as a string) is available as the value of the "
"global variable ``__name__``.  For instance, use your favorite text editor "
"to create a file called :file:`fibo.py` in the current directory with the "
"following contents::"
msgstr ""
"Moduł to plik zawierający definicje i instrukcje Pythona. Nazwą pliku jest "
"nazwa modułu z dodanym sufiksem :file:`.py`. Wewnątrz modułu, jego nazwa "
"(jako ciąg znaków) jest dostępna jako wartość zmiennej globalnej "
"``__name__``. Na przykład użyj swojego ulubionego edytora tekstu, by "
"stworzyć plik o nazwie :file:`fibo.py` w bieżącym katalogu, z następującą "
"zawartością::"

msgid ""
"Now enter the Python interpreter and import this module with the following "
"command::"
msgstr ""
"Wejdź w interpreter Pythona i zaimportuj ten moduł następującą komendą::"

msgid ""
"This does not enter the names of the functions defined in ``fibo``  directly "
"in the current symbol table; it only enters the module name ``fibo`` there. "
"Using the module name you can access the functions::"
msgstr ""
"Ta komenda nie umieszcza nazw funkcji określonych w ``fibo`` bezpośrednio w "
"bieżącej tabeli symboli; umieszcza ona tam tylko nazwę modułu ``fibo``. "
"Używając nazwy modułu możesz użyć funkcji::"

msgid ""
"If you intend to use a function often you can assign it to a local name::"
msgstr ""
"Jeśli zamierzasz używać funkcji często, możesz przypisać ją do lokalnej "
"nazwy::"

msgid "More on Modules"
msgstr "Więcej o modułach"

msgid ""
"A module can contain executable statements as well as function definitions. "
"These statements are intended to initialize the module. They are executed "
"only the *first* time the module name is encountered in an import statement. "
"[#]_ (They are also run if the file is executed as a script.)"
msgstr ""
"Moduł może zawierać zarówno wykonywalne instrukcje jak i definicje funkcji. "
"Instrukcje mają inicjalizować moduł. Są wykonywane tylko za *pierwszym* "
"razem, gdy nazwa modułu zostanie napotkana w instrukcji importu. [#]_ (Są "
"one również wykonywane, jeśli plik jest wykonywany jako skrypt.)"

msgid ""
"Each module has its own private symbol table, which is used as the global "
"symbol table by all functions defined in the module. Thus, the author of a "
"module can use global variables in the module without worrying about "
"accidental clashes with a user's global variables. On the other hand, if you "
"know what you are doing you can touch a module's global variables with the "
"same notation used to refer to its functions, ``modname.itemname``."
msgstr ""
"Każdy moduł ma swoją własną tablicę symboli, która jest używana jako "
"globalna tablica symboli przez wszystkie funkcje zdefiniowane w tym module. "
"Tak więc autor modułu może używać globalnych zmiennych nie martwiąc się o "
"przypadkowe konflikty z globalnymi zmiennymi użytkownika. Z drugiej strony, "
"jeśli wiesz co robisz, możesz odnosić się do globalnych zmiennych modułu tą "
"samą notacją, którą używa się do odniesień do jego funkcji, ``nazwamodułu."
"nazwalementu``."

msgid ""
"Modules can import other modules.  It is customary but not required to place "
"all :keyword:`import` statements at the beginning of a module (or script, "
"for that matter).  The imported module names are placed in the importing "
"module's global symbol table."
msgstr ""
"Moduły mogą importować inne moduły. Zwyczajowo (nieobowiązkowo) umieszcza "
"się wszystkie instrukcje :keyword:`import` na początku modułu (lub skryptu). "
"Zaimportowane nazwy modułów są umieszczane w globalnej tablicy symboli "
"modułu importującego."

msgid ""
"There is a variant of the :keyword:`import` statement that imports names "
"from a module directly into the importing module's symbol table.  For "
"example::"
msgstr ""
"Istnieje wariant instrukcji :keyword:`import`, który importuje nazwy z "
"modułu bezpośrednio do tablicy symboli modułu importującego. Na przykład::"

msgid ""
"This does not introduce the module name from which the imports are taken in "
"the local symbol table (so in the example, ``fibo`` is not defined)."
msgstr ""
"Nie wprowadza to nazwy modułu, z którego wzięte są importy do lokalnej "
"tablicy symboli (więc w przykładzie ``fibo`` nie jest zdefiniowane)."

msgid "There is even a variant to import all names that a module defines::"
msgstr ""
"Jest również wariant importujący wszystkie nazwy definiowane przez moduł::"

msgid ""
"This imports all names except those beginning with an underscore (``_``). In "
"most cases Python programmers do not use this facility since it introduces "
"an unknown set of names into the interpreter, possibly hiding some things "
"you have already defined."
msgstr ""
"Importuje to wszystkie nazwy z wyjątkiem tych zaczynających się od "
"podkreślenia (``_``). W większości przypadków programiści Pythona nie "
"używają tego udogodnienia, ponieważ wprowadza ono nieznany zestaw nazw do "
"interpretera, być może ukrywając niektóre już zdefiniowane rzeczy."

msgid ""
"Note that in general the practice of importing ``*`` from a module or "
"package is frowned upon, since it often causes poorly readable code. "
"However, it is okay to use it to save typing in interactive sessions."
msgstr ""
"Zauważ, że ogólnie praktyka importowania ``*`` z modułu lub pakietu jest "
"niemile widziana, ponieważ często powoduje, że kod jest mało czytelny. Można "
"jej jednak używać do oszczędzania pisania w sesjach interaktywnych."

msgid ""
"If the module name is followed by :keyword:`!as`, then the name following :"
"keyword:`!as` is bound directly to the imported module."
msgstr ""
"Jeżeli po nazwie modułu następuje :keyword:`!as`, to nazwa następująca po :"
"keyword:`!as` jest powiązana bezpośrednio z importowanym modułem."

msgid ""
"This is effectively importing the module in the same way that ``import "
"fibo`` will do, with the only difference of it being available as ``fib``."
msgstr ""
"W praktyce jest to importowanie modułu w taki sam sposób, jak robi to "
"``import fibo``, z tą różnicą, że jest on dostępny jako ``fib``."

msgid ""
"It can also be used when utilising :keyword:`from` with similar effects::"
msgstr "Można go również użyć przy użyciu :keyword:`from` z podobnym efektem::"

msgid ""
"For efficiency reasons, each module is only imported once per interpreter "
"session.  Therefore, if you change your modules, you must restart the "
"interpreter -- or, if it's just one module you want to test interactively, "
"use :func:`importlib.reload`, e.g. ``import importlib; importlib."
"reload(modulename)``."
msgstr ""
"Ze względów wydajnościowych każdy moduł jest importowany tylko raz dla sesji "
"interpretera. W związku z tym jeśli zmienisz swoje moduły, musisz "
"zrestartować interpreter – lub, jeśli to tylko jeden moduł, który chcesz "
"testować interaktywnie, użyj :func:`importlib.reload`, na przykład ``import "
"importlib; importlib.reload(modulename)``."

msgid "Executing modules as scripts"
msgstr "Wykonywanie modułów jako skryptów"

msgid "When you run a Python module with ::"
msgstr "Kiedy uruchamiasz moduł Pythona::"

msgid ""
"the code in the module will be executed, just as if you imported it, but "
"with the ``__name__`` set to ``\"__main__\"``.  That means that by adding "
"this code at the end of your module::"
msgstr ""
"kod w module zostanie wykonany, tak jakbyś go zaimportował, ale z "
"``__name__`` ustawionym na ``\"__main__\"``. To oznacza, że dodając ten kod "
"na końcu swojego modułu::"

msgid ""
"you can make the file usable as a script as well as an importable module, "
"because the code that parses the command line only runs if the module is "
"executed as the \"main\" file:"
msgstr ""
"możesz uczynić plik używalnym zarówno jako skrypt oraz jako importowalny "
"moduł, ponieważ kod, który parsuje linię komend uruchamia się tylko jeśli "
"moduł jest wykonywany jako plik „główny”:"

msgid "If the module is imported, the code is not run::"
msgstr "Jeśli moduł jest zaimportowany, kod nie jest uruchamiany::"

msgid ""
"This is often used either to provide a convenient user interface to a "
"module, or for testing purposes (running the module as a script executes a "
"test suite)."
msgstr ""
"Często się z tego korzysta, aby dodać wygodny interfejs użytkownika do "
"modułu lub na potrzeby testów (uruchomienie modułu jako skryptu wykonuje "
"zestaw testów)."

msgid "The Module Search Path"
msgstr "Ścieżka wyszukiwania modułów"

msgid ""
"When a module named :mod:`spam` is imported, the interpreter first searches "
"for a built-in module with that name. If not found, it then searches for a "
"file named :file:`spam.py` in a list of directories given by the variable :"
"data:`sys.path`.  :data:`sys.path` is initialized from these locations:"
msgstr ""
"Kiedy importowany jest moduł o nazwie :mod:`spam`, interpreter najpierw "
"szuka wbudowanego modułu o takiej nazwie. Jeśli nie znajdzie, wtedy szuka "
"pliku o nazwie :file:`spam.py` na liście katalogów danych w zmiennej :data:"
"`sys.path`. :data:`sys.path` jest inicjalizowane z tych lokalizacji:"

msgid ""
"The directory containing the input script (or the current directory when no "
"file is specified)."
msgstr ""
"Katalog zawierający skrypt wejściowy (lub bieżący katalog, jeśli plik nie "
"jest określony)."

msgid ""
":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the "
"shell variable :envvar:`PATH`)."
msgstr ""
":envvar:`PYTHONPATH` (lista nazw katalogów o takiej samej składni jak "
"zmienna shell :envvar:`PATH`)."

msgid "The installation-dependent default."
msgstr ""

msgid ""
"On file systems which support symlinks, the directory containing the input "
"script is calculated after the symlink is followed. In other words the "
"directory containing the symlink is **not** added to the module search path."
msgstr ""
"W systemach plików wspierających dowiązania symboliczne, katalog zawierający "
"skrypt wejściowy jest wyliczany po rozwiązaniu dowiązania symbolicznego. "
"Innymi słowy katalog zawierający dowiązanie symboliczne **nie** jest dodany "
"do ścieżki wyszukiwania modułów."

msgid ""
"After initialization, Python programs can modify :data:`sys.path`.  The "
"directory containing the script being run is placed at the beginning of the "
"search path, ahead of the standard library path. This means that scripts in "
"that directory will be loaded instead of modules of the same name in the "
"library directory. This is an error unless the replacement is intended.  See "
"section :ref:`tut-standardmodules` for more information."
msgstr ""
"Po inicjalizacji programy pythonowe mogą modyfikować :data:`sys.path`. "
"Katalog zwierający uruchamiany skrypt jest umieszczony na początku ścieżki "
"wyszukiwania, przed ścieżką biblioteki standardowej. To znaczy, że skrypty w "
"tym katalogu zostaną załadowane zamiast modułów o tej samej nazwie w "
"katalogu biblioteki. Jest to błąd, o ile taka zamiana jest zamierzona. Patrz "
"sekcja :ref:`tut-standardmodules` po więcej informacji."

msgid "\"Compiled\" Python files"
msgstr "„Skompilowane” pliki Pythona"

msgid ""
"To speed up loading modules, Python caches the compiled version of each "
"module in the ``__pycache__`` directory under the name :file:`module."
"{version}.pyc`, where the version encodes the format of the compiled file; "
"it generally contains the Python version number.  For example, in CPython "
"release 3.3 the compiled version of spam.py would be cached as ``__pycache__/"
"spam.cpython-33.pyc``.  This naming convention allows compiled modules from "
"different releases and different versions of Python to coexist."
msgstr ""
"Aby przyspieszyć ładowanie modułów, Python cache'uje skompilowaną wersję "
"każdego modułu w katalogu ``__pycache__`` pod nazwą :file:`module.{wersja}."
"pyc`, gdzie wersja koduje format skompilowanego pliku; zazwyczaj zawiera "
"numer wersji Pythona. Na przykład w wydaniu CPythona 3.3 skompilowana wersja "
"spam.py zostałaby zcache'owana jako ``__pycache__/spam.cpython-33.pyc``. Ta "
"konwencja nazw pozwala na współistnienie skompilowanych modułów z różnych "
"wydań i wersji Pythona."

msgid ""
"Python checks the modification date of the source against the compiled "
"version to see if it's out of date and needs to be recompiled.  This is a "
"completely automatic process.  Also, the compiled modules are platform-"
"independent, so the same library can be shared among systems with different "
"architectures."
msgstr ""
"Python porównuje datę modyfikacji źródła ze skompilowaną wersją, aby "
"ustalić, czy jest przeterminowana i powinna zostać zrekompilowana. To "
"całkowicie automatyczny proces. Skompilowane moduły są niezależne od "
"platformy, więc ta sama biblioteka może być współdzielona pomiędzy systemami "
"z innymi architekturami."

msgid ""
"Python does not check the cache in two circumstances.  First, it always "
"recompiles and does not store the result for the module that's loaded "
"directly from the command line.  Second, it does not check the cache if "
"there is no source module.  To support a non-source (compiled only) "
"distribution, the compiled module must be in the source directory, and there "
"must not be a source module."
msgstr ""
"Python nie sprawdza cache'u w dwóch przypadkach. Po pierwsze zawsze "
"rekompiluje i nie zapisuje wyniku dla modułu załadowanego bezpośrednio z "
"linii komend. Po drugie nie sprawdza cache'u, kiedy nie ma modułu "
"źródłowego. Dla wsparcia dystrybucji bez źródła (tylko kompilowany), "
"skompilowany moduł musi być w katalogu źródłowym i nie może być modułu "
"źródłowego."

msgid "Some tips for experts:"
msgstr "Wskazówki dla ekspertów:"

msgid ""
"You can use the :option:`-O` or :option:`-OO` switches on the Python command "
"to reduce the size of a compiled module.  The ``-O`` switch removes assert "
"statements, the ``-OO`` switch removes both assert statements and __doc__ "
"strings.  Since some programs may rely on having these available, you should "
"only use this option if you know what you're doing.  \"Optimized\" modules "
"have an ``opt-`` tag and are usually smaller.  Future releases may change "
"the effects of optimization."
msgstr ""
"Możesz użyć przełączników :option:`-O` lub :option:`-OO` na komendzie "
"``python``, aby zmniejszyć rozmiar skompilowanego modułu. Przełącznik ``-O`` "
"usuwa instrukcje assert. Przełącznik ``-OO`` usuwa zarówno instrukcje assert "
"jak i docstringi. Jako że niektóre programy mogą polegać na dostępności "
"powyższych, powinieneś(-nnaś) używać tylko jeśli wiesz, co robisz. "
"„Zoptymalizowane” moduły mają tag ``opt-`` i zazwyczaj są mniejsze. Przyszłe "
"wydania mogą zmienić efekty optymalizacji."

msgid ""
"A program doesn't run any faster when it is read from a ``.pyc`` file than "
"when it is read from a ``.py`` file; the only thing that's faster about ``."
"pyc`` files is the speed with which they are loaded."
msgstr ""
"Program nie wykonuje się ani chwili szybciej, gdy jest czytany z pliku ``."
"pyc`` niż gdy jest czytany z pliku ``.py``. Jedyna rzecz, która jest szybsza "
"w plikach ``.pyc`` to szybkość, w jakiej są one ładowane."

msgid ""
"The module :mod:`compileall` can create .pyc files for all modules in a "
"directory."
msgstr ""

msgid ""
"There is more detail on this process, including a flow chart of the "
"decisions, in :pep:`3147`."
msgstr ""

msgid "Standard Modules"
msgstr "Moduły standardowe"

msgid ""
"Python comes with a library of standard modules, described in a separate "
"document, the Python Library Reference (\"Library Reference\" hereafter).  "
"Some modules are built into the interpreter; these provide access to "
"operations that are not part of the core of the language but are "
"nevertheless built in, either for efficiency or to provide access to "
"operating system primitives such as system calls.  The set of such modules "
"is a configuration option which also depends on the underlying platform.  "
"For example, the :mod:`winreg` module is only provided on Windows systems. "
"One particular module deserves some attention: :mod:`sys`, which is built "
"into every Python interpreter.  The variables ``sys.ps1`` and ``sys.ps2`` "
"define the strings used as primary and secondary prompts::"
msgstr ""

msgid ""
"These two variables are only defined if the interpreter is in interactive "
"mode."
msgstr ""

msgid ""
"The variable ``sys.path`` is a list of strings that determines the "
"interpreter's search path for modules. It is initialized to a default path "
"taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in "
"default if :envvar:`PYTHONPATH` is not set.  You can modify it using "
"standard list operations::"
msgstr ""

msgid "The :func:`dir` Function"
msgstr ""

msgid ""
"The built-in function :func:`dir` is used to find out which names a module "
"defines.  It returns a sorted list of strings::"
msgstr ""

msgid ""
"Without arguments, :func:`dir` lists the names you have defined currently::"
msgstr ""

msgid ""
"Note that it lists all types of names: variables, modules, functions, etc."
msgstr ""

msgid ""
":func:`dir` does not list the names of built-in functions and variables.  If "
"you want a list of those, they are defined in the standard module :mod:"
"`builtins`::"
msgstr ""

msgid "Packages"
msgstr ""

msgid ""
"Packages are a way of structuring Python's module namespace by using "
"\"dotted module names\".  For example, the module name :mod:`A.B` designates "
"a submodule named ``B`` in a package named ``A``.  Just like the use of "
"modules saves the authors of different modules from having to worry about "
"each other's global variable names, the use of dotted module names saves the "
"authors of multi-module packages like NumPy or Pillow from having to worry "
"about each other's module names."
msgstr ""

msgid ""
"Suppose you want to design a collection of modules (a \"package\") for the "
"uniform handling of sound files and sound data.  There are many different "
"sound file formats (usually recognized by their extension, for example: :"
"file:`.wav`, :file:`.aiff`, :file:`.au`), so you may need to create and "
"maintain a growing collection of modules for the conversion between the "
"various file formats. There are also many different operations you might "
"want to perform on sound data (such as mixing, adding echo, applying an "
"equalizer function, creating an artificial stereo effect), so in addition "
"you will be writing a never-ending stream of modules to perform these "
"operations.  Here's a possible structure for your package (expressed in "
"terms of a hierarchical filesystem):"
msgstr ""

msgid ""
"When importing the package, Python searches through the directories on ``sys."
"path`` looking for the package subdirectory."
msgstr ""

msgid ""
"The :file:`__init__.py` files are required to make Python treat directories "
"containing the file as packages.  This prevents directories with a common "
"name, such as ``string``, unintentionally hiding valid modules that occur "
"later on the module search path. In the simplest case, :file:`__init__.py` "
"can just be an empty file, but it can also execute initialization code for "
"the package or set the ``__all__`` variable, described later."
msgstr ""

msgid ""
"Users of the package can import individual modules from the package, for "
"example::"
msgstr ""

msgid ""
"This loads the submodule :mod:`sound.effects.echo`.  It must be referenced "
"with its full name. ::"
msgstr ""

msgid "An alternative way of importing the submodule is::"
msgstr ""

msgid ""
"This also loads the submodule :mod:`echo`, and makes it available without "
"its package prefix, so it can be used as follows::"
msgstr ""

msgid ""
"Yet another variation is to import the desired function or variable "
"directly::"
msgstr ""

msgid ""
"Again, this loads the submodule :mod:`echo`, but this makes its function :"
"func:`echofilter` directly available::"
msgstr ""

msgid ""
"Note that when using ``from package import item``, the item can be either a "
"submodule (or subpackage) of the package, or some  other name defined in the "
"package, like a function, class or variable.  The ``import`` statement first "
"tests whether the item is defined in the package; if not, it assumes it is a "
"module and attempts to load it.  If it fails to find it, an :exc:"
"`ImportError` exception is raised."
msgstr ""

msgid ""
"Contrarily, when using syntax like ``import item.subitem.subsubitem``, each "
"item except for the last must be a package; the last item can be a module or "
"a package but can't be a class or function or variable defined in the "
"previous item."
msgstr ""

msgid "Importing \\* From a Package"
msgstr ""

msgid ""
"Now what happens when the user writes ``from sound.effects import *``?  "
"Ideally, one would hope that this somehow goes out to the filesystem, finds "
"which submodules are present in the package, and imports them all.  This "
"could take a long time and importing sub-modules might have unwanted side-"
"effects that should only happen when the sub-module is explicitly imported."
msgstr ""

msgid ""
"The only solution is for the package author to provide an explicit index of "
"the package.  The :keyword:`import` statement uses the following convention: "
"if a package's :file:`__init__.py` code defines a list named ``__all__``, it "
"is taken to be the list of module names that should be imported when ``from "
"package import *`` is encountered.  It is up to the package author to keep "
"this list up-to-date when a new version of the package is released.  Package "
"authors may also decide not to support it, if they don't see a use for "
"importing \\* from their package.  For example, the file :file:`sound/"
"effects/__init__.py` could contain the following code::"
msgstr ""

msgid ""
"This would mean that ``from sound.effects import *`` would import the three "
"named submodules of the :mod:`sound` package."
msgstr ""

msgid ""
"If ``__all__`` is not defined, the statement ``from sound.effects import *`` "
"does *not* import all submodules from the package :mod:`sound.effects` into "
"the current namespace; it only ensures that the package :mod:`sound.effects` "
"has been imported (possibly running any initialization code in :file:"
"`__init__.py`) and then imports whatever names are defined in the package.  "
"This includes any names defined (and submodules explicitly loaded) by :file:"
"`__init__.py`.  It also includes any submodules of the package that were "
"explicitly loaded by previous :keyword:`import` statements.  Consider this "
"code::"
msgstr ""

msgid ""
"In this example, the :mod:`echo` and :mod:`surround` modules are imported in "
"the current namespace because they are defined in the :mod:`sound.effects` "
"package when the ``from...import`` statement is executed.  (This also works "
"when ``__all__`` is defined.)"
msgstr ""

msgid ""
"Although certain modules are designed to export only names that follow "
"certain patterns when you use ``import *``, it is still considered bad "
"practice in production code."
msgstr ""

msgid ""
"Remember, there is nothing wrong with using ``from package import "
"specific_submodule``!  In fact, this is the recommended notation unless the "
"importing module needs to use submodules with the same name from different "
"packages."
msgstr ""

msgid "Intra-package References"
msgstr ""

msgid ""
"When packages are structured into subpackages (as with the :mod:`sound` "
"package in the example), you can use absolute imports to refer to submodules "
"of siblings packages.  For example, if the module :mod:`sound.filters."
"vocoder` needs to use the :mod:`echo` module in the :mod:`sound.effects` "
"package, it can use ``from sound.effects import echo``."
msgstr ""

msgid ""
"You can also write relative imports, with the ``from module import name`` "
"form of import statement.  These imports use leading dots to indicate the "
"current and parent packages involved in the relative import.  From the :mod:"
"`surround` module for example, you might use::"
msgstr ""

msgid ""
"Note that relative imports are based on the name of the current module.  "
"Since the name of the main module is always ``\"__main__\"``, modules "
"intended for use as the main module of a Python application must always use "
"absolute imports."
msgstr ""

msgid "Packages in Multiple Directories"
msgstr ""

msgid ""
"Packages support one more special attribute, :attr:`__path__`.  This is "
"initialized to be a list containing the name of the directory holding the "
"package's :file:`__init__.py` before the code in that file is executed.  "
"This variable can be modified; doing so affects future searches for modules "
"and subpackages contained in the package."
msgstr ""

msgid ""
"While this feature is not often needed, it can be used to extend the set of "
"modules found in a package."
msgstr ""

msgid "Footnotes"
msgstr "Przypisy"

msgid ""
"In fact function definitions are also 'statements' that are 'executed'; the "
"execution of a module-level function definition enters the function name in "
"the module's global symbol table."
msgstr ""