# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-08-22 12:07+0200\n"

"PO-Revision-Date: 2025-09-16 00:02+0000\n"

"Last-Translator: Swen Bachmann <[email protected]>\n"

"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/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"

#: ../../tutorial/modules.rst:5

msgid "Modules"

msgstr "Module"

#: ../../tutorial/modules.rst:7

msgid ""

"If you quit from the Python interpreter and enter it again, the definitions "

"you have made (functions and variables) are lost. Therefore, if you want to "

"write a somewhat longer program, you are better off using a text editor to "

"prepare the input for the interpreter and running it with that file as input "

"instead. This is known as creating a *script*. As your program gets "

"longer, you may want to split it into several files for easier maintenance. "

"You may also want to use a handy function that you've written in several "

"programs without copying its definition into each program."

msgstr ""

"Wenn du den Python-Interpreter beenden und erneut starten, gehen die von dir "

"erstellten Definitionen (Funktionen und Variablen) verloren. Wenn du also "

"ein etwas längeres Programm schreiben möchtest, solltest du die Eingabe für "

"den Interpreter besser in einem Texteditor vorbereiten und den Interpreter "

"stattdessen mit dieser Datei als Eingabe ausführen. Dies wird als Erstellen "

"eines *Skripts* bezeichnet. Wenn dein Programm länger wird, möchtest du es "

"möglicherweise zur einfacheren Wartung in mehrere Dateien aufteilen. "

"Vielleicht möchtest du auch eine nützliche Funktion, die du geschrieben "

"hast, in mehreren Programmen verwenden, ohne deren Definition in jedes "

"Programm kopieren zu müssen."

#: ../../tutorial/modules.rst:16

msgid ""

"To support this, Python has a way to put definitions in a file and use them "

"in a script or in an interactive instance of the interpreter. Such a file is "

"called a *module*; definitions from a module can be *imported* into other "

"modules or into the *main* module (the collection of variables that you have "

"access to in a script executed at the top level and in calculator mode)."

msgstr ""

"Um dies zu unterstützen, bietet Python die Möglichkeit, Definitionen in "

"einer Datei zu speichern und sie in einem Skript oder in einer interaktiven "

"Instanz des Interpreters zu verwenden. Eine solche Datei wird als *Modul* "

"bezeichnet; Definitionen aus einem Modul können in andere Module oder in das "

"*Hauptmodul* (*main*) *importiert* werden (die Sammlung von Variablen, auf "

"die du in einem Skript auf oberster Ebene und im Taschenrechnermodus Zugriff "

"hast)."

#: ../../tutorial/modules.rst:22

msgid ""

"A module is a file containing Python definitions and statements. The file "

"name is the module name with the suffix :file:`.py` appended. Within a "

"module, the module's name (as a string) is available as the value of the "

"global variable ``__name__``. For instance, use your favorite text editor "

"to create a file called :file:`fibo.py` in the current directory with the "

"following contents::"

msgstr ""

"Ein Modul ist eine Datei, die Python-Definitionen und -Anweisungen enthält. "

"Der Dateiname besteht aus dem Modulnamen mit dem angehängten Suffix :file:`."

"py`. Innerhalb eines Moduls steht der Modulname (als Zeichenkette) als Wert "

"der globalen Variablen ``__name__`` zur Verfügung. Erstelle beispielsweise "

"mit deinem bevorzugten Texteditor im aktuellen Verzeichnis eine Datei "

"namens :file:`fibo.py` mit folgendem Inhalt::"

#: ../../tutorial/modules.rst:28

msgid ""

"# Fibonacci numbers module\n"

"\n"

"def fib(n):\n"

" \"\"\"Write Fibonacci series up to n.\"\"\"\n"

" a, b = 0, 1\n"

" while a < n:\n"

" print(a, end=' ')\n"

" a, b = b, a+b\n"

" print()\n"

"\n"

"def fib2(n):\n"

" \"\"\"Return Fibonacci series up to n.\"\"\"\n"

" result = []\n"

" a, b = 0, 1\n"

" while a < n:\n"

" result.append(a)\n"

" a, b = b, a+b\n"

" return result"

msgstr ""

"# Modul „Fibonacci-Zahlen“\n"

"\n"

"def fib(n):\n"

" \"\"\"Die Fibonacci-Folge bis n ausgeben.\"\"\"\n"

" a, b = 0, 1\n"

" while a < n:\n"

" print(a, end=' ')\n"

" a, b = b, a+b\n"

" print()\n"

"\n"

"def fib2(n):\n"

" \"\"\"Gibt die Fibonacci-Folge bis n zurück.\"\"\"\n"

" result = []\n"

" a, b = 0, 1\n"

" while a < n:\n"

" result.append(a)\n"

" a, b = b, a+b\n"

" return result"

#: ../../tutorial/modules.rst:47

msgid ""

"Now enter the Python interpreter and import this module with the following "

"command::"

msgstr ""

"Öffne nun den Python-Interpreter und importiere dieses Modul mit dem "

"folgenden Befehl::"

#: ../../tutorial/modules.rst:50

msgid ">>> import fibo"

msgstr ">>> import fibo"

#: ../../tutorial/modules.rst:52

