6. Module

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.

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).

Ein Modul ist eine Datei, die Python-Definitionen und -Anweisungen enthält. Der Dateiname besteht aus dem Modulnamen mit dem angehängten Suffix .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 fibo.py mit folgendem Inhalt:

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a+b
    return result

Öffne nun den Python-Interpreter und importiere dieses Modul mit dem folgenden Befehl:

>>> import fibo

Dadurch werden die Namen der in fibo definierten Funktionen nicht direkt zum aktuellen Namensraum hinzugefügt (weitere Details findest du unter Python-Gültigkeitsbereiche und Namensräume ); es wird dort lediglich der Modulname fibo hinzugefügt. Über den Modulnamen kannst du auf die Funktionen zugreifen:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'

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

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

6.1. Mehr zum Thema Module

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. 1 (Sie werden auch ausgeführt, wenn die Datei als Skript ausgeführt wird.)

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.

Module können andere Module importieren. Es ist üblich, aber nicht zwingend erforderlich, alle 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.

Es gibt eine Variante der Anweisung import, mit der Namen aus einem Modul direkt in den Namensraum des importierenden Moduls importiert werden. Zum Beispiel:

>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Dadurch wird der Modulname, aus dem die Importe stammen, nicht in den lokalen Namensraum eingeführt (im Beispiel ist fibo also nicht definiert).

Es gibt sogar eine Variante, mit der alle von einem Modul definierten Namen importiert werden können:

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

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.

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.

Folgt auf den Modulnamen as, wird der Name nach as direkt an das importierte Modul gebunden.

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

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.

Es kann auch bei der Verwendung von from mit ähnlichen Effekten eingesetzt werden:

>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Bemerkung

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 importlib.reload() verwenden, z. B. import importlib; importlib.reload(modulename).

6.1.1. Module als Skripte ausführen

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

python fibo.py <arguments>

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:

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

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:

$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34

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

>>> import fibo
>>>

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).

6.1.2. Der Suchpfad für Module

When a module named spam is imported, the interpreter first searches for a built-in module with that name. These module names are listed in sys.builtin_module_names. If not found, it then searches for a file named spam.py in a list of directories given by the variable sys.path. sys.path is initialized from these locations:

• Das Verzeichnis, in dem sich das Eingabeskript befindet (oder das aktuelle Verzeichnis, wenn keine Datei angegeben ist).

• PYTHONPATH (eine Liste von Verzeichnisnamen, deren Syntax der der Shell-Variablen PATH entspricht).

• Die installationsabhängige Standardeinstellung (gemäß Konvention einschließlich des Verzeichnisses site-packages, das vom Modul site verwaltet wird).

Bemerkung

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.

Nach der Initialisierung können Python-Programme die Variable 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 Standardmodule .

6.1.3. „Kompilierte“ Python-Dateien

Um das Laden von Modulen zu beschleunigen, speichert Python die kompilierte Version jedes Moduls im Verzeichnis __pycache__ unter dem Namen 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.

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.

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.

Einige Tipps für Experten:

• Sie können die Schalter -O oder -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.

• 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.

• Das Modul compileall kann für alle Module in einem Verzeichnis .pyc-Dateien erstellen.

• Weitere Einzelheiten zu diesem Prozess, einschließlich eines Entscheidungsdiagramms, findest du unter PEP 3147.

6.2. Standardmodule

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 winreg nur auf Windows-Systemen bereitgestellt. Ein bestimmtes Modul verdient besondere Beachtung: 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:

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>

Diese beiden Variablen sind nur definiert, wenn sich der Interpreter im interaktiven Modus befindet.

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 PYTHONPATH übernommen wird, oder – falls PYTHONPATH nicht gesetzt ist – mit einem integrierten Standardwert. Sie können sie mithilfe von Standardoperationen für Listen ändern:

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

6.3. Die Funktion dir()

Die integrierte Funktion dir() dient dazu, herauszufinden, welche Namen ein Modul definiert. Sie gibt eine sortierte Liste von Zeichenketten zurück:

>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)  
['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',
 '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__',
 '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',
 '_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',
 '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',
 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',
 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',
 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info',
 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',
 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth',
 'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',
 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',
 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',
 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',
 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'pycache_prefix',
 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'setdlopenflags',
 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr',
 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', 'version_info',
 'warnoptions']

Ohne Argumente listet der Befehl dir() die Namen auf, die du derzeit definiert hast:

>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir()
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']

Beachte, dass hier alle Arten von Namen aufgeführt sind: Variablen, Module, Funktionen usw.

dir() enthält keine Auflistung der Namen der integrierten Funktionen und Variablen. Wenn du eine Liste davon benötigst: Diese sind im Standardmodul builtins definiert

