Module importeren Python met voorbeelden

De onderstaande secties leggen modules, pakketten, de verschillende importstijlen en de werking van absolute en relatieve imports uit. Python.

Waar zitten de modules in Python?

Een module is een bestand met Python Code. De code kan de vorm hebben van variabelen, functies of een gedefinieerde klasse. 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 beschouwd als een module in PythonOm de module te gebruiken, moet je deze importeren met behulp van de importeren trefwoord. De functies of variabelen in het bestand kunnen in een ander bestand worden gebruikt door de module te importeren. Deze functionaliteit is ook beschikbaar in andere programmeertalen, zoals TypeScript, 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 aangegeven stappen om een ​​module te maken in Python.

De mapstructuur die wordt gebruikt om de code te testen is als volgt:

modtest/
	test.py
	display.py	

Stap 1) Maak een bestand aan 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 modulebestand test.py, zoals hieronder weergegeven:

import test

Bij het importeren hoef je niet het bestand test.py te vermelden, maar alleen de naam van het bestand.

Stap 5) Vervolgens kun je de functie display_message() uit test.py aanroepen vanuit display.py. Je moet hiervoor gebruikmaken van module_name.function_name.

Bijvoorbeeld test.display_message().

Import test
print(test.display_message())

Stap 6) Wanneer je display.py uitvoert, krijg je het volgende te zien: Output:

Welcome to Guru99 Tutorials!

Een klas importeren in Python

Eerder hebben we een eenvoudige module met een functie gezien. Nu gaan we een klasse maken en die klasse in een ander bestand aanroepen.

De mapstructuur voor het testen van de code 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 bevinden zich de attributen brand_name, model en manu_year. De functies die binnen de klasse zijn gedefinieerd, zijn car_details(), get_Car_brand() en 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 kunnen dus via de Car-module toegang krijgen tot alle variabelen en functies van Car.py.

Met behulp van van naar importmodule

Je kunt ervoor kiezen om slechts een klein deel van de module te importeren, bijvoorbeeld alleen de benodigde functies en variabelenamen, in plaats van de volledige code.

Als je alleen specifieke items wilt importeren, kun je het trefwoord "from" gebruiken om aan te geven wat je wilt importeren.

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 staan ​​2 functies, zoals weergegeven:

Bestandsnaam: test.py

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

Nu wilt u de functie display_message() gebruiken. De functie of variabele die u importeert, kunt u rechtstreeks benaderen zoals hieronder weergegeven:

Bestandsnaam: display.py

from test import display_message
print(display_message())

Output:

Welcome to Guru99 Tutorials!

Als je nu de functie display_message1() gebruikt, krijg je een foutmelding dat de functie niet is gedefinieerd, zoals hieronder te zien is:

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 `import` kunt u de volledige module importeren door `import` te gebruiken, gevolgd door de modulenaam, oftewel 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 je alleen de naam van de importmodule gebruikt om naar de variabelen en functies binnen die module te verwijzen, moet je die naam ervoor plaatsen.

Voorbeeld

Bestandsnaam: display.py

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

De modulenaam 'test' wordt gebruikt om te verwijzen naar de functies en variabelen binnen de module 'test'.

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 functie dir() is een ingebouwde functie in PythonDe functie `dir()` retourneert alle eigenschappen en methoden, inclusief de ingebouwde eigenschappen van het betreffende object.

Als je `dir()` op een module toepast, krijg je de variabelen en functies te zien die zich in die module bevinden.

Hier is een werkend voorbeeld van het gebruik van `dir()` op een module. We hebben een klasse genaamd `Car.py`. Laten we `Car` importeren en deze toewijzen aan `dir()` om de uitvoer te bekijken.

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 PythonLaten we hetzelfde eens proberen op de json module zoals weergegeven in het onderstaande voorbeeld. Het zal alle beschikbare eigenschappen en methoden in de module weergeven. 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']

Arrangementen

Een pakket is een map waarin alle modules zijn gedefinieerd. Om een Python De interpreter behandelt het als een pakket; je map moet het bestand __init__.py bevatten. Het bestand __init__.py maakt van de map een pakket. Hier is de structuur van het pakket waarmee we gaan werken.

De naam van het pakket is mijn pakketOm met het pakket aan de slag te gaan, maak je een map aan met de naam mypackage/. Maak in deze map een leeg bestand aan met de naam __init__.py. Maak vervolgens nog drie bestanden aan: module1.py, module2.py en module3.py, en definieer de functies zoals weergegeven in de schermafbeelding. Hieronder vind je 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 pakket is klaar voor gebruik. Roep het pakket nu aan in een van je bestanden, zoals hieronder weergegeven in test.py:

Hier wordt mypackage.module1 geïmporteerd en krijgt het een aliasnaam als modus1Op dezelfde manier kun je de 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 het pakket zojuist gedemonstreerd met een eenvoudige module met functies erin. Zoals in uw project is aangegeven, kunt u ook pakketten maken met subpakketten, oftewel submappen met modules waarin klassen zijn gedefinieerd.

Python Modulezoekpad

Tijdens de uitvoering, wanneer Python komt over modulenaam importerenDe interpreter probeert de module te vinden. Hij zoekt de module in de lijst met ingebouwde modules en vervolgens in alle mappen die zijn gedefinieerd in sys.path.

Samengevat voert de interpreter de volgende zoekopdracht uit om de module te lokaliseren:

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

Je kunt de details van sys.path verkrijgen door de sys-module te importeren en sys.path af te drukken. Dit geeft je een 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

Je kunt de modulenaam ook inkorten door er een alias aan toe te kennen. De alias kan worden aangemaakt met behulp van de as 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!"

Nu gaan we een alias voor test.py gebruiken 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 voor de testmodule wordt gebruikt, is t. De functies en variabelen in test.py kunnen dus worden aangeroepen met behulp van 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 myproject/. Deze bevat twee submappen: package1 en package2.

De map package1 bevat 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 bevindt zich een functie genaamd myfunc1.
• In module2.py bevindt zich een functie genaamd myfunc2.
• In module3.py bevindt zich een functie genaamd myfunc3.
• In module4.py bevindt zich een functie genaamd myfunc4.

Absolute import gebruiken

Voor absolute imports moet je het volledige pad van je module rechtstreeks vanuit de hoofdmap van je project toevoegen.

Laten we nu eens kijken hoe we absolute imports kunnen gebruiken om te verwijzen naar de functies in elk van de modules.

Om met de functie myfunc1 te werken, moet je deze als volgt importeren:

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

Om met de functie myfunc3 te werken, moet je deze 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 gemakkelijk om trace stuur de modules terug voor codecontrole.
• Gemakkelijk te gebruiken en zeer eenvoudig.
• Als het project naar een ander pad wordt verplaatst, blijven de importregels ongewijzigd.

Nadelen van het gebruik van absolute import

Hieronder volgen de nadelen van het gebruik van absolute imports:

• Het importpad kan erg lang worden als de modules genesteld zijn en de modulenamen lang zijn.

Relatieve import gebruiken

Gezien de hierboven beschreven mapstructuur, zullen we bekijken hoe we deze kunnen importeren met behulp van relatieve imports.

Bij een relatieve import is de te importeren module relatief ten opzichte van de huidige locatie, oftewel de locatie waar de importinstructie zich bevindt.

Syntaxis

Bij relatieve import moet u een punt (.) vóór de modulenaam toevoegen wanneer u importeert met vanaf.

Er komen twee punten (..) voor de modulenaam te staan ​​als de module zich één niveau hoger bevindt dan de huidige locatie.

Aan de hand van de hierboven getoonde mapstructuur zien we de volgende modules met hun functies, waarnaar we moeten verwijzen.

• In module1.py bevindt zich een functie genaamd myfunc1.
• In module2.py bevindt zich een functie genaamd myfunc2.
• In module3.py bevindt zich een functie genaamd myfunc3.
• In module4.py bevindt zich een functie genaamd myfunc4.

Om met de functie myfunc1 te werken, moet je deze als volgt importeren:

from  .module1  import  myfunc1

Om met de functie myfunc3 te werken, moet je deze als volgt importeren:

from  .subpkg.module3  import  myfunc3

Voordelen van relatieve import

• 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

• Bij gebruik van relatieve imports is het moeilijk om trace terug naar de plek waar de code zich bevindt.

Veelgestelde vragen