msgid ""

"This does not add the names of the functions defined in ``fibo`` directly "

"to the current :term:`namespace` (see :ref:`tut-scopes` for more details); "

"it only adds the module name ``fibo`` there. Using the module name you can "

"access the functions::"

msgstr ""

"Dadurch werden die Namen der in ``fibo`` definierten Funktionen nicht direkt "

"zum aktuellen :term:`Namensraum <namespace>` hinzugefügt (weitere Details "

"findest du unter :ref:`tut-scopes` ); es wird dort lediglich der Modulname "

"``fibo`` hinzugefügt. Über den Modulnamen kannst du auf die Funktionen "

"zugreifen::"

#: ../../tutorial/modules.rst:57

msgid ""

">>> fibo.fib(1000)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987\n"

">>> fibo.fib2(100)\n"

"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n"

">>> fibo.__name__\n"

"'fibo'"

msgstr ""

">>> fibo.fib(1000)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987\n"

">>> fibo.fib2(100)\n"

"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n"

">>> fibo.__name__\n"

"'fibo'"

#: ../../tutorial/modules.rst:64

msgid ""

"If you intend to use a function often you can assign it to a local name::"

msgstr ""

"Wenn du eine Funktion häufig verwenden möchtest, kannst du ihr einen lokalen "

"Namen zuweisen::"

#: ../../tutorial/modules.rst:66

msgid ""

">>> fib = fibo.fib\n"

">>> fib(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

msgstr ""

">>> fib = fibo.fib\n"

">>> fib(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

#: ../../tutorial/modules.rst:74

msgid "More on Modules"

msgstr "Mehr zum Thema Module"

#: ../../tutorial/modules.rst:76

msgid ""

"A module can contain executable statements as well as function definitions. "

"These statements are intended to initialize the module. They are executed "

"only the *first* time the module name is encountered in an import statement. "

"[#]_ (They are also run if the file is executed as a script.)"

msgstr ""

"Ein Modul kann sowohl ausführbare Anweisungen als auch Funktionsdefinitionen "

"enthalten. Diese Anweisungen dienen der Initialisierung des Moduls. Sie "

"werden nur beim *ersten* Auftreten des Modulnamens in einer Importanweisung "

"ausgeführt. [#]_ (Sie werden auch ausgeführt, wenn die Datei als Skript "

"ausgeführt wird.)"

#: ../../tutorial/modules.rst:81

msgid ""

"Each module has its own private namespace, which is used as the global "

"namespace by all functions defined in the module. Thus, the author of a "

"module can use global variables in the module without worrying about "

"accidental clashes with a user's global variables. On the other hand, if you "

"know what you are doing you can touch a module's global variables with the "

"same notation used to refer to its functions, ``modname.itemname``."

msgstr ""

"Jedes Modul verfügt über einen eigenen privaten Namensraum, der von allen im "

"Modul definierten Funktionen als globaler Namensraum genutzt wird. Somit "

"kann der Autor eines Moduls globale Variablen im Modul verwenden, ohne sich "

"Gedanken über versehentliche Konflikte mit den globalen Variablen eines "

"Benutzers machen zu müssen. Andererseits kannst du, wenn du weisst, was du "

"tust, auf die globalen Variablen eines Moduls mit derselben Notation "

"zugreifen, die auch für den Verweis auf dessen Funktionen verwendet wird: "

"``modname.itemname``."

#: ../../tutorial/modules.rst:88

msgid ""

"Modules can import other modules. It is customary but not required to place "

"all :keyword:`import` statements at the beginning of a module (or script, "

"for that matter). The imported module names, if placed at the top level of "

"a module (outside any functions or classes), are added to the module's "

"global namespace."

msgstr ""

"Module können andere Module importieren. Es ist üblich, aber nicht zwingend "

"erforderlich, alle :keyword:`import`-Anweisungen am Anfang eines Moduls "

"(oder Skripts) zu platzieren. Die Namen der importierten Module werden, "

"sofern sie auf der obersten Ebene eines Moduls (außerhalb von Funktionen "

"oder Klassen) stehen, dem globalen Namensraum des Moduls hinzugefügt."

#: ../../tutorial/modules.rst:93

msgid ""

"There is a variant of the :keyword:`import` statement that imports names "

"from a module directly into the importing module's namespace. For example::"

msgstr ""

"Es gibt eine Variante der Anweisung :keyword:`import`, mit der Namen aus "

"einem Modul direkt in den Namensraum des importierenden Moduls importiert "

"werden. Zum Beispiel::"

#: ../../tutorial/modules.rst:96

msgid ""

">>> from fibo import fib, fib2\n"

">>> fib(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

msgstr ""

">>> from fibo import fib, fib2\n"

">>> fib(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

#: ../../tutorial/modules.rst:100

msgid ""

"This does not introduce the module name from which the imports are taken in "

"the local namespace (so in the example, ``fibo`` is not defined)."

msgstr ""

"Dadurch wird der Modulname, aus dem die Importe stammen, nicht in den "

"lokalen Namensraum eingeführt (im Beispiel ist ``fibo`` also nicht "

"definiert)."

#: ../../tutorial/modules.rst:103

msgid "There is even a variant to import all names that a module defines::"

msgstr ""

"Es gibt sogar eine Variante, mit der alle von einem Modul definierten Namen "

"importiert werden können::"

#: ../../tutorial/modules.rst:105

msgid ""

">>> from fibo import *\n"

">>> fib(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

msgstr ""

">>> from fibo import *\n"

">>> fib(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

#: ../../tutorial/modules.rst:109

msgid ""

"This imports all names except those beginning with an underscore (``_``). In "

"most cases Python programmers do not use this facility since it introduces "

"an unknown set of names into the interpreter, possibly hiding some things "

"you have already defined."

msgstr ""

"Dadurch werden alle Namen importiert, mit Ausnahme derjenigen, die mit einem "

"Unterstrich beginnen (``_``). In den meisten Fällen nutzen Python-"

"Programmierer diese Funktion nicht, da dadurch eine unbekannte Menge von "

"Namen in den Interpreter eingeführt wird, wodurch möglicherweise einige "

"bereits von dir definierte Elemente verdeckt werden."

#: ../../tutorial/modules.rst:114

msgid ""

"Note that in general the practice of importing ``*`` from a module or "

"package is frowned upon, since it often causes poorly readable code. "

"However, it is okay to use it to save typing in interactive sessions."

msgstr ""

"Beachte, dass das Importieren von ``*`` aus einem Modul oder Paket im "

"Allgemeinen nicht gerne gesehen wird, da dies oft zu schwer lesbarem Code "

"führt. Es ist jedoch in Ordnung, diese Funktion zu verwenden, um sich in "

"interaktiven Sitzungen Tipparbeit zu ersparen."

#: ../../tutorial/modules.rst:118

msgid ""

"If the module name is followed by :keyword:`!as`, then the name following :"

"keyword:`!as` is bound directly to the imported module."

msgstr ""

"Folgt auf den Modulnamen :keyword:`!as`, wird der Name nach :keyword:`!as` "

"direkt an das importierte Modul gebunden."

#: ../../tutorial/modules.rst:123

msgid ""

">>> import fibo as fib\n"

">>> fib.fib(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

msgstr ""

">>> import fibo as fib\n"

">>> fib.fib(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

#: ../../tutorial/modules.rst:127

msgid ""

"This is effectively importing the module in the same way that ``import "

"fibo`` will do, with the only difference of it being available as ``fib``."

msgstr ""

"Damit wird das Modul im Grunde genauso importiert wie mit dem Befehl "

"``import fibo``, mit dem einzigen Unterschied, dass es unter ``fib`` "

"verfügbar ist."

#: ../../tutorial/modules.rst:130

msgid ""

"It can also be used when utilising :keyword:`from` with similar effects::"

msgstr ""

"Es kann auch bei der Verwendung von :keyword:`from` mit ähnlichen Effekten "

"eingesetzt werden::"

#: ../../tutorial/modules.rst:132

msgid ""

">>> from fibo import fib as fibonacci\n"

">>> fibonacci(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

msgstr ""

">>> from fibo import fib as fibonacci\n"

">>> fibonacci(500)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"

#: ../../tutorial/modules.rst:139

msgid ""

"For efficiency reasons, each module is only imported once per interpreter "

"session. Therefore, if you change your modules, you must restart the "

"interpreter -- or, if it's just one module you want to test interactively, "

"use :func:`importlib.reload`, e.g. ``import importlib; importlib."

"reload(modulename)``."

msgstr ""

"Aus Effizienzgründen wird jedes Modul pro Interpreter-Sitzung nur einmal "

"geladen. Wenn du also deine Module änderst, musst du den Interpreter neu "

"starten – oder, falls du nur ein Modul interaktiv testen möchten, die "

"Funktion :func:`importlib.reload` verwenden, z. B. ``import importlib; "

"importlib.reload(modulename)``."

#: ../../tutorial/modules.rst:149

msgid "Executing modules as scripts"

msgstr "Module als Skripte ausführen"

#: ../../tutorial/modules.rst:151

msgid "When you run a Python module with ::"

msgstr "Wenn du ein Python-Modul mit :: ausführst:"

#: ../../tutorial/modules.rst:153

msgid "python fibo.py <arguments>"

msgstr "python fibo.py <arguments>"

#: ../../tutorial/modules.rst:155

msgid ""

"the code in the module will be executed, just as if you imported it, but "

"with the ``__name__`` set to ``\"__main__\"``. That means that by adding "

"this code at the end of your module::"

msgstr ""

"Der Code im Modul wird ausgeführt, genau so, als hättest du ihn importiert, "

"allerdings mit der Einstellung ``__name__`` auf ``\"__main__\"``. Das "

"bedeutet, dass du durch Hinzufügen dieses Codes am Ende deines Moduls::"

#: ../../tutorial/modules.rst:159

msgid ""

"if __name__ == \"__main__\":\n"

" import sys\n"

" fib(int(sys.argv[1]))"

msgstr ""

"if __name__ == \"__main__\":\n"

" import sys\n"

" fib(int(sys.argv[1]))"

#: ../../tutorial/modules.rst:163

msgid ""

"you can make the file usable as a script as well as an importable module, "

"because the code that parses the command line only runs if the module is "

"executed as the \"main\" file:"

msgstr ""

"Du kannst die Datei sowohl als Skript als auch als importierbares Modul "

"nutzen, da der Code, der die Befehlszeile auswertet, nur ausgeführt wird, "

"wenn das Modul als \"Hauptdatei\" ausgeführt wird:"

#: ../../tutorial/modules.rst:167

msgid ""

"$ python fibo.py 50\n"

"0 1 1 2 3 5 8 13 21 34"

msgstr ""

"$ python fibo.py 50\n"

"0 1 1 2 3 5 8 13 21 34"

#: ../../tutorial/modules.rst:172

msgid "If the module is imported, the code is not run::"

msgstr "Wenn das Modul importiert wird, wird der Code nicht ausgeführt::"

#: ../../tutorial/modules.rst:174

msgid ""

">>> import fibo\n"

">>>"

msgstr ""

">>> import fibo\n"

">>>"

#: ../../tutorial/modules.rst:177

msgid ""

"This is often used either to provide a convenient user interface to a "

"module, or for testing purposes (running the module as a script executes a "

"test suite)."

msgstr ""

"Dies wird häufig entweder verwendet, um eine benutzerfreundliche Oberfläche "

"für ein Modul bereitzustellen, oder zu Testzwecken (die Ausführung des "

"Moduls als Skript führt eine Testsuite aus)."

#: ../../tutorial/modules.rst:184

msgid "The Module Search Path"

msgstr "Der Suchpfad für Module"

#: ../../tutorial/modules.rst:188

msgid ""

"When a module named :mod:`!spam` is imported, the interpreter first searches "

"for a built-in module with that name. These module names are listed in :data:"

"`sys.builtin_module_names`. If not found, it then searches for a file named :"

"file:`spam.py` in a list of directories given by the variable :data:`sys."

"path`. :data:`sys.path` is initialized from these locations:"

msgstr ""

"Wenn ein Modul namens :mod:`!spam` importiert wird, sucht der Interpreter "

"zunächst nach einem integrierten Modul mit diesem Namen. Diese Modulnamen "

"sind unter :data:`sys.builtin_module_names` aufgeführt. Wird es dort nicht "

"gefunden, sucht er anschließend nach einer Datei namens :file:`spam.py` in "

"einer Liste von Verzeichnissen, die durch die Variable :data:`sys.path` "

"angegeben wird. :data:`sys.path` wird anhand dieser Speicherorte "

"initialisiert:"

#: ../../tutorial/modules.rst:194

msgid ""

"The directory containing the input script (or the current directory when no "

"file is specified)."

msgstr ""

"Das Verzeichnis, in dem sich das Eingabeskript befindet (oder das aktuelle "

"Verzeichnis, wenn keine Datei angegeben ist)."

#: ../../tutorial/modules.rst:196

msgid ""

":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the "

"shell variable :envvar:`PATH`)."

msgstr ""

":envvar:`PYTHONPATH` (eine Liste von Verzeichnisnamen, deren Syntax der der "

"Shell-Variablen :envvar:`PATH` entspricht)."

#: ../../tutorial/modules.rst:198

msgid ""

"The installation-dependent default (by convention including a ``site-"

"packages`` directory, handled by the :mod:`site` module)."

msgstr ""

"Die installationsabhängige Standardeinstellung (gemäß Konvention "

"einschließlich des Verzeichnisses ``site-packages``, das vom Modul :mod:"

"`site` verwaltet wird)."

#: ../../tutorial/modules.rst:201

msgid "More details are at :ref:`sys-path-init`."

msgstr "Weitere Informationen findest du unter :ref:`sys-path-init`."

#: ../../tutorial/modules.rst:204

msgid ""

"On file systems which support symlinks, the directory containing the input "

"script is calculated after the symlink is followed. In other words the "

"directory containing the symlink is **not** added to the module search path."

msgstr ""

"Bei Dateisystemen, die symbolische Links unterstützen, wird das Verzeichnis, "

"in dem sich das Eingabeskript befindet, erst ermittelt, nachdem dem "

"symbolischen Link gefolgt wurde. Mit anderen Worten: Das Verzeichnis, in dem "

"sich der symbolische Link befindet, wird **nicht** zum Suchpfad des Moduls "

"hinzugefügt."

#: ../../tutorial/modules.rst:208

msgid ""

"After initialization, Python programs can modify :data:`sys.path`. The "

"directory containing the script being run is placed at the beginning of the "

"search path, ahead of the standard library path. This means that scripts in "

"that directory will be loaded instead of modules of the same name in the "

"library directory. This is an error unless the replacement is intended. See "

"section :ref:`tut-standardmodules` for more information."

msgstr ""

"Nach der Initialisierung können Python-Programme die Variable :data:`sys."

"path` ändern. Das Verzeichnis, in dem sich das ausgeführte Skript befindet, "

"wird an den Anfang des Suchpfads gesetzt, noch vor dem "

"Standardbibliothekspfad. Das bedeutet, dass Skripte in diesem Verzeichnis "

"anstelle von Modulen mit demselben Namen im Bibliotheksverzeichnis geladen "

"werden. Dies führt zu einem Fehler, es sei denn, die Ersetzung ist "

"beabsichtigt. Weitere Informationen findest du im Abschnitt :ref:`tut-"

"standardmodules` ."

#: ../../tutorial/modules.rst:221

msgid "\"Compiled\" Python files"

msgstr "\"Kompilierte\" Python-Dateien"

#: ../../tutorial/modules.rst:223

msgid ""

"To speed up loading modules, Python caches the compiled version of each "

"module in the ``__pycache__`` directory under the name :file:`module."

"{version}.pyc`, where the version encodes the format of the compiled file; "

"it generally contains the Python version number. For example, in CPython "

"release 3.3 the compiled version of spam.py would be cached as ``__pycache__/"

"spam.cpython-33.pyc``. This naming convention allows compiled modules from "

"different releases and different versions of Python to coexist."

msgstr ""

"Um das Laden von Modulen zu beschleunigen, speichert Python die kompilierte "

"Version jedes Moduls im Verzeichnis ``__pycache__`` unter dem Namen :file:"

"`module.{version}.pyc` , wobei die Versionsangabe das Format der "

"kompilierten Datei angibt; sie enthält in der Regel die Python-"

"Versionsnummer. Beispielsweise würde in der CPython-Version 3.3 die "

"kompilierte Version von spam.py als ``__pycache__/spam.cpython-33.pyc`` "

"zwischengespeichert werden. Diese Namenskonvention ermöglicht es, dass "

"kompilierte Module aus verschiedenen Releases und verschiedenen Python-"

"Versionen nebeneinander existieren können."

#: ../../tutorial/modules.rst:231

msgid ""

"Python checks the modification date of the source against the compiled "

"version to see if it's out of date and needs to be recompiled. This is a "

"completely automatic process. Also, the compiled modules are platform-"

"independent, so the same library can be shared among systems with different "

"architectures."

msgstr ""

"Python vergleicht das Änderungsdatum der Quelldatei mit der kompilierten "

"Version, um festzustellen, ob diese veraltet ist und neu kompiliert werden "

"muss. Dies ist ein vollständig automatischer Vorgang. Außerdem sind die "

"kompilierten Module plattformunabhängig, sodass dieselbe Bibliothek auf "

"Systemen mit unterschiedlichen Architekturen gemeinsam genutzt werden kann."

#: ../../tutorial/modules.rst:236

msgid ""

"Python does not check the cache in two circumstances. First, it always "

"recompiles and does not store the result for the module that's loaded "

"directly from the command line. Second, it does not check the cache if "

"there is no source module. To support a non-source (compiled only) "

"distribution, the compiled module must be in the source directory, and there "

"must not be a source module."

msgstr ""

"Python überprüft den Cache unter zwei Umständen nicht. Erstens wird das "

"Modul, das direkt über die Befehlszeile geladen wird, immer neu kompiliert, "

"und das Ergebnis wird nicht gespeichert. Zweitens wird der Cache nicht "

"überprüft, wenn kein Quellmodul vorhanden ist. Um eine Distribution ohne "

"Quellcode (nur kompiliert) zu unterstützen, muss sich das kompilierte Modul "

"im Quellverzeichnis befinden, und es darf kein Quellmodul vorhanden sein."

#: ../../tutorial/modules.rst:243

msgid "Some tips for experts:"

msgstr "Einige Tipps für Experten:"

#: ../../tutorial/modules.rst:245

msgid ""

"You can use the :option:`-O` or :option:`-OO` switches on the Python command "

"to reduce the size of a compiled module. The ``-O`` switch removes assert "

"statements, the ``-OO`` switch removes both assert statements and __doc__ "

"strings. Since some programs may rely on having these available, you should "

"only use this option if you know what you're doing. \"Optimized\" modules "

"have an ``opt-`` tag and are usually smaller. Future releases may change "

"the effects of optimization."

msgstr ""

"Sie können die Schalter :option:`-O` oder :option:`-OO` im Python-Befehl "

"verwenden, um die Größe eines kompilierten Moduls zu verringern. Der "

"Schalter ``-O`` entfernt \"assert\"-Anweisungen, der Schalter ``-OO`` "

"entfernt sowohl \"assert\"-Anweisungen als auch \"__doc__\"-Zeichenketten. "

"Da manche Programme möglicherweise darauf angewiesen sind, dass diese "

"verfügbar sind, solltest du diese Option nur verwenden, wenn du genau "

"weisst, was du tust. \"Optimierte\" Module tragen das Tag ``opt-`` und sind "

"in der Regel kleiner. In zukünftigen Versionen können sich die Auswirkungen "

"der Optimierung ändern."

#: ../../tutorial/modules.rst:253

msgid ""

"A program doesn't run any faster when it is read from a ``.pyc`` file than "

"when it is read from a ``.py`` file; the only thing that's faster about ``."

"pyc`` files is the speed with which they are loaded."

msgstr ""

"Ein Programm läuft nicht schneller, wenn es aus einer ``.pyc`` -Datei "

"geladen wird, als wenn es aus einer ``.py`` -Datei geladen wird; das "

