Python 3 - Module

Mit einem Modul können Sie Ihren Python-Code logisch organisieren. Das Gruppieren von verwandtem Code 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 mit dem Namen aname befindet sich normalerweise in einer Datei mit dem Namen aname.py. Hier ist ein Beispiel für ein einfaches Modul, support.py -

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

Die Importanweisung

Sie können jede Python-Quelldatei als Modul verwenden, indem Sie eine Importanweisung in einer anderen Python-Quelldatei ausführen. Dasimport hat die folgende Syntax -

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

Wenn der Interpreter auf eine Importanweisung stößt, importiert er das Modul, wenn das Modul im Suchpfad vorhanden ist. Ein Suchpfad ist eine Liste von Verzeichnissen, die der Interpreter vor dem Importieren eines Moduls durchsucht. Um beispielsweise das Modul hello.py zu importieren, müssen Sie den folgenden Befehl oben im Skript einfügen:

#!/usr/bin/python3

# 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, wird das folgende Ergebnis erzeugt:

Hello : Zara

Ein Modul wird nur einmal geladen, unabhängig davon, wie oft es importiert wird. Dies verhindert, dass die Modulausführung wiederholt erfolgt, wenn mehrere Importe ausgeführt werden.

Die from ... import Anweisung

Pythons fromMit dieser Anweisung können Sie bestimmte Attribute aus einem Modul in den aktuellen Namespace importieren. Dasfrom...import hat die folgende Syntax -

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

Verwenden Sie beispielsweise die folgende Anweisung, um die Funktion fibonacci aus dem Modul fib zu importieren:

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Diese Anweisung importiert nicht das gesamte Modul fib in den aktuellen Namespace. Es wird lediglich das Element Fibonacci aus dem Modul Fib in die globale Symboltabelle des importierenden Moduls eingefügt.

Die from ... import * -Anweisung

Es ist auch möglich, alle Namen aus einem Modul in den aktuellen Namespace zu importieren, indem Sie die folgende import-Anweisung verwenden:

from modname import *

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

Module als Skripte ausführen

Innerhalb eines Moduls ist der Name des Moduls (als Zeichenfolge) als Wert der globalen Variablen __name__ verfügbar. Der Code im Modul wird so ausgeführt, als ob Sie ihn importiert hätten, jedoch mit dem Namen __name__ auf "__main__".

Fügen Sie diesen Code am Ende Ihres Moduls hinzu -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
if __name__ == "__main__":
   f = fib(100)
   print(f)

Wenn Sie den obigen Code ausführen, wird die folgende Ausgabe angezeigt.

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Module suchen

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 lautet dieser Standardpfad normalerweise / usr / local / lib / python3 /.

Der Modul-Suchpfad wird im Systemmodul sys als gespeichert sys.pathVariable. Die Variable sys.path enthält das aktuelle Verzeichnis PYTHONPATH und den installationsabhängigen Standard.

Die PYTHONPATH-Variable

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

Hier ist ein typischer PYTHONPATH von einem Windows-System -

set PYTHONPATH = c:\python34\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 Namespace ist ein Wörterbuch mit Variablennamen (Schlüsseln) und den entsprechenden Objekten (Werten).

Eine Python-Anweisung kann auf Variablen in einem lokalen Namespace und im globalen Namespace zugreifen . Wenn eine lokale und eine globale Variable denselben Namen haben, schattiert die lokale Variable die globale Variable.
Jede Funktion hat einen eigenen lokalen Namespace. Klassenmethoden folgen der gleichen Gültigkeitsregel wie normale Funktionen.
Python macht fundierte Vermutungen darüber, ob Variablen lokal oder global sind. Es wird davon ausgegangen, dass jede Variable, der in einer Funktion ein Wert zugewiesen wurde, 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 Namespace nach der Variablen.

Zum Beispiel definieren wir eine Variable Money im globalen Namespace. Innerhalb der Funktion Money weisen wir Money einen Wert zu, daher nimmt Python Money als lokale Variable an.

Wir haben jedoch vor dem Festlegen auf den Wert der lokalen Variablen Money zugegriffen , sodass ein UnboundLocalError das Ergebnis ist. Das Nichtkommentieren der globalen Anweisung behebt das Problem.

#!/usr/bin/python3

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

print (Money)
AddMoney()
print (Money)

Die dir () Funktion

Die integrierte Funktion dir () gibt eine sortierte Liste von Zeichenfolgen 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. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python3

# Import built-in module math
import math

content = dir(math)
print (content)

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

['__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 ist die spezielle Zeichenfolgenvariable __name__ der Name des Moduls und __file__ der Dateiname, aus dem das Modul geladen wurde.

Die Funktionen Globals () und Locals ()

Das globals() und locals() Mit Funktionen können die Namen in den globalen und lokalen Namespaces zurückgegeben werden, je nachdem, von wo aus sie aufgerufen werden.

Wenn locals() Wird innerhalb einer Funktion aufgerufen, werden alle Namen zurückgegeben, auf die von dieser Funktion aus lokal zugegriffen werden kann.
Wenn globals() Wird innerhalb einer Funktion aufgerufen, werden alle Namen zurückgegeben, auf die von dieser Funktion aus global zugegriffen werden kann.

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

Die Funktion reload ()

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

Wenn Sie den Code der obersten Ebene in einem Modul erneut ausführen möchten, können Sie daher die Funktion reload () verwenden. Die Funktion reload () importiert ein zuvor importiertes Modul erneut. Die Syntax der Funktion reload () lautet:

reload(module_name)

Hier ist Modulname der Name des Moduls, das Sie neu laden möchten, und nicht die Zeichenfolge, die den Modulnamen enthält. Um beispielsweise das Hallo-Modul neu zu laden, 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.

Betrachten Sie eine Datei Pots.py, die im Telefonverzeichnis verfügbar ist. Diese Datei enthält die folgende Zeile des Quellcodes:

#!/usr/bin/python3

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

Ähnlich haben wir zwei andere Dateien mit unterschiedlichen Funktionen mit demselben Namen wie oben. Sie sind -

Telefon / Isdn.py- Datei mit der Funktion Isdn ()
Telefon / G3.py- Datei mit der Funktion G3 ()

Erstellen Sie nun eine weitere Datei __init__.py im Telefonverzeichnis -

Phone/__init__.py

Um alle Ihre Funktionen verfügbar zu machen, wenn Sie Phone importiert haben, müssen Sie explizite Importanweisungen in __init__.py wie folgt 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 beim Importieren des Telefonpakets alle diese Klassen zur Verfügung.

#!/usr/bin/python3

# Now import your Phone Package.
import Phone

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

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

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.