import.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-09-03 11:11+0800\n"
"PO-Revision-Date: 2024-12-23 15:33+0800\n"
"Last-Translator: Ken Cheng <ken71301@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.5\n"

#: ../../reference/import.rst:6
msgid "The import system"
msgstr "模組引入系統"

#: ../../reference/import.rst:10
msgid ""
"Python code in one :term:`module` gains access to the code in another module "
"by the process of :term:`importing` it.  The :keyword:`import` statement is "
"the most common way of invoking the import machinery, but it is not the only "
"way.  Functions such as :func:`importlib.import_module` and built-in :func:"
"`__import__` can also be used to invoke the import machinery."
msgstr ""
"一個 :term:`module` 中的 Python 程式碼透過 :term:`importing` 的過程來存取另一"
"個模組中的程式碼。:keyword:`import` 陳述式是調用 (invoke) 引入機制最常見的方"
"法，但這不是唯一的方法。函式如 :func:`importlib.import_module` 以及內建函式 :"
"func:`__import__` 也可以用來調用引入機制。"

#: ../../reference/import.rst:16
msgid ""
"The :keyword:`import` statement combines two operations; it searches for the "
"named module, then it binds the results of that search to a name in the "
"local scope.  The search operation of the :keyword:`!import` statement is "
"defined as a call to the :func:`__import__` function, with the appropriate "
"arguments. The return value of :func:`__import__` is used to perform the "
"name binding operation of the :keyword:`!import` statement.  See the :"
"keyword:`!import` statement for the exact details of that name binding "
"operation."
msgstr ""
":keyword:`import` 陳述式結合了兩個操作：首先搜尋指定的模組，然後將搜尋結果繫"
"結到本地作用域中的一個名稱。:keyword:`!import` 陳述式的搜尋操作被定義為一個"
"對 :func:`__import__` 函式的呼叫，並帶有相應的引數。:func:`__import__` 的回傳"
"值用於執行 :keyword:`!import` 陳述式的名稱繫結操作。有關名稱繫結操作的詳細資"
"訊，請參見 :keyword:`!import` 陳述式。"

#: ../../reference/import.rst:25
msgid ""
"A direct call to :func:`__import__` performs only the module search and, if "
"found, the module creation operation.  While certain side-effects may occur, "
"such as the importing of parent packages, and the updating of various caches "
"(including :data:`sys.modules`), only the :keyword:`import` statement "
"performs a name binding operation."
msgstr ""
"直接呼叫 :func:`__import__` 只會執行模組搜尋操作，以及在找到時執行模組的建立"
"操作。雖然某些副作用可能會發生，例如引入父套件 (parent package)，以及更新各種"
"快取（包括 :data:`sys.modules`），但只有 :keyword:`import` 陳述式會執行名稱繫"
"結操作。"

#: ../../reference/import.rst:31
msgid ""
"When an :keyword:`import` statement is executed, the standard builtin :func:"
"`__import__` function is called. Other mechanisms for invoking the import "
"system (such as :func:`importlib.import_module`) may choose to bypass :func:"
"`__import__` and use their own solutions to implement import semantics."
msgstr ""
"當執行 :keyword:`import` 陳述式時，會呼叫內建的 :func:`__import__` 函式。其他"
"調用引入系統的機制（如 :func:`importlib.import_module`）可以選擇略過 :func:"
"`__import__`，並使用它們自己的解決方案來實作引入語意。"

#: ../../reference/import.rst:36
msgid ""
"When a module is first imported, Python searches for the module and if "
"found, it creates a module object [#fnmo]_, initializing it.  If the named "
"module cannot be found, a :exc:`ModuleNotFoundError` is raised.  Python "
"implements various strategies to search for the named module when the import "
"machinery is invoked.  These strategies can be modified and extended by "
"using various hooks described in the sections below."
msgstr ""
"當模組首次被引入時，Python 會搜尋該模組，若找到則會建立一個模組物件 "
"[#fnmo]_，並對其進行初始化。如果找不到指定的模組，則會引發 :exc:"
"`ModuleNotFoundError`。當引入機制被調用時，Python 會實作各種策略來搜尋指定的"
"模組。這些策略可以透過使用以下章節描述的各種 hook（掛鉤）來修改和擴展。"

#: ../../reference/import.rst:43
msgid ""
"The import system has been updated to fully implement the second phase of :"
"pep:`302`. There is no longer any implicit import machinery - the full "
"import system is exposed through :data:`sys.meta_path`. In addition, native "
"namespace package support has been implemented (see :pep:`420`)."
msgstr ""
"引入系統已被更新，以完全實作 :pep:`302` 的第二階段。不再有隱式引入機制——完整"
"的引入系統已透過 :data:`sys.meta_path` 公開。此外，原生命名空間套件支援（請參"
"閱 :pep:`420`）也已被實作。"

#: ../../reference/import.rst:51
msgid ":mod:`importlib`"
msgstr ":mod:`importlib`"

#: ../../reference/import.rst:53
msgid ""
"The :mod:`importlib` module provides a rich API for interacting with the "
"import system.  For example :func:`importlib.import_module` provides a "
"recommended, simpler API than built-in :func:`__import__` for invoking the "
"import machinery.  Refer to the :mod:`importlib` library documentation for "
"additional detail."
msgstr ""
":mod:`importlib` 模組提供了豐富的 API 來與引入系統互動。例如，:func:"
"`importlib.import_module` 提供了一個比內建的 :func:`__import__` 更推薦且更簡"
"單的 API 來調用引入機制。更多詳細資訊請參閱 :mod:`importlib` 函式庫文件。"

#: ../../reference/import.rst:62
msgid "Packages"
msgstr "套件"

#: ../../reference/import.rst:67
msgid ""
"Python has only one type of module object, and all modules are of this type, "
"regardless of whether the module is implemented in Python, C, or something "
"else.  To help organize modules and provide a naming hierarchy, Python has a "
"concept of :term:`packages <package>`."
msgstr ""
"Python 只有一種類型的模組物件，且所有模組，無論其是使用 Python、C 還是其他語"
"言實作，都是這種類型。為了幫助組織模組並提供命名階層，Python 導入了\\ :term:`"
"套件 <package>`\\ 的概念。"

#: ../../reference/import.rst:72
msgid ""
"You can think of packages as the directories on a file system and modules as "
"files within directories, but don't take this analogy too literally since "
"packages and modules need not originate from the file system.  For the "
"purposes of this documentation, we'll use this convenient analogy of "
"directories and files.  Like file system directories, packages are organized "
"hierarchically, and packages may themselves contain subpackages, as well as "
"regular modules."
msgstr ""
"你可以將套件視為檔案系統中的目錄，模組則是目錄中的檔案，但不要過於字面地理解"
"這個比喻，因為套件和模組不一定來自檔案系統。為了方便解釋，我們將使用這個目錄"
"和檔案的比喻。就像檔案系統目錄一樣，套件是分層組織的，套件本身可以包含子套件"
"以及一般模組。"

#: ../../reference/import.rst:80
msgid ""
"It's important to keep in mind that all packages are modules, but not all "
"modules are packages.  Or put another way, packages are just a special kind "
"of module.  Specifically, any module that contains a ``__path__`` attribute "
"is considered a package."
msgstr ""
"請記住，所有的套件都是模組，但並非所有模組都是套件。換句話說，套件只是一種特"
"殊的模組。具體來說，任何包含 ``__path__`` 屬性的模組都被視為套件。"

#: ../../reference/import.rst:85
msgid ""
"All modules have a name.  Subpackage names are separated from their parent "
"package name by a dot, akin to Python's standard attribute access syntax.  "
"Thus you might have a package called :mod:`email`, which in turn has a "
"subpackage called :mod:`email.mime` and a module within that subpackage "
"called :mod:`email.mime.text`."
msgstr ""
"所有模組都有一個名稱。子套件的名稱與其父套件名稱之間用一個點來分隔，類似於 "
"Python 的標準屬性存取語法。因此，你可能會有一個名為 :mod:`email` 的套件，該套"
"件又有一個名為 :mod:`email.mime` 的子套件，並且該子套件中有一個名為 :mod:"
"`email.mime.text` 的模組。"

#: ../../reference/import.rst:93
msgid "Regular packages"
msgstr "一般套件"

#: ../../reference/import.rst:98
msgid ""
"Python defines two types of packages, :term:`regular packages <regular "
"package>` and :term:`namespace packages <namespace package>`.  Regular "
"packages are traditional packages as they existed in Python 3.2 and earlier. "
"A regular package is typically implemented as a directory containing an "
"``__init__.py`` file.  When a regular package is imported, this ``__init__."
"py`` file is implicitly executed, and the objects it defines are bound to "
"names in the package's namespace.  The ``__init__.py`` file can contain the "
"same Python code that any other module can contain, and Python will add some "
"additional attributes to the module when it is imported."
msgstr ""
"Python 定義了兩種類型的套件，:term:`一般套件 <regular package>`\\ 和\\ :term:"
"`命名空間套件 <namespace package>`。一般套件是 Python 3.2 及更早版本中存在的"
"傳統套件。一般套件通常實作成一個包含 ``__init__.py`` 檔案的目錄。當引入一般套"
"件時，該 ``__init__.py`` 檔案會被隱式執行，其定義的物件會繫結到該套件的命名空"
"間中的名稱。``__init__.py`` 檔案可以包含與任何其他模組相同的 Python 程式碼，"
"並且 Python 會在引入時為該模組增加一些額外的屬性。"

#: ../../reference/import.rst:108
msgid ""
"For example, the following file system layout defines a top level ``parent`` "
"package with three subpackages::"
msgstr ""
"例如，以下檔案系統布置定義了一個頂層的 ``parent`` 套件，該套件包含三個子套"
"件： ::"

#: ../../reference/import.rst:111
msgid ""
"parent/\n"
"    __init__.py\n"
"    one/\n"
"        __init__.py\n"
"    two/\n"
"        __init__.py\n"
"    three/\n"
"        __init__.py"
msgstr ""
"parent/\n"
"    __init__.py\n"
"    one/\n"
"        __init__.py\n"
"    two/\n"
"        __init__.py\n"
"    three/\n"
"        __init__.py"