"Einzige, was bei ``.pyc`` -Dateien schneller ist, ist die Geschwindigkeit, "

"mit der sie geladen werden."

#: ../../tutorial/modules.rst:257

msgid ""

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

"directory."

msgstr ""

"Das Modul :mod:`compileall` kann für alle Module in einem Verzeichnis .pyc-"

"Dateien erstellen."

#: ../../tutorial/modules.rst:260

msgid ""

"There is more detail on this process, including a flow chart of the "

"decisions, in :pep:`3147`."

msgstr ""

"Weitere Einzelheiten zu diesem Prozess, einschließlich eines "

"Entscheidungsdiagramms, findest du unter :pep:`3147`."

#: ../../tutorial/modules.rst:267

msgid "Standard Modules"

msgstr "Standardmodule"

#: ../../tutorial/modules.rst:271

msgid ""

"Python comes with a library of standard modules, described in a separate "

"document, the Python Library Reference (\"Library Reference\" hereafter). "

"Some modules are built into the interpreter; these provide access to "

"operations that are not part of the core of the language but are "

"nevertheless built in, either for efficiency or to provide access to "

"operating system primitives such as system calls. The set of such modules "

"is a configuration option which also depends on the underlying platform. "

"For example, the :mod:`winreg` module is only provided on Windows systems. "

"One particular module deserves some attention: :mod:`sys`, which is built "

"into every Python interpreter. The variables ``sys.ps1`` and ``sys.ps2`` "

"define the strings used as primary and secondary prompts::"

msgstr ""

"Python verfügt über eine Bibliothek mit Standardmodulen, die in einem "

"separaten Dokument, der Python-Bibliotheksreferenz (im Folgenden "

"\"Bibliotheksreferenz\"), beschrieben sind. Einige Module sind in den "

"Interpreter integriert; diese bieten Zugriff auf Operationen, die zwar nicht "

"zum Kern der Sprache gehören, aber dennoch integriert sind – entweder aus "

"Gründen der Effizienz oder um Zugriff auf Betriebssystemprimitive wie "

"Systemaufrufe zu ermöglichen. Die Auswahl dieser Module ist eine "

"Konfigurationsoption, die zudem von der zugrunde liegenden Plattform "

"abhängt. Beispielsweise wird das Modul :mod:`winreg` nur auf Windows-"

"Systemen bereitgestellt. Ein bestimmtes Modul verdient besondere "

"Beachtung: :mod:`sys` , das in jeden Python-Interpreter integriert ist. Die "

"Variablen ``sys.ps1`` und ``sys.ps2`` definieren die Zeichenketten, die als "

"primäre und sekundäre Eingabeaufforderung verwendet werden::"

#: ../../tutorial/modules.rst:283

msgid ""

">>> import sys\n"

">>> sys.ps1\n"

"'>>> '\n"

">>> sys.ps2\n"

"'... '\n"

">>> sys.ps1 = 'C> '\n"

"C> print('Yuck!')\n"

"Yuck!\n"

"C>"

msgstr ""

">>> import sys\n"

">>> sys.ps1\n"

"'>>> '\n"

">>> sys.ps2\n"

"'... '\n"

">>> sys.ps1 = 'C> '\n"

"C> print('Igitt!')\n"

"Igitt!\n"

"C>"

#: ../../tutorial/modules.rst:294

msgid ""

"These two variables are only defined if the interpreter is in interactive "

"mode."

msgstr ""

"Diese beiden Variablen sind nur definiert, wenn sich der Interpreter im "

"interaktiven Modus befindet."

#: ../../tutorial/modules.rst:296

msgid ""

"The variable ``sys.path`` is a list of strings that determines the "

"interpreter's search path for modules. It is initialized to a default path "

"taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in "

"default if :envvar:`PYTHONPATH` is not set. You can modify it using "

"standard list operations::"

msgstr ""

"Die Variable ``sys.path`` ist eine Liste von Zeichenketten, die den Suchpfad "

"des Interpreters für Module festlegt. Sie wird mit einem Standardpfad "

"initialisiert, der aus der Umgebungsvariable :envvar:`PYTHONPATH` übernommen "

"wird, oder – falls :envvar:`PYTHONPATH` nicht gesetzt ist – mit einem "

"integrierten Standardwert. Sie können sie mithilfe von Standardoperationen "

"für Listen ändern::"

#: ../../tutorial/modules.rst:302

msgid ""

">>> import sys\n"

">>> sys.path.append('/ufs/guido/lib/python')"

msgstr ""

">>> import sys\n"

">>> sys.path.append('/ufs/guido/lib/python')"

#: ../../tutorial/modules.rst:309

msgid "The :func:`dir` Function"

msgstr "Die Funktion :func:`dir`"

#: ../../tutorial/modules.rst:311

msgid ""

"The built-in function :func:`dir` is used to find out which names a module "

"defines. It returns a sorted list of strings::"

msgstr ""

"Die integrierte Funktion :func:`dir` dient dazu, herauszufinden, welche "

"Namen ein Modul definiert. Sie gibt eine sortierte Liste von Zeichenketten "

"zurück::"

#: ../../tutorial/modules.rst:314

msgid ""

">>> import fibo, sys\n"

