# German translation of the Python documentation.

# Copyright (C) 2001 Python Software Foundation

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

#

# Translators:

# Swen Bachmann, 2026

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.15\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-09-23 06:17+0000\n"

"PO-Revision-Date: 2026-09-23 08:00+0200\n"

"Last-Translator: Swen Bachmann\n"

"Language-Team: German (https://github.com/python/python-docs-de)\n"

"Language: de\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../reference/import.rst:6

msgid "The import system"

msgstr "Das Importsystem"

#: ../../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 ""

"Python-Code in einem :term:`Modul <module>` erhält Zugriff auf den Code in "

"einem anderen Modul, indem er diesen :term:`importiert <importing>`. Die "

"Anweisung :keyword:`import` ist die gängigste Methode, um den Importvorgang "

"auszulösen, aber es ist nicht die einzige Möglichkeit. Auch Funktionen "

"wie :func:`importlib.import_module` und die integrierte "

"Funktion :func:`__import__` können verwendet werden, um den Importvorgang "

"auszulösen."

#: ../../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 ""

"Die Anweisung :keyword:`import` kombiniert zwei Operationen: Sie sucht nach "

"dem genannten Modul und bindet anschließend die Ergebnisse dieser Suche an "

"einen Namen im lokalen Geltungsbereich. Die Suchoperation der Anweisung "

"„ :keyword:`!import` ist als Aufruf der Funktion :func:`__import__` mit den "

"entsprechenden Argumenten definiert. Der Rückgabewert von :func:`__import__` "

"wird verwendet, um die Namensbindung der Anweisung :keyword:`!import` "

"durchzuführen. Genaue Einzelheiten zu dieser Namensbindung findest du in "

"der Anweisung :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 ""

"Ein direkter Aufruf von :func:`__import__` führt lediglich die Modulsuche "

"durch und, falls das Modul gefunden wird, die Modulerstellung. Zwar können "

"dabei gewisse Nebeneffekte auftreten, wie beispielsweise das Importieren "

"übergeordneter Pakete und die Aktualisierung verschiedener Caches "

"(einschließlich :data:`sys.modules`), doch nur die "

"Anweisung :keyword:`import` führt eine Namensbindung durch."

#: ../../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 ""

"Bei der Ausführung einer Anweisung vom Typ :keyword:`import` wird die "

"standardmäßige integrierte Funktion :func:`__import__` aufgerufen. Andere "

"Mechanismen zum Aufruf des Importsystems (wie "

"beispielsweise :func:`importlib.import_module` ) können :func:`__import__` "

"umgehen und stattdessen eigene Lösungen zur Implementierung der Import-"

"Semantik verwenden."

#: ../../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 ""

"Wenn ein Modul zum ersten Mal importiert wird, sucht Python nach dem Modul "

"und erstellt, falls es gefunden wird, ein Modulobjekt [#fnmo]_ und "

"initialisiert es. Kann das genannte Modul nicht gefunden werden, wird eine "

"Ausnahme vom Typ :exc:`ModuleNotFoundError` ausgelöst. Python setzt "

"verschiedene Strategien ein, um nach dem genannten Modul zu suchen, wenn der "

"Importmechanismus aufgerufen wird. Diese Strategien können mithilfe "

"verschiedener Hooks, die in den folgenden Abschnitten beschrieben werden, "

"angepasst und erweitert werden."

#: ../../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 ""

"Das Import-System wurde aktualisiert, um die zweite Phase von :pep:`302` "

"vollständig umzusetzen. Es gibt keine implizite Import-Mechanik mehr – das "

"gesamte Import-System wird über :data:`sys.meta_path` bereitgestellt. "

"Darüber hinaus wurde die native Unterstützung für Namespace-Pakete "

"implementiert (siehe :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 ""

"Das Modul :mod:`importlib` bietet eine umfangreiche API für die Interaktion "

"mit dem Import-System. So stellt "

"beispielsweise :func:`importlib.import_module` eine empfohlene, einfachere "

"API zum Aufrufen der Import-Funktionen dar als die integrierte "

"Funktion :func:`__import__` “. Weitere Informationen findest du in der "

