Modul importieren in Python mit Beispielen

Die folgenden Abschnitte erläutern Module, Pakete, die verschiedenen Importstile und die Funktionsweise absoluter und relativer Importe. Python.

Was sind die Module in Python?

Ein Modul ist eine Datei mit Python Code. Der Code kann in Form von Variablen, Funktionen oder einer definierten Klasse vorliegen. Der Dateiname wird zum Modulnamen.

Wenn Ihr Dateiname beispielsweise guru99.py lautet, lautet der Modulname guru99. Mit der Modulfunktionalität können Sie Ihren Code in verschiedene Dateien aufteilen, anstatt alles in eine Datei zu schreiben.

Herausforderungen in der Python Modul importieren?

Eine Datei wird als Modul betrachtet in PythonUm das Modul zu verwenden, müssen Sie es mit folgendem Befehl importieren: importieren Schlüsselwort. Die in der Datei vorhandenen Funktionen oder Variablen können in einer anderen Datei durch Importieren des Moduls verwendet werden. Diese Funktionalität ist auch in anderen Sprachen verfügbar, wie zum Beispiel TypeScript, JavaSkript, Java, Rubin usw.

So erstellen und importieren Sie ein Modul in Python?

Nun erstellen wir ein Modul und importieren es in eine andere Datei.

Hier ist der Ablauf zum Erstellen und Importieren des Moduls, wie im Screenshot gezeigt:

Folgen Sie den angegebenen Schritten, um ein Modul zu erstellen in Python.

Die zum Testen des Codes verwendete Ordnerstruktur ist wie folgt:

modtest/
	test.py
	display.py	

Schritt 1) Erstelle eine Datei und nenne sie test.py

Schritt 2) Erstellen Sie in test.py eine Funktion namens display_message()

Def display_message():
    return "Welcome to Guru99 Tutorials!"

Schritt 3) Erstellen Sie nun eine weitere Datei display.py.

Schritt 4) Importieren Sie innerhalb der Datei display.py die Moduldatei test.py, wie unten gezeigt:

import test

Beim Importieren muss die Datei test.py nicht angegeben werden, sondern nur der Dateiname.

Schritt 5) Anschließend können Sie die Funktion `display_message()` aus `test.py` innerhalb von `display.py` aufrufen. Dabei müssen Sie die Formel `module_name.function_name` verwenden.

Zum Beispiel test.display_message().

Import test
print(test.display_message())

Schritt 6) Wenn Sie display.py ausführen, erhalten Sie Folgendes: Ausgang:

Welcome to Guru99 Tutorials!

Importieren einer Klasse in Python

Wir haben bereits ein einfaches Modul mit einer Funktion kennengelernt. Hier erstellen wir eine Klasse und greifen in einer anderen Datei auf diese Klasse zu.

Die Ordnerstruktur zum Testen des Codes sieht wie folgt aus:

myproj/
	Car.py
	display.py

Erstellen Sie eine Datei namens Car.py mit dem folgenden Code:

Dateiname: Car.py

class Car:
	brand_name = "BMW"
	model = "Z4"
	manu_year = "2020"

	def __init__(self, brand_name, model, manu_year):
		self.brand_name = brand_name
		self.model = model
		self.manu_year = manu_year

	def car_details(self):
		print("Car brand is ", self.brand_name)
		print("Car model is ", self.model)
		print("Car manufacture year is ", self.manu_year)
			
			
	def get_Car_brand(self):
		print("Car brand is ", self.brand_name)

	def get_Car_model(self):
		print("Car model is ", self.model) 

Die Datei Car.py enthält die Attribute brand_name, model und manu_year. Die in der Klasse definierten Funktionen sind car_details(), get_Car_brand() und get_Car_model().

Lassen Sie uns nun die Datei Car.py als Modul in einer anderen Datei namens display.py verwenden.

Dateiname: display.py

import Car
car_det = Car.Car("BMW","Z5", 2020)
print(car_det.brand_name)
print(car_det.car_details())
print(car_det.get_Car_brand())
print(car_det.get_Car_model())

Ausgang:

BMW
Car brand is  BMW
Car model is  Z5
Car manufacture year is  2020
Car brand is  BMW
Car model is  Z5

Wir können also über das Car-Modul auf alle Variablen und Funktionen aus Car.py zugreifen.

Verwenden des From-to-Importmoduls

Sie können nur einen kleinen Teil des Moduls importieren, d. h. nur die benötigten Funktionen und Variablennamen aus dem Modul, anstatt den gesamten Code zu importieren.

Wenn Sie nur bestimmte Dinge importieren möchten, können Sie das Schlüsselwort „from“ verwenden, um die gewünschten Daten zu importieren.

Die Syntax ist also

from  module import your function_name , variables,... etc.

Die zum Testen des Codes verwendete Ordnerstruktur ist wie folgt:

modtest/
	test.py
	display.py	

In test.py gibt es zwei Funktionen, wie folgt:

Dateiname: test.py

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
def display_message1():
	return "All about Python!"

Nun benötigen Sie die Funktion display_message(). Auf die Funktion oder Variable, die Sie importieren, kann direkt zugegriffen werden, wie unten gezeigt:

Dateiname: display.py

from test import display_message
print(display_message())

Ausgang:

Welcome to Guru99 Tutorials!

Wenn Sie nun die Funktion display_message1() verwenden, wird ein Fehler ausgegeben, dass die Funktion nicht definiert ist, wie unten gezeigt:

from test import display_message
print(display_message1())

Ausgang:

Traceback (most recent call last):
File "display.py", line 3, in <module>
print(display_message1())
Name Error: name 'display_message1' is not defined

Alles aus dem Modul importieren

Mit dem Befehl „Import“ können Sie das gesamte Modul importieren, indem Sie „import“ gefolgt vom Modulnamen, d. h. dem Dateinamen oder der zu verwendenden Bibliothek, angeben.

Syntax:

Import module

Oder mit

from module import *

Die zum Testen des Codes verwendete Ordnerstruktur ist wie folgt:

modtest/
	test.py
	display.py	

Nachfolgend sind die Codedetails in test.py aufgeführt.

my_name = "Guru99"
my_address = "Mumbai"

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
	
def display_message1():
	return "All about Python!"

Verwendung des Importmoduls

Um auf die Variablen und Funktionen innerhalb des Moduls zuzugreifen, müssen Sie ihnen den Modulnamen voranstellen, wenn Sie nur den Namen des Importmoduls verwenden.

Beispiel

Dateiname: display.py

Import test
print(test.display_message())
print(test.display_message1())
print(test.my_name)
print(test.my_address)

Der Modulname „test“ dient dazu, auf die Funktionen und Variablen innerhalb des Moduls „test“ zu verweisen.

Ausgang:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Import verwenden *

Sehen wir uns ein Beispiel mit an importieren *. Mit importieren *, sind die Funktionen und Variablen direkt zugänglich, wie im folgenden Beispiel gezeigt:

from test import *

print(display_message())
print(display_message1())
print(my_name)
print(my_address)

Ausgang:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Die dir( )-Funktion

dir() ist eine eingebaute Funktion in PythonDie Methode dir() gibt alle Eigenschaften und Methoden zurück, einschließlich der eingebauten Eigenschaften des gegebenen Objekts.

Wenn also dir() auf das Modul angewendet wird, liefert es die Variablen und Funktionen, die innerhalb des Moduls vorhanden sind.

Hier ist ein funktionierendes Beispiel für die Verwendung von `dir()` in einem Modul. Wir haben eine Klasse namens `Car.py`. Importieren wir `Car` und weisen wir sie `dir()` zu, um die Ausgabe zu sehen.

Die Ordnerstruktur zum Testen des Codes sieht wie folgt aus:

test prop/
	Car.py
	test.py	

Dateiname: Car.py

class Car:
	brand_name = "BMW"
	model = "Z4"
	manu_year = "2020"

	def __init__(self, brand_name, model, manu_year):
		self.brand_name = brand_name
		self.model = model
		self.manu_year = manu_year

	def car_details(self):
		print("Car brand is ", self.brand_name)
		print("Car model is ", self.model)
		print("Car manufacture year is ", self.manu_year)
			
			
	def get_Car_brand(self):
		print("Car brand is ", self.brand_name)

	def get_Car_model(self):
		print("Car model is ", self.model) 

Dateiname: test.py

import Car

class_contents = dir(Car)
print(class_contents)

Die Ausgabe gibt uns den Namen der Klasse und alle in Car.py definierten Funktionen.

