In diesem Artikel erfahren Sie, wie Sie benutzerdefinierte Module in Python erstellen und importieren. Außerdem finden Sie verschiedene Techniken zum Importieren und Verwenden von benutzerdefinierten und integrierten Modulen in Python.
Video: Python-Module
Was sind Module in Python?
Module beziehen sich auf eine Datei mit Python-Anweisungen und -Definitionen.
Eine Datei, die Python-Code enthält, zum Beispiel:, example.pywird als Modul bezeichnet, und ihr Modulname lautet example.
Wir verwenden Module, um große Programme in kleine verwaltbare und organisierte Dateien aufzuteilen. Darüber hinaus bieten Module die Wiederverwendbarkeit von Code.
Wir können unsere am häufigsten verwendeten Funktionen in einem Modul definieren und importieren, anstatt ihre Definitionen in verschiedene Programme zu kopieren.
Lassen Sie uns ein Modul erstellen. Geben Sie Folgendes ein und speichern Sie es unter example.py.
# Python Module example def add(a, b): """This program adds two numbers and return the result""" result = a + b return result
Hier haben wir eine Funktion add()innerhalb eines Moduls mit dem Namen definiert example. Die Funktion nimmt zwei Zahlen auf und gibt deren Summe zurück.
Wie importiere ich Module in Python?
Wir können die Definitionen innerhalb eines Moduls in ein anderes Modul oder den interaktiven Interpreter in Python importieren.
Wir verwenden dazu das importSchlüsselwort. Um unser zuvor definiertes Modul zu importieren example, geben Sie Folgendes in die Python-Eingabeaufforderung ein.
>>> import example
Dadurch werden die Namen der Funktionen, die exampledirekt in der aktuellen Symboltabelle definiert sind, nicht importiert . Dort wird nur der Modulname importiert example.
Über den Modulnamen können wir mit dem Punktoperator auf die Funktion zugreifen .. Beispielsweise:
>>> example.add(4,5.5) 9.5
Python hat Tonnen von Standardmodulen. Sie können die vollständige Liste der Python-Standardmodule und ihrer Anwendungsfälle einsehen. Diese Dateien befinden sich im Lib-Verzeichnis an dem Speicherort, an dem Sie Python installiert haben.
Standardmodule können genauso importiert werden wie unsere benutzerdefinierten Module.
Es gibt verschiedene Möglichkeiten, Module zu importieren. Sie sind unten aufgeführt …
Python-Importanweisung
Wir können ein Modul mithilfe der importAnweisung importieren und mit dem oben beschriebenen Punktoperator auf die darin enthaltenen Definitionen zugreifen. Hier ist ein Beispiel.
# import statement example # to import standard module math import math print("The value of pi is", math.pi)
Wenn Sie das Programm ausführen, lautet die Ausgabe wie folgt:
Der Wert von pi ist 3.141592653589793
Importieren mit Umbenennen
Wir können ein Modul importieren, indem wir es wie folgt umbenennen:
# import module by renaming it import math as m print("The value of pi is", m.pi)
Wir haben das mathModul umbenannt in m. Dies kann uns in einigen Fällen Zeit beim Tippen sparen.
Beachten Sie, dass der Name mathin unserem Bereich nicht erkannt wird. Daher math.piist ungültig und m.piist die richtige Implementierung.
Python aus … import Anweisung
Wir können bestimmte Namen aus einem Modul importieren, ohne das Modul als Ganzes zu importieren. Hier ist ein Beispiel.
# import only pi from math module from math import pi print("The value of pi is", pi)
Hier haben wir nur das piAttribut aus dem mathModul importiert .
In solchen Fällen verwenden wir den Punktoperator nicht. Wir können auch mehrere Attribute wie folgt importieren:
>>> from math import pi, e >>> pi 3.141592653589793 >>> e 2.718281828459045
Importieren Sie alle Namen
Wir können alle Namen (Definitionen) aus einem Modul mit dem folgenden Konstrukt importieren:
# import all names from the standard module math from math import * print("The value of pi is", pi)
Hier haben wir alle Definitionen aus dem Mathematikmodul importiert. Dies schließt alle Namen ein, die in unserem Bereich sichtbar sind, mit Ausnahme derjenigen, die mit einem Unterstrich beginnen (private Definitionen).
Importing everything with the asterisk (*) symbol is not a good programming practice. This can lead to duplicate definitions for an identifier. It also hampers the readability of our code.
Python Module Search Path
While importing a module, Python looks at several places. Interpreter first looks for a built-in module. Then(if built-in module not found), Python looks into a list of directories defined in sys.path. The search is in this order.
- The current directory.
PYTHONPATH(an environment variable with a list of directories).- The installation-dependent default directory.
>>> 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-packages')
We can add and modify this list to add our own path.
Reloading a module
The Python interpreter imports a module only once during a session. This makes things more efficient. Here is an example to show how this works.
Suppose we have the following code in a module named my_module.
# This module shows the effect of # multiple imports and reload print("This code got executed")
Now we see the effect of multiple imports.
>>> import my_module This code got executed >>> import my_module >>> import my_module
We can see that our code got executed only once. This goes to say that our module was imported only once.
Now if our module changed during the course of the program, we would have to reload it.One way to do this is to restart the interpreter. But this does not help much.
Python provides a more efficient way of doing this. We can use the reload() function inside the imp module to reload a module. We can do it in the following ways:
>>> import imp >>> import my_module This code got executed >>> import my_module >>> imp.reload(my_module) This code got executed
The dir() built-in function
Wir können die dir()Funktion verwenden, um Namen herauszufinden, die innerhalb eines Moduls definiert sind.
Zum Beispiel haben wir add()in dem Modul example, das wir am Anfang hatten, eine Funktion definiert .
Wir können verwenden dirin exampleModul auf folgende Weise:
>>> dir(example) ('__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__', '__name__', '__package__', 'add')
Hier sehen wir eine sortierte Liste von Namen (zusammen mit add). Alle anderen Namen, die mit einem Unterstrich beginnen, sind Standard-Python-Attribute, die dem Modul zugeordnet sind (nicht benutzerdefiniert).
Das __name__Attribut enthält beispielsweise den Namen des Moduls.
>>> import example >>> example.__name__ 'example'
Alle in unserem aktuellen Namespace definierten Namen können mit der dir()Funktion ohne Argumente ermittelt werden.
>>> a = 1 >>> b = "hello" >>> import math >>> dir() ('__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter')