"Dokumentation zur Bibliothek :mod:`importlib` ."

#: ../../reference/import.rst:62

msgid "Packages"

msgstr "Pakete"

#: ../../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 kennt nur einen Typ von Modulobjekt, und alle Module gehören zu "

"diesem Typ, unabhängig davon, ob das Modul in Python, C oder einer anderen "

"Sprache implementiert ist. Um die Organisation von Modulen zu erleichtern "

"und eine Namenshierarchie bereitzustellen, gibt es in Python das Konzept "

"der :term:`Pakete <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 ""

"Man kann sich Pakete wie Verzeichnisse in einem Dateisystem und Module wie "

"Dateien innerhalb dieser Verzeichnisse vorstellen, sollte diese Analogie "

"jedoch nicht allzu wörtlich nehmen, da Pakete und Module nicht unbedingt aus "

"dem Dateisystem stammen müssen. Für die Zwecke dieser Dokumentation werden "

"wir diese praktische Analogie von Verzeichnissen und Dateien verwenden. Wie "

"Verzeichnisse im Dateisystem sind Pakete hierarchisch organisiert, und "

"Pakete können ihrerseits sowohl Unterpakete als auch reguläre Module "

"enthalten."

#: ../../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 ""

"Man sollte unbedingt beachten, dass alle Pakete Module sind, aber nicht alle "

"Module Pakete sind. Oder anders ausgedrückt: Pakete sind lediglich eine "

"besondere Art von Modulen. Genauer gesagt gilt jedes Modul, das ein Attribut "

"``__path__`` enthält, als Paket."

#: ../../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 ""

"Alle Module haben einen Namen. Die Namen von Unterpaketen werden durch einen "

"Punkt vom Namen ihres übergeordneten Pakets getrennt, ähnlich wie bei der "

"Standard-Syntax für den Zugriff auf Attribute in Python. So könnte es "

"beispielsweise ein Paket namens :mod:`email` geben, das wiederum ein "

"Unterpaket namens :mod:`email.mime` enthält, in dem sich ein Modul "

"namens :mod:`email.mime.text` befindet."

#: ../../reference/import.rst:93

msgid "Regular packages"

msgstr "Reguläre Pakete"

#: ../../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 definiert zwei Arten von Paketen: :term:`reguläre Pakete <regular "

"package>` und :term:`Namespace-Pakete <namespace package>`. Reguläre Pakete "

"sind herkömmliche Pakete, wie sie bereits in Python 3.2 und früheren "

"Versionen existierten. Ein reguläres Paket wird in der Regel als Verzeichnis "

"implementiert, das eine Datei ``__init__.py`` enthält. Wenn ein reguläres "

"Paket importiert wird, wird diese Datei ``__init__.py`` implizit ausgeführt, "

"und die darin definierten Objekte werden an Namen im Namensraum des Pakets "

"gebunden. Die Datei ``__init__.py`` kann denselben Python-Code enthalten wie "

"jedes andere Modul auch, und Python fügt dem Modul beim Importieren einige "

"zusätzliche Attribute hinzu."

#: ../../reference/import.rst:108

msgid ""

"For example, the following file system layout defines a top level ``parent`` "

"package with three subpackages::"

msgstr ""

"Beispielsweise definiert die folgende Dateisystemstruktur ein Paket der "

"obersten Ebene ``parent`` mit drei Unterpaketen::"

#: ../../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 ""

"Durch das Importieren von ``parent.one`` werden implizit die Dateien "

"``parent/__init__.py`` und ``parent/one/__init__.py`` ausgeführt. Bei "

"nachfolgenden Importen von ``parent.two`` oder ``parent.three`` werden "

"jeweils die Dateien ``parent/two/__init__.py`` und ``parent/three/"

"__init__.py`` ausgeführt."

#: ../../reference/import.rst:125

msgid ""

"A subdirectory inside a regular package that does not contain an "

"``__init__.py`` file is treated as an implicit :ref:`namespace package "

"<reference-namespace-package>` (a \"namespace subpackage\") rooted in that "

"parent. See :pep:`420` for the underlying specification."

msgstr ""

"Ein Unterverzeichnis innerhalb eines regulären Pakets, das keine Datei "

"``__init__.py`` enthält, wird als implizites :ref:`namespace-Paket "

"<reference-namespace-package>` (ein \"Namespace-Unterpaket\") behandelt, "

"dessen Stammverzeichnis das übergeordnete Paket ist. Die zugrunde liegende "

"Spezifikation findest du unter :pep:`420`."

#: ../../reference/import.rst:135

msgid "Namespace packages"

msgstr "Namespace-Pakete"

#: ../../reference/import.rst:141

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

"Ein Namespace-Paket ist eine Zusammensetzung aus verschiedenen :term:`Teilen "

"<portion>`, wobei jeder Teil ein Unterpaket zum übergeordneten Paket "

"beiträgt. Teile können sich an verschiedenen Orten im Dateisystem befinden. "

"Teile können sich auch in ZIP-Dateien, im Netzwerk oder an jedem anderen Ort "

"befinden, den Python beim Import durchsucht. Namespace-Pakete müssen nicht "

"unbedingt direkt mit Objekten im Dateisystem korrespondieren. Es kann sich "

"um virtuelle Module handeln, die keine konkrete Darstellung haben."

#: ../../reference/import.rst:149

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

"Namespace-Pakete verwenden für ihr Attribut ``__path__`` keine gewöhnliche "

"Liste. Stattdessen nutzen sie einen benutzerdefinierten iterierbaren Typ, "

"der beim nächsten Importversuch innerhalb dieses Pakets automatisch eine "

"neue Suche nach Paketteilen durchführt, falls sich der Pfad ihres "

"übergeordneten Pakets (oder :data:`sys.path` bei einem Paket der obersten "

"Ebene) ändert."

#: ../../reference/import.rst:155

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

"Bei Namespace-Paketen gibt es keine Datei ``parent/__init__.py`` . "

"Tatsächlich können bei der Importsuche mehrere Verzeichnisse ``parent`` "

"gefunden werden, wobei jedes von einem anderen Teil bereitgestellt wird. "

"Daher befindet sich ``parent/one`` möglicherweise nicht physisch neben "

"„ ``parent/two`` . In diesem Fall erstellt Python ein Namespace-Paket für "

"das Paket ``parent`` auf oberster Ebene, sobald dieses oder eines seiner "

"Unterpakete importiert wird."

#: ../../reference/import.rst:162

msgid ""

"Namespace packages may also be nested inside a regular package. When the "

"import system searches a regular package's ``__path__`` and encounters a "

"subdirectory that does not contain an ``__init__.py`` file, that "

"subdirectory becomes a :term:`portion` contributing to a namespace "

"subpackage of the enclosing regular package."

msgstr ""

"Namespace-Pakete können auch innerhalb eines regulären Pakets verschachtelt "

"sein. Wenn das Import-System die Datei ``__path__`` eines regulären Pakets "

"durchsucht und auf ein Unterverzeichnis stößt, das keine ``__init__.py``-"

"Datei enthält, wird dieses Unterverzeichnis zu einem :term:`Teil <portion>`, "

"der zu einem Namespace-Unterpaket des umgebenden regulären Pakets beiträgt."

#: ../../reference/import.rst:168

msgid "See also :pep:`420` for the namespace package specification."

msgstr "Siehe auch :pep:`420` für die Spezifikation des Namespace-Pakets."

#: ../../reference/import.rst:172

msgid "Searching"

msgstr "Suchen"

#: ../../reference/import.rst:174

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

"Um die Suche zu starten, benötigt Python den :term:`vollständig "

"qualifizierten <qualified name>` Namen des Moduls (oder Pakets – für die "

"Zwecke dieser Erörterung ist der Unterschied jedoch unerheblich), das "

"importiert werden soll. Dieser Name kann aus verschiedenen Argumenten der "

"Anweisung :keyword:`import` oder aus den Parametern der "

"Funktionen :func:`importlib.import_module` oder :func:`__import__` stammen."

#: ../../reference/import.rst:180

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

"Dieser Name wird in verschiedenen Phasen der Import-Suche verwendet und kann "