#: ../../reference/import.rst:120
msgid ""
"Importing ``parent.one`` will implicitly execute ``parent/__init__.py`` and "
"``parent/one/__init__.py``.  Subsequent imports of ``parent.two`` or "
"``parent.three`` will execute ``parent/two/__init__.py`` and ``parent/three/"
"__init__.py`` respectively."
msgstr ""
"引入 ``parent.one`` 將隱式執行 ``parent/__init__.py`` 和 ``parent/one/"
"__init__.py``。隨後引入 ``parent.two`` 或 ``parent.three`` 將分別執行 "
"``parent/two/__init__.py`` 和 ``parent/three/__init__.py``。"

#: ../../reference/import.rst:127
msgid "Namespace packages"
msgstr "命名空間套件"

#: ../../reference/import.rst:133
msgid ""
"A namespace package is a composite of various :term:`portions <portion>`, "
"where each portion contributes a subpackage to the parent package.  Portions "
"may reside in different locations on the file system.  Portions may also be "
"found in zip files, on the network, or anywhere else that Python searches "
"during import.  Namespace packages may or may not correspond directly to "
"objects on the file system; they may be virtual modules that have no "
"concrete representation."
msgstr ""
"命名空間套件是由不同的\\ :term:`部分 <portion>` 組成的，每個部分都為父套件提"
"供一個子套件。這些部分可以位於檔案系統上的不同位置。部分可能也存在於壓縮檔案"
"中、網路上，或 Python 在引入時搜尋的任何其他地方。命名空間套件不一定直接對應"
"於檔案系統中的對象；它們可能是沒有具體表示的虛擬模組。"

#: ../../reference/import.rst:141
msgid ""
"Namespace packages do not use an ordinary list for their ``__path__`` "
"attribute. They instead use a custom iterable type which will automatically "
"perform a new search for package portions on the next import attempt within "
"that package if the path of their parent package (or :data:`sys.path` for a "
"top level package) changes."
msgstr ""
"命名空間套件的 ``__path__`` 屬性不使用普通的串列。它們使用自定義的可疊代型"
"別，當父套件的路徑（或頂層套件的 :data:`sys.path`）發生變化時，會在下一次引入"
"嘗試時自動執行新一輪的套件部分搜尋。"

#: ../../reference/import.rst:147
msgid ""
"With namespace packages, there is no ``parent/__init__.py`` file.  In fact, "
"there may be multiple ``parent`` directories found during import search, "
"where each one is provided by a different portion.  Thus ``parent/one`` may "
"not be physically located next to ``parent/two``.  In this case, Python will "
"create a namespace package for the top-level ``parent`` package whenever it "
"or one of its subpackages is imported."
msgstr ""
"在命名空間套件中，不存在 ``parent/__init__.py`` 檔案。實際上，在引入搜尋過程"
"中可能會找到多個 ``parent`` 目錄，每個目錄由不同的部分提供。因此，``parent/"
"one`` 可能與 ``parent/two`` 不會實際位於一起。在這種情況下，每當引入頂層 "
"``parent`` 套件或其子套件之一時，Python 會為頂層 ``parent`` 套件建立一個命名"
"空間套件。"

#: ../../reference/import.rst:154
msgid "See also :pep:`420` for the namespace package specification."
msgstr "有關命名空間套件的規範，請參見 :pep:`420`。"

#: ../../reference/import.rst:158
msgid "Searching"
msgstr "搜尋"

#: ../../reference/import.rst:160
msgid ""
"To begin the search, Python needs the :term:`fully qualified <qualified "
"name>` name of the module (or package, but for the purposes of this "
"discussion, the difference is immaterial) being imported.  This name may "
"come from various arguments to the :keyword:`import` statement, or from the "
"parameters to the :func:`importlib.import_module` or :func:`__import__` "
"functions."
msgstr ""
"在開始搜尋之前，Python 需要被引入模組（或套件，但在本討論中，兩者的區別無關緊"
"要）的完整\\ :term:`限定名稱 (qualified name) <qualified name>`。此名稱可能來"
"自 :keyword:`import` 陳述式的各種引數，或來自 :func:`importlib."
"import_module` 或 :func:`__import__` 函式的參數。"

#: ../../reference/import.rst:166
msgid ""
"This name will be used in various phases of the import search, and it may be "
"the dotted path to a submodule, e.g. ``foo.bar.baz``.  In this case, Python "
"first tries to import ``foo``, then ``foo.bar``, and finally ``foo.bar."
"baz``. If any of the intermediate imports fail, a :exc:`ModuleNotFoundError` "
"is raised."
msgstr ""
"此名稱將在引入搜尋的各個階段中使用，並且它可能是指向子模組的點分隔路徑，例如 "
"``foo.bar.baz``。在這種情況下，Python 會首先嘗試引入 ``foo``，然後是 ``foo."
"bar``，最後是 ``foo.bar.baz``。如果任何中間引入失敗，則會引發 :exc:"
"`ModuleNotFoundError`。"

#: ../../reference/import.rst:173
msgid "The module cache"
msgstr "模組快取"

#: ../../reference/import.rst:178
msgid ""
"The first place checked during import search is :data:`sys.modules`.  This "
"mapping serves as a cache of all modules that have been previously imported, "
"including the intermediate paths.  So if ``foo.bar.baz`` was previously "
"imported, :data:`sys.modules` will contain entries for ``foo``, ``foo.bar``, "
"and ``foo.bar.baz``.  Each key will have as its value the corresponding "
"module object."
msgstr ""
"在引入搜尋過程中首先檢查的地方是 :data:`sys.modules`。此對映用作所有先前引入"
"過的模組的快取，包括中間路徑。因此，如果 ``foo.bar.baz`` 之前已被引入，:data:"
"`sys.modules` 將包含 ``foo``、``foo.bar`` 和 ``foo.bar.baz`` 的條目。每個鍵的"
"值都是相應的模組物件。"

#: ../../reference/import.rst:185
msgid ""
"During import, the module name is looked up in :data:`sys.modules` and if "
"present, the associated value is the module satisfying the import, and the "
"process completes.  However, if the value is ``None``, then a :exc:"
"`ModuleNotFoundError` is raised.  If the module name is missing, Python will "
"continue searching for the module."
msgstr ""
"在引入過程中，會在 :data:`sys.modules` 中查找模組名稱，如果存在，則相關的值為"
"滿足此引入的模組，此引入過程即完成。然而，如果值是 ``None``，則會引發 :exc:"
"`ModuleNotFoundError`。如果模組名稱不存在，Python 會繼續搜尋該模組。"

#: ../../reference/import.rst:191
msgid ""
":data:`sys.modules` is writable.  Deleting a key may not destroy the "
"associated module (as other modules may hold references to it), but it will "
"invalidate the cache entry for the named module, causing Python to search "
"anew for the named module upon its next import. The key can also be assigned "
"to ``None``, forcing the next import of the module to result in a :exc:"
"`ModuleNotFoundError`."
msgstr ""
":data:`sys.modules` 是可寫入的。刪除一個鍵可能不會銷毀相關聯的模組（因為其他"
"模組可能持有對它的參照），但會使指定的模組的快取條目失效，導致 Python 在下一"
"次引入該模組時重新搜尋。也可以將鍵賦值為 ``None``，這會強制下一次引入該模組時"
"引發 :exc:`ModuleNotFoundError`。"

#: ../../reference/import.rst:198
msgid ""
"Beware though, as if you keep a reference to the module object, invalidate "
"its cache entry in :data:`sys.modules`, and then re-import the named module, "
"the two module objects will *not* be the same. By contrast, :func:`importlib."
"reload` will reuse the *same* module object, and simply reinitialise the "
"module contents by rerunning the module's code."
msgstr ""
"但請注意，如果你保留了對模組物件的參照，並在 :data:`sys.modules` 中使其快取條"
"目失效，然後重新引入指定的模組，這兩個模組物件將\\ *不會*\\ 相同。相比之下，:"
"func:`importlib.reload` 會重用\\ *相同的*\\ 模組物件，並透過重新執行模組的程"
"式碼來簡單地重新初始化模組內容。"

#: ../../reference/import.rst:208
msgid "Finders and loaders"
msgstr "尋檢器 (Finder) 與載入器 (Loader)"

#: ../../reference/import.rst:215
msgid ""
"If the named module is not found in :data:`sys.modules`, then Python's "
"import protocol is invoked to find and load the module.  This protocol "
"consists of two conceptual objects, :term:`finders <finder>` and :term:"
"`loaders <loader>`. A finder's job is to determine whether it can find the "
"named module using whatever strategy it knows about. Objects that implement "
"both of these interfaces are referred to as :term:`importers <importer>` - "
"they return themselves when they find that they can load the requested "
"module."
msgstr ""
"如果在 :data:`sys.modules` 中找不到指定的模組，則會調用 Python 的引入協定來尋"
"找並載入該模組。這個協定由兩個概念性物件組成，:term:`尋檢器 <finder>` 和\\ :"
"term:`載入器 <loader>`。尋檢器的任務是使用其已知的策略來確定是否能找到命名模"
"組。實作這兩個介面的物件稱為\\ :term:`引入器 (importer) <importer>` ——當它們"
"發現可以載入所請求的模組時，會回傳它們自己。"

#: ../../reference/import.rst:223
msgid ""
"Python includes a number of default finders and importers.  The first one "
"knows how to locate built-in modules, and the second knows how to locate "
"frozen modules.  A third default finder searches an :term:`import path` for "
"modules.  The :term:`import path` is a list of locations that may name file "
"system paths or zip files.  It can also be extended to search for any "
"locatable resource, such as those identified by URLs."
msgstr ""
"Python 包含多個預設的尋檢器和引入器。第一個尋檢器知道如何定位內建模組，第二個"
"尋檢器知道如何定位凍結模組。第三個預設尋檢器會在 :term:`import path` 中搜尋模"
"組。:term:`import path` 是一個位置的列表，這些位置可能是檔案系統路徑或壓縮檔"
"案，也可以擴展以搜尋任何可定位的資源，例如由 URL 識別的資源。"

#: ../../reference/import.rst:230
msgid ""
"The import machinery is extensible, so new finders can be added to extend "
"the range and scope of module searching."
msgstr ""
"引入機制是可擴展的，因此可以增加新的尋檢器來擴展模組搜尋的範圍和作用域。"

