.. _tut-modules:
****************************
Modulmodule
****************************
Wenn Sie den Python-Interpreter verlassen und ihn erneut eingeben, werden die Definitionen angezeigt
gemachte (Funktionen und Variablen) gehen daher verloren, wenn Sie ein
etwas längeres Programm schreiben möchten, verwenden Sie besser einen Texteditor, um die
Eingabe vorzubereiten für den Interpreter und führen Sie es stattdessen mit dieser Datei als Eingabe aus. Dies wird als *Skript* bezeichnet. Wenn Ihr Programm länger wird, möchten Sie es möglicherweise
in mehrere Dateien aufteilen Zur einfacheren Wartung möchten Sie möglicherweise auch eine
praktische Funktion verwenden, die Sie in mehreren Programmen geschrieben haben, ohne deren Definition in jedes Programm zu kopieren.
Beim Beenden Wenn der Python-Interpreter erneut eintritt, gehen alle zuvor erstellten Definitionen (Variablen und Funktionen) verloren. Wenn Sie daher einige Programme schreiben möchten, die für längere Zeit gespeichert werden, verwenden Sie am besten einen Texteditor, um
das Programm zu schreiben und die gespeicherte Datei in den Interpreter einzugeben. Wir nennen dies das Erstellen eines *Skripts*. Oder das Programm
wird länger und Sie können es zur einfacheren Wartung in mehrere Dateien aufteilen. Möglicherweise möchten Sie eine gemeinsame Funktion auch in mehreren
-Programmen verwenden, möchten deren Definition jedoch nicht in jedes Programm kopieren.
Um dies zu unterstützen, verfügt Python über eine Möglichkeit, Definitionen in eine Datei einzufügen und sie in einem
Skript oder in einer interaktiven Instanz des Interpreters zu verwenden. Eine solche Datei wird als
bezeichnet*Modul*; Definitionen aus einem Modul können in andere Module oder in
das *Hauptmodul* (die Sammlung von Variablen, auf die Sie in einem
Zugriff haben) *importiert* werden Skript, das auf der obersten Ebene und im Rechnermodus ausgeführt wird).
Um diese Anforderungen zu erfüllen, bietet Python eine Methode zum Abrufen von Definitionen aus einer Datei, in einem Skript oder einem interaktiven Teil des
Interpreters in Beispielen verwendet. Eine solche Datei wird als *Modul* bezeichnet; Definitionen in einem Modul können
in ein anderes Modul oder in das Hauptmodul *importiert* werden (der Satz von Variablen, die aufgerufen werden können, wenn das Skript ausgeführt wird, befindet sich). am weitesten fortgeschritten und
im Rechnermodus).
Ein Modul ist eine Datei, die Python-Definitionen und -Anweisungen enthält.
ist der Modulname mit dem Suffix :file:`.py` innerhalb eines Moduls
Der Name des Moduls (als Zeichenfolge) ist als Wert der globalen Variablen verfügbar``__name__`` Verwenden Sie beispielsweise Ihren bevorzugten Texteditor, um eine Dateizu erstellen :file:`fibo.py` im aktuellen Verzeichnis mit folgendem Inhalt:Ein Modul ist eine Datei, die Python-Definitionen und -Deklarationen enthält. Der Dateiname ist der Modulname plus das Suffix :file:`.py`. Der Modulname (als String) des Modulblocks kann aus der globalen Variablen „__name__“ abgerufen werden. Sie können beispielsweise mit Ihrem bevorzugten Dateieditor eine Datei mit dem Namen :file:`fibo.py` im aktuellen Verzeichnis erstellen und den folgenden Inhalt::# Fibonacci-Zahlenmodul
def fib(n): # Fibonacci-Reihe bis n schreiben
a, b = 0, 1
while b <
🎜> a, b = b, a+b
Ergebnis zurückgeben
Geben Sie nun den Python-Interpreter ein und importieren Sie dieses Modul mit dem folgenden
Befehl:
Geben Sie nun den Python-Interpreter ein und verwenden Sie den folgenden Befehl, um dieses Modul zu importieren:
>>> import fibo
Dadurch werden nicht die Namen der in „`“ definierten Funktionen eingegeben fibo`` direkt in
der aktuellen Symboltabelle; es wird dort nur der Modulname „fibo“ eingetragen. Über
den Modulnamen können Sie auf die Funktionen zugreifen:
Dadurch werden „Funktionen in „fibo“ nicht direkt in die aktuelle semantische Tabelle importiert, sondern lediglich der Modulname
„fibo“. Sie können diese Funktion über den Modulnamen wie folgt erreichen:
>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
Wenn Sie beabsichtigen, eine Funktion häufig zu verwenden, können Sie sie einem lokalen Namen zuweisen:
Wenn Sie die Funktion direkt aufrufen möchten, können Sie ihr normalerweise einen lokalen Namen geben::
>>> fib = fibo.fib
>>> ; fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
.. _tut-moremodules:
Mehr zu Modulen im Detailmodul
=============================
Ein Modul kann sowohl ausführbare Anweisungen als auch Funktionsdefinitionen enthalten .
Diese Anweisungen sollen das Modul initialisieren
das *erste* Mal, wenn das Modul irgendwo importiert wird.
Das Modul kann Wie Funktionsdefinitionen enthalten auch Ausführungsanweisungen. Diese Anweisungen werden normalerweise zum Initialisieren von Modulen verwendet. Sie werden nur
einmal ausgeführt, wenn das Modul *zum ersten Mal* importiert wird. [#]_
Jedes Modul verfügt über eine eigene private Symboltabelle, die von allen im Modul definierten Funktionen als globale Symboltabelle verwendet wird 🎜>
Verwenden Sie globale Variablen im Modul, ohne sich Gedanken über versehentliche Konfliktemit den globalen Variablen eines Benutzers machen zu müssen. Wenn Sie andererseits wissen, was Sie tunkönnen Sie a Die globalen Variablen des Moduls mit der gleichen Notation, die verwendet wird, umauf seine Funktionen zu verweisen, „modname.itemname“. entspricht der globalen semantischen Tabelle, die alle Funktionen im Modul jedes Moduls definiert hat eine eigene private semantische Tabelle. Daher kann der Modulautor daher einige globale Variablen im Modul verwenden, ohne dass es zu Fehlern aufgrund von Konflikten mit den globalen Variablen des Benutzers kommt. Wenn Sie jedoch sicher sind, dass Sie dies benötigen, können Sie auf die globalen Variablen im Modul zugreifen, genau wie Sie auf Funktionen im Modul verweisen, etwa so: „modname.itemname“. Module können andere Module importieren. Es ist üblich, aber nicht erforderlich, alle:keyword:`import`-Anweisungen am Anfang eines Moduls (oder dafür eines Skripts) zu platzieren 🎜>Angelegenheit). Es ist üblich, alle Importanweisungen am Anfang eines Moduls (oder Skripts usw.) zu platzieren, dies ist jedoch nicht erforderlich. Der importierte Modulname wird in die globale Syntax dieses Moduls eingetragen. Es gibt eine Variante der :keyword:`import`-Anweisung, die Namen aus einemModul direkt in die Symboltabelle des importierenden Moduls importiert, zum Beispiel::keyword Eine Variante der :`import`-Anweisung importiert Namen direkt aus dem importierten Modul in die semantische Tabelle des Moduls. Zum Beispiel:: >>> aus fibo import fib, fib2 >>> 1 1 2 3 5 8 13 21 34 55 89 144 233 377Dadurch wird nicht der Modulname eingeführt, von dem die Importe in dielokale Symboltabelle übernommen werden (also im Beispiel ` `fibo`` ist nicht definiert).Dadurch wird der Modulname nicht aus der lokalen semantischen Tabelle importiert (wie oben gezeigt, ist `fibo`` nicht definiert). Es gibt sogar eine Variante, um alle Namen zu importieren, die ein Modul definiert: ; from fibo import * >>>1 1 2 3 5 8 13 21 34 55 89 144 233 377
Dies importiert alle Namen außer denen, die mit einem Unterstrich (``_``) beginnen.
Dies wird importiert alle Namen außer denen, die mit einem Unterstrich („_“) beginnen.
Beachten Sie, dass das Importieren von „*“ aus einem Modul oder Paket im Allgemeinen
verpönt ist, da dies häufig zu schlecht lesbarem Code führt. Dies ist jedoch in Ordnung
Verwenden Sie es, um in interaktiven Sitzungen Tipparbeit zu sparen.
Es ist zu beachten, dass in der Praxis oft davon abgeraten wird, „*“ zu verwenden, um alles aus einem Modul oder Paket zu importieren, weil
Dadurch ist der Code schwer lesbar. Dies ist jedoch praktisch und spart Aufwand in einer interaktiven Sitzung.
.. Hinweis::
.. [#] Aus Effizienzgründen wird jedes Modul nur einmal pro Dolmetschersitzung importiert
Wenn Sie also Ihre Module ändern, Sie müssen den
Interpreter neu starten – oder, wenn es sich nur um ein Modul handelt, das Sie interaktiv testen möchten,
verwenden Sie :func:`reload`, z. B. ``reload(modulename)``.
.. [#] Aus Leistungsgründen wird jedes Modul nur einmal pro Dolmetschersitzung importiert. Wenn Sie
Ihr Modul ändern, müssen Sie daher den Interpreter neu starten – oder, wenn Sie ein solches Modul nur interaktiv testen möchten, können Sie :func:` reload` Neu laden, z. B. „reload“. (Modulname)``.
.. _tut-modulesasscripts:
Module als Skripte ausführen
---------------- ------ ----------------------------
Wenn Sie ein Python-Modul ausführen mit:
Verwenden Sie die Folgende Methode zum Ausführen eines Python-Moduls::
python fibo.py
Der Code im Modul wird ausgeführt, so als ob Sie ihn importiert hätten, jedoch mit
Der ``__name__`` wird auf ``"__main__"`` gesetzt. Das bedeutet, dass durch Hinzufügen dieses Codes am Ende Ihres Moduls:
Modul Der Code lautet ausgeführt, als ob es importiert worden wäre, aber jetzt ist ``__name__`` auf
``"__main__"`` gesetzt. Dies entspricht dem Hinzufügen des folgenden Codes nach dem Modul::
if __name__ == "__main__":
import sys
fib(int(sys.argv[1]))
Sie können die Datei sowohl als Skript als auch als importierbares Modul nutzbar machen,
Da der Code, der die Befehlszeile analysiert, nur ausgeführt wird, wenn das Modul
als „Hauptdatei“ ausgeführt wird:
ermöglicht die Ausführung dieser Datei als Skript, genau wie beim Import als Modul. Dieser Code wird nur aufgerufen, wenn das Modul als
„Hauptdatei“ ausgeführt wird::
$ python fibo.py 50
1 1 2 3 5 8 13 21 34
Wenn das Modul importiert wird, wird der Code nicht ausgeführt:
Wenn das Modul importiert wird, wird dieser Code nicht ausgeführt::
>>> ; fibo importieren
>>>
Dies wird häufig verwendet, um entweder eine praktische Benutzeroberfläche für ein Modul bereitzustellen oder
zu Testzwecken (Ausführen des Moduls). als Skript führt eine Testsuite aus).
Dies wird normalerweise verwendet, um eine Benutzeroberfläche für das Modul bereitzustellen, um das Testen zu erleichtern (Verwendung des Moduls als Skript zur Ausführung von Testanforderungen).
.. _tut-searchpath:
Der Modulsuchpfad Modulsuchpfad
-------------------------------- - ----------
.. index:: triple: module; search
Wann Wenn ein Modul mit dem Namen :mod:`spam` importiert wird, sucht der Interpreter nach einer Datei
mit dem Namen :file:`spam.py` im aktuellen Verzeichnis und dann in der Liste von
Verzeichnisse, die durch die Umgebungsvariable :envvar:`PYTHONPATH` angegeben werden. Dies
hat die gleiche Syntax wie die Shell-Variable :envvar:`PATH`, also eine Liste von
Verzeichnisnamen. Wenn :envvar:`PYTHONPATH` nicht festgelegt ist oder die Datei dort nicht
gefunden wird, wird die Suche in einem installationsabhängigen Standardpfad unter
Unix fortgesetzt. Dies ist normalerweise: file:`.:/usr/local/lib/python`.
Beim Importieren eines Moduls namens :mod:`spam` sucht der Interpreter zunächst nach dem Namen
:file:`spam.py` Datei, suchen Sie dann in der Liste der Verzeichnisse , die durch die Umgebungsvariable:envvar:`PYTHONPATH` dargestellt werden, und dann in der Liste der Pfade in der Umgebungsvariablen:envvar:`PATH `. Wenn :envvar:`PYTHONPATH` nicht festgelegt ist oder die Datei nicht gefunden wird, durchsuchen Sie das Installationsverzeichnis, Unter Unix ist es normalerweise:file:`.:/usr /local/ lib/python` . Tatsächlich werden Module in der Liste der Verzeichnisse gesucht, die durch die Variable``sys.path`` angegeben wird, die aus dem Verzeichnis initialisiert wird, das das Eingabeskript enthält( oder das aktuelle Verzeichnis), :envvar:`PYTHONPATH` und die installationsabhängigeStandardeinstellung. Dadurch können Python-Programme, die wissen, was sie tun, den Modulsuchpfad ändern oderersetzen . Beachten Sie, dass das Verzeichnis, das das auszuführendeSkript enthält, sich im Suchpfad befindet. Daher ist es wichtig, dass das Skript nichtden gleichen Namen wie ein Standardmodul hat, da Python sonst versucht, dies zu tun Laden Sie das Skript als Modul, wenn dieses Modul importiert wird. Weitere Informationen finden Sie im Abschnitt :ref:`tut-standardmodules.Tatsächlich sucht der Interpreter nach Modulen in dem durch die Variable „sys.path“ angegebenen Pfadverzeichnis, das bei der Initialisierung standardmäßig das Eingabeskript (oder das aktuelle Verzeichnis) enthält , :envvar: „PYTHONPATH“ und Installationsverzeichnis. Dadurch können Python-Programme wissen, wie sie das Modulsuchverzeichnis ändern oder ersetzen können. Da diese Verzeichnisse Skripte enthalten, die im Suchpfad ausgeführt werden, ist zu beachten, dass diese Skripte nicht denselben Namen wie das Standardmodul haben sollten, da Python sonst versucht, diese zu ersetzen Beim Importieren des Moduls werden Skripte als Module geladen. Dies führt normalerweise zu einem Fehler. Weitere Informationen finden Sie unter :ref:`tut-standardmodules`. "Kompilierte" Python-Dateien "Kompilierte" Python-Dateien----------------------------------------- -- ------------------------Als wichtige Beschleunigung der Startzeit für kurze Programme, die viel verbrauchenWenn bei Standardmodulen eine Datei mit dem Namen :file:`spam.pyc` in dem Verzeichnisexistiert, in dem :file:`spam.py` gefunden wird, wird davon ausgegangen, dass diese eine Datei enthält 🎜>bereits „Byte-kompilierte“ Version des Moduls :mod:`spam` Die Änderungszeit
der Version von :file:`spam.py`, die zum Erstellen von :file: verwendet wurde. „spam.pyc“ wird in
:file:`spam.pyc` aufgezeichnet und die Datei :file:`.pyc` wird ignoriert, wenn diese nicht übereinstimmen.
Kurz gesagt Programme, die auf eine große Anzahl von Standardmodulen verweisen, gibt es eine wichtige Möglichkeit, die Startgeschwindigkeit zu verbessern, wenn sich eine Datei mit dem Namen :file:`spam im Verzeichnis befindet, in dem sich
:file:`spam.py` befindet befindet. pyc`-Datei, wird sie
als vor-"Byte-kompilierte" (Byte-kompilierte)
Version des :mod:`spam`-Moduls behandelt. Die Änderungszeit der Version von :file:`spam.py`, die zum Erstellen von :file:`spam.pyc` verwendet wurde, wird in der Datei :file:`spam.pyc` aufgezeichnet. Wenn die beiden nicht übereinstimmen, wird die Datei :file.`spam.pyc` aufgezeichnet :`.pyc`-Datei wird ignoriert.
Normalerweise müssen Sie nichts tun, um die Datei :file:`spam.pyc` zu erstellen.
Immer wenn :file:`spam.py` erfolgreich kompiliert wurde, wird ein Versuch unternommen ist zum Schreiben gemacht
die kompilierte Version in :file:`spam.pyc` Es ist kein Fehler, wenn dieser Versuch
fehlschlägt; wenn die Datei aus irgendeinem Grund nicht vollständig geschrieben wird
:file:`spam.pyc`-Datei wird als ungültig erkannt und daher später ignoriert. Der
Inhalt der :file:`spam.pyc`-Datei ist plattformunabhängig, also ein Python
Das Modulverzeichnis kann von Maschinen unterschiedlicher Architektur gemeinsam genutzt werden.
Normalerweise müssen Sie keine Arbeit leisten, um die Datei :file:`spam.pyc` zu erstellen. Sobald :file:`spam.py` erfolgreich kompiliert wurde, wird
versuchen, die entsprechende Version von :file:`spam.pyc` zu generieren. Wenn das Schreiben aus irgendeinem Grund fehlschlägt, wird die von
generierte Datei :file:`spam.pyc` als ungültig betrachtet und anschließend ignoriert. :file:`spam.pyc` Der Inhalt der Datei ist plattformunabhängig, sodass das Python-Modulverzeichnis von Maschinen unterschiedlicher Architektur gemeinsam genutzt werden kann.
Einige Tipps für Experten:
Einige Tipps für Fortgeschrittene:
* Wenn der Python-Interpreter mit dem Flag :option:`-O` aufgerufen wird, optimiert
Code wird in :file:`.pyo`-Dateien generiert und gespeichert
hilft nur nicht viel; :keyword:`assert`-Anweisungen
:option:`-O` wird verwendet, *all* :term:`bytecode` wird optimiert; ``.pyc``-Dateien werden
ignoriert und ``.py``-Dateien werden zu optimiertem Bytecode kompiliert .
Beim Aufruf des Python-Interpreters mit dem Parameter :option:`-O` wird optimierter Code generiert und in der Datei :file:`.pyo` gespeichert.
Der aktuelle Optimierer hilft nicht viel; er entfernt lediglich Behauptungsanweisungen ( :keyword:`assert` ). Mit dem Parameter :option:`-O` werden *alle* Bytecodes ( :term:`bytecode` ) optimiert.
Ignoriert, ``.py``-Dateien werden ignoriert in optimierten Code kompiliert.
* Die Übergabe von zwei :option:`-O`-Flags an den Python-Interpreter (:option:`-OO`) wird
dazu führen, dass der Bytecode-Compiler Optimierungen durchführt, die in einigen seltenen Fällen
Fälle führen zu fehlerhaften Programmen. werden nur ``__doc__``-Strings aus dem Bytecode entfernt, was zu kompakteren :file:`.pyo`-Dateien führt. Einige Programme sind möglicherweise darauf angewiesen, dass diese verfügbar sind. Sie sollten diese Option nur verwenden, wenn Sie wissen, was Sie tun. Übergeben Sie two:option:`-O an den Python-Interpreter Das Argument ` ( :option:`-OO` ) führt eine vollständig optimierte Binärkompilierung durch, die gelegentlich falsche Programme generieren kann. Der aktuelle Optimierer entfernt nur die Zeichenfolge „__doc__“ aus dem Abschnittscode , um eine kompaktere :file:`.pyo`-Datei zu generieren. Da einige Programme auf die Verfügbarkeit dieser Variablen angewiesen sind, sollten Sie diese Option nur verwenden, wenn Sie sich dessen sicher sind. * Ein Programm läuft nicht schneller, wenn es aus einer :file:`.pyc`- oder :file:`.pyo`-Datei gelesen wird, als wenn es aus einer gelesen wird :file:`.py`-Dateien; das Einzige, das an :file:`.pyc`- oder :file:`.pyo`-Dateien schneller ist, ist die Geschwindigkeit, mit der sie sind geladen. Ein Programm aus einer :file:`.pyc`-Datei oder einer :file:`.pyo`-Datei wird nicht schneller ausgeführt als ein Programm aus einer :file:` .py`-Datei Schnell; :file:`.pyc`- oder :file:`.pyo`-Dateien sind beim Laden einfach schneller. * Wenn ein Skript durch Angabe seines Namens in der Befehlszeile ausgeführt wird, wird der Bytecode für das Skript niemals in eine :file:`.pyc` oder :file:` geschrieben. pyo`-Datei. Daher kann die Startzeit eines Skripts verkürzt werden, indem der größte Teil seines Codes in ein Modul verschoben wird und ein kleines Bootstrap-Skript vorhanden ist, das dieses Modul importiert Es ist möglich, eine :file:`.pyc`- oder :file:`.pyo`-Datei direkt in der Befehlszeile zu benennen Beim Ausführen eines Skripts wird der für das Skript erstellte Binärcode angezeigt wird nicht in die Datei :file:`.pyc` oder :file:`.pyo` geschrieben. Natürlich kann das Verschieben des Hauptcodes des Skripts in einen Modulblock und das anschließende Importieren dieses Moduls mit einem kleinen Startskript die Startgeschwindigkeit des Skripts verbessern. Sie können eine :file:`.pyc`- oder :file:`.pyo`-Datei auch direkt in der Befehlszeile angeben. * Es ist möglich, eine Datei namens :file:`spam.pyc` (oder :file:`spam.pyo` zu haben, wenn :option:`-O` verwendet wird) ohne eine Datei :file:`spam.py` für dasselbe Modul. Dies kann verwendet werden, um eine Bibliothek von Python-Code in einer Form zu verteilen, die mäßig schwer zurückzuentwickeln ist. Für das gleiche Modul (bezieht sich hier auf die Routine:file:`spam.py` - Übersetzer) können Sie nur die Datei:file:`spam.pyc` haben (oder: file:`spam.pyc`, wenn der Parameter :option:`-O` verwendet wird), aber es gibt keine :file:`spam.py`-Datei. Auf diese Weise kann es verpackt und veröffentlicht werdenEine Python-Codebasis, die schwer zurückzuentwickeln ist.
.. index:: module: compileall
* Das Modul :mod:`compileall` kann :file:`.pyc`-Dateien (oder :file:`.pyo`
Dateien, wenn :option:`-O` verwendet wird) für alle Module in einem Verzeichnis. :mod:`compileall` Das :mod:`compileall`-Modul kann :file:` für erstellen Alle Module im angegebenen Verzeichnis. pyc`-Datei (oder verwenden Sie den Parameter :file:`.pyo`, um eine :file:`.pyo`-Datei zu erstellen). .. _tut-standardmodules:Standardmodule Standardmodule====================== ==========.. index:: module: sysPython wird mit einer Bibliothek von Standardmodulen geliefert, die in einem separatenDokument beschrieben werden , die Python-Bibliotheksreferenz (im Folgenden „Bibliotheksreferenz“). EinigeModule sind in den Interpreter integriert; diese bieten Zugriff auf Operationen, dienicht zum Kern der Sprache gehören, es aber sind dennoch eingebaut, entwederaus Effizienzgründen oder um Zugriff auf Betriebssystemprimitive wiezu ermöglichen. Der Satz solcher Module ist eine Konfigurationsoption, die auchabhängig ist auf der zugrunde liegenden Plattform: Das Modul :mod:`winreg` ist beispielsweise nurauf Windows-Systemen verfügbar. Ein bestimmtes Modul verdient einige Aufmerksamkeit::mod:`sys` In jeden Python-Interpreter integriert. Die Variablen „sys.ps1“ und „sys.ps2“ definieren die als primäre und sekundäre Eingabeaufforderungen verwendeten Zeichenfolgen:Python wird mit einer Standardmodulbibliothek geliefert und veröffentlicht ein unabhängiges Dokument mit dem Namen Python Library Reference Manual (im Folgenden als „Bibliotheksreferenzhandbuch“ bezeichnet). Im Interpreter sind einige Module integriert. Die Zugriffsschnittstellen für diese Operationen sind nicht Teil des Sprachkerns, sondern bereits im Interpreter integriert. Dies dient nicht nur der Verbesserung der Effizienz, sondern auch der Bereitstellung einer Schnittstelle für den nativen Zugriff auf das Betriebssystem, beispielsweise durch Systemaufrufe. Diese Art der Modulsammlung ist eine Konfigurationsoption, die von der zugrunde liegenden Plattform abhängt. Beispielsweise ist das Modul :mod:`winreg` nur auf Windows-Systemen verfügbar . Es gibt ein bestimmtes Modul, das erwähnenswert ist: :mod:`sys`, dieses Modul ist in alle Python-Interpreter integriert. Die Variablen sys.ps1 und sys.ps2 definieren die primäre Eingabeaufforderung und die sekundäre Eingabeaufforderung:: >>> import sys >>> >'>>> '
>>> sys.ps1 = 'C> '
C> print 'Yuck!'
Yuck!
C>
Diese beiden Variablen sind nur definiert, wenn Der Interpreter befindet sich im interaktiven Modus.
Diese beiden Variablen sind nur im interaktiven Modus des Interpreters von Bedeutung.
Die Variable „sys.path“ ist eine Liste von Zeichenfolgen, die den
Suchpfad des Interpreters für Module bestimmt. Sie wird auf einen Standardpfad initialisiert, der dem
Umgebungsvariable :envvar:`PYTHONPATH` oder aus einer integrierten Standardeinstellung, wenn:envvar:`PYTHONPATH` nicht festgelegt ist. Sie können sie mithilfe der StandardlisteOperationen:Die Variable „sys.path“ ist eine Liste von Zeichenfolgen für den Suchpfad des Interpretermoduls. Es wird durch die Umgebungsvariable
:envvar:`PYTHONPATH` initialisiert. Wenn :envvar:`PYTHONPATH` nicht festgelegt ist, wird es durch den integrierten Standardwert von
initialisiert. Sie können es mit Standard-String-Operationen ändern::
>>> import sys
>>> python')
.. _tut-dir:
Die :func:`dir`-Funktion :func:`dir`-Funktion
====== == ===========================================
Die integrierte Funktion :func:`dir` wird verwendet, um herauszufinden, welche Namen ein Modul
definiert. Sie gibt eine sortierte Liste von Zeichenfolgen zurück:
Eingebaute Funktion:func :`dir` wird verwendet, um Moduldefinitionen nach Modulnamen zu durchsuchen. Es gibt eine Speicherspalte vom Typ String
table::
>>> import fibo, sys
>>> dir(fibo) ['__name__', 'fib', 'fib2'] >>> dir(sys)['__displayhook__', '__doc__', '__exclushook__', '__name__', '__stderr__', '__stdin__', '__stdout__', '_getframe', 'api_version', 'argv', 'builtin_module_names', 'byteorder', 'callstats', 'copyright', 'displayhook', 'exc_clear', 'exc_info', 'exc_type', 'Exception', 'exec_prefix', 'executable', 'exit', 'getdefaultencoding', 'getdlopenflags', 'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode',
'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache',
'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', ' setdlopenflags',
'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',
'version', 'version_info', 'warnoptions' ]
Ohne Argumente listet :func:`dir` die Namen auf, die Sie aktuell definiert haben:
Beim Aufruf ohne Parameter gibt die Funktion :func:`dir` die aktuell definierten Namen zurück::
>>> a = [1, 2, 3, 4, 5]
>>> fibo importieren
>>> ; fib = fibo.fib
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'fib ' , 'fibo', 'sys']
Beachten Sie, dass alle Arten von Namen aufgelistet sind: Variablen, Module, Funktionen usw.
Beachten Sie, dass alle Arten von Namen aufgelistet sind: Variablen , Module, Funktionen usw.
.. index:: module: __builtin__
:func:`dir` listet nicht die Namen der integrierten Funktionen und Variablen auf, wenn Sie
eine Liste wünschen Davon sind sie im Standardmodul definiert
:mod:`__builtin__`:
:func:`dir` listet keine integrierten Funktions- und Variablennamen auf. Wenn Sie diese auflisten möchten, sind sie im Standardmodul
:mod:`__builtin__`::
>>> import __builtin__
> >> dir(__builtin__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning',
'EOFError', 'Ellipsis', 'EnvironmentError', ' Exception', 'False',
'FloatingPointError', 'FutureWarning', 'IOError', 'ImportError',
'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt' ,
'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
'NotImplementedError', 'OSerror', 'OverflowError',
'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',
'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError',
'SyntaxWarning', 'SystemError', ' SystemExit', 'TabError', 'True',
'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',
'UserWarning', 'ValueError', 'Warning', 'WindowsError',
'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__',
'__name__', 'abs', 'apply', 'basestring', 'bool', 'buffer',
'callable', 'chr', 'classmethod', 'cmp', 'coerce' , 'compile',
'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
'enumerate', ' eval', 'execfile', 'exit', 'file', 'filter', 'float',
'frozenset', 'getattr', 'globals', 'hasattr', 'hash', ' help', 'hex',
'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter',
'len' , 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview',
'min', 'object', 'oct', 'open' , 'ord', 'pow', 'property', 'quit', 'range',
'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round' , 'set',
'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
'tuple', ' type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
.. _tut-packages:
Paketpaket
=============
Pakete sind eine Möglichkeit, den Modul-Namespace von Python durch die Verwendung von „gepunkteten“
Modulnamen zu strukturieren Modulname :mod:`A.B` bezeichnet ein Submodul
mit dem Namen „B“ in einem Paket mit dem Namen „A“ Genauso wie die Verwendung von Modulen die
Autoren verschiedener Module müssen sich nicht um die globalen Variablennamen anderer kümmern, die Verwendung von gepunkteten Modulnamen erspart den Autoren von Paketen mit mehreren Modulen
wie NumPy oder der Python Imaging Library die Sorge
die Modulnamen des anderen.
Pakete verwenden normalerweise einen strukturierten Modul-Namensraum mit „Punkt-Modulnamen“. Beispielsweise stellt ein Modul mit dem Namen
:mod:`A.B` ein Submodul mit dem Namen „A“ in einem Paket mit dem Namen „B“ dar. So wie die Verwendung von
-Modulen zum Speichern verschiedener Modularchitekturen Konflikte zwischen globalen Variablen vermeidet, können Sie mit Punktmodulnamen
verschiedene Bibliotheken wie NumPy oder Python Imaging Library speichern. Die Architektur kann Namenskonflikte zwischen Modulen vermeiden
.
Angenommen, Sie möchten eine Sammlung von Modulen (ein „Paket“) für die einheitliche
Verarbeitung von Sounddateien und Sounddaten entwerfen.
Formate (normalerweise an ihrer Erweiterung erkennbar, zum Beispiel: :file:`.wav`,
:file:`.aiff`, :file:`.au`), sodass Sie sie möglicherweise erstellen und verwalten müssen eine wachsende
Sammlung von Modulen für die Konvertierung zwischen den verschiedenen Dateiformaten.
Es gibt auch viele verschiedene Vorgänge, die Sie möglicherweise an Sounddaten durchführen möchten
(z. B. Mischen). , Hinzufügen von Echo, Anwenden einer Equalizer-Funktion, Erstellen eines
künstlichen Stereoeffekts), also schreiben Sie zusätzlich einen endlosen
Strom von Modulen, um diese Vorgänge auszuführen. Hier ist eine Möglichkeit Struktur für
Ihr Paket (ausgedrückt als hierarchisches Dateisystem):
Angenommen, Sie möchten jetzt einen Modulsatz (ein „Paket“) entwerfen, um Sounddateien und Sounddaten einheitlich zu verarbeiten.
Es gibt mehrere verschiedene Tonformate (häufig erkennbar an ihren Erweiterungen, zum Beispiel: :file:`.wav`
, :file:`.aiff`, :file: `.au` ), also müssen Sie zum
Konvertieren zwischen verschiedenen Arten von Dateiformaten eine wachsende Sammlung von Paketen verwalten. Vielleicht möchten Sie auch viele verschiedene
Operationen an den Klangdaten durchführen (z. B. mischen, Echo hinzufügen, eine Balance-Funktion anwenden, einen künstlichen Effekt erzeugen), also möchten Sie
beitreten ein Infinite-Stream-Modul zum Ausführen dieser Operationen. Ihr Paket könnte so aussehen (gruppiert nach einem hierarchischen Dateisystem):
Wavread.py
Wavwrite.py
Aifread. py
aiffwrite.py
aure.py
auwrite.py
...
Effekte/ Unterpaket für Soundeffekte
… Filter/ Unterpaket für Filter
__init__. py
equalizer.py
vo coder.py
karaoke.py
Beim Importieren des Pakets durchsucht Python das Verzeichnisse auf
„sys.path“ auf der Suche nach dem Paket-Unterverzeichnis.
Beim Importieren von Modulen durchsucht Python die „Verzeichnisliste in sys.path“, um nach Unterverzeichnissen zu suchen, in denen sich Pakete befinden werden gespeichert.
Die :file:`__init__.py`-Dateien sind erforderlich, damit Python die Verzeichnisse behandelt
da sie Pakete enthalten; dies geschieht, um zu verhindern, dass Verzeichnisse mit einem gemeinsamen Namen,
wie „string“, unbeabsichtigt gültige Module verbergen, die später
bei der Modulsuche auftreten Im einfachsten Fall kann :file:`__init__.py` einfach
eine leere Datei sein, es kann aber auch Initialisierungscode für das Paket ausführen oder
den Wert „__all__“ festlegen. ``-Variable, später beschrieben.
Es muss eine :file:`__init__.py`-Datei vorhanden sein, damit Python das Verzeichnis als
-Paket behandelt; dies soll bestimmte Some verhindern Verzeichnisse verwenden einen allgemeinen Namen wie „string“ und überschreiben versehentlich das richtige Modul im Modulsuchpfad, der auf
folgt. Im einfachsten Fall kann
:file:`__init__.py` nur eine leere Datei sein, sie kann aber auch Paketinitialisierungscode enthalten oder die Variable „__all__“ festlegen, der später gefolgt wird Verwandte Einführung.
Benutzer des Pakets können einzelne Module aus dem Paket importieren, zum Beispiel:
Beispiel:
Benutzer des Pakets können einzelne Module aus dem Paket importieren, zum Beispiel::
sound.effects.echo importieren
Dadurch wird das Submodul :mod:`sound.effects.echo` geladen. Es muss mit
seinem vollständigen Namen referenziert werden >
Auf diese Weise wird das Submodul :mod:`Sound.Effects.echo` importiert. Es muss mit seinem vollständigen Namen referenziert werden. ::sound.effects.echo.echofilter(input,output,delay=0.7, atten=4)Eine alternative Möglichkeit, das Submodul zu importieren, ist:import Es gibt eine optionale Möglichkeit, Folgendes zu verpacken: from sound.effects import echoDadurch wird auch das Submodul :mod:`echo` geladen und ohne dessen verfügbar gemachtPaketpräfix, sodass es wie folgt verwendet werden kann:Dies lädt das :mod:`echo`-Submodul und macht es ohne das verwendete Paketpräfix verfügbar, sodass es aufgerufen werden kann als folgt:: echo.echofilter(input, output, delay=0.7, atten=4)Eine weitere Variante besteht darin, die gewünschte Funktion oder Variable direkt zu importieren : Es gibt eine weitere Variante zum direkten Importieren von Funktionen oder Variablen:: from sound.effects.echo import echofilterAuch hier wird das Submodul: mod:`echo` geladen, aber dadurch wird seine Funktion erfüllt :func:`echofilter` direkt verfügbar:Dadurch wird das :mod:`echo`-Submodul erneut geladen, aber dadurch wird es aufgerufen. Sie können es :func aufrufen: `echofilter`-Funktion direkt:: echofilter(input,output,delay=0.7, atten=4)Beachten Sie, dass bei Verwendung von „from package import item“ das Element sein kann entweder einSubmodul (oder Unterpaket) des Pakets oder ein anderer imPaket definierter Name, wie eine Funktion, Klasse oder Variable. Zuerst die „import“-Anweisungtestet, ob das Element im Paket definiert ist; wenn nicht, geht es davon aus, dass es sich um einModul handelt, und versucht, es zu laden. Wenn es nicht gefunden wird, wird ein :exc:`ImportError`Ausnahme wird ausgelöst.
Es ist zu beachten, dass bei Verwendung der Methode „Aus Paketimportelement“ zum Importieren eines Pakets dieses Unterelement (Element) entweder ein Untermodul ( oder ein Unterpaket) im Paket oder andere im Paket definierte Namen wie Funktionen, Klassen oder Variablen. Die Importanweisung prüft zunächst, ob der Unterschlüssel im Paket vorhanden ist. Wenn nicht, geht sie davon aus, dass es sich um ein Modul handelt, und versucht, es zu laden. Wenn es nicht gefunden wird, wird eine ImportError-Ausnahme ausgelöst.
Im Gegensatz dazu muss bei Verwendung einer Syntax wie „import item.subitem.subsubitem“ jedes Element
außer dem letzten ein Paket sein; das letzte Element kann ein Modul oder ein
Paket, kann aber keine im vorherigenitem definierte Klasse, Funktion oder Variable sein.Verwenden Sie stattdessen etwas wie „import item.subitem.subsubitem“. Bei Verwendung der Syntax müssen diese Unterelemente Pakete sein. Das letzte Unterelement kann ein Paket oder Modul sein, es darf jedoch keine Klasse, Funktion oder Variable sein, die im definiert ist vorheriger Unterpunkt. .. _tut-pkg-import-star:/* aus einem Paket importieren---------------- -----------.. index:: single: __all__Was passiert nun, wenn der Benutzer „from sound.effects import *“ schreibt? ,man würde hoffen, dass dies irgendwie ins Dateisystem geht, findet, welcheSubmodule im Paket vorhanden sind, und sie alle importiert. Dies könntelange dauern Zeit und das Importieren von Submodulen können unerwünschte Nebenwirkungen haben, die nur auftreten sollten, wenn das Submodul explizit importiert wird. „Was passiert, wenn?“ Idealerweise möchten Sie alle Submodule des Pakets im Dateisystem finden und importieren. Dies kann lange dauern und unerwartete Randeffekte haben. Der Export von Paketen, die Sie wünschen, könnte nur explizit importiert werden. Die einzige Lösung besteht darin, dass der Paketautor einen expliziten Index desPakets bereitstellt. Die :keyword:`import`-Anweisung verwendet die folgende Konvention: if a package's:file:`__init__.py`-Code definiert eine Liste mit dem Namen „__all__“ und wird als Liste der Modulnamen angesehen, die importiert werden sollen, wenn „from package import *“ lautetEs ist Sache des Paketautors, diese Liste auf dem neuesten Stand zu halten, wenn eine neue Version des Pakets veröffentlicht wird. Paketautoren können sich auch dagegen entscheiden Unterstützen Sie es, wenn sie keine Verwendung für den Import von /* aus ihrem Paket sehen.
Beispiel: Die Datei :file:`sounds/effects/__init__.py` könnte Folgendes enthalten
Code:
Die einzige Lösung für Paketautoren besteht darin, einen expliziten Paketindex bereitzustellen.
:keyword:`import`-Anweisung wird gemäß den folgenden Bedingungen konvertiert: beim Ausführen von „from package import
*``, wenn die :file:`__init__.py`-Codedefinition im Paket Eine Liste mit dem Namen „__all__“
wird entsprechend dem in der Liste angegebenen Modulnamen importiert. Der Autor kann
diese Liste nach Belieben aktualisieren, wenn eine neue Version des Pakets veröffentlicht wird. Wenn ein Paketautor beim Importieren von * nicht alle Module in seinem Paket importieren möchte,
, kann er sich entscheiden, dies nicht zu unterstützen (import /*). Beispiel:
:file:`Sounds/Effects/__init__.py` Diese Datei kann den folgenden Code enthalten::
__all__ = ["echo", "surround", "reverse" ]
Dies würde bedeuten, dass „from sound.effects import *“ die drei
benannten Submodule des :mod:`sound`-Pakets importieren würde.
Dies würde bedeuten, dass die Anweisung „from Sound.Effects import *“ die oben genannten drei Submodule aus dem Paket „:mod:`sound“ importiert.
Wenn „__all__“ nicht definiert ist, importiert die Anweisung „from sound.effects import *“
nicht alle Submodule aus dem Paket :mod:`sound. effects` in den
aktuellen Namespace; es stellt nur sicher, dass das Paket :mod:`sound.effects`
importiert wurde (möglicherweise wird ein Initialisierungscode in :file:`__init__.py ausgeführt). `)
und importiert dann alle im Paket definierten Namen (und explizit geladene Submodule) von :file:`__init__.py`
Enthält auch alle Submodule des Pakets, die explizit durch vorherige :keyword:`import`-Anweisungen geladen wurden:Wenn „__all__“ nicht definiert ist, ` Die `from Sound.Effects import *``-Anweisung importiert nicht alle Submodule aus dem Paket :mod:`sound.effects`. Unabhängig davon, wie viele Namen im Paket definiert sind, kann nur festgestellt werden, dass das Paket :mod:`sound.effects` importiert wird (der Initialisierungscode in __init__.py kann ausgeführt werden) und alle im Paket definierten Namen importiert werden importiert. Dadurch wird jedes benannte (und explizit importierte Submodul) aus __init__.py importiert. Es umfasst auch Submodule, die durch die oben genannte :keyword:`import`-Anweisung explizit aus dem Paket importiert wurden:: import sound.effects.echo import sound.effects.surround from sound.effects import *In diesem Beispiel werden die Module :mod:`echo` und :mod:`surround` inimportiert
aktueller Namespace, da sie im :mod:`sound.effects`-Paket definiert sindwenn die ``from...import``-Anweisung ausgeführt wird (Dies funktioniert auch, wenn``__all__`` ist definiert.)In diesem Beispiel importieren die Module :mod:`echo` und :mod:`surround` den aktuellen Namespace , das liegt daran Sie sind bereits im Paket :mod:`sound.effects` definiert, wenn die Anweisung „from...import“ ausgeführt wird (dasselbe funktioniert, wenn „__all__“ definiert ist). Obwohl bestimmte Module so konzipiert sind, dass sie nur Namen exportieren, die bestimmtenMustern folgen, wenn Sie „import *“ verwenden, gilt dies immer noch als schlechte Praxis imProduktionscode .Obwohl einige Module so konzipiert sind, dass sie bei Verwendung von „import *“ nur Namen exportieren, die einem bestimmten Muster entsprechen, wird nicht für die Verwendung im Produktionscode empfohlen. Denken Sie daran, dass an der Verwendung von „aus Paketimportspezifisches_Submodul“ nichts auszusetzen ist. Tatsächlich ist dies die empfohlene Notation, es sei denn, das Importmodul muss verwendet werden Submodule mit demselben Namen aus verschiedenenPaketen.Denken Sie daran, dass es keinen Fehler in „aus Paketimport spezifisches_Submodul“ gibt! Tatsächlich müssen mit Ausnahme von nicht importierte Module Submodule mit demselben Namen in anderen Paketen verwenden, andernfalls ist dies die empfohlene Schreibweise. Paketinterne Referenzen Paketreferenzen-------------------------------- - ------Die Submodule müssen häufig aufeinander verweisen. Beispielsweise könnte das:mod:`surround`-Modul das :mod:`echo`-Modul verwenden . Tatsächlich sind solcheReferenzen so häufig, dass die :keyword:`import`-Anweisung zuerst imenthaltenden Paket sucht, bevor sie im Standardmodul-Suchpfad sucht >
:mod:`surround`-Modul kann einfach „import echo“ oder „from echo import
echofilter“ verwenden. Wenn das importierte Modul nicht im aktuellen Paket gefunden wird (das
Paket, von dem das aktuelle Modul ein Submodul ist), sucht die :keyword:`import`
Anweisung nach einem Modul der obersten Ebene mit dem angegebenen Namen.
Submodul Sie müssen oft aufeinander verweisen. Beispielsweise könnte das Modul :mod:`surround` auf
verweisen:mod:`echo`-Modul. Tatsächlich sind solche Verweise so häufig, dass die :keyword:`import`
-Anweisung zuerst innerhalb des Pakets und dann im Standardmodulsuchpfad sucht. Daher kann der Modulblock :mod:`surround`
einfach „import echo“ oder „from echo import echofilter“
aufrufen. Wenn das zu importierende Modul nicht im aktuellen Paket gefunden wird, sucht die :keyword:`import`-Anweisung nach einem Modul der obersten Ebene, das entsprechend dem Index
benannt ist.
Wenn Pakete in Unterpakete strukturiert sind (wie beim :mod:`sound`-Paket
im Beispiel), können Sie absolute Importe verwenden, um auf Untermodule von Geschwistern zu verweisen
Pakete. Wenn das Modul :mod:`sound.filters.vocoder` beispielsweise
das :mod:`echo`-Modul im :mod:`sound.effects`-Paket verwenden muss, ist dies möglich Verwenden Sie „from
sound.effects import echo“.
Wenn eine Unterpaketstruktur im Paket verwendet wird (wie das :mod:`sound`-Paket im Beispiel), Sie können die absolute Position
drücken, um Submodule aus benachbarten Paketen zu importieren. Wenn zum Beispiel das Paket „:mod:`sound.filters.vocoder“ erfordert, dass
das Modul „:mod:`echo“ aus dem Paket „:mod:`sound.effects“ verwendet, kann es
` ``aus Sound.Effects import echo`` .
Ab Python 2.5 können Sie zusätzlich zu den oben beschriebenen impliziten relativen Importen
explizite relative Importe mit der Form „aus Modulimport
Name“ schreiben Diese expliziten relativen Importe verwenden führende
Punkte, um die aktuellen und übergeordneten Pakete anzugeben, die am relativen
Import beteiligt sind verwenden:
Ab Python 2.5 wurde der oben erwähnte interne explizite relative Positionsimport verbessert. Sie können „from module import name“ in der Form
verwenden, um explizit zu schreiben Die Position der Formel wird importiert. Diese expliziten
-Paare von Importen sind mit Punkten markiert, um die importierten aktuellen und übergeordneten Pakete zuzuordnen. Am Beispiel des :mod:`surround`-Moduls können Sie
wie folgt verwenden::
from .. import formats
von ..filters import equalizer
Beachten Sie, dass sowohl explizite als auch implizite relative Importe auf dem Namen
des aktuellen Moduls basieren, da der Name des Hauptmoduls immer „“ ist „__main__“ ``,
Module, die als Hauptmodul einer Python-Anwendung verwendet werden sollen, sollten
immer absolute Importe verwenden.
Es ist zu beachten, ob explizit oder implizit relative Positionen Importe basieren auf der Benennung des aktuellen Moduls. Da der Name des Hauptmoduls immer „__main__“ lautet, sollte das Hauptmodul einer Python-Anwendung immer unbedingt importiert werden.
Pakete in mehreren Verzeichnissen
-------------------------------- -- ------------------------
Pakete unterstützen ein weiteres spezielles Attribut, :attr:`__path__` Dies ist
wird als Liste initialisiert, die den Namen des Verzeichnisses enthält, das die :file:`__init__.py` enthält, bevor der Code in dieser Datei ausgeführt wird. Diese
Variable kann geändert werden ; dies wirkt sich auf zukünftige Suchen nach Modulen und
Unterpaketen aus, die im Paket enthalten sind. Das Paket
unterstützt eine weitere spezielle Funktion: :attr:`__path__` . Diese Variable initialisiert eine Liste von Verzeichnisnamen, bevor der Dateicode
:file:`__init__.py`
des Pakets ausgeführt wird. Diese Variable kann geändert werden und wirkt auf die Suchfunktion von Unterpaketen und Modulen im Paket
.
Obwohl diese Funktion nicht oft benötigt wird, kann sie verwendet werden, um den Satz von
Modulen in einem Paket zu erweitern, wird jedoch nicht häufig verwendet.
.. rubric:: Fußnoten
.. [#] Tatsächlich sind Funktionsdefinitionen auch „Anweisungen“, die bei der Ausführung eines Moduls „ausgeführt“ werden. Ebenenfunktion trägt den Funktionsnamen in die globale Symboltabelle des Moduls ein.
.. [#] Tatsächlich ist die Funktionsdefinition sowohl eine „Deklaration“ als auch ein „ausführbarer Körper“. Der ausführbare Körper besteht aus benannten Funktionen, die in die globale semantische Tabelle des Moduls importiert werden.
Das Obige ist der Inhalt des Python 2.7-Basis-Tutorials: Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