"den durch Punkte getrennten Pfad zu einem Submodul darstellen, z. B. "

"``foo.bar.baz``. In diesem Fall versucht Python zunächst, ``foo`` zu "

"importieren, dann ``foo.bar`` und schließlich ``foo.bar.baz``. Wenn einer "

"der Zwischenimporte fehlschlägt, wird ein :exc:`ModuleNotFoundError` "

"ausgelöst."

#: ../../reference/import.rst:187

msgid "The module cache"

msgstr "Der Modul-Cache"

#: ../../reference/import.rst:192

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

"Bei der Suche nach importierten Modulen wird zunächst "

"unter :data:`sys.modules` nachgeschaut. Diese Zuordnung dient als Cache für "

"alle Module, die zuvor importiert wurden, einschließlich der Zwischenpfade. "

"Wenn also ``foo.bar.baz`` zuvor importiert wurde, "

"enthält :data:`sys.modules` Einträge für ``foo``, ``foo.bar`` und "

"``foo.bar.baz``. Jeder Schlüssel hat als Wert das entsprechende Modulobjekt."

#: ../../reference/import.rst:199

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

"Beim Import wird der Modulname unter :data:`sys.modules` nachgeschlagen. Ist "

"dort ein Eintrag vorhanden, entspricht der zugehörige Wert dem Modul, das "

"den Import erfüllt, und der Vorgang wird abgeschlossen. Ist der Wert jedoch "

"``None``, wird eine Ausnahme vom Typ :exc:`ModuleNotFoundError` ausgelöst. "

"Fehlt der Modulname, setzt Python die Suche nach dem Modul fort."

#: ../../reference/import.rst:205

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` ist beschreibbar. Das Löschen eines Schlüssels führt "

"möglicherweise nicht zur Löschung des zugehörigen Moduls (da andere Module "

"möglicherweise Verweise darauf enthalten), macht jedoch den Cache-Eintrag "

"für das genannte Modul ungültig, sodass Python bei dessen nächstem Import "

"erneut nach dem genannten Modul sucht. Dem Schlüssel kann auch der Wert "

"``None`` zugewiesen werden, wodurch der nächste Import des Moduls "

"zwangsläufig zu einem :exc:`ModuleNotFoundError` führt."

#: ../../reference/import.rst:212

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

"Beachte jedoch: Wenn du einen Verweis auf das Modulobjekt beibehältst, "

"dessen Cache-Eintrag unter :data:`sys.modules` ungültig machst und "

"anschließend das genannte Modul erneut importierst, sind die beiden "

"Modulobjekte *nicht* identisch. Im Gegensatz dazu wird "

"bei :func:`importlib.reload` das *gleiche* Modulobjekt wiederverwendet und "

"der Inhalt des Moduls durch erneutes Ausführen des Modulcodes einfach neu "

"initialisiert."

#: ../../reference/import.rst:222

msgid "Finders and loaders"

msgstr "Finders und Loader"

#: ../../reference/import.rst:229

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

"Wird das angegebene Modul nicht unter :data:`sys.modules` gefunden, wird das "

"Importprotokoll von Python aufgerufen, um das Modul zu suchen und zu laden. "

"Dieses Protokoll besteht aus zwei konzeptionellen Objekten: :term:`finders "

"<finder>` und :term:`loaders <loader>`. Die Aufgabe eines Finders besteht "

"darin, mithilfe aller ihm bekannten Strategien festzustellen, ob er das "

"angegebene Modul finden kann. Objekte, die beide dieser Schnittstellen "

"implementieren, werden als :term:`Importer <importer>` bezeichnet – sie "

"geben sich selbst zurück, wenn sie feststellen, dass sie das angeforderte "

"Modul laden können."

#: ../../reference/import.rst:237

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 enthält eine Reihe von Standard-Findern und -Importern. Der erste "

"findet eingebaute Module, der zweite findet „frozen“ Module. Ein dritter "

"Standard-Finder durchsucht einen :term:`Importpfad <import path>` nach "

"Modulen. Der :term:`Importpfad <import path>` ist eine Liste von "