">>> dir(fibo)\n"

"['__name__', 'fib', 'fib2']\n"

">>> dir(sys)\n"

"['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',\n"

" '__interactivehook__', '__loader__', '__name__', '__package__', "

"'__spec__',\n"

" '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',\n"

" '_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',\n"

" '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',\n"

" 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',\n"

" 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',\n"

" 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', "

"'exc_info',\n"

" 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',\n"

" 'float_repr_style', 'get_asyncgen_hooks', "

"'get_coroutine_origin_tracking_depth',\n"

" 'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',\n"

" 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',\n"

" 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',\n"

" 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',\n"

" 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',\n"

" 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',\n"

" 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', "

"'pycache_prefix',\n"

" 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', "

"'setdlopenflags',\n"

" 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', "

"'stderr',\n"

" 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', "

"'version_info',\n"

" 'warnoptions']"

msgstr ""

">>> import fibo, sys\n"

">>> dir(fibo)\n"

"['__name__', 'fib', 'fib2']\n"

">>> dir(sys)\n"

"['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',\n"

" '__interactivehook__', '__loader__', '__name__', '__package__', "

"'__spec__',\n"

" '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',\n"

" '_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',\n"

" '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',\n"

" 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',\n"

" 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',\n"

" 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', "

"'exc_info',\n"

" 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',\n"

" 'float_repr_style', 'get_asyncgen_hooks', "

"'get_coroutine_origin_tracking_depth',\n"

" 'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',\n"

" 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',\n"

" 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',\n"

" 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',\n"

" 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',\n"

" 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',\n"

" 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', "

"'pycache_prefix',\n"

" 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', "

"'setdlopenflags',\n"

" 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', "

"'stderr',\n"

" 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', "

"'version_info',\n"

" 'warnoptions']"

#: ../../tutorial/modules.rst:340

msgid ""

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

msgstr ""

"Ohne Argumente listet der Befehl :func:`dir` die Namen auf, die du derzeit "

"definiert hast::"

#: ../../tutorial/modules.rst:342

msgid ""

">>> a = [1, 2, 3, 4, 5]\n"

">>> import fibo\n"

">>> fib = fibo.fib\n"

">>> dir()\n"

"['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']"

msgstr ""

">>> a = [1, 2, 3, 4, 5]\n"

">>> import fibo\n"

">>> fib = fibo.fib\n"

">>> dir()\n"

"['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']"

#: ../../tutorial/modules.rst:348

msgid ""

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

msgstr ""

"Beachte, dass hier alle Arten von Namen aufgeführt sind: Variablen, Module, "

"Funktionen usw."

#: ../../tutorial/modules.rst:352

msgid ""

":func:`dir` does not list the names of built-in functions and variables. If "

"you want a list of those, they are defined in the standard module :mod:"

"`builtins`::"

msgstr ""

":func:`dir` enthält keine Auflistung der Namen der integrierten Funktionen "

"und Variablen. Wenn du eine Liste davon benötigst: Diese sind im "

"Standardmodul :mod:`builtins` definiert ::"

#: ../../tutorial/modules.rst:356

msgid ""

">>> import builtins\n"

">>> dir(builtins)\n"

"['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',\n"

" 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',\n"

" 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',\n"

" 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',\n"

" 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',\n"

" 'FileExistsError', 'FileNotFoundError', 'FloatingPointError',\n"

" 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',\n"

" 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',\n"

" 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',\n"

" 'MemoryError', 'NameError', 'None', 'NotADirectoryError', "

"'NotImplemented',\n"

" 'NotImplementedError', 'OSError', 'OverflowError',\n"

" 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',\n"

" 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',\n"

" 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',\n"

" 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',\n"

" 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',\n"

" 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',\n"

" 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',\n"

" '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',\n"

" 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',\n"

" 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',\n"

" 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',\n"

" 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',\n"

" 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',\n"

" 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',\n"

" 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property',\n"

" 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',\n"

" 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars',\n"

" 'zip']"

msgstr ""

">>> import builtins\n"

">>> dir(builtins)\n"

"['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',\n"

" 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',\n"

" 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',\n"

" 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',\n"

" 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',\n"

" 'FileExistsError', 'FileNotFoundError', 'FloatingPointError',\n"

" 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',\n"

" 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',\n"

" 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',\n"

" 'MemoryError', 'NameError', 'None', 'NotADirectoryError', "

"'NotImplemented',\n"

" 'NotImplementedError', 'OSError', 'OverflowError',\n"

" 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',\n"

" 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',\n"

" 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',\n"

" 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',\n"

" 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',\n"

" 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',\n"

" 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',\n"

" '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',\n"

" 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',\n"

" 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',\n"

" 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',\n"

" 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',\n"

" 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',\n"

" 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',\n"

" 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property',\n"

" 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',\n"

" 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars',\n"

" 'zip']"

#: ../../tutorial/modules.rst:391

msgid "Packages"

msgstr "Pakete"

#: ../../tutorial/modules.rst:393

msgid ""

"Packages are a way of structuring Python's module namespace by using "

"\"dotted module names\". For example, the module name :mod:`!A.B` "