#: ../../reference/import.rst:233
msgid ""
"Finders do not actually load modules.  If they can find the named module, "
"they return a :dfn:`module spec`, an encapsulation of the module's import-"
"related information, which the import machinery then uses when loading the "
"module."
msgstr ""
"尋檢器實際上不會載入模組。如果它們能找到指定的模組，它們會回傳一個\\ :dfn:`模"
"組規格`，這是一個模組的引入相關資訊的封裝，引入機制會在載入模組時使用這些資"
"訊。"

#: ../../reference/import.rst:237
msgid ""
"The following sections describe the protocol for finders and loaders in more "
"detail, including how you can create and register new ones to extend the "
"import machinery."
msgstr ""
"以下各節將更詳細地描述尋檢器和載入器的協定，包括如何建立和註冊新的尋檢器和載"
"入器來擴展引入機制。"

#: ../../reference/import.rst:241
msgid ""
"In previous versions of Python, finders returned :term:`loaders <loader>` "
"directly, whereas now they return module specs which *contain* loaders. "
"Loaders are still used during import but have fewer responsibilities."
msgstr ""
"Python 在之前的版本中，尋檢器會直接回傳\\ :term:`載入器 <loader>`，而現在它們"
"回傳的是\\ *包含*\\ 載入器的模組規格。載入器仍在引入過程中使用，但其責任減少"
"了。"

#: ../../reference/import.rst:247
msgid "Import hooks"
msgstr "引入掛鉤 (Import hooks)"

#: ../../reference/import.rst:257
msgid ""
"The import machinery is designed to be extensible; the primary mechanism for "
"this are the *import hooks*.  There are two types of import hooks: *meta "
"hooks* and *import path hooks*."
msgstr ""
"引入機制的設計是可擴展的；其主要機制是\\ *引入掛鉤*。引入掛鉤有兩種類型：*元"
"掛鉤 (meta hooks)* 和\\ *引入路徑掛鉤*。"

#: ../../reference/import.rst:261
msgid ""
"Meta hooks are called at the start of import processing, before any other "
"import processing has occurred, other than :data:`sys.modules` cache look "
"up. This allows meta hooks to override :data:`sys.path` processing, frozen "
"modules, or even built-in modules.  Meta hooks are registered by adding new "
"finder objects to :data:`sys.meta_path`, as described below."
msgstr ""
"元掛鉤會在引入處理的開始階段被呼叫，除了查找 :data:`sys.modules` 快取外，其他"
"引入處理還未發生時就會呼叫。這允許元掛鉤覆蓋 :data:`sys.path` 的處理、凍結模"
"組，甚至是內建模組。元掛鉤透過將新的尋檢器物件添加到 :data:`sys.meta_path` 中"
"來註冊，具體描述請參閱以下段落。"

#: ../../reference/import.rst:267
msgid ""
"Import path hooks are called as part of :data:`sys.path` (or ``package."
"__path__``) processing, at the point where their associated path item is "
"encountered.  Import path hooks are registered by adding new callables to :"
"data:`sys.path_hooks` as described below."
msgstr ""
"引入路徑掛鉤被視為 :data:`sys.path`\\ （或 ``package.__path__``）處理過程的一"
"部分來呼叫，當遇到與其相關聯的路徑項目時就會被觸發。引入路徑掛鉤透過將新的可"
"呼叫對象增加到 :data:`sys.path_hooks` 中來註冊，具體描述請參閱以下段落。"

#: ../../reference/import.rst:274
msgid "The meta path"
msgstr "元路徑"

#: ../../reference/import.rst:280
msgid ""
"When the named module is not found in :data:`sys.modules`, Python next "
"searches :data:`sys.meta_path`, which contains a list of meta path finder "
"objects.  These finders are queried in order to see if they know how to "
"handle the named module.  Meta path finders must implement a method called :"
"meth:`~importlib.abc.MetaPathFinder.find_spec` which takes three arguments: "
"a name, an import path, and (optionally) a target module.  The meta path "
"finder can use any strategy it wants to determine whether it can handle the "
"named module or not."
msgstr ""
"當在 :data:`sys.modules` 中找不到命名模組時，Python 接下來會搜尋 :data:`sys."
"meta_path`，其中包含一個元路徑尋檢器物件串列。這些尋檢器會依次被查詢，看它們"
"是否知道如何處理命名模組。元路徑尋檢器必須實作一個名為 :meth:`~importlib.abc."
"MetaPathFinder.find_spec` 的方法，該方法接收三個引數：名稱、引入路徑和（可選"
"的）目標模組。元路徑尋檢器可以使用任何策略來確定它是否能處理命名模組。"

#: ../../reference/import.rst:289
msgid ""
"If the meta path finder knows how to handle the named module, it returns a "
"spec object.  If it cannot handle the named module, it returns ``None``.  "
"If :data:`sys.meta_path` processing reaches the end of its list without "
"returning a spec, then a :exc:`ModuleNotFoundError` is raised.  Any other "
"exceptions raised are simply propagated up, aborting the import process."
msgstr ""
"如果元路徑尋檢器知道如何處理命名模組，它會回傳一個規格物件。如果它無法處理命"
"名模組，則回傳 ``None``。如果 :data:`sys.meta_path` 的處理到達串列的末尾仍未"
"回傳規格，則會引發 :exc:`ModuleNotFoundError`。任何其他引發的例外將直接向上傳"
"播，並中止引入過程。"

#: ../../reference/import.rst:295
msgid ""
"The :meth:`~importlib.abc.MetaPathFinder.find_spec` method of meta path "
"finders is called with two or three arguments.  The first is the fully "
"qualified name of the module being imported, for example ``foo.bar.baz``. "
"The second argument is the path entries to use for the module search.  For "
"top-level modules, the second argument is ``None``, but for submodules or "
"subpackages, the second argument is the value of the parent package's "
"``__path__`` attribute. If the appropriate ``__path__`` attribute cannot be "
"accessed, a :exc:`ModuleNotFoundError` is raised.  The third argument is an "
"existing module object that will be the target of loading later. The import "
"system passes in a target module only during reload."
msgstr ""
"元路徑尋檢器的 :meth:`~importlib.abc.MetaPathFinder.find_spec` 方法會以兩個或"
"三個引數來呼叫。第一個是被引入模組的完全限定名稱，例如 ``foo.bar.baz``。第二"
"個引數是用於模組搜尋的路徑條目。對於頂層模組，第二個引數是 ``None``，但對於子"
"模組或子套件，第二個引數是父套件的 ``__path__`` 屬性的值。如果無法存取相應的 "
"``__path__`` 屬性，將引發 :exc:`ModuleNotFoundError`。第三個引數是一個現有的"
"模組物件，該物件將成為後續載入的目標。引入系統只會在重新載入時傳入目標模組。"

#: ../../reference/import.rst:306
msgid ""
"The meta path may be traversed multiple times for a single import request. "
"For example, assuming none of the modules involved has already been cached, "
"importing ``foo.bar.baz`` will first perform a top level import, calling "
"``mpf.find_spec(\"foo\", None, None)`` on each meta path finder (``mpf``). "
"After ``foo`` has been imported, ``foo.bar`` will be imported by traversing "
"the meta path a second time, calling ``mpf.find_spec(\"foo.bar\", foo."
"__path__, None)``. Once ``foo.bar`` has been imported, the final traversal "
"will call ``mpf.find_spec(\"foo.bar.baz\", foo.bar.__path__, None)``."
msgstr ""
"對於一個引入請求，元路徑可能會被遍歷多次。例如，假設參與的模組都沒有被快取，"
"則引入 ``foo.bar.baz`` 將首先執行頂層引入，對每個元路徑尋檢器（``mpf``）呼叫 "
"``mpf.find_spec(\"foo\", None, None)``。當 ``foo`` 被引入後，將再次藉由遍歷元"
"路徑引入 ``foo.bar``，並呼叫 ``mpf.find_spec(\"foo.bar\", foo.__path__, "
"None)``。當 ``foo.bar`` 被引入後，最後一次遍歷會呼叫 ``mpf.find_spec(\"foo."
"bar.baz\", foo.bar.__path__, None)``。"

#: ../../reference/import.rst:316
msgid ""
"Some meta path finders only support top level imports. These importers will "
"always return ``None`` when anything other than ``None`` is passed as the "
"second argument."
msgstr ""
"一些元路徑尋檢器僅支援頂層引入。當第二個引數傳入 ``None`` 以外的值時，這些引"
"入器將始終回傳 ``None``。"

#: ../../reference/import.rst:320
msgid ""
"Python's default :data:`sys.meta_path` has three meta path finders, one that "
"knows how to import built-in modules, one that knows how to import frozen "
"modules, and one that knows how to import modules from an :term:`import "
"path` (i.e. the :term:`path based finder`)."
msgstr ""
"Python 的預設 :data:`sys.meta_path` 有三個元路徑尋檢器，一個知道如何引入內建"
"模組，一個知道如何引入凍結模組，還有一個知道如何從 :term:`import path` 引入模"
"組（即 :term:`path based finder`）。"

#: ../../reference/import.rst:325
msgid ""
"The :meth:`~importlib.abc.MetaPathFinder.find_spec` method of meta path "
"finders replaced :meth:`!find_module`, which is now deprecated.  While it "
"will continue to work without change, the import machinery will try it only "
"if the finder does not implement :meth:`~importlib.abc.MetaPathFinder."
"find_spec`."
msgstr ""
"元路徑尋檢器的 :meth:`~importlib.abc.MetaPathFinder.find_spec` 方法取代了 :"
"meth:`!find_module`，後者現在已被棄用。雖然它將繼續正常工作，但引入機制僅在尋"
"檢器未實作 :meth:`~importlib.abc.MetaPathFinder.find_spec` 時才會嘗試使用它。"

#: ../../reference/import.rst:332
msgid ""
"Use of :meth:`!find_module` by the import system now raises :exc:"
"`ImportWarning`."
msgstr "引入系統現在使用 :meth:`!find_module` 時將引發 :exc:`ImportWarning`。"

