Importmodule in Python met voorbeelden

Wat zijn 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 de 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 typescript, JavaScript, Java, Ruby, enz.

Hoe maak en importeer je een module in 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:

Maak en importeer een module in Python

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 volgendewing Output:

Welcome to Guru99 Tutorials!

Een klasse 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 opdrachtwing 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 staan ​​de kenmerken merknaam, model en fabrikantjaar. 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	

Following zijn de code details binnen 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 ervoor te zorgen dat een Python-interpreter het als een pakket behandelt, moet uw map het bestand init.py bevatten. De init.py maakt de map als een pakket. Hier is de lay-out van het pakket waar we aan gaan werken.

Pakketten in Python

De naam van het pakket is mijn pakket. Om met het pakket te gaan werken, maakt u een map met de naam package/. Maak in de map een leeg bestand met de naam __init__.py. Maak nog 3 bestanden module1.py, module2.py en module3.py en definieer de functies zoals weergegeven in de schermafbeelding. 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")

Het 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.

Zoekpad Python-module

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.

Kortom, de tolk doet het volgendewing zoek om de module te lokaliseren:

  1. In uw huidige map.
  2. In de lijst met ingebouwde modules
  3. Binnen de sys.path-mappen

Je kunt de details van sys.path door de sys-module te importeren en het sys.path af te drukken. Het geeft je de lijst met mappen zoals hieronder weergegeven:

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	

Following is 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:

Absolute en relatieve import in Python

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 oppompen van.

Er staan ​​2 punten (..) vóór de modulenaam als de module zich op een niveau hoger bevindt dan de huidige locatie.

Verwijzend naar de hierboven genoemde mapstructuur, hebben we het volgendewing 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

Samengevat

  • Importeren in Python helpt u te verwijzen naar de code, dat wil zeggen .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-pakketbeheerder), en die u vervolgens in uw code moet gebruiken.
  • Importfunctionaliteit is beschikbaar in andere talen zoals typescript, 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 ervoor te zorgen dat een Python-interpreter het als een pakket behandelt, moet je directory het bestand __init.py bevatten. 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.