Python - Module

Vorherige SeiteNächste Seite

Mit einem Modul können Sie Ihren Python-Code logisch organisieren. Das Gruppieren verwandten Codes in einem Modul erleichtert das Verständnis und die Verwendung des Codes. Ein Modul ist ein Python-Objekt mit willkürlich benannten Attributen, die Sie binden und referenzieren können.

Ein Modul ist einfach eine Datei, die aus Python-Code besteht. Ein Modul kann Funktionen, Klassen und Variablen definieren. Ein Modul kann auch ausführbaren Code enthalten.

Beispiel

Der Python-Code für ein Modul namens aname befindet sich normalerweise in einer Datei namens aname.py . Hier ist ein Beispiel für ein einfaches Modul, support.py

def print_func( par ):
   print "Hello : ", par
   return

Der Import Erklärung

Sie können jede Python-Quelldatei als Modul verwenden, indem Sie eine import-Anweisung in einer anderen Python-Quelldatei ausführen. Der Import hat die folgende Syntax −

import module1[, module2[,... moduleN]

Wenn der Interpreter auf eine import-Anweisung trifft, importiert er das Modul, wenn das Modul im Suchpfad vorhanden ist. Ein Suchpfad ist eine Liste von Verzeichnissen, die der Interpreter durchsucht, bevor er ein Modul importiert. Um beispielsweise das Modul support.py zu importieren, müssen Sie den folgenden Befehl an den Anfang des Skripts setzen −

#!/usr/bin/python

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Zara")

Wenn der obige Code ausgeführt wird, erzeugt er das folgende Ergebnis −

Hello : Zara

Ein Modul wird nur einmal geladen, unabhängig davon, wie oft es importiert wird. Dadurch wird verhindert, dass das Modul immer wieder ausgeführt wird, wenn mehrere Importe auftreten.

Der von...import Erklärung

Pythons von -Anweisung können Sie bestimmte Attribute aus einem Modul in den aktuellen Namespace importieren. Die von...import hat die folgende Syntax −

from modname import name1[, name2[, ... nameN]]

Um beispielsweise die Funktion fibonacci aus dem Modul fib zu importieren, verwenden Sie die folgende Anweisung −

from fib import fibonacci

Diese Anweisung importiert nicht das gesamte Modul fib in den aktuellen Namespace; es fügt lediglich das Element fibonacci aus dem Modul fib in die globale Symboltabelle des importierenden Moduls ein.

Der von...import * Erklärung

Es ist auch möglich, alle Namen aus einem Modul in den aktuellen Namensraum zu importieren, indem Sie die folgende Importanweisung verwenden −

from modname import *

Dies bietet eine einfache Möglichkeit, alle Elemente aus einem Modul in den aktuellen Namensraum zu importieren; Diese Anweisung sollte jedoch sparsam verwendet werden.

Module lokalisieren

Wenn Sie ein Modul importieren, sucht der Python-Interpreter in den folgenden Sequenzen nach dem Modul −

• Das aktuelle Verzeichnis.

• Wenn das Modul nicht gefunden wird, durchsucht Python jedes Verzeichnis in der Shell-Variablen PYTHONPATH.

• Wenn alles andere fehlschlägt, überprüft Python den Standardpfad. Unter UNIX ist dieser Standardpfad normalerweise /usr/local/lib/python/.

Der Modulsuchpfad wird im Systemmodul sys als sys.path gespeichert Variable. Die Variable sys.path enthält das aktuelle Verzeichnis, PYTHONPATH, und die installationsabhängige Vorgabe.

Der PYTHONPATH Variable

Der PYTHONPATH ist eine Umgebungsvariable, die aus einer Liste von Verzeichnissen besteht. Die Syntax von PYTHONPATH ist dieselbe wie die der Shell-Variablen PATH.

Hier ist ein typischer PYTHONPATH von einem Windows-System −

set PYTHONPATH = c:\python20\lib;

Und hier ist ein typischer PYTHONPATH von einem UNIX-System −

set PYTHONPATH = /usr/local/lib/python

Namespaces und Scoping

Variablen sind Namen (Bezeichner), die Objekten zugeordnet sind. Ein Namensraum ist ein Wörterbuch von Variablennamen (Schlüsseln) und ihren entsprechenden Objekten (Werten).

Eine Python-Anweisung kann auf Variablen in einem lokalen Namespace zugreifen und im globalen Namensraum . Wenn eine lokale und eine globale Variable den gleichen Namen haben, überschattet die lokale Variable die globale Variable.

Jede Funktion hat ihren eigenen lokalen Namensraum. Klassenmethoden folgen denselben Scoping-Regeln wie gewöhnliche Funktionen.

Python macht fundierte Vermutungen darüber, ob Variablen lokal oder global sind. Es geht davon aus, dass jede Variable, der in einer Funktion ein Wert zugewiesen wird, lokal ist.

Um einer globalen Variablen innerhalb einer Funktion einen Wert zuzuweisen, müssen Sie daher zuerst die globale Anweisung verwenden.

Die Anweisung global VarName teilt Python mit, dass VarName eine globale Variable ist. Python beendet die Suche im lokalen Namensraum nach der Variable.

Beispielsweise definieren wir eine Variable Geld im globalen Namensraum. Innerhalb der Funktion Geld , weisen wir Geld zu ein Wert, daher nimmt Python Geld an als lokale Variable. Allerdings haben wir auf den Wert der lokalen Variable Money zugegriffen bevor Sie es festlegen, sodass ein UnboundLocalError das Ergebnis ist. Das Auskommentieren der globalen Anweisung behebt das Problem.

#!/usr/bin/python

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print Money
AddMoney()
print Money

Die Funktion dir( )

Die eingebaute Funktion dir() gibt eine sortierte Liste von Strings zurück, die die von einem Modul definierten Namen enthalten.

Die Liste enthält die Namen aller Module, Variablen und Funktionen, die in einem Modul definiert sind. Es folgt ein einfaches Beispiel −

Live-Demo

#!/usr/bin/python

# Import built-in module math
import math

content = dir(math)
print content

Wenn der obige Code ausgeführt wird, erzeugt er das folgende Ergebnis −

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh']

Hier die spezielle String-Variable __name__ der Name des Moduls ist und __file__ ist der Dateiname, aus dem das Modul geladen wurde.

Die Globals() und Einheimische() Funktionen

Die globals() und Einheimische() Funktionen können verwendet werden, um die Namen in den globalen und lokalen Namespaces zurückzugeben, je nachdem, von wo aus sie aufgerufen werden.

Wenn locals() innerhalb einer Funktion aufgerufen wird, gibt es alle Namen zurück, auf die lokal von dieser Funktion aus zugegriffen werden kann.

Wenn globals() innerhalb einer Funktion aufgerufen wird, gibt es alle Namen zurück, auf die global von dieser Funktion aus zugegriffen werden kann.

Der Rückgabetyp dieser beiden Funktionen ist Dictionary. Daher können Namen mit der Funktion keys() extrahiert werden.

Das reload() Funktion

Wenn das Modul in ein Skript importiert wird, wird der Code im obersten Teil eines Moduls nur einmal ausgeführt.

Wenn Sie also den Top-Level-Code in einem Modul erneut ausführen möchten, können Sie reload() verwenden Funktion. Die Funktion reload() importiert ein zuvor importiertes Modul erneut. Die Syntax der reload()-Funktion ist diese −

reload(module_name)

Hier, Modulname ist der Name des Moduls, das Sie neu laden möchten, und nicht die Zeichenfolge, die den Modulnamen enthält. Zum Beispiel, um Hallo neu zu laden Modul, gehen Sie wie folgt vor −

reload(hello)

Pakete in Python

Ein Paket ist eine hierarchische Dateiverzeichnisstruktur, die eine einzelne Python-Anwendungsumgebung definiert, die aus Modulen und Unterpaketen und Unterunterpaketen usw. besteht.

Stellen Sie sich eine Datei Pots.py vor verfügbar unter Telefon Verzeichnis. Diese Datei hat die folgende Quellcodezeile −

#!/usr/bin/python

def Pots():
   print "I'm Pots Phone"

Auf ähnliche Weise haben wir zwei weitere Dateien mit unterschiedlichen Funktionen mit demselben Namen wie oben −

• Telefon/Isdn.py Datei mit Funktion Isdn()

• Telefon/G3.py Datei mit der Funktion G3()

Erstellen Sie nun eine weitere Datei __init__.py in Phone Verzeichnis −

• Telefon/__init__.py

Um alle Ihre Funktionen verfügbar zu machen, wenn Sie Phone importiert haben, müssen Sie explizite Importanweisungen wie folgt in __init__.py einfügen −

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Nachdem Sie diese Zeilen zu __init__.py hinzugefügt haben, stehen Ihnen alle diese Klassen zur Verfügung, wenn Sie das Telefonpaket importieren.

#!/usr/bin/python

# Now import your Phone Package.
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

Wenn der obige Code ausgeführt wird, erzeugt er das folgende Ergebnis −

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

Im obigen Beispiel haben wir ein Beispiel für eine einzelne Funktion in jeder Datei genommen, aber Sie können mehrere Funktionen in Ihren Dateien behalten. Sie können in diesen Dateien auch verschiedene Python-Klassen definieren und dann Ihre Pakete aus diesen Klassen erstellen.