#: ../../reference/import.rst:336
msgid ""
":meth:`!find_module` has been removed. Use :meth:`~importlib.abc."
"MetaPathFinder.find_spec` instead."
msgstr ""
":meth:`!find_module` 已被移除。請改用 :meth:`~importlib.abc.MetaPathFinder."
"find_spec`。"

#: ../../reference/import.rst:342
msgid "Loading"
msgstr "載入"

#: ../../reference/import.rst:344
msgid ""
"If and when a module spec is found, the import machinery will use it (and "
"the loader it contains) when loading the module.  Here is an approximation "
"of what happens during the loading portion of import::"
msgstr ""
"如果找到模組規格，引入機制會在載入模組時使用該規格（以及它包含的載入器）。以"
"下是引入過程中載入部分的大致情況： ::"

#: ../../reference/import.rst:348
msgid ""
"module = None\n"
"if spec.loader is not None and hasattr(spec.loader, 'create_module'):\n"
"    # It is assumed 'exec_module' will also be defined on the loader.\n"
"    module = spec.loader.create_module(spec)\n"
"if module is None:\n"
"    module = ModuleType(spec.name)\n"
"# The import-related module attributes get set here:\n"
"_init_module_attrs(spec, module)\n"
"\n"
"if spec.loader is None:\n"
"    # unsupported\n"
"    raise ImportError\n"
"if spec.origin is None and spec.submodule_search_locations is not None:\n"
"    # namespace package\n"
"    sys.modules[spec.name] = module\n"
"elif not hasattr(spec.loader, 'exec_module'):\n"
"    module = spec.loader.load_module(spec.name)\n"
"else:\n"
"    sys.modules[spec.name] = module\n"
"    try:\n"
"        spec.loader.exec_module(module)\n"
"    except BaseException:\n"
"        try:\n"
"            del sys.modules[spec.name]\n"
"        except KeyError:\n"
"            pass\n"
"        raise\n"
"return sys.modules[spec.name]"
msgstr ""
"module = None\n"
"if spec.loader is not None and hasattr(spec.loader, 'create_module'):\n"
"    # 這裡假設載入器上也會定義 'exec_module'\n"
"    module = spec.loader.create_module(spec)\n"
"if module is None:\n"
"    module = ModuleType(spec.name)\n"
"# 與引入相關的模組屬性會在此處設定：\n"
"_init_module_attrs(spec, module)\n"
"\n"
"if spec.loader is None:\n"
"    # 不支援\n"
"    raise ImportError\n"
"if spec.origin is None and spec.submodule_search_locations is not None:\n"
"    # 命名空間套件\n"
"    sys.modules[spec.name] = module\n"
"elif not hasattr(spec.loader, 'exec_module'):\n"
"    module = spec.loader.load_module(spec.name)\n"
"else:\n"
"    sys.modules[spec.name] = module\n"
"    try:\n"
"        spec.loader.exec_module(module)\n"
"    except BaseException:\n"
"        try:\n"
"            del sys.modules[spec.name]\n"
"        except KeyError:\n"
"            pass\n"
"        raise\n"
"return sys.modules[spec.name]"

#: ../../reference/import.rst:377
msgid "Note the following details:"
msgstr "請注意下列細節："

#: ../../reference/import.rst:379
msgid ""
"If there is an existing module object with the given name in :data:`sys."
"modules`, import will have already returned it."
msgstr ""
"如果 :data:`sys.modules` 中已存在具有給定名稱的模組物件，引入會已回傳該物件。"

#: ../../reference/import.rst:382
msgid ""
"The module will exist in :data:`sys.modules` before the loader executes the "
"module code.  This is crucial because the module code may (directly or "
"indirectly) import itself; adding it to :data:`sys.modules` beforehand "
"prevents unbounded recursion in the worst case and multiple loading in the "
"best."
msgstr ""
"在載入器執行模組程式碼之前，模組將已存在於 :data:`sys.modules` 中。這一點至關"
"重要，因為模組程式碼可能會（直接或間接）引入自己；事先將其增加到 :data:`sys."
"modules` 可以預防類似無限遞迴以及多次重覆載入等情形。"

#: ../../reference/import.rst:388
msgid ""
"If loading fails, the failing module -- and only the failing module -- gets "
"removed from :data:`sys.modules`.  Any module already in the :data:`sys."
"modules` cache, and any module that was successfully loaded as a side-"
"effect, must remain in the cache.  This contrasts with reloading where even "
"the failing module is left in :data:`sys.modules`."
msgstr ""
"如果載入失敗，只有載入失敗的模組會從 :data:`sys.modules` 中刪除。任何已存在"
"於 :data:`sys.modules` 快取中的模組，以及任何在載入失敗前成功載入的模組，都必"
"須保留在快取中。此情形與重新載入不同，在重新載入時，即使載入失敗的模組也會保"
"留在 :data:`sys.modules` 中。"

#: ../../reference/import.rst:394
msgid ""
"After the module is created but before execution, the import machinery sets "
"the import-related module attributes (\"_init_module_attrs\" in the pseudo-"
"code example above), as summarized in a :ref:`later section <import-mod-"
"attrs>`."
msgstr ""
"模組建立後、在執行之前，引入機制會設置與引入相關的模組屬性（在上面的偽程式碼"
"範例中為 \"_init_module_attrs\"），具體內容在\\ :ref:`之後的段落<import-mod-"
"attrs>`\\ 會總結。"

#: ../../reference/import.rst:399
msgid ""
"Module execution is the key moment of loading in which the module's "
"namespace gets populated.  Execution is entirely delegated to the loader, "
"which gets to decide what gets populated and how."
msgstr ""
"模組執行是載入過程中的關鍵時刻，此時模組的命名空間會被新增名稱。執行過程完全"
"交由載入器處理，由其決定如何新增以及新增什麼。"

#: ../../reference/import.rst:403
msgid ""
"The module created during loading and passed to exec_module() may not be the "
"one returned at the end of import [#fnlo]_."
msgstr ""
"在載入過程中建立並傳遞給 exec_module() 的模組，可能不會是引入結束時回傳的模"
"組 [#fnlo]_。"

#: ../../reference/import.rst:406
msgid ""
"The import system has taken over the boilerplate responsibilities of "
"loaders.  These were previously performed by the :meth:`importlib.abc.Loader."
"load_module` method."
msgstr ""
"引入系統已接管載入器的模板 (boilerplate) 責任。之前是由 :meth:`importlib.abc."
"Loader.load_module` 方法執行的。"

#: ../../reference/import.rst:412
msgid "Loaders"
msgstr "載入器"

#: ../../reference/import.rst:414
msgid ""
"Module loaders provide the critical function of loading: module execution. "
"The import machinery calls the :meth:`importlib.abc.Loader.exec_module` "
"method with a single argument, the module object to execute.  Any value "
"returned from :meth:`~importlib.abc.Loader.exec_module` is ignored."
msgstr ""
"模組載入器提供了載入的關鍵功能：模組執行。引入機制會以單一引數（即要執行的模"
"組物件）呼叫 :meth:`importlib.abc.Loader.exec_module` 方法。任何從 :meth:"
"`~importlib.abc.Loader.exec_module` 回傳的值都會被忽略。"

#: ../../reference/import.rst:419
msgid "Loaders must satisfy the following requirements:"
msgstr "載入器必須滿足以下要求："

#: ../../reference/import.rst:421
msgid ""
"If the module is a Python module (as opposed to a built-in module or a "
"dynamically loaded extension), the loader should execute the module's code "
"in the module's global name space (``module.__dict__``)."
msgstr ""
"如果模組是 Python 模組（而非內建模組或動態載入的擴充），載入器應在模組的全域"
"命名空間 (``module.__dict__``\\ ) 中執行該模組的程式碼。"

#: ../../reference/import.rst:425
msgid ""
"If the loader cannot execute the module, it should raise an :exc:"
"`ImportError`, although any other exception raised during :meth:`~importlib."
"abc.Loader.exec_module` will be propagated."
msgstr ""
"如果載入器無法執行該模組，應引發 :exc:`ImportError`。不過，在 :meth:"
"`~importlib.abc.Loader.exec_module` 中引發的任何其他例外也會被傳播。"

#: ../../reference/import.rst:429
msgid ""
"In many cases, the finder and loader can be the same object; in such cases "
"the :meth:`~importlib.abc.MetaPathFinder.find_spec` method would just return "
"a spec with the loader set to ``self``."
msgstr ""
"在許多情況下，尋檢器和載入器可以是同一個物件；在這種情況下，:meth:"
"`~importlib.abc.MetaPathFinder.find_spec` 方法只需回傳一個載入器設為 "
"``self`` 的規格即可。"

#: ../../reference/import.rst:433
msgid ""
"Module loaders may opt in to creating the module object during loading by "
"implementing a :meth:`~importlib.abc.Loader.create_module` method. It takes "
"one argument, the module spec, and returns the new module object to use "
"during loading.  ``create_module()`` does not need to set any attributes on "
"the module object.  If the method returns ``None``, the import machinery "
"will create the new module itself."
msgstr ""
"模組載入器可以選擇透過實作 :meth:`~importlib.abc.Loader.create_module` 方法，"
"在載入過程中建立模組物件。該方法接受一個引數，即模組規格，並回傳在載入過程中"
"要使用的新的模組物件。``create_module()`` 不需要在模組物件上設定任何屬性。如"
"果該方法回傳 ``None``，引入機制將自行建立新的模組。"

#: ../../reference/import.rst:440
msgid "The :meth:`~importlib.abc.Loader.create_module` method of loaders."
msgstr "載入器的 :meth:`~importlib.abc.Loader.create_module` 方法。"

#: ../../reference/import.rst:443
msgid ""
"The :meth:`~importlib.abc.Loader.load_module` method was replaced by :meth:"
"`~importlib.abc.Loader.exec_module` and the import machinery assumed all the "
"boilerplate responsibilities of loading."
msgstr ""
":meth:`~importlib.abc.Loader.load_module` 方法已被 :meth:`~importlib.abc."
"Loader.exec_module` 取代，引入機制已承擔所有載入的模板責任。"