"Speicherorten, die Dateisystempfade oder ZIP-Dateien bezeichnen können. Er "

"lässt sich auch erweitern, um nach beliebigen auffindbaren Ressourcen zu "

"suchen, beispielsweise solchen, die durch URLs identifiziert werden."

#: ../../reference/import.rst:244

msgid ""

"The import machinery is extensible, so new finders can be added to extend "

"the range and scope of module searching."

msgstr ""

"Die Importmechanismen sind erweiterbar, sodass neue Suchfunktionen "

"hinzugefügt werden können, um den Umfang und die Reichweite der Modulsuche "

"zu erweitern."

#: ../../reference/import.rst:247

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

"Finder laden Module nicht tatsächlich. Wenn sie das angegebene Modul finden "

"können, geben sie eine :dfn:`Modulspezifikation` zurück, eine Kapselung der "

"importbezogenen Informationen des Moduls, die der Importmechanismus dann "

"beim Laden des Moduls verwendet."

#: ../../reference/import.rst:251

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

"In den folgenden Abschnitten wird das Protokoll für Finder und Loader näher "

"beschrieben, einschließlich der Vorgehensweise, wie du neue Finder und "

"Loader erstellst und registrierst, um die Importmechanismen zu erweitern."

#: ../../reference/import.rst:255

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

"In früheren Python-Versionen gaben Suchfunktionen direkt :term:`Loader "

"<loader>` zurück, während sie nun Modulspezifikationen zurückgeben, die "

"Loader *enthalten*. Loader werden beim Import weiterhin verwendet, haben "

"jedoch weniger Aufgaben."

#: ../../reference/import.rst:261

msgid "Import hooks"

msgstr "Import-Hooks"

#: ../../reference/import.rst:271

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

"Die Import-Mechanismen sind so konzipiert, dass sie erweiterbar sind. Der "

"wichtigste Mechanismus hierfür sind die *Import-Hooks*. Es gibt zwei Arten "

"von Import-Hooks: *Meta-Hooks* und *Import-Pfad-Hooks*."

#: ../../reference/import.rst:275

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

"Meta-Hooks werden zu Beginn der Importverarbeitung aufgerufen, noch bevor "

"andere Importvorgänge stattfinden – mit Ausnahme der Cache-Abfrage "

"unter :data:`sys.modules` “. Dadurch können Meta-Hooks die Verarbeitung "

"von :data:`sys.path`, eingefrorene Module oder sogar integrierte Module "

"überschreiben. Meta-Hooks werden registriert, indem neue Finder-Objekte zu "

"„ :data:`sys.meta_path` hinzugefügt werden, wie im Folgenden beschrieben."

#: ../../reference/import.rst:281

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

"Import-Pfad-Hooks werden im Rahmen der Verarbeitung von :data:`sys.path` "

"(oder ``package.__path__`` ) an der Stelle aufgerufen, an der das zugehörige "

"Pfadelement gefunden wird. Import-Pfad-Hooks werden registriert, indem neue "

"aufrufbare Funktionen wie unten beschrieben zu :data:`sys.path_hooks` "

"hinzugefügt werden."

#: ../../reference/import.rst:288

msgid "The meta path"

msgstr "Der Metapfad"

#: ../../reference/import.rst:294

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

"Wenn das genannte Modul unter :data:`sys.modules` nicht gefunden wird, "

"durchsucht Python als Nächstes :data:`sys.meta_path`, das eine Liste von "

"Meta-Path-Finder-Objekten enthält. Diese Finder werden abgefragt, um "

"festzustellen, ob sie wissen, wie das genannte Modul zu behandeln ist. Meta-"

"Pfadfinder müssen eine Methode "

"namens :meth:`~importlib.abc.MetaPathFinder.find_spec` implementieren, die "

"drei Argumente entgegennimmt: einen Namen, einen Importpfad und (optional) "

"ein Zielmodul. Der Meta-Pfadfinder kann eine beliebige Strategie anwenden, "

"um festzustellen, ob er das genannte Modul verarbeiten kann oder nicht."

#: ../../reference/import.rst:303

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

"Wenn der Meta-Path-Finder weiß, wie das benannte Modul zu verarbeiten ist, "

"gibt er ein Spec-Objekt zurück. Kann er das benannte Modul nicht "

"verarbeiten, gibt er ``None`` zurück. Erreicht die Verarbeitung "

"von :data:`sys.meta_path` das Ende der Liste, ohne ein Spec zurückzugeben, "

"wird eine :exc:`ModuleNotFoundError`-Ausnahme ausgelöst. Alle anderen "

"ausgelösten Ausnahmen werden einfach nach oben weitergeleitet, wodurch der "

"Importvorgang abgebrochen wird."

#: ../../reference/import.rst:309

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

"Die Methode :meth:`~importlib.abc.MetaPathFinder.find_spec` von Meta-"

"Pfadfindern wird mit zwei oder drei Argumenten aufgerufen. Das erste "

"Argument ist der vollqualifizierte Name des zu importierenden Moduls, zum "

"Beispiel ``foo.bar.baz``. Das zweite Argument enthält die Pfadeinträge, die "

"für die Modulsuche verwendet werden sollen. Bei Modulen der obersten Ebene "

"ist das zweite Argument ``None``, bei Submodulen oder Subpaketen hingegen "

"ist das zweite Argument der Wert des Attributs ``__path__`` des "

"übergeordneten Pakets. Kann nicht auf das entsprechende Attribut "

"``__path__`` zugegriffen werden, wird eine :exc:`ModuleNotFoundError` "

"ausgelöst. Das dritte Argument ist ein vorhandenes Modulobjekt, das später "

"als Ziel für das Laden dient. Das Import-System übergibt ein Zielmodul nur "

"während des Neuladens."

#: ../../reference/import.rst:320

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

"Der Metapfad kann bei einer einzelnen Importanforderung mehrfach durchlaufen "

"werden. Angenommen, keines der beteiligten Module wurde bereits "

"zwischengespeichert, dann führt der Import von ``foo.bar.baz`` zunächst "

"einen Import auf oberster Ebene durch, wobei bei jedem Metapfad-Finder "

"(``mpf``) die Funktion ``mpf.find_spec(\"foo\", None, None)`` aufgerufen "

"wird. Nachdem ``foo`` importiert wurde, wird ``foo.bar`` durch ein zweites "

"Durchlaufen des Metapfads importiert, wobei ``mpf.find_spec(\"foo.bar\", "

"foo.__path__, None)`` aufgerufen wird. Sobald ``foo.bar`` importiert wurde, "

"ruft der letzte Durchlauf ``mpf.find_spec(\"foo.bar.baz\", foo.bar.__path__, "

"None)`` auf."

#: ../../reference/import.rst:330

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

"Einige Meta-Path-Finder unterstützen nur Importe auf oberster Ebene. Diese "

"Importer geben stets ``None`` zurück, wenn als zweites Argument etwas "

"anderes als ``None`` übergeben wird."

#: ../../reference/import.rst:334

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

"Pythons Standard- :data:`sys.meta_path` verfügt über drei Meta-Pfadfinder: "

"einen, der weiß, wie man integrierte Module importiert, einen, der weiß, wie "

"man \"frozen\" Module importiert, und einen, der weiß, wie man Module aus "

"einem :term:`Importpfad <import path>` importiert (d. h. "

"den :term:`pfadbasierten Finder <path based finder>`)."

#: ../../reference/import.rst:339

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

"Die Methode :meth:`~importlib.abc.MetaPathFinder.find_spec` der Meta-Path-"

"Finder hat :meth:`!find_module` ersetzt, die nun veraltet ist. Sie "

"funktioniert zwar weiterhin unverändert, doch der Importmechanismus greift "

"nur dann darauf zurück, wenn der "

"Finder :meth:`~importlib.abc.MetaPathFinder.find_spec` nicht implementiert."

#: ../../reference/import.rst:346

msgid ""

"Use of :meth:`!find_module` by the import system now "

"raises :exc:`ImportWarning`."

msgstr ""

"Die Verwendung von :meth:`!find_module` durch das Import-System löst nun den "

"Fehler :exc:`ImportWarning` aus."

#: ../../reference/import.rst:350