"designates a submodule named ``B`` in a package named ``A``. Just like the "

"use of modules saves the authors of different modules from having to worry "

"about each other's global variable names, the use of dotted module names "

"saves the authors of multi-module packages like NumPy or Pillow from having "

"to worry about each other's module names."

msgstr ""

"Pakete sind eine Möglichkeit, den Modul-Namensraum von Python mithilfe von "

"\"Modulnamen mit Punkt\" zu strukturieren. Der Modulname :mod:`!A.B` "

"bezeichnet beispielsweise ein Untermodul namens ``B`` in einem Paket namens "

"``A`` . Genauso wie die Verwendung von Modulen den Autoren verschiedener "

"Module erspart, sich um die globalen Variablennamen der anderen kümmern zu "

"müssen, erspart die Verwendung von Modulnamen mit Punkten den Autoren von "

"Paketen mit mehreren Modulen wie NumPy oder Pillow, sich um die Modulnamen "

"der anderen kümmern zu müssen."

#: ../../tutorial/modules.rst:401

msgid ""

"Suppose you want to design a collection of modules (a \"package\") for the "

"uniform handling of sound files and sound data. There are many different "

"sound file formats (usually recognized by their extension, for example: :"

"file:`.wav`, :file:`.aiff`, :file:`.au`), so you may need to create and "

"maintain a growing collection of modules for the conversion between the "

"various file formats. There are also many different operations you might "

"want to perform on sound data (such as mixing, adding echo, applying an "

"equalizer function, creating an artificial stereo effect), so in addition "

"you will be writing a never-ending stream of modules to perform these "

"operations. Here's a possible structure for your package (expressed in "

"terms of a hierarchical filesystem):"

msgstr ""

"Angenommen, du möchtest eine Sammlung von Modulen (ein „Paket“) für die "

"einheitliche Verarbeitung von Audiodateien und Audiodaten entwerfen. Es gibt "

"viele verschiedene Audiodateiformate (die in der Regel an ihrer Dateiendung "

"zu erkennen sind, zum Beispiel: :file:`.wav`, :file:`.aiff`, :file:`.au`), "

"sodass du möglicherweise eine ständig wachsende Sammlung von Modulen für die "

"Konvertierung zwischen den verschiedenen Dateiformaten erstellen und pflegen "

"musst. Außerdem gibt es viele verschiedene Operationen, die du "

"möglicherweise an Audiodaten durchführen möchtest (wie Mischen, Hinzufügen "

"eines Echos, Anwenden einer Equalizer-Funktion, Erzeugen eines künstlichen "

"Stereoeffekts), sodass du darüber hinaus eine endlose Reihe von Modulen "

"schreiben wirst, um diese Operationen auszuführen. Hier ist eine mögliche "

"Struktur für dein Paket (dargestellt als hierarchisches Dateisystem):"

#: ../../tutorial/modules.rst:412

msgid ""

"sound/ Top-level package\n"

" __init__.py Initialize the sound package\n"

" formats/ Subpackage for file format conversions\n"

" __init__.py\n"

" wavread.py\n"

" wavwrite.py\n"

" aiffread.py\n"

" aiffwrite.py\n"

" auread.py\n"

" auwrite.py\n"

" ...\n"

" effects/ Subpackage for sound effects\n"

" __init__.py\n"

" echo.py\n"

" surround.py\n"

" reverse.py\n"

" ...\n"

" filters/ Subpackage for filters\n"

" __init__.py\n"

" equalizer.py\n"

" vocoder.py\n"

" karaoke.py\n"

" ..."

msgstr ""

"sound/ Paket der obersten Ebene\n"

" __init__.py Initialisierung des Sound-Pakets\n"

" formats/ Unterpaket für Dateiformatkonvertierungen\n"

" __init__.py\n"

" wavread.py\n"

" wavwrite.py\n"

" aiffread.py\n"

" aiffwrite.py\n"

" auread.py\n"

" auwrite.py\n"

" ...\n"

" effects/ Unterpaket für Soundeffekte\n"

" __init__.py\n"

" echo.py\n"

" surround.py\n"

" reverse.py\n"

" ...\n"

" filters/ Unterpaket für Filter\n"

" __init__.py\n"

" equalizer.py\n"

" vocoder.py\n"

" karaoke.py\n"

" ..."

#: ../../tutorial/modules.rst:438

msgid ""

"When importing the package, Python searches through the directories on ``sys."

"path`` looking for the package subdirectory."

msgstr ""

"Beim Importieren des Pakets durchsucht Python die Verzeichnisse unter ``sys."

"path`` nach dem Unterverzeichnis des Pakets."

#: ../../tutorial/modules.rst:441

msgid ""

"The :file:`__init__.py` files are required to make Python treat directories "

"containing the file as packages (unless using a :term:`namespace package`, a "

"relatively advanced feature). This prevents directories with a common name, "

"such as ``string``, from unintentionally hiding valid modules that occur "

"later on the module search path. In the simplest case, :file:`__init__.py` "

"can just be an empty file, but it can also execute initialization code for "

"the package or set the ``__all__`` variable, described later."

msgstr ""

"Die :file:`__init__.py` -Dateien sind erforderlich, damit Python "