>>> import builtins
>>> dir(builtins)  
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',
 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',
 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',
 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
 'FileExistsError', 'FileNotFoundError', 'FloatingPointError',
 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',
 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',
 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',
 'MemoryError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented',
 'NotImplementedError', 'OSError', 'OverflowError',
 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',
 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',
 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',
 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',
 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',
 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',
 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',
 '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',
 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',
 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',
 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',
 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',
 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',
 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',
 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property',
 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',
 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars',
 'zip']

6.4. Pakete

Packages are a way of structuring Python’s module namespace by using „dotted module names“. For example, the module name 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.

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: .wav, .aiff, .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):

sound/                          Top-level package
      __init__.py               Initialize the sound package
      formats/                  Subpackage for file format conversions
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  Subpackage for sound effects
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  Subpackage for filters
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

Beim Importieren des Pakets durchsucht Python die Verzeichnisse unter sys.path nach dem Unterverzeichnis des Pakets.

The __init__.py files are required to make Python treat directories containing the file as packages. This prevents directories with a common name, such as string, from unintentionally hiding valid modules that occur later on the module search path. In the simplest case, __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.

Benutzer des Pakets können einzelne Module aus dem Paket importieren, zum Beispiel:

import sound.effects.echo

This loads the submodule sound.effects.echo. It must be referenced with its full name.

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

Eine alternative Möglichkeit, das Submodul zu importieren, ist:

from sound.effects import echo

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

echo.echofilter(input, output, delay=0.7, atten=4)

Eine weitere Möglichkeit besteht darin, die gewünschte Funktion oder Variable direkt zu importieren:

from sound.effects.echo import echofilter

Again, this loads the submodule echo, but this makes its function echofilter() directly available:

echofilter(input, output, delay=0.7, atten=4)

Beachte dass bei der Verwendung von from package import item das Element entweder ein Submodul (oder Subpaket) des Pakets oder ein anderer im Paket definierter Name sein kann, wie beispielsweise eine Funktion, eine Klasse oder eine Variable. Die Anweisung import prüft zunächst, ob das Element im Paket definiert ist; ist dies nicht der Fall, geht sie davon aus, dass es sich um ein Modul handelt, und versucht, dieses zu laden. Wird das Element nicht gefunden, wird eine Ausnahme vom Typ ImportError ausgelöst.

Im Gegensatz dazu muss bei der Verwendung einer Syntax wie import item.subitem.subsubitem jedes Element mit Ausnahme des letzten ein Paket sein; das letzte Element kann ein Modul oder ein Paket sein, darf jedoch keine Klasse, Funktion oder Variable sein, die im vorherigen Element definiert wurde.

6.4.1. Importieren von * aus einem Paket

Was passiert nun, wenn der Benutzer from sound.effects import * eingibt? Im Idealfall würde man hoffen, dass dies irgendwie an das Dateisystem weitergeleitet wird, das dann ermittelt, welche Submodule im Paket vorhanden sind, und diese alle importiert. Dies könnte lange dauern, und das Importieren von Submodulen könnte unerwünschte Nebenwirkungen haben, die nur auftreten sollten, wenn das Submodul explizit importiert wird.

Die einzige Lösung besteht darin, dass der Paketautor einen expliziten Index des Pakets bereitstellt. Die Anweisung import verwendet die folgende Konvention: Wenn im Code von __init__.py eines Pakets eine Liste namens __all__ definiert ist, wird diese als Liste der Modulnamen angesehen, die importiert werden sollen, sobald auf from package import * gestoßen wird. Es liegt im Ermessen des Paketautors, diese Liste bei der Veröffentlichung einer neuen Version des Pakets auf dem neuesten Stand zu halten. Paketautoren können sich auch dafür entscheiden, diese Funktion nicht zu unterstützen, wenn sie keinen Nutzen darin sehen, * aus ihrem Paket zu importieren. Beispielsweise könnte die Datei sound/effects/__init__.py den folgenden Code enthalten:

__all__ = ["echo", "surround", "reverse"]

This would mean that from sound.effects import * would import the three named submodules of the sound.effects package.

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

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

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

Obwohl bestimmte Module so konzipiert sind, dass sie bei Verwendung von import * nur Namen exportieren, die bestimmten Mustern entsprechen, gilt dies im Produktionscode dennoch als schlechte Praxis.

Denke daran: Es ist völlig in Ordnung, from package import specific_submodule zu verwenden! Tatsächlich ist dies die empfohlene Schreibweise, es sei denn, das importierende Modul muss Submodule mit demselben Namen aus verschiedenen Paketen verwenden.

6.4.2. Verweise innerhalb eines Pakets

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

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

from . import echo
from .. import formats
from ..filters import equalizer

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

6.4.3. Packages in Multiple Directories

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

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

Fußnoten

1

Tatsächlich sind Funktionsdefinitionen ebenfalls „Anweisungen“, die „ausgeführt“ werden; durch die Ausführung einer Funktionsdefinition auf Modulebene wird der Funktionsname dem globalen Namensraum des Moduls hinzugefügt.