msgid ""

":meth:`!find_module` has been removed. "

"Use :meth:`~importlib.abc.MetaPathFinder.find_spec` instead."

msgstr ""

":meth:`!find_module` wurde entfernt. Verwende "

"stattdessen :meth:`~importlib.abc.MetaPathFinder.find_spec`."

#: ../../reference/import.rst:356

msgid "Loading"

msgstr "Module laden"

#: ../../reference/import.rst:358

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

"Wird eine Modulspezifikation gefunden, verwendet der Importmechanismus diese "

"(und den darin enthaltenen Loader) beim Laden des Moduls. Hier ist eine "

"grobe Beschreibung dessen, was während des Ladevorgangs von \"import:\" "

"geschieht:"

#: ../../reference/import.rst:362

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"

"\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"

" # Es wird davon ausgegangen, dass 'exec_module' ebenfalls auf dem Loader "

"definiert ist.\n"

" module = spec.loader.create_module(spec)\n"

"if module is None:\n"

" module = ModuleType(spec.name)\n"

"# Die importbezogenen Modulattribute werden hier gesetzt:\n"

"_init_module_attrs(spec, module)\n"

"\n"

"if spec.loader is None:\n"

" # nicht unterstützt\n"

" raise ImportError\n"

"\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:386

msgid "Note the following details:"

msgstr "Beachte bitte folgende Details:"

#: ../../reference/import.rst:388

msgid ""

"If there is an existing module object with the given name "

"in :data:`sys.modules`, import will have already returned it."

msgstr ""

"Wenn unter :data:`sys.modules` bereits ein Modulobjekt mit dem angegebenen "

"Namen vorhanden ist, hat \"import\" dieses bereits zurückgegeben."

#: ../../reference/import.rst:391

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

"Das Modul wird in :data:`sys.modules` vorhanden sein, bevor der Loader den "

"Modulcode ausführt. Dies ist von entscheidender Bedeutung, da der Modulcode "

"sich möglicherweise (direkt oder indirekt) selbst importiert. Durch das "

"vorherige Hinzufügen zu :data:`sys.modules` wird im schlimmsten Fall eine "

"unbegrenzte Rekursion und im besten Fall ein mehrfaches Laden verhindert."

#: ../../reference/import.rst:397

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

"Wenn das Laden fehlschlägt, wird das fehlerhafte Modul – und nur das "

"fehlerhafte Modul – aus :data:`sys.modules` entfernt. Alle Module, die sich "

"bereits im Cache von :data:`sys.modules` befinden, sowie alle Module, die "

"als Nebeneffekt erfolgreich geladen wurden, müssen im Cache verbleiben. Dies "

"steht im Gegensatz zum Neuladen, bei dem selbst das fehlerhafte Modul "

"in :data:`sys.modules` verbleibt."

#: ../../reference/import.rst:403

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

"Nachdem das Modul erstellt wurde, aber noch vor seiner Ausführung, legt der "

"Importmechanismus die importbezogenen Modulattribute fest "

"(\"_init_module_attrs\" im obigen Pseudocode-Beispiel), wie in "

"einem :ref:`späteren Abschnitt <import-mod-attrs>` zusammengefasst."

#: ../../reference/import.rst:408

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

"Die Modulausführung ist der entscheidende Moment beim Laden, in dem der "

"Namensraum des Moduls gefüllt wird. Die Ausführung wird vollständig an den "

"Loader delegiert, der entscheidet, was wie gefüllt wird."

#: ../../reference/import.rst:412

msgid ""

"The module created during loading and passed to exec_module() may not be the "

"one returned at the end of import [#fnlo]_."

msgstr ""

"Das beim Laden erstellte und an `exec_module()` übergebene Modul ist "

"möglicherweise nicht dasselbe, das am Ende des Importvorgangs von [#fnlo]_ "

"zurückgegeben wird."

#: ../../reference/import.rst:415

msgid ""

"The import system has taken over the boilerplate responsibilities of "

"loaders. These were previously performed by the "

"``importlib.abc.Loader.load_module`` method."

msgstr ""

"Das Import-System hat die Routineaufgaben der Loader übernommen. Diese "