#: ../../reference/import.rst:448
msgid ""
"For compatibility with existing loaders, the import machinery will use the "
"``load_module()`` method of loaders if it exists and the loader does not "
"also implement ``exec_module()``.  However, ``load_module()`` has been "
"deprecated and loaders should implement ``exec_module()`` instead."
msgstr ""
"為了與現有的載入器相容，引入機制會在載入器未實作 ``exec_module()`` 且存在 "
"``load_module()`` 方法時使用該方法。然而，``load_module()`` 已被棄用，載入器"
"應改為實作 ``exec_module()``。"

#: ../../reference/import.rst:453
msgid ""
"The ``load_module()`` method must implement all the boilerplate loading "
"functionality described above in addition to executing the module.  All the "
"same constraints apply, with some additional clarification:"
msgstr ""
"``load_module()`` 方法除了執行模組外，還必須實作上述全部的模板載入功能。所有"
"相同的限制依然適用，並且還有一些額外的說明："

#: ../../reference/import.rst:457
msgid ""
"If there is an existing module object with the given name in :data:`sys."
"modules`, the loader must use that existing module. (Otherwise, :func:"
"`importlib.reload` will not work correctly.)  If the named module does not "
"exist in :data:`sys.modules`, the loader must create a new module object and "
"add it to :data:`sys.modules`."
msgstr ""
"如果 :data:`sys.modules` 中已存在具有給定名稱的模組物件，載入器必須使用該模組"
"（否則 :func:`importlib.reload` 將無法正常運作）。如果命名模組不存在於 :data:"
"`sys.modules` 中，載入器必須建立一個新的模組物件並將其新增至 :data:`sys."
"modules`。"

#: ../../reference/import.rst:463
msgid ""
"The module *must* exist in :data:`sys.modules` before the loader executes "
"the module code, to prevent unbounded recursion or multiple loading."
msgstr ""
"在載入器執行模組程式碼之前，該模組\\ *必須*\\ 已存在於 :data:`sys.modules` "
"中，以防止無限遞迴或多次載入。"

#: ../../reference/import.rst:467
msgid ""
"If loading fails, the loader must remove any modules it has inserted into :"
"data:`sys.modules`, but it must remove **only** the failing module(s), and "
"only if the loader itself has loaded the module(s) explicitly."
msgstr ""
"如果載入失敗，載入器必須移除已經插入到 :data:`sys.modules` 中的任何模組，但"
"\\ **只能**\\ 移除失敗的模組（們），且僅在載入器本身明確載入這些模組時才需移"
"除。"

#: ../../reference/import.rst:472
msgid ""
"A :exc:`DeprecationWarning` is raised when ``exec_module()`` is defined but "
"``create_module()`` is not."
msgstr ""
"當 ``exec_module()`` 已定義但未定義 ``create_module()`` 時，將引發 :exc:"
"`DeprecationWarning`。"

#: ../../reference/import.rst:476
msgid ""
"An :exc:`ImportError` is raised when ``exec_module()`` is defined but "
"``create_module()`` is not."
msgstr ""
"當 ``exec_module()`` 已定義但未定義 ``create_module()`` 時，將引發 :exc:"
"`ImportError`。"

#: ../../reference/import.rst:480
msgid "Use of ``load_module()`` will raise :exc:`ImportWarning`."
msgstr "使用 ``load_module()`` 將引發 :exc:`ImportWarning`。"

#: ../../reference/import.rst:484
msgid "Submodules"
msgstr "子模組"

#: ../../reference/import.rst:486
msgid ""
"When a submodule is loaded using any mechanism (e.g. ``importlib`` APIs, the "
"``import`` or ``import-from`` statements, or built-in ``__import__()``) a "
"binding is placed in the parent module's namespace to the submodule object. "
"For example, if package ``spam`` has a submodule ``foo``, after importing "
"``spam.foo``, ``spam`` will have an attribute ``foo`` which is bound to the "
"submodule.  Let's say you have the following directory structure::"
msgstr ""
"當使用任何機制（例如 ``importlib`` APIs、``import`` 或 ``import-from`` 陳述"
"式，或內建的 ``__import__()``\\ ）載入子模組時，會將子模組物件繫結到父模組的"
"命名空間中。例如，如果套件 ``spam`` 有一個子模組 ``foo``，則在引入 ``spam."
"foo`` 之後，``spam`` 將擁有一個名為 ``foo`` 的屬性，該屬性繫結到子模組。我們"
"假設你有以下的目錄結構： ::"

#: ../../reference/import.rst:493
msgid ""
"spam/\n"
"    __init__.py\n"
"    foo.py"
msgstr ""
"spam/\n"
"    __init__.py\n"
"    foo.py"

#: ../../reference/import.rst:497
msgid "and ``spam/__init__.py`` has the following line in it::"
msgstr "並且 ``spam/__init__.py`` 中包含以下程式碼： ::"

#: ../../reference/import.rst:499
msgid "from .foo import Foo"
msgstr "from .foo import Foo"

#: ../../reference/import.rst:501
msgid ""
"then executing the following puts name bindings for ``foo`` and ``Foo`` in "
"the ``spam`` module::"
msgstr ""
"那麼執行以下程式碼會將 ``foo`` 和 ``Foo`` 的名稱繫結到 ``spam`` 模組中： ::"

#: ../../reference/import.rst:504
msgid ""
">>> import spam\n"
">>> spam.foo\n"
"<module 'spam.foo' from '/tmp/imports/spam/foo.py'>\n"
">>> spam.Foo\n"
"<class 'spam.foo.Foo'>"
msgstr ""
">>> import spam\n"
">>> spam.foo\n"
"<module 'spam.foo' from '/tmp/imports/spam/foo.py'>\n"
">>> spam.Foo\n"
"<class 'spam.foo.Foo'>"

#: ../../reference/import.rst:510
msgid ""
"Given Python's familiar name binding rules this might seem surprising, but "
"it's actually a fundamental feature of the import system.  The invariant "
"holding is that if you have ``sys.modules['spam']`` and ``sys.modules['spam."
"foo']`` (as you would after the above import), the latter must appear as the "
"``foo`` attribute of the former."
msgstr ""
"鑑於 Python 相似的名稱繫結規則，這可能看起來有些出人意料，但這實際上是引入系"
"統的一個基本特性。不變的是如果你擁有 ``sys.modules['spam']`` 和 ``sys."
"modules['spam.foo']``\\ （就像上述引入後那樣），那麼後者必須作為前者的 "
"``foo`` 屬性出現。"

#: ../../reference/import.rst:519
msgid "Module specs"
msgstr "模組規格"

#: ../../reference/import.rst:521
msgid ""
"The import machinery uses a variety of information about each module during "
"import, especially before loading.  Most of the information is common to all "
"modules.  The purpose of a module's spec is to encapsulate this import-"
"related information on a per-module basis."
msgstr ""
"引入機制在引入過程中使用有關每個模組的各種資訊，尤其是在載入之前。大多數資訊"
"對所有模組來說都是通用的。模組規格的目的是以每個模組為基礎封裝這些與引入相關"
"的資訊。"

#: ../../reference/import.rst:526
msgid ""
"Using a spec during import allows state to be transferred between import "
"system components, e.g. between the finder that creates the module spec and "
"the loader that executes it.  Most importantly, it allows the import "
"machinery to perform the boilerplate operations of loading, whereas without "
"a module spec the loader had that responsibility."
msgstr ""
"在引入過程中使用規格允許在引入系統的各個組件之間傳遞狀態，例如在建立模組規格"
"的尋檢器和執行該規格的載入器之間傳遞。最重要的是，這允許引入機制執行載入的模"
"板操作，而在沒有模組規格的情況下，這些操作則是載入器的責任。"

#: ../../reference/import.rst:532
msgid ""
"The module's spec is exposed as :attr:`module.__spec__`. Setting :attr:`!"
"__spec__` appropriately applies equally to :ref:`modules initialized during "
"interpreter startup <programs>`. The one exception is ``__main__``, where :"
"attr:`!__spec__` is :ref:`set to None in some cases <main_spec>`."
msgstr ""
"模組的規格以 :attr:`module.__spec__` 的形式公開。適當地設定 :attr:`!"
"__spec__` 同樣適用於\\ :ref:`在直譯器啟動期間初始化的模組 <programs>`。唯一的"
"例外是 ``__main__``，其中 :attr:`!__spec__` 會\\ :ref:`在某些情況下被設定成 "
"None <main_spec>`。"

#: ../../reference/import.rst:538
msgid ""
"See :class:`~importlib.machinery.ModuleSpec` for details on the contents of "
"the module spec."
msgstr ""
"有關模組規格內容的詳細資訊，請參閱 :class:`~importlib.machinery.ModuleSpec`。"

#: ../../reference/import.rst:546
msgid "__path__ attributes on modules"
msgstr "模組上的 __path__ 屬性"

#: ../../reference/import.rst:548
msgid ""
"The :attr:`~module.__path__` attribute should be a (possibly empty) :term:"
"`sequence` of strings enumerating the locations where the package's "
"submodules will be found. By definition, if a module has a :attr:`!__path__` "
"attribute, it is a :term:`package`."
msgstr ""
":attr:`~module.__path__` 屬性應該是一個（可能為空的）\\ :term:`sequence`，其"
"包含列舉套件子模組位置的字串。根據定義，如果一個模組有 :attr:`!__path__` 屬"
"性，那麼它就是一個 :term:`package`。"

#: ../../reference/import.rst:553
msgid ""
"A package's :attr:`~module.__path__` attribute is used during imports of its "
"subpackages. Within the import machinery, it functions much the same as :"
"data:`sys.path`, i.e. providing a list of locations to search for modules "
"during import. However, :attr:`!__path__` is typically much more constrained "
"than :data:`!sys.path`."
msgstr ""
"套件的 :attr:`~module.__path__` 屬性在引入其子套件時被使用。在引入機制中，其"
"功能與 :data:`sys.path` 類似，即提供在引入期間搜尋模組的位置串列。然而，:"
"attr:`!__path__` 通常比 :data:`!sys.path` 更受限制。"

#: ../../reference/import.rst:560
msgid ""
"The same rules used for :data:`sys.path` also apply to a package's :attr:`!"
"__path__`. :data:`sys.path_hooks` (described below) are consulted when "
"traversing a package's :attr:`!__path__`."
msgstr ""
":data:`sys.path` 適用的規則同樣也適用於套件的 :attr:`!__path__`。 :data:`sys."
"path_hooks` 會在遍歷套件的 :attr:`!__path__` 時被參考（於後文詳述）。"