Sie können auch versuchen, dir() auf einem integrierten Modul zu verwenden, das verfügbar ist in PythonVersuchen wir dasselbe mit dem JSON Das Modul wird wie im folgenden Beispiel gezeigt angezeigt. Es werden alle im Modul verfügbaren Eigenschaften und Methoden angezeigt. JSON Modul.

Import json
json_details = dir(json)
print(json_details)

Ausgang:

['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__bu
iltins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__pac
kage__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_en
coder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'loa
d', 'loads', 'scanner']

Pakete

Ein Paket ist ein Verzeichnis, in dem alle Module definiert sind. Um ein Python Der Interpreter behandelt es als Paket; Ihr Verzeichnis sollte die Datei __init__.py enthalten. Die __init__.py-Datei macht das Verzeichnis zu einem Paket. Hier ist die Struktur des Pakets, mit dem wir arbeiten werden.

Der Name des Pakets ist mein PaketUm mit dem Paket zu arbeiten, erstellen Sie ein Verzeichnis namens „mypackage/“. Erstellen Sie darin eine leere Datei namens „__init__.py“. Erstellen Sie anschließend drei weitere Dateien: „module1.py“, „module2.py“ und „module3.py“. Definieren Sie die Funktionen wie im Screenshot gezeigt. Im Folgenden finden Sie die Details zu „module1.py“, „module2.py“ und „module3.py“.

module1.py

def mod1_func1():
print("Welcome to Module1 function1")

def mod1_func2():
print("Welcome to Module1 function2")

def mod1_func3():
print("Welcome to Module1 function3")

module2.py

def mod2_func1():
print("Welcome to Module2 function1")

def mod2_func2():
print("Welcome to Module2 function2")

def mod2_func3():
print("Welcome to Module2 function3")

module3.py

def mod3_func1():
print("Welcome to Module3 function1")

def mod3_func2():
print("Welcome to Module3 function2")

def mod3_func3():
print("Welcome to Module3 function3")

Das Paket ist nun einsatzbereit. Rufen Sie das Paket jetzt in einer Ihrer Dateien auf, wie unten in test.py gezeigt:

Hier wird mypackage.module1 importiert und mit einem Aliasnamen versehen Mod1In ähnlicher Weise können Sie die anderen Module module2.py und module3.py aus mypackage verwenden.

import mypackage.module1 as mod1

print(mod1.mod1_func1())
print(mod1.mod1_func2())
print(mod1.mod1_func2())

Ausgang:

Welcome to Module1 function1
None
Welcome to Module1 function2
None
Welcome to Module1 function2
None

Wir haben das Paket anhand eines einfachen Moduls mit darin enthaltenen Funktionen demonstriert. Entsprechend Ihrem Projekt können Sie auch Pakete erstellen, die Unterpakete enthalten, d. h. Unterordner mit Modulen, in denen Klassen definiert sind.

Python Modulsuchpfad

Während der Ausführung, wenn Python treffen Name des ImportmodulsDer Interpreter versucht, das Modul zu finden. Er sucht das Modul in der Liste der integrierten Module und anschließend in allen Verzeichnissen, die in sys.path definiert sind.

Zusammenfassend führt der Interpreter die folgende Suche durch, um das Modul zu finden:

1. In Ihrem aktuellen Verzeichnis.
2. In der Liste der integrierten Module.
3. Innerhalb der sys.path-Verzeichnisse.

Die Details von sys.path erhalten Sie durch Importieren des sys-Moduls und anschließendes Ausgeben von sys.path. Sie erhalten dann die unten dargestellte Liste der Verzeichnisse:

importsys
print(sys.path)

Ausgang:

['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\
\Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P
ython37\\DLLs']

Sie können auch den Pfad ändern und die Verzeichnisse Ihren Anforderungen entsprechend beibehalten.

Modulalias beim Import verwenden

Sie können den Modulnamen auch durch einen Aliasnamen verkürzen. Der Alias ​​kann mit folgendem Befehl erstellt werden: as Stichwort.

Syntax:

import filename as alias name

Die Ordnerstruktur zum Testen des Codes sieht wie folgt aus:

Mod test/
	test.py
	display.py	

Es folgt der Code in test.py

my_name = "Guru99"
my_address = "Mumbai"

def display_message():
	return "Welcome to Guru99 Tutorials!"	
	
def display_message1():
	return "All about Python!"

Nun werden wir in display.py einen Alias ​​für test.py verwenden.

Import test as t

print(t.display_message())
print(t.display_message1())
print(t.my_name)
print(t.my_address)

Der Alias ​​für das Testmodul ist t. Daher können die Funktionen und Variablen aus test.py mit dem Alias ​​t aufgerufen werden.

Ausgang:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Absolute und relative Importe in Python

Sie wissen jetzt, wie Sie eine Datei als Modul in eine andere Datei importieren. Lassen Sie uns nun sehen, wie Sie die in Ordnern verfügbaren Dateien verwalten. Die Dateien in den Ordnern können entweder durch absolute oder relative Importe importiert werden.

Stellen Sie sich vor, Sie haben die Struktur Ihres Projektordners wie unten dargestellt:

Der Stammordner ist myproject/. Er enthält zwei Unterordner: package1 und package2.

Der Ordner package1 enthält zwei Module, module1.py und module2.py.

Der Ordner package2 hat eine Klasse myclass.py, ein Unterpaket subpkg mit module3.py und zuletzt module4.py.

• In module1.py gibt es eine Funktion namens myfunc1.
• In module2.py gibt es eine Funktion namens myfunc2.
• In module3.py gibt es eine Funktion namens myfunc3.
• In module4.py gibt es eine Funktion namens myfunc4.

Verwendung absoluter Importe

Bei absoluten Importen müssen Sie den gesamten Pfad Ihres Moduls direkt vom Projektstammverzeichnis aus hinzufügen.

Schauen wir uns nun an, wie man absolute Importe verwendet, um auf die Funktionen in den einzelnen Modulen zu verweisen.

Um mit der Funktion myfunc1 zu arbeiten, müssen Sie sie wie folgt importieren:

from package1.module1  import  myfunc1
or
from package1 import module1
module1.myfunc1()  

Um mit der Funktion myfunc3 zu arbeiten, müssen Sie sie wie folgt importieren:

from package1.subpkg.module3  import  myfunc3
or
from package1.subpkg import module3
module3.myfunc3()  

Vor- und Nachteile der Verwendung absoluter Importe

Hier sind die Vorteile der Verwendung absoluter Importe:

• Es wird einfach tracSenden Sie die Module zur Codeüberprüfung zurück.
• Einfach zu bedienen und sehr unkompliziert.
• Wird das Projekt auf einen anderen Pfad verschoben, bleiben die Importe dennoch gleich.

Nachteile der Verwendung absoluter Importe

Hier sind die Nachteile der Verwendung absoluter Importe:

• Der Importpfad kann sehr lang werden, wenn die Module verschachtelt sind und die Modulnamen lang sind.

Verwendung relativer Importe

Unter Berücksichtigung der oben genannten Ordnerstruktur werden wir sehen, wie man dieselben Dateien mithilfe relativer Importe importiert.

Bei einem relativen Import bezieht sich das zu importierende Modul auf den aktuellen Speicherort, also den Speicherort, an dem die Importanweisung vorhanden ist.

Syntax

Bei relativen Importen müssen Sie beim Importieren mit einen Punkt (.) vor dem Modulnamen hinzufügen ab.

Vor dem Modulnamen stehen zwei Punkte (..), wenn sich das Modul eine Ebene über dem aktuellen Speicherort befindet.

In Anlehnung an die oben erwähnte Ordnerstrukturabbildung haben wir die folgenden Module mit ihren Funktionen, auf die wir uns beziehen müssen.

• In module1.py gibt es eine Funktion namens myfunc1.
• In module2.py gibt es eine Funktion namens myfunc2.
• In module3.py gibt es eine Funktion namens myfunc3.
• In module4.py gibt es eine Funktion namens myfunc4.

Um mit der Funktion myfunc1 zu arbeiten, müssen Sie sie wie folgt importieren:

from  .module1  import  myfunc1

Um mit der Funktion myfunc3 zu arbeiten, müssen Sie sie wie folgt importieren:

from  .subpkg.module3  import  myfunc3

Vorteile relativer Importe

• Es ist einfach, mit relativen Importen zu arbeiten.
• Vom aktuellen Standort aus können die Importe im Vergleich zu absoluten Importen verkürzt werden.

Nachteile relativer Importe

• Bei Verwendung relativer Importe ist es schwierig, trace zurück dorthin, wo sich der Code befindet.

Häufig gestellte Fragen