"wurden zuvor von der Methode ``importlib.abc.Loader.load_module`` ausgeführt."

#: ../../reference/import.rst:420

msgid "The ``load_module`` method is no longer used."

msgstr "Die Methode ``load_module`` wird nicht mehr verwendet."

#: ../../reference/import.rst:424

msgid "Loaders"

msgstr "Modullader"

#: ../../reference/import.rst:426

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

"Modullader erfüllen die entscheidende Funktion des Ladens: die Ausführung "

"des Moduls. Der Importmechanismus ruft die "

"Methode :meth:`importlib.abc.Loader.exec_module` mit einem einzigen Argument "

"auf, nämlich dem auszuführenden Modulobjekt. Jeder "

"von :meth:`~importlib.abc.Loader.exec_module` zurückgegebene Wert wird "

"ignoriert."

#: ../../reference/import.rst:431

msgid "Loaders must satisfy the following requirements:"

msgstr "Lader müssen die folgenden Anforderungen erfüllen:"

#: ../../reference/import.rst:433

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

"Handelt es sich bei dem Modul um ein Python-Modul (im Gegensatz zu einem "

"integrierten Modul oder einer dynamisch geladenen Erweiterung), sollte der "

"Loader den Code des Moduls im globalen Namensraum des Moduls ausführen "

"(``module.__dict__``)."

#: ../../reference/import.rst:437

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

"Wenn der Loader das Modul nicht ausführen kann, sollte er "

"eine :exc:`ImportError` auslösen. Alle anderen Ausnahmen, die "

"während :meth:`~importlib.abc.Loader.exec_module` ausgelöst werden, werden "

"jedoch weitergegeben."

#: ../../reference/import.rst:441

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

"In vielen Fällen können Finder und Loader dasselbe Objekt sein. In solchen "

"Fällen würde die Methode :meth:`~importlib.abc.MetaPathFinder.find_spec` "

"lediglich eine Spezifikation zurückgeben, bei der der Loader auf ``self`` "

"gesetzt ist."

#: ../../reference/import.rst:445

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

"Modullader können sich dafür entscheiden, das Modulobjekt während des Ladens "

"zu erstellen, indem sie eine "

"Methode :meth:`~importlib.abc.Loader.create_module` implementieren. Diese "

"Methode nimmt ein Argument entgegen – die Modulspezifikation – und gibt das "

"neue Modulobjekt zurück, das während des Ladens verwendet werden soll. "

"``create_module()`` muss keine Attribute für das Modulobjekt festlegen. Wenn "

"die Methode ``None`` zurückgibt, erstellt der Importmechanismus das neue "

"Modul selbst."

#: ../../reference/import.rst:452

msgid "The :meth:`~importlib.abc.Loader.create_module` method of loaders."

msgstr ""

"Die :meth:`~importlib.abc.Loader.create_module`-Methode bei Modullader."

#: ../../reference/import.rst:455

msgid ""

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

"Die Methode ``importlib.abc.Loader.load_module`` wurde "

"durch :meth:`~importlib.abc.Loader.exec_module` ersetzt, und der "

"Importmechanismus hat alle Routineaufgaben beim Laden übernommen."

#: ../../reference/import.rst:460

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

"Um die Kompatibilität mit bestehenden Ladern zu gewährleisten, verwendet die "

"Import-Maschinerie die Methode ``load_module()`` der Lader, sofern diese "

"vorhanden ist und der Lader nicht zusätzlich ``exec_module()`` "

"implementiert. ``load_module()`` ist jedoch veraltet, und Lader sollten "

"stattdessen ``exec_module()`` implementieren."

#: ../../reference/import.rst:465

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

"Die Methode ``load_module()`` muss neben der Ausführung des Moduls auch alle "

"oben beschriebenen Standardfunktionen zum Laden des Moduls implementieren. "

"Es gelten dieselben Einschränkungen, wobei einige zusätzliche Erläuterungen "

"zu beachten sind:"

#: ../../reference/import.rst:469

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

"Wenn in :data:`sys.modules` bereits ein Modulobjekt mit dem angegebenen "