#: ../../reference/import.rst:564
msgid ""
"A package's ``__init__.py`` file may set or alter the package's :attr:"
"`~module.__path__` attribute, and this was typically the way namespace "
"packages were implemented prior to :pep:`420`.  With the adoption of :pep:"
"`420`, namespace packages no longer need to supply ``__init__.py`` files "
"containing only :attr:`!__path__` manipulation code; the import machinery "
"automatically sets :attr:`!__path__` correctly for the namespace package."
msgstr ""
"套件的 ``__init__.py`` 檔案可以設定或修改套件的 :attr:`~module.__path__` 屬"
"性，這通常是 :pep:`420` 之前實作命名空間套件的方式。隨著 :pep:`420` 的採用，"
"命名空間套件不再需要提供僅包含 :attr:`!__path__` 操作程式碼的 ``__init__."
"py`` 檔案；引入機制會自動為命名空間套件正確地設定 :attr:`!__path__`。"

#: ../../reference/import.rst:573
msgid "Module reprs"
msgstr "模組的 reprs"

#: ../../reference/import.rst:575
msgid ""
"By default, all modules have a usable repr, however depending on the "
"attributes set above, and in the module's spec, you can more explicitly "
"control the repr of module objects."
msgstr ""
"預設情況下，所有模組都有可用的 repr，然而，根據上述設定及模組規格中的屬性，你"
"可以更明確地控制模組物件的 repr。"

#: ../../reference/import.rst:579
msgid ""
"If the module has a spec (``__spec__``), the import machinery will try to "
"generate a repr from it.  If that fails or there is no spec, the import "
"system will craft a default repr using whatever information is available on "
"the module.  It will try to use the ``module.__name__``, ``module."
"__file__``, and ``module.__loader__`` as input into the repr, with defaults "
"for whatever information is missing."
msgstr ""
"如果模組具有規格（\\ ``__spec__``\\ ），引入機制將嘗試從規格中產生 repr。如果"
"失敗或沒有規格，引入系統將使用模組上可用的資訊製作一個預設的 repr。它會嘗試使"
"用 ``module.__name__``、``module.__file__`` 和 ``module.__loader__`` 作為 "
"repr 的輸入，並為缺少的資訊提供預設值。"

#: ../../reference/import.rst:586
msgid "Here are the exact rules used:"
msgstr "以下是具體的使用規則："

#: ../../reference/import.rst:588
msgid ""
"If the module has a ``__spec__`` attribute, the information in the spec is "
"used to generate the repr.  The \"name\", \"loader\", \"origin\", and "
"\"has_location\" attributes are consulted."
msgstr ""
"如果模組具有 ``__spec__`` 屬性，則使用規格中的資訊產生 repr。會參考 "
"\"name\"、\"loader\"、\"origin\" 和 \"has_location\" 屬性。"

#: ../../reference/import.rst:592
msgid ""
"If the module has a ``__file__`` attribute, this is used as part of the "
"module's repr."
msgstr "如果模組具有 ``__file__`` 屬性，則會將其作為模組 repr 的一部分。"

#: ../../reference/import.rst:595
msgid ""
"If the module has no ``__file__`` but does have a ``__loader__`` that is not "
"``None``, then the loader's repr is used as part of the module's repr."
msgstr ""
"如果模組沒有 ``__file__`` 但有一個不為 ``None`` 的 ``__loader__`` ，則會將載"
"入器的 repr 作為模組 repr 的一部分。"

#: ../../reference/import.rst:598
msgid "Otherwise, just use the module's ``__name__`` in the repr."
msgstr "否則，在 repr 中只使用模組的 ``__name__``。"

#: ../../reference/import.rst:600
msgid ""
"Use of :meth:`!module_repr`, having been deprecated since Python 3.4, was "
"removed in Python 3.12 and is no longer called during the resolution of a "
"module's repr."
msgstr ""
":meth:`!module_repr` 自 Python 3.4 起被棄用，並在 Python 3.12 中移除，且不會"
"在解析模組的 repr 時被呼叫。"

#: ../../reference/import.rst:608
msgid "Cached bytecode invalidation"
msgstr "被快取的位元組碼的無效化"

#: ../../reference/import.rst:610
msgid ""
"Before Python loads cached bytecode from a ``.pyc`` file, it checks whether "
"the cache is up-to-date with the source ``.py`` file. By default, Python "
"does this by storing the source's last-modified timestamp and size in the "
"cache file when writing it. At runtime, the import system then validates the "
"cache file by checking the stored metadata in the cache file against the "
"source's metadata."
msgstr ""
"在 Python 從 ``.pyc`` 檔案載入被快取的位元組碼之前，會檢查該快取是否與來源的 "
"``.py`` 檔案保持同步。預設情況下，Python 透過在寫入快取檔案時儲存來源檔案的最"
"後修改時間戳和大小來完成此操作。在執行時，引入系統會透過將快取檔案中儲存的元"
"資料 (metadata) 與來源檔案的元資料進行比對來驗證快取檔案。"

#: ../../reference/import.rst:617
msgid ""
"Python also supports \"hash-based\" cache files, which store a hash of the "
"source file's contents rather than its metadata. There are two variants of "
"hash-based ``.pyc`` files: checked and unchecked. For checked hash-based ``."
"pyc`` files, Python validates the cache file by hashing the source file and "
"comparing the resulting hash with the hash in the cache file. If a checked "
"hash-based cache file is found to be invalid, Python regenerates it and "
"writes a new checked hash-based cache file. For unchecked hash-based ``."
"pyc`` files, Python simply assumes the cache file is valid if it exists. "
"Hash-based ``.pyc`` files validation behavior may be overridden with the :"
"option:`--check-hash-based-pycs` flag."
msgstr ""
"Python 還支援「基於雜湊」的快取檔案，這些檔案儲存來源檔案內容的雜湊值，而不是"
"其元資料。基於雜湊的 ``.pyc`` 檔案有兩種變體：需檢查和不需要檢查的。對於需檢"
"查的基於雜湊的 ``.pyc`` 檔案，Python 透過對來源檔案進行雜湊並將結果與快取檔案"
"中的雜湊進行比較來驗證快取檔案。如果發現需檢查的基於雜湊的快取檔案無效，"
"Python 會重新產生並寫入新的需檢查的基於雜湊的快取檔案。對於不需要檢查的基於雜"
"湊的 ``.pyc`` 檔案，只要檔案存在，Python 就假設快取檔案是有效的。可以使用 :"
"option:`--check-hash-based-pycs` 旗標覆蓋基於雜湊的 ``.pyc`` 檔案的驗證行為。"

#: ../../reference/import.rst:628
msgid ""
"Added hash-based ``.pyc`` files. Previously, Python only supported timestamp-"
"based invalidation of bytecode caches."
msgstr ""
"新增了基於雜湊的 ``.pyc`` 檔案。此前，Python 只支援基於時間戳的位元組碼快取無"
"效化。"

#: ../../reference/import.rst:634
msgid "The Path Based Finder"
msgstr "基於路徑的尋檢器"

#: ../../reference/import.rst:639
msgid ""
"As mentioned previously, Python comes with several default meta path "
"finders. One of these, called the :term:`path based finder` (:class:"
"`~importlib.machinery.PathFinder`), searches an :term:`import path`, which "
"contains a list of :term:`path entries <path entry>`.  Each path entry names "
"a location to search for modules."
msgstr ""
"如前所述，Python 附帶了幾個預設的元路徑尋檢器。其中之一稱為 :term:`path "
"based finder`\\ （\\ :class:`~importlib.machinery.PathFinder`\\ ），它搜尋 :"
"term:`import path`，該路徑包含一個 :term:`路徑條目 <path entry>` 的串列。每個"
"路徑條目都指定了一個用於搜尋模組的位置。"

#: ../../reference/import.rst:645
msgid ""
"The path based finder itself doesn't know how to import anything. Instead, "
"it traverses the individual path entries, associating each of them with a "
"path entry finder that knows how to handle that particular kind of path."
msgstr ""
"基於路徑的尋檢器本身並不知道如何引入任何東西。相反，它遍歷各個路徑條目，並將"
"每個路徑條目與一個知道如何處理該特定路徑類型的路徑條目尋檢器關聯起來。"

#: ../../reference/import.rst:649
msgid ""
"The default set of path entry finders implement all the semantics for "
"finding modules on the file system, handling special file types such as "
"Python source code (``.py`` files), Python byte code (``.pyc`` files) and "
"shared libraries (e.g. ``.so`` files). When supported by the :mod:"
"`zipimport` module in the standard library, the default path entry finders "
"also handle loading all of these file types (other than shared libraries) "
"from zipfiles."
msgstr ""
"預設的一組路徑條目尋檢器實作了在檔案系統中尋找模組的所有語意，包括處理特殊檔"
"案類型，例如 Python 原始程式碼檔案（``.py`` 檔案）、Python 位元組程式碼檔案"
"（``.pyc`` 檔案）以及共享函式庫（例如 ``.so`` 檔案）。當標準函式庫中的 :mod:"
"`zipimport` 模組支援時，預設的路徑條目尋檢器也能處理從壓縮檔案中載入這些檔案"
"類型（共享函式庫除外）。"

#: ../../reference/import.rst:656
msgid ""
"Path entries need not be limited to file system locations.  They can refer "
"to URLs, database queries, or any other location that can be specified as a "
"string."
msgstr ""
"路徑條目不必侷限於檔案系統位置。它們可以參照 URL、資料庫查詢或任何可以作為字"
"串指定的位置。"

#: ../../reference/import.rst:660
msgid ""
"The path based finder provides additional hooks and protocols so that you "
"can extend and customize the types of searchable path entries.  For example, "
"if you wanted to support path entries as network URLs, you could write a "
"hook that implements HTTP semantics to find modules on the web.  This hook "
"(a callable) would return a :term:`path entry finder` supporting the "
"protocol described below, which was then used to get a loader for the module "
"from the web."
msgstr ""
"基於路徑的尋檢器提供了額外的掛鉤和協定，讓你可以擴展和自定可搜尋的路徑條目類"
"型。例如，如果你希望支援將路徑條目作為網路 URLs，你可以撰寫一個實作 HTTP 語意"
"的掛鉤，用於在網路上尋找模組。這個掛鉤（一個可呼叫物件）會回傳一個支援下述協"
"定的 :term:`path entry finder` ，該尋檢器隨後用於從網路中獲取模組的載入器。"

#: ../../reference/import.rst:668
msgid ""
"A word of warning: this section and the previous both use the term *finder*, "
"distinguishing between them by using the terms :term:`meta path finder` and :"
"term:`path entry finder`.  These two types of finders are very similar, "
"support similar protocols, and function in similar ways during the import "
"process, but it's important to keep in mind that they are subtly different. "
"In particular, meta path finders operate at the beginning of the import "
"process, as keyed off the :data:`sys.meta_path` traversal."
msgstr ""
"提醒一句：本節與前一節都使用了 *尋檢器* 這個術語，並透過使用術語 :term:`meta "
"path finder` 和 :term:`path entry finder` 來區分它們。這兩種類型的尋檢器非常"
"相似，支援類似的協定，並在引入過程中以類似的方式運作，但請記住，它們之間有些"
"微的差異。特別是，元路徑尋檢器在引入過程的一開始運作，並通過 :data:`sys."
"meta_path` 的遍歷關閉 (key off)。"

#: ../../reference/import.rst:676
msgid ""
"By contrast, path entry finders are in a sense an implementation detail of "
"the path based finder, and in fact, if the path based finder were to be "
"removed from :data:`sys.meta_path`, none of the path entry finder semantics "
"would be invoked."
msgstr ""
"相比之下，路徑條目尋檢器在某種意義上是基於路徑的尋檢器的一個實作細節。事實"
"上，如果基於路徑的尋檢器從 :data:`sys.meta_path` 中移除，路徑條目尋檢器的任何"
"語意都不會被調用。"

#: ../../reference/import.rst:683
msgid "Path entry finders"
msgstr ""

#: ../../reference/import.rst:691
msgid ""
"The :term:`path based finder` is responsible for finding and loading Python "
"modules and packages whose location is specified with a string :term:`path "
"entry`.  Most path entries name locations in the file system, but they need "
"not be limited to this."
msgstr ""

#: ../../reference/import.rst:696
msgid ""
"As a meta path finder, the :term:`path based finder` implements the :meth:"
"`~importlib.abc.MetaPathFinder.find_spec` protocol previously described, "
"however it exposes additional hooks that can be used to customize how "
"modules are found and loaded from the :term:`import path`."
msgstr ""

#: ../../reference/import.rst:701
msgid ""
"Three variables are used by the :term:`path based finder`, :data:`sys."
"path`, :data:`sys.path_hooks` and :data:`sys.path_importer_cache`.  The "
"``__path__`` attributes on package objects are also used.  These provide "
"additional ways that the import machinery can be customized."
msgstr ""

#: ../../reference/import.rst:706
msgid ""
":data:`sys.path` contains a list of strings providing search locations for "
"modules and packages.  It is initialized from the :envvar:`PYTHONPATH` "
"environment variable and various other installation- and implementation-"
"specific defaults.  Entries in :data:`sys.path` can name directories on the "
"file system, zip files, and potentially other \"locations\" (see the :mod:"
"`site` module) that should be searched for modules, such as URLs, or "
"database queries.  Only strings should be present on :data:`sys.path`; all "
"other data types are ignored."
msgstr ""

#: ../../reference/import.rst:715
msgid ""
"The :term:`path based finder` is a :term:`meta path finder`, so the import "
"machinery begins the :term:`import path` search by calling the path based "
"finder's :meth:`~importlib.machinery.PathFinder.find_spec` method as "
"described previously.  When the ``path`` argument to :meth:`~importlib."
"machinery.PathFinder.find_spec` is given, it will be a list of string paths "
"to traverse - typically a package's ``__path__`` attribute for an import "
"within that package.  If the ``path`` argument is ``None``, this indicates a "
"top level import and :data:`sys.path` is used."
msgstr ""

#: ../../reference/import.rst:724
msgid ""
"The path based finder iterates over every entry in the search path, and for "
"each of these, looks for an appropriate :term:`path entry finder` (:class:"
"`~importlib.abc.PathEntryFinder`) for the path entry.  Because this can be "
"an expensive operation (e.g. there may be ``stat()`` call overheads for this "
"search), the path based finder maintains a cache mapping path entries to "
"path entry finders.  This cache is maintained in :data:`sys."
"path_importer_cache` (despite the name, this cache actually stores finder "
"objects rather than being limited to :term:`importer` objects). In this way, "
"the expensive search for a particular :term:`path entry` location's :term:"
"`path entry finder` need only be done once.  User code is free to remove "
"cache entries from :data:`sys.path_importer_cache` forcing the path based "
"finder to perform the path entry search again."
msgstr ""

#: ../../reference/import.rst:737
msgid ""
"If the path entry is not present in the cache, the path based finder "
"iterates over every callable in :data:`sys.path_hooks`.  Each of the :term:"
"`path entry hooks <path entry hook>` in this list is called with a single "
"argument, the path entry to be searched.  This callable may either return a :"
"term:`path entry finder` that can handle the path entry, or it may raise :"
"exc:`ImportError`.  An :exc:`ImportError` is used by the path based finder "
"to signal that the hook cannot find a :term:`path entry finder` for that :"
"term:`path entry`.  The exception is ignored and :term:`import path` "
"iteration continues.  The hook should expect either a string or bytes "
"object; the encoding of bytes objects is up to the hook (e.g. it may be a "
"file system encoding, UTF-8, or something else), and if the hook cannot "
"decode the argument, it should raise :exc:`ImportError`."
msgstr ""

#: ../../reference/import.rst:751
msgid ""
"If :data:`sys.path_hooks` iteration ends with no :term:`path entry finder` "
"being returned, then the path based finder's :meth:`~importlib.machinery."
"PathFinder.find_spec` method will store ``None`` in :data:`sys."
"path_importer_cache` (to indicate that there is no finder for this path "
"entry) and return ``None``, indicating that this :term:`meta path finder` "
"could not find the module."
msgstr ""

#: ../../reference/import.rst:758
msgid ""
"If a :term:`path entry finder` *is* returned by one of the :term:`path entry "
"hook` callables on :data:`sys.path_hooks`, then the following protocol is "
"used to ask the finder for a module spec, which is then used when loading "
"the module."
msgstr ""

#: ../../reference/import.rst:763
msgid ""
"The current working directory -- denoted by an empty string -- is handled "
"slightly differently from other entries on :data:`sys.path`. First, if the "
"current working directory is found to not exist, no value is stored in :data:"
"`sys.path_importer_cache`. Second, the value for the current working "
"directory is looked up fresh for each module lookup. Third, the path used "
"for :data:`sys.path_importer_cache` and returned by :meth:`importlib."
"machinery.PathFinder.find_spec` will be the actual current working directory "
"and not the empty string."
msgstr ""

#: ../../reference/import.rst:773
msgid "Path entry finder protocol"
msgstr ""

#: ../../reference/import.rst:775
msgid ""
"In order to support imports of modules and initialized packages and also to "
"contribute portions to namespace packages, path entry finders must implement "
"the :meth:`~importlib.abc.PathEntryFinder.find_spec` method."
msgstr ""

#: ../../reference/import.rst:779
msgid ""
":meth:`~importlib.abc.PathEntryFinder.find_spec` takes two arguments: the "
"fully qualified name of the module being imported, and the (optional) target "
"module.  ``find_spec()`` returns a fully populated spec for the module. This "
"spec will always have \"loader\" set (with one exception)."
msgstr ""

#: ../../reference/import.rst:784
msgid ""
"To indicate to the import machinery that the spec represents a namespace :"
"term:`portion`, the path entry finder sets ``submodule_search_locations`` to "
"a list containing the portion."
msgstr ""

#: ../../reference/import.rst:788
msgid ""
":meth:`~importlib.abc.PathEntryFinder.find_spec` replaced :meth:`!"
"find_loader` and :meth:`!find_module`, both of which are now deprecated, but "
"will be used if ``find_spec()`` is not defined."
msgstr ""

#: ../../reference/import.rst:794
msgid ""
"Older path entry finders may implement one of these two deprecated methods "
"instead of ``find_spec()``.  The methods are still respected for the sake of "
"backward compatibility.  However, if ``find_spec()`` is implemented on the "
"path entry finder, the legacy methods are ignored."
msgstr ""

#: ../../reference/import.rst:799
msgid ""
":meth:`!find_loader` takes one argument, the fully qualified name of the "
"module being imported.  ``find_loader()`` returns a 2-tuple where the first "
"item is the loader and the second item is a namespace :term:`portion`."
msgstr ""

#: ../../reference/import.rst:804
msgid ""
"For backwards compatibility with other implementations of the import "
"protocol, many path entry finders also support the same, traditional "
"``find_module()`` method that meta path finders support. However path entry "
"finder ``find_module()`` methods are never called with a ``path`` argument "
"(they are expected to record the appropriate path information from the "
"initial call to the path hook)."
msgstr ""

#: ../../reference/import.rst:811
msgid ""
"The ``find_module()`` method on path entry finders is deprecated, as it does "
"not allow the path entry finder to contribute portions to namespace "
"packages.  If both ``find_loader()`` and ``find_module()`` exist on a path "
"entry finder, the import system will always call ``find_loader()`` in "
"preference to ``find_module()``."
msgstr ""

#: ../../reference/import.rst:817
msgid ""
"Calls to :meth:`!find_module` and :meth:`!find_loader` by the import system "
"will raise :exc:`ImportWarning`."
msgstr ""

#: ../../reference/import.rst:822
msgid "``find_module()`` and ``find_loader()`` have been removed."
msgstr ""

#: ../../reference/import.rst:827
msgid "Replacing the standard import system"
msgstr ""

#: ../../reference/import.rst:829
msgid ""
"The most reliable mechanism for replacing the entire import system is to "
"delete the default contents of :data:`sys.meta_path`, replacing them "
"entirely with a custom meta path hook."
msgstr ""

#: ../../reference/import.rst:833
msgid ""
"If it is acceptable to only alter the behaviour of import statements without "
"affecting other APIs that access the import system, then replacing the "
"builtin :func:`__import__` function may be sufficient. This technique may "
"also be employed at the module level to only alter the behaviour of import "
"statements within that module."
msgstr ""

#: ../../reference/import.rst:839
msgid ""
"To selectively prevent the import of some modules from a hook early on the "
"meta path (rather than disabling the standard import system entirely), it is "
"sufficient to raise :exc:`ModuleNotFoundError` directly from :meth:"
"`~importlib.abc.MetaPathFinder.find_spec` instead of returning ``None``. The "
"latter indicates that the meta path search should continue, while raising an "
"exception terminates it immediately."
msgstr ""

#: ../../reference/import.rst:849
msgid "Package Relative Imports"
msgstr ""

#: ../../reference/import.rst:851
msgid ""
"Relative imports use leading dots. A single leading dot indicates a relative "
"import, starting with the current package. Two or more leading dots indicate "
"a relative import to the parent(s) of the current package, one level per dot "
"after the first. For example, given the following package layout::"
msgstr ""

#: ../../reference/import.rst:856
msgid ""
"package/\n"
"    __init__.py\n"
"    subpackage1/\n"
"        __init__.py\n"
"        moduleX.py\n"
"        moduleY.py\n"
"    subpackage2/\n"
"        __init__.py\n"
"        moduleZ.py\n"
"    moduleA.py"
msgstr ""
"package/\n"
"    __init__.py\n"
"    subpackage1/\n"
"        __init__.py\n"
"        moduleX.py\n"
"        moduleY.py\n"
"    subpackage2/\n"
"        __init__.py\n"
"        moduleZ.py\n"
"    moduleA.py"

#: ../../reference/import.rst:867
msgid ""
"In either ``subpackage1/moduleX.py`` or ``subpackage1/__init__.py``, the "
"following are valid relative imports::"
msgstr ""

#: ../../reference/import.rst:870
msgid ""
"from .moduleY import spam\n"
"from .moduleY import spam as ham\n"
"from . import moduleY\n"
"from ..subpackage1 import moduleY\n"
"from ..subpackage2.moduleZ import eggs\n"
"from ..moduleA import foo"
msgstr ""
"from .moduleY import spam\n"
"from .moduleY import spam as ham\n"
"from . import moduleY\n"
"from ..subpackage1 import moduleY\n"
"from ..subpackage2.moduleZ import eggs\n"
"from ..moduleA import foo"

#: ../../reference/import.rst:877
msgid ""
"Absolute imports may use either the ``import <>`` or ``from <> import <>`` "
"syntax, but relative imports may only use the second form; the reason for "
"this is that::"
msgstr ""

#: ../../reference/import.rst:881
msgid "import XXX.YYY.ZZZ"
msgstr "import XXX.YYY.ZZZ"

#: ../../reference/import.rst:883
msgid ""
"should expose ``XXX.YYY.ZZZ`` as a usable expression, but .moduleY is not a "
"valid expression."
msgstr ""

#: ../../reference/import.rst:890
msgid "Special considerations for __main__"
msgstr ""

#: ../../reference/import.rst:892
msgid ""
"The :mod:`__main__` module is a special case relative to Python's import "
"system.  As noted :ref:`elsewhere <programs>`, the ``__main__`` module is "
"directly initialized at interpreter startup, much like :mod:`sys` and :mod:"
"`builtins`.  However, unlike those two, it doesn't strictly qualify as a "
"built-in module.  This is because the manner in which ``__main__`` is "
"initialized depends on the flags and other options with which the "
"interpreter is invoked."
msgstr ""

#: ../../reference/import.rst:903
msgid "__main__.__spec__"
msgstr "__main__.__spec__"

#: ../../reference/import.rst:905
msgid ""
"Depending on how :mod:`__main__` is initialized, ``__main__.__spec__`` gets "
"set appropriately or to ``None``."
msgstr ""

#: ../../reference/import.rst:908
msgid ""
"When Python is started with the :option:`-m` option, ``__spec__`` is set to "
"the module spec of the corresponding module or package. ``__spec__`` is also "
"populated when the ``__main__`` module is loaded as part of executing a "
"directory, zipfile or other :data:`sys.path` entry."
msgstr ""

#: ../../reference/import.rst:913
msgid ""
"In :ref:`the remaining cases <using-on-interface-options>` ``__main__."
"__spec__`` is set to ``None``, as the code used to populate the :mod:"
"`__main__` does not correspond directly with an importable module:"
msgstr ""

#: ../../reference/import.rst:917
msgid "interactive prompt"
msgstr ""

#: ../../reference/import.rst:918
msgid ":option:`-c` option"
msgstr ":option:`-c` 選項"

#: ../../reference/import.rst:919
msgid "running from stdin"
msgstr ""

#: ../../reference/import.rst:920
msgid "running directly from a source or bytecode file"
msgstr ""

#: ../../reference/import.rst:922
msgid ""
"Note that ``__main__.__spec__`` is always ``None`` in the last case, *even "
"if* the file could technically be imported directly as a module instead. Use "
"the :option:`-m` switch if valid module metadata is desired in :mod:"
"`__main__`."
msgstr ""

#: ../../reference/import.rst:927
msgid ""
"Note also that even when ``__main__`` corresponds with an importable module "
"and ``__main__.__spec__`` is set accordingly, they're still considered "
"*distinct* modules. This is due to the fact that blocks guarded by ``if "
"__name__ == \"__main__\":`` checks only execute when the module is used to "
"populate the ``__main__`` namespace, and not during normal import."
msgstr ""

#: ../../reference/import.rst:935
msgid "References"
msgstr ""

#: ../../reference/import.rst:937
msgid ""
"The import machinery has evolved considerably since Python's early days.  "
"The original `specification for packages <https://www.python.org/doc/essays/"
"packages/>`_ is still available to read, although some details have changed "
"since the writing of that document."
msgstr ""

#: ../../reference/import.rst:942
msgid ""
"The original specification for :data:`sys.meta_path` was :pep:`302`, with "
"subsequent extension in :pep:`420`."
msgstr ""

#: ../../reference/import.rst:945
msgid ""
":pep:`420` introduced :term:`namespace packages <namespace package>` for "
"Python 3.3.  :pep:`420` also introduced the :meth:`!find_loader` protocol as "
"an alternative to :meth:`!find_module`."
msgstr ""

#: ../../reference/import.rst:949
msgid ""
":pep:`366` describes the addition of the ``__package__`` attribute for "
"explicit relative imports in main modules."
msgstr ""

#: ../../reference/import.rst:952
msgid ""
":pep:`328` introduced absolute and explicit relative imports and initially "
"proposed ``__name__`` for semantics :pep:`366` would eventually specify for "
"``__package__``."
msgstr ""

#: ../../reference/import.rst:956
msgid ":pep:`338` defines executing modules as scripts."
msgstr ""

#: ../../reference/import.rst:958
msgid ""
":pep:`451` adds the encapsulation of per-module import state in spec "
"objects.  It also off-loads most of the boilerplate responsibilities of "
"loaders back onto the import machinery.  These changes allow the deprecation "
"of several APIs in the import system and also addition of new methods to "
"finders and loaders."
msgstr ""

#: ../../reference/import.rst:965
msgid "Footnotes"
msgstr "註解"

#: ../../reference/import.rst:966
msgid "See :class:`types.ModuleType`."
msgstr "參閱 :class:`types.ModuleType`。"

#: ../../reference/import.rst:968
msgid ""
"The importlib implementation avoids using the return value directly. "
"Instead, it gets the module object by looking the module name up in :data:"
"`sys.modules`.  The indirect effect of this is that an imported module may "
"replace itself in :data:`sys.modules`.  This is implementation-specific "
"behavior that is not guaranteed to work in other Python implementations."
msgstr ""

#: ../../reference/import.rst:8
msgid "import machinery"
msgstr "import machinery（引入機制）"

#: ../../reference/import.rst:64 ../../reference/import.rst:95
#: ../../reference/import.rst:129
msgid "package"
msgstr "package（套件）"

#: ../../reference/import.rst:95
msgid "regular"
msgstr "regular（一般）"

#: ../../reference/import.rst:129
msgid "namespace"
msgstr "namespace（命名空間）"

#: ../../reference/import.rst:129
msgid "portion"
msgstr "portion（部分）"

#: ../../reference/import.rst:175
msgid "sys.modules"
msgstr "sys.modules"

#: ../../reference/import.rst:210 ../../reference/import.rst:276
msgid "finder"
msgstr "finder（搜尋器）"

#: ../../reference/import.rst:210
msgid "loader"
msgstr "loader（載入器）"

#: ../../reference/import.rst:210
msgid "module spec"
msgstr "module spec"

#: ../../reference/import.rst:249
msgid "import hooks"
msgstr "import hooks"

#: ../../reference/import.rst:249
msgid "meta hooks"
msgstr "meta hooks"

#: ../../reference/import.rst:249
msgid "path hooks"
msgstr "path hooks"

#: ../../reference/import.rst:249
msgid "hooks"
msgstr "hooks"

#: ../../reference/import.rst:249
msgid "import"
msgstr "import（引入）"

#: ../../reference/import.rst:249
msgid "meta"
msgstr "meta"

#: ../../reference/import.rst:249
msgid "path"
msgstr "path（路徑）"

#: ../../reference/import.rst:276
msgid "sys.meta_path"
msgstr "sys.meta_path"

#: ../../reference/import.rst:276
msgid "find_spec"
msgstr "find_spec"

#: ../../reference/import.rst:636
msgid "path based finder"
msgstr "path based finder（基於路徑的搜尋器）"

#: ../../reference/import.rst:685
msgid "sys.path"
msgstr "sys.path"

#: ../../reference/import.rst:685
msgid "sys.path_hooks"
msgstr "sys.path_hooks"

#: ../../reference/import.rst:685
msgid "sys.path_importer_cache"
msgstr "sys.path_importer_cache"

#: ../../reference/import.rst:685
msgid "PYTHONPATH"
msgstr "PYTHONPATH"

#~ msgid "module.__path__"
#~ msgstr "module.__path__"