Python Modul

In diesem Artikel werden Sie lernen, wie Sie benutzerdefinierte Module mit Python erstellen und importieren. Sie werden auch verschiedene Techniken zur Importierung und Verwendung von benutzerdefinierten und eingebauten Modulen in Python entdecken.

Was ist ein Modul in Python?

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

Dateien, die Python-Code enthalten, wie z.B. example.py, werden Module genannt und haben den Modulnamen example.

Wir verwenden Module, um große Programme in verwaltbare kleine Dateien zu zerlegen. Außerdem bieten Module die Wiederverwendbarkeit von Code.

Wir können in Modulen die häufigsten Funktionen definieren und sie importieren, anstatt sie in anderen Programmen zu kopieren.

Lassen Sie uns ein Modul erstellen. Geben Sie folgenden Inhalt ein und speichern Sie es als example.py ab.

# Beispiel für Python-Modul
def add(a, b):
　　　"""Diese Programm addiert zwei Zahlen"
　　　　　　　und gibt das Ergebnis der Addition """ zurück
　　　result = a　+　b
　　　return result

Hier definieren wir eine Funktion namens add() in einem Modul namens example.Funktion. Diese Funktion akzeptiert zwei Zahlen und gibt deren Summe zurück.

Wie importiert man Module in Python?

Wir können Definitionen innerhalb eines Moduls in ein anderes Modul oder in den interaktiven Python-Interpreter importieren.

Um dies zu erreichen, verwenden wir den Schlüsselwort Import. Um ein zuvor definiertes Modul zu importieren, geben wir im Python-Interaktionsprompt folgende Inhalt ein.

>>> import example

Dies fügt nicht direkt die Definition der Funktion mit dem Namen example in das aktuelle Symboltable ein. Es fügt nur den Modulnamen hier ein.

Mit dem Modulnamen können wir den Punktoperator . verwenden, um auf Funktionen zuzugreifen. Zum Beispiel:

>>> example.add(4,5.5)
9.5

Python verfügt über eine Vielzahl von verfügbaren Standardmodulen.

Sie könnenPython-StandardmoduleDie vollständige Liste und deren Verwendungszweck. Diese Dateien befinden sich im Verzeichnis Lib innerhalb des Python-Installationsorts.

Standardmodule können wie benutzerdefinierte Module importiert werden.

Es gibt mehrere Methoden zum Importieren von Modulen. Sie sind wie folgt aufgelistet.

Python-Import-Syntax

Wir können Module mit dem Import-Syntax importieren und wie oben beschrieben mit dem Punktoperator auf ihre internen Definitionen zugreifen. Dies ist ein Beispiel.

# Beispiel für Import-Syntax
# Standardmodul Mathematik importieren
import math
print("π-Wert", math.pi)

Wenn Sie dieses Programm ausführen, wird ausgegeben:

π-Wert　3.141592653589793

Modul umbenennen

Wir können Module wie folgt umbenennen, um sie zu importieren.

# Modul durch Umbenennung importieren
import math as m
print("π-Wert", m.pi)

Wir haben das Modul math in m umbenannt. In einigen Fällen kann dies unsere Schreibzeit sparen.

Bitte beachten Sie, dass der Name math in unserem Bereich nicht erkannt wird. Daher ist math.pi ungültig, während m.pi die richtige Verwendung ist.

Python from ... import Anweisung

Wir können spezifische Namen aus einem Modul importieren, ohne das Modul insgesamt zu importieren. Dies ist ein Beispiel.

#　Importiere nur pi aus dem Mathematikmodul
from　math　import　pi
print("Der Wert von π",　pi)

Wir importieren nur den Attribut pi aus dem Modul.

In diesem Fall verwenden wir den Punktoperator nicht. Wir können mehrere Attribute wie folgt importieren.

>>>　from　math　import　pi,　e
>>>　pi
3.141592653589793
>>>　e
2.718281828459045

