Module importeren Python met voorbeelden
Anna Blake
Waar zitten de modules in Python?
Een module is een bestand met Python-code. De code kan de vorm hebben van variabelen, functies of gedefinieerde klassen. De bestandsnaam wordt de modulenaam.
Als uw bestandsnaam bijvoorbeeld guru99.py is, zal de modulenaam dat zijn guru99. Met modulefunctionaliteit kunt u uw code in verschillende bestanden opdelen in plaats van alles in één bestand te schrijven.
Wat is het Python importmodule?
Een bestand wordt in Python beschouwd als een module. Om de module te gebruiken, moet u deze importeren met behulp van de import trefwoord. De functie of variabelen die in het bestand aanwezig zijn, kunnen in een ander bestand worden gebruikt door de module te importeren. Deze functionaliteit is beschikbaar in andere talen, zoals typoscript, JavaScript, Java, Ruby, enz.
Hoe u een module kunt maken en importeren Python?
Nu gaan we een module maken en deze in een ander bestand importeren.
Hier is de procedure voor het maken en importeren van de module, zoals weergegeven in de schermafbeelding:
Volg de gegeven stappen om een module in Python te maken.
De mapstructuur die wordt gebruikt om de code te testen is als volgt:
modtest/ test.py display.py
Stap 1) Maak een bestand en noem het test.py
Stap 2) Binnen test.py maak je een functie met de naam display_message()
Def display_message():
return "Welcome to Guru99 Tutorials!"
Stap 3) Maak nu een ander bestand display.py.
Stap 4) Importeer in display.py het bestand moduletest.py, zoals hieronder weergegeven:
import test
Tijdens het importeren hoeft u niet de test.py te vermelden, maar alleen de naam van het bestand.
Stap 5) Vervolgens kunt u de functie display_message() vanuit test.py in display.py aanroepen, u moet gebruik maken van module_name.function_name.
Bijvoorbeeld test.display_message().
Import test print(test.display_message())
Stap 6) Wanneer u display.py uitvoert, krijgt u het volgende Output:
Welcome to Guru99 Tutorials!
Een klas importeren in Python
Eerder hebben we een eenvoudige module met een functie gezien. Hier wordt een klasse gemaakt en de klasse naar een ander bestand verwezen.
De mapstructuur om de code te testen is als volgt:
myproj/ Car.py display.py
Maak een bestand met de naam Car.py met de volgende code:
Bestandsnaam: 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)
In het bestand Car.py zijn de attributen brand_name, model en manu_year. De functies die binnen de klasse zijn gedefinieerd zijn car_details(), get_Car_brand(), get_Car_model().
Laten we nu het bestand Car.py gebruiken als een module in een ander bestand genaamd display.py.
Bestandsnaam: 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())
Output:
BMW Car brand is BMW Car model is Z5 Car manufacture year is 2020 Car brand is BMW Car model is Z5
We hebben dus toegang tot alle variabelen en functies van Car.py met behulp van de Car-module.
Met behulp van van naar importmodule
U kunt slechts een klein deel van de module importeren, dat wil zeggen alleen de vereiste functies en namen van variabelen uit de module, in plaats van de volledige code te importeren.
Als u alleen specifieke dingen wilt importeren, kunt u het trefwoord 'van' gebruiken om te importeren wat u wilt.
De syntaxis is dus
from module import your function_name , variables,... etc.
De mapstructuur die wordt gebruikt om de code te testen is als volgt:
modtest/ test.py display.py
In test.py zijn er 2 functies zoals weergegeven:
Bestandsnaam: test.py
defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Nu wil je de functie display_message(). De functie of variabele die u importeert, is direct toegankelijk, zoals hieronder weergegeven:
Bestandsnaam: display.py
from test import display_message print(display_message())
Output:
Welcome to Guru99 Tutorials!
Als u nu de functie display_message1() gebruikt, krijgt u een foutmelding dat de functie niet is gedefinieerd zoals hieronder weergegeven:
from test import display_message print(display_message1())
Output:
Traceback (most recent call last): File "display.py", line 3, in <module> print(display_message1()) Name Error: name 'display_message1' is not defined
Alles uit de module importeren
Met Importeren kunt u de volledige module importeren door gebruik te maken van import gevolgd door de modulenaam, dwz de bestandsnaam of de te gebruiken bibliotheek.
Syntax:
Import module
Of door gebruik te maken van
from module import *
De mapstructuur die wordt gebruikt om de code te testen is als volgt:
modtest/ test.py display.py
Hieronder staan de codedetails in test.py
my_name = "Guru99" my_address = "Mumbai" defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Met behulp van de importmodule
Als u alleen de importmodulenaam gebruikt, om naar de variabelen en functies in de module te verwijzen, moet deze vooraf worden gegaan door de modulenaam.
Voorbeeld
Bestandsnaam: display.py
Import test print(test.display_message()) print(test.display_message1()) print(test.my_name) print(test.my_address)
De modulenaamtest wordt gebruikt om te verwijzen naar de functie en variabelen binnen de moduletest.
Output:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Importeren gebruiken *
Laten we een voorbeeld bekijken met behulp van importeren *. gebruik importeren *, zijn de functies en variabelen direct toegankelijk, zoals weergegeven in het onderstaande voorbeeld:
from test import * print(display_message()) print(display_message1()) print(my_name) print(my_address)
Output:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
De dir() functie
De dir() is een ingebouwde functie in Python. De dir() retourneert alle eigenschappen en methoden, inclusief de ingebouwde eigenschappen van het gegeven object.
Dus als dir() op de module wordt gebruikt, krijgt u de variabelen en functies die in de module aanwezig zijn.
Hier is een werkend voorbeeld van dir() op een module. We hebben een klasse genaamd Car.py, laten we Car importeren en toewijzen aan dir() om de uitvoer te zien.
De mapstructuur om de code te testen is als volgt:
test prop/ Car.py test.py
Bestandsnaam: 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)
Bestandsnaam: test.py
import Car class_contents = dir(Car) print(class_contents)
De uitvoer geeft ons de naam van de klasse en alle functies die zijn gedefinieerd in Car.py.
Je kunt ook dir() proberen te gebruiken op een ingebouwde module die beschikbaar is in Python. Laten we hetzelfde proberen json module zoals weergegeven in het onderstaande voorbeeld. Het toont alle eigenschappen en methoden die beschikbaar zijn in json module.
Import json json_details = dir(json) print(json_details)
Output:
['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']
Pakketten
Een pakket is een map waarin alle modules zijn gedefinieerd. Om een Python interpreter het als een pakket behandelt, zou uw directory de init.pyfile moeten hebben. De init.py maakt de map als een pakket. Hier is de lay-out van het pakket waar we aan gaan werken.
De naam van het pakket is mijn pakket. Om te beginnen met werken met het pakket, maak een directory genaamd package/. Maak binnen de directory een leeg bestand genaamd __init__.py. Maak nog 3 bestanden module1.py, module2.py en module3.py en definieer de functies zoals getoond in de screenshot. Hier zijn de details van module1.py, module2.py en 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")
De pakketis klaar voor gebruik. Roep nu het pakket aan in een van uw bestanden, zoals hieronder weergegeven:test.py:
Hier wordt mypackage.module1 geïmporteerd en krijgt het een aliasnaam als mod1. Op dezelfde manier kunt u andere modules module2.py en module3.py uit mijn pakket gebruiken.
import mypackage.module1 as mod1 print(mod1.mod1_func1()) print(mod1.mod1_func2()) print(mod1.mod1_func2())
Output:
Welcome to Module1 function1 None Welcome to Module1 function2 None Welcome to Module1 function2 None
We hebben zojuist het pakket gedemonstreerd met een eenvoudige module met functies erin. Afhankelijk van uw project kunt u ook verpakken met subpakketten. Submappen/met modules waarin klassen zijn gedefinieerd.
Python Modulezoekpad
Tijdens de uitvoering, wanneer Python tegenkomt modulenaam importeren, probeert de tolk de module te lokaliseren. Het zoekt de module in de ingebouwde modulelijst. Later in totaal de mappen die zijn gedefinieerd in sys.path.
Samengevat voert de interpreter de volgende zoekopdracht uit om de module te lokaliseren:
- In uw huidige map.
- In de lijst met ingebouwde modules
- Binnen de sys.path-mappen
U kunt de details van sys.path verkrijgen door de sys module te importeren en de sys.path af te drukken. Het zal u de lijst met directories geven zoals hieronder getoond:
importsys print(sys.path)
Output:
['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\ \Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P ython37\\DLLs']
U kunt ook het pad wijzigen en de mappen behouden volgens uw vereisten.
Modulealias gebruiken bij het importeren
U kunt de modulenaam ook naar een kortere vorm converteren door er een aliasnaam aan te geven. De alias kan worden gemaakt met behulp van het trefwoord.
Syntax:
import filename as alias name
De mapstructuur om de code te testen is als volgt:
Mod test/ test.py display.py
Hieronder staat de 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!"
Gebruik nu een alias voor test.py in display.py
Import test as t print(t.display_message()) print(t.display_message1()) print(t.my_name) print(t.my_address)
De alias die wordt gebruikt voor de testmodule is t . De functie en variabelen van test.py kunnen dus worden verwezen met de alias t.
Output:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Absolute en relatieve import in Python
Je weet nu hoe je een bestand als module in een ander bestand kunt importeren. Laten we nu kijken hoe we de bestanden kunnen beheren die beschikbaar zijn in mappen. De bestanden in de mappen kunnen worden geïmporteerd door middel van absolute of relatieve import.
Stel dat u de structuur van uw projectmap heeft, zoals hieronder weergegeven:
De hoofdmap is mijn project/. Het heeft twee submappen pakket1 en pakket2.
De map package1 heeft twee modules, module1.py en module2.py.
De map package2 heeft één klasse myclass.py, een subpakket subpkg met module3.py en als laatste module4.py.
- In module1.py is er een functie genaamdmyfunc1.
- In module2.py is er een functie genaamdmyfunc2.
- In module3.py is er een functie genaamdmyfunc3.
- In module4.py is er een functie genaamdmyfunc4.
Absolute import gebruiken
Voor absolute importen moet u het volledige pad van uw module rechtstreeks vanuit de hoofdmap van het project toevoegen.
Laten we nu kijken hoe we gebruik kunnen maken van absolute import om te verwijzen naar de functies die in elk van de modules aanwezig zijn.
Om met de functiemijnfunc1 te werken, moet u als volgt importeren:
from package1.module1 import myfunc1 or from package1 import module1 module1.myfunc1()
Om met de functie myfunc3 te werken, moet u als volgt importeren:
from package1.subpkg.module3 import myfunc3 or from package1.subpkg import module3 module3.myfunc3()
Voor- en nadelen van het gebruik van absolute import
Dit zijn de voordelen van het gebruik van absolute import:
- Het wordt eenvoudig om de modules terug te traceren voor codecontrole.
- Gemakkelijk te gebruiken en zeer eenvoudig.
- Als het project naar een ander pad wordt verplaatst, blijft de import hetzelfde.
Nadelen van het gebruik van absolute import
Hier volgen de nadelen van het gebruik van absolute import:
nadelen:
- Het importpad kan erg lang worden als de modules genest zijn en als de naam van de modules lang is.
Relatieve import gebruiken
Gezien dezelfde mapstructuur die hieronder wordt vermeld, zullen we zien hoe u deze kunt importeren met behulp van relatieve import.
Bij relatieve import is de te importeren module relatief ten opzichte van de huidige locatie, dat wil zeggen de locatie waar de importinstructie aanwezig is.
Syntaxis
Bij relatieve import moet u een punt (.) vóór de modulenaam toevoegen wanneer u importeert met van.
Er staan 2 punten (..) vóór de modulenaam als de module zich op een niveau hoger bevindt dan de huidige locatie.
Als we kijken naar de hierboven genoemde afbeelding van de mappenstructuur, zien we de volgende modules met hun functie waarnaar we moeten verwijzen.
- In module1.py is er een functie genaamdmyfunc1.
- In module2.py is er een functie genaamdmyfunc2.
- In module3.py is er een functie genaamdmyfunc3.
- In module4.py is er een functie genaamdmyfunc4.
Om met de functiemijnfunc1 te werken, moet u als volgt importeren:
from .module1 import myfunc1
Om met de functie myfunc3 te werken, moet u als volgt importeren:
from .subpkg.module3 import myfunc3
Voordelen van relatieve import
voordelen:
- Het is gemakkelijk om met relatieve importen te werken.
- Vanaf de huidige locatie kan de import worden ingekort ten opzichte van de absolute import.
Nadelen van relatieve import
nadelen:
- Met behulp van relatieve import is het moeilijk om te achterhalen waar de code zich bevindt
Samenvatting
- Importeren Python helpt u te verwijzen naar de code, d.w.z. .functions/objects die in een ander bestand zijn geschreven. Het wordt ook gebruikt om python-bibliotheken/pakketten te importeren die zijn geïnstalleerd met pip(python package manager), en die u vervolgens in uw code moet gebruiken.
- Importfunctionaliteit is beschikbaar in andere talen, zoals typoscript, JavaScript, Java, Ruby, enz.
- Een module in Python is de code die in het bestand is geschreven, bijvoorbeeld (test.py). In uw bestand kunt u uw variabelen, functies of uw klasse laten definiëren. Het hele bestand wordt een module en kan in een ander bestand worden geïmporteerd om naar de code te verwijzen.
- Met modulefunctionaliteit kunt u uw code in verschillende bestanden opdelen in plaats van alles in één bestand te schrijven. LaterMet behulp van import kunt u verwijzen naar de code in het bestand dat u nodig hebt.
- Python heeft zijn ingebouwde modules, en ook externe bibliotheken/pakketten geïnstalleerd met behulp van een Python-pakketbeheerder (pip), bijvoorbeeld panda's, NumPy, etc. worden modules genoemd.
- U kunt slechts een klein deel van de module importeren, dat wil zeggen alleen de vereiste functies en namen van variabelen uit de module, in plaats van de volledige code te importeren.
- U kunt de modulenaam ook naar een kortere vorm converteren door er een aliasnaam aan te geven. De alias kan worden gemaakt met behulp van het trefwoord.
- Een pakket is een map waarin alle modules zijn gedefinieerd. Om een Python interpreter het als een pakket behandelt, zou uw directory de __init.pyfile moeten hebben. De init.py maakt de map als een pakket. Hier is de lay-out van het pakket waar we aan gaan werken.
- Tijdens de uitvoering, wanneer Python tegenkomt modulenaam importeren, probeert de tolk de module te lokaliseren. Het zoekt de module in de ingebouwde modulelijst. Later in totaal de mappen die zijn gedefinieerd in sys.path.
- Voor absolute importen moet u het volledige pad van uw module rechtstreeks vanuit de hoofdmap van het project toevoegen.
- Bij relatieve import is de te importeren module relatief ten opzichte van de huidige locatie, dat wil zeggen de locatie waar de importinstructie aanwezig is.