Importiere alle Namen

Wir können diese Konstrukte verwenden, um alle Namen aus einem Modul zu importieren (definieren).

#　Importiere alle Namen aus dem Standardmodul math
from　math　import　*
print("Der Wert von pi",　pi)

Wir haben alle Definitionen aus dem Mathematikmodul importiert. Dies macht alle Namen außer denjenigen, die mit Unterstrich beginnen, in unserem Bereich sichtbar.

Import mit Stern (**Alle Inhalte, die mit dem Symbol ) enthalten, sind keine gute Programmierpraxis. Dies kann zu wiederholten Definitionen von Identifikatoren führen. Dies beeinflusst auch die Lesbarkeit unseres Codes.

Python Modul-Suchpfad

Wenn Python Module importiert, überprüft er mehrere Orte. Der Interpreter sucht zunächst nach einem eingebauten Modul und dann (wenn es nicht gefunden wird) in die definierten Verzeichnislisten sys.path. Die Suche erfolgt in dieser Reihenfolge.

• Aktuelles Verzeichnis.

• PYTHONPATH (umgebungsvariable mit Verzeichnislisten).

• Standardverzeichnisse, die mit der Installation zusammenhängen.

>>>　import　sys
>>>　sys.path
['',
'C:\\Python33\\Lib\\idlelib',
'C:\\Windows\\system32\\python33.zip',
'C:\\Python33\\DLLs',
'C:\\Python33\\lib',
'C:\\Python33',
'C:\\Python33\\lib\\site-Pakete']

Wir können diesem Pfad hinzufügen, um unseren eigenen Pfad hinzuzufügen.

Modul neu laden

Der Python-Interpreter lädt Module während einer Sitzung nur einmal. Dies macht die Dinge effizienter. Dies ist ein Beispiel, das zeigt, wie es funktioniert.

Angenommen, es gibt in einem Modul namens my_module den folgenden Code.

#　Dieses Modul zeigt
#　Mehrfach importieren und neu hinzufügen
print("Dieses Code-Stück wurde ausgeführt")

Jetzt haben wir die Wirkung mehrfacher Importe gesehen.

>>> import my_module
Dieser Code wird ausgeführt
>>> import my_module
>>> import my_module

Wir können sehen, dass unser Code nur einmal ausgeführt wurde. Dies zeigt, dass unser Modul nur einmal importiert wurde.

Wenn unser Modul während der Ausführung des Programms geändert wird, müssen wir es neu laden. Eine Methode ist, den Interpreter neu zu starten. Das hilft aber nicht viel.

Python bietet eine einfache Methode. Wir können die Funktion reload() im Modul verwenden, um das Modul neu zu laden. Wie funktioniert das?

>>> import imp
>>> import my_module
Dieser Code wird ausgeführt
>>> import my_module
>>> imp.reload(my_module)
Dieser Code wird ausgeführt
<Modul 'my_module' aus '.\\my_module.py'>

dir()-integrierte Funktion

Man kann mit der Funktion dir() die in einem Modul definierten Namen finden.

Beispielsweise haben wir in dem Anfangsmodul example eine add()-Funktion definiert.

>>> dir(example)
['__builtins__',
'__cached__',
'__doc__',
'__file__',
'__initializing__',
'__loader__',
'__name__',
'__package__',
'add'

Hier können wir eine sortierte Namensliste (sowie add) sehen. Alle mit einem Unterstrich beginnenden anderen Namen sind mit dem Modul verbundenen Standard-Python-Attribute (die wir selbst nicht definiert haben).

Beispielsweise enthält die __name__-Eigenschaft den Namen des Moduls.

>>> import example
>>> example.__name__
'example'

Man kann mit der Funktion dir() ohne jegliche Parameter alle in der aktuellen Namensraum definierten Namen finden.

>>> a =　1
>>> b = "hello"
>>> import math
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter']