मॉड्यूल आयात करें Python उदाहरण के साथ

इसमें कौन से मॉड्यूल हैं? Python?

मॉड्यूल पाइथन कोड वाली एक फ़ाइल है। कोड वैरिएबल, फ़ंक्शन या परिभाषित क्लास के रूप में हो सकता है। फ़ाइल नाम मॉड्यूल नाम बन जाता है।

उदाहरण के लिए, यदि आपका फ़ाइल नाम guru99.py है, तो मॉड्यूल का नाम होगा guru99मॉड्यूल कार्यक्षमता के साथ, आप अपने कोड को एक फ़ाइल के अंदर सब कुछ लिखने के बजाय अलग-अलग फ़ाइलों में तोड़ सकते हैं।

क्या है Python आयात मॉड्यूल?

पायथन में एक फ़ाइल को एक मॉड्यूल माना जाता है। मॉड्यूल का उपयोग करने के लिए, आपको इसका उपयोग करके आयात करना होगा आयात कीवर्ड। फ़ाइल के अंदर मौजूद फ़ंक्शन या वैरिएबल को मॉड्यूल आयात करके किसी अन्य फ़ाइल में इस्तेमाल किया जा सकता है। यह कार्यक्षमता अन्य भाषाओं में उपलब्ध है, जैसे टाइपस्क्रिप्ट, Javaस्क्रिप्ट, जावा, रूबी, आदि.

मॉड्यूल कैसे बनाएं और आयात करें? Python?

अब हम एक मॉड्यूल बनाएंगे और इसे दूसरी फ़ाइल में आयात करेंगे।

स्क्रीनशॉट में दिखाए अनुसार मॉड्यूल बनाने और आयात करने का प्रवाह इस प्रकार है:

मॉड्यूल बनाएं और आयात करें Python

पायथन में मॉड्यूल बनाने के लिए दिए गए चरणों का पालन करें।

कोड का परीक्षण करने के लिए प्रयुक्त फ़ोल्डर संरचना इस प्रकार है:

modtest/
	test.py
	display.py	

चरण 1) एक फ़ाइल बनाएं और उसका नाम test.py रखें

चरण 2) test.py के अंदर display_message() नामक एक फ़ंक्शन बनाएं

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

चरण 3) अब एक और फ़ाइल display.py बनाएं.

चरण 4) display.py के अंदर moduletest.py फ़ाइल आयात करें, जैसा कि नीचे दिखाया गया है:

import test

आयात करते समय, आपको test.py का उल्लेख करने की आवश्यकता नहीं है, बल्कि केवल फ़ाइल का नाम बताना है।

चरण 5) फिर आप test.py के अंदर display.py से display_message() फ़ंक्शन को कॉल कर सकते हैं, आपको module_name.function_name का उपयोग करने की आवश्यकता है।

उदाहरण के लिए test.display_message().

Import test
print(test.display_message())

चरण 6) जब आप display.py निष्पादित करेंगे, तो आपको निम्नलिखित मिलेगा आउटपुट:

Welcome to Guru99 Tutorials!

क्लास को आयात करना Python

इससे पहले, हमने एक फ़ंक्शन के साथ एक सरल मॉड्यूल देखा है। यहाँ एक क्लास बनाई जाएगी और क्लास को दूसरी फ़ाइल के अंदर संदर्भित किया जाएगा।

कोड का परीक्षण करने के लिए फ़ोल्डर संरचना इस प्रकार है:

myproj/
	Car.py
	display.py

निम्नलिखित कोड के साथ Car.py नामक फ़ाइल बनाएँ:

फ़ाइल नाम : 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) 

Car.py फ़ाइल में, विशेषताएँ brand_name, model और manu_year हैं। क्लास के अंदर परिभाषित फ़ंक्शन car_details(), get_Car_brand(), get_Car_model() हैं।

आइए अब Car.py फ़ाइल को display.py नामक एक अन्य फ़ाइल में मॉड्यूल के रूप में उपयोग करें।

फ़ाइल नाम : 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())

आउटपुट:

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

इसलिए हम Car मॉड्यूल का उपयोग करके Car.py से सभी वेरिएबल्स और फ़ंक्शन तक पहुंच सकते हैं।

मॉड्यूल आयात करने के लिए from का उपयोग करना

आप मॉड्यूल का केवल एक छोटा सा हिस्सा आयात कर सकते हैं, अर्थात, संपूर्ण कोड आयात करने के बजाय मॉड्यूल से केवल आवश्यक फ़ंक्शन और चर नाम।

जब आप केवल विशिष्ट चीजों को आयात करना चाहते हैं, तो आप जो चाहते हैं उसे आयात करने के लिए "from" कीवर्ड का उपयोग कर सकते हैं।

तो वाक्यविन्यास है

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

कोड का परीक्षण करने के लिए प्रयुक्त फ़ोल्डर संरचना इस प्रकार है:

modtest/
	test.py
	display.py	

test.py में 2 फ़ंक्शन हैं जैसा कि दिखाया गया है:

फ़ाइल नाम : test.py

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

अब आपको display_message() फ़ंक्शन चाहिए। आप जिस फ़ंक्शन या वेरिएबल को आयात कर रहे हैं, उसे नीचे दिखाए अनुसार सीधे एक्सेस किया जा सकता है:

फ़ाइल का नाम : display.py

from test import display_message
print(display_message())

आउटपुट:

Welcome to Guru99 Tutorials!

अब यदि आप display_message1() फ़ंक्शन का उपयोग करते हैं, तो यह एक त्रुटि उत्पन्न करेगा कि फ़ंक्शन परिभाषित नहीं है, जैसा कि नीचे दिखाया गया है:

from test import display_message
print(display_message1())

आउटपुट:

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

मॉड्यूल से सब कुछ आयात करना

आयात आपको आयात के बाद मॉड्यूल नाम, अर्थात, फ़ाइल नाम या उपयोग की जाने वाली लाइब्रेरी का उपयोग करके संपूर्ण मॉड्यूल आयात करने की अनुमति देता है।

सिंटेक्स:

Import module

या का उपयोग करके

from module import *

कोड का परीक्षण करने के लिए प्रयुक्त फ़ोल्डर संरचना इस प्रकार है:

modtest/
	test.py
	display.py	

test.py के अंदर कोड विवरण निम्नलिखित हैं

my_name = "Guru99"
my_address = "Mumbai"

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

आयात मॉड्यूल का उपयोग करना

मॉड्यूल के अंदर चर और फ़ंक्शन को संदर्भित करने के लिए, बस आयात मॉड्यूल नाम का उपयोग करके, इसे मॉड्यूल नाम के साथ उपसर्ग करना होगा।

उदाहरण

फ़ाइल नाम : display.py

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

मॉड्यूल नाम test का उपयोग मॉड्यूल test के अंदर फ़ंक्शन और चर को संदर्भित करने के लिए किया जाता है।

आउटपुट:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

आयात * का उपयोग करना

आइये एक उदाहरण देखते हैं आयात *। का उपयोग करते हुए आयात *, फ़ंक्शन और चर सीधे पहुँच योग्य हैं, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

from test import *

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

आउटपुट:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

dir() फ़ंक्शन

dir() पाइथन में एक अंतर्निहित फ़ंक्शन है। dir() दिए गए ऑब्जेक्ट के अंतर्निहित गुणों सहित सभी गुण और विधियाँ लौटाता है।

इसलिए जब मॉड्यूल पर dir() का उपयोग किया जाता है, तो यह आपको मॉड्यूल के अंदर मौजूद वेरिएबल्स, फ़ंक्शन देगा।

यहाँ एक मॉड्यूल पर dir() का एक कार्यशील उदाहरण दिया गया है। हमारे पास Car.py नामक एक क्लास है, आइए Car को आयात करें और आउटपुट देखने के लिए dir() को असाइन करें।

कोड का परीक्षण करने के लिए फ़ोल्डर संरचना निम्नानुसार होगी:

test prop/
	Car.py
	test.py	

फ़ाइल नाम: 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) 

फ़ाइल नाम: test.py

import Car

class_contents = dir(Car)
print(class_contents)

आउटपुट हमें क्लास का नाम और Car.py में परिभाषित सभी फ़ंक्शन देता है।

आप उपलब्ध अंतर्निहित मॉड्यूल पर dir() का उपयोग करने का भी प्रयास कर सकते हैं Python. आइए हम भी यही प्रयास करें JSON मॉड्यूल जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है। यह उपलब्ध सभी गुण और विधियों को प्रदर्शित करेगा JSON मॉड्यूल।

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

आउटपुट:

['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']

संकुल

पैकेज एक निर्देशिका है जिसके अंदर सभी मॉड्यूल परिभाषित हैं। Python इंटरप्रेटर इसे पैकेज के रूप में मानता है, आपकी निर्देशिका में init.py फ़ाइल होनी चाहिए। init.py निर्देशिका को पैकेज के रूप में बनाता है। यहाँ उस पैकेज का लेआउट है जिस पर हम काम करने जा रहे हैं।

पैकेज में Python

पैकेज का नाम है मेरा पैकेजपैकेज के साथ काम करना शुरू करने के लिए, package/ नामक एक निर्देशिका बनाएँ। निर्देशिका के अंदर, __init__.py नामक एक खाली फ़ाइल बनाएँ। 3 और फ़ाइलें module1.py, module2.py, और module3.py बनाएँ और स्क्रीनशॉट में दिखाए अनुसार फ़ंक्शन परिभाषित करें। यहाँ module1.py,module2.py और module3.py का विवरण दिया गया है

मॉड्यूल1.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")

मॉड्यूल2.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")

मॉड्यूल3.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")

RSI पैकेजउपयोग के लिए तैयार है। अब नीचे दिखाए अनुसार अपनी किसी भी फ़ाइल के अंदर पैकेज को कॉल करें: test.py:

यहाँ, mypackage.module1 को आयात किया गया है और इसे एक उपनाम नाम दिया गया है मॉड1. इसी तरह, आप मेरे पैकेज से अन्य मॉड्यूल module2.py और module3.py का उपयोग कर सकते हैं।

import mypackage.module1 as mod1

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

आउटपुट:

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

हमने अभी-अभी एक सरल मॉड्यूल के साथ पैकेज का प्रदर्शन किया है, जिसके अंदर फ़ंक्शन हैं। अपने प्रोजेक्ट के अनुसार, आप उप-पैकेज के साथ पैकेज भी बना सकते हैं। उप-फ़ोल्डर/ जिसमें परिभाषित क्लास के साथ मॉड्यूल हैं।

Python मॉड्यूल खोज पथ

निष्पादन के दौरान, जब python सामने आता है आयात मॉड्यूल नाम, इंटरप्रेटर मॉड्यूल का पता लगाने की कोशिश करता है। यह बिल्ट-इन मॉड्यूल सूची में मॉड्यूल खोजता है। Later कुल मिलाकर, sys.path के अंदर परिभाषित निर्देशिकाएँ।

संक्षेप में, मॉड्यूल का पता लगाने के लिए इंटरप्रेटर निम्नलिखित खोज करता है:

  1. आपकी वर्तमान निर्देशिका में.
  2. बिल्ट-इन मॉड्यूल सूची में
  3. Sys.path निर्देशिकाओं के अंदर

आप sys मॉड्यूल को आयात करके sys.path का विवरण प्राप्त कर सकते हैं और sys.path को प्रिंट कर सकते हैं। यह आपको नीचे दिखाए अनुसार निर्देशिकाओं की सूची देगा:

importsys
print(sys.path)

आउटपुट:

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

आप पथ को संशोधित भी कर सकते हैं और निर्देशिकाओं को अपनी आवश्यकतानुसार रख सकते हैं।

आयात में मॉड्यूल उपनाम का उपयोग करना

आप मॉड्यूल नाम को उपनाम देकर उसे छोटे रूप में भी बदल सकते हैं। उपनाम कीवर्ड का उपयोग करके किया जा सकता है।

सिंटेक्स:

import filename as alias name

कोड का परीक्षण करने के लिए फ़ोल्डर संरचना निम्नानुसार होगी:

Mod test/
	test.py
	display.py	

test.py के अंदर कोड निम्नलिखित है

my_name = "Guru99"
my_address = "Mumbai"

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

अब display.py में test.py के लिए एक उपनाम का उपयोग किया जाएगा

Import test as t

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

टेस्ट मॉड्यूल के लिए उपयोग किया जाने वाला उपनाम t है। इसलिए test.py से फ़ंक्शन और चर को उपनाम t का उपयोग करके संदर्भित किया जा सकता है।

आउटपुट:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

निरपेक्ष और सापेक्ष आयात Python

अब आप जानते हैं कि किसी फ़ाइल को किसी अन्य फ़ाइल के अंदर मॉड्यूल के रूप में कैसे आयात किया जाता है। आइए अब देखें कि फ़ोल्डर्स में उपलब्ध फ़ाइलों को कैसे प्रबंधित किया जाता है। फ़ोल्डर्स में फ़ाइलों को पूर्ण या सापेक्ष आयात का उपयोग करके आयात किया जा सकता है।

मान लीजिए कि आपके पास प्रोजेक्ट फ़ोल्डर संरचना है, जैसा कि नीचे दिखाया गया है:

निरपेक्ष और सापेक्ष आयात Python

रूट फ़ोल्डर मेरा प्रोजेक्ट/ है। इसमें दो सबफ़ोल्डर package1 और package2 हैं।

फ़ोल्डर package1 में दो मॉड्यूल हैं, module1.py और module2.py.

फ़ोल्डर package2 में एक क्लास myclass.py, एक उप-पैकेज subpkg जिसमें module3.py है, तथा अंतिम module4.py है।

  • मॉड्यूल1.py में, myfunc1 नामक एक फ़ंक्शन है।
  • मॉड्यूल2.py में, myfunc2 नामक एक फ़ंक्शन है।
  • मॉड्यूल 3.py में, myfunc3 नामक एक फ़ंक्शन है।
  • मॉड्यूल4.py में, myfunc4 नामक एक फ़ंक्शन है।

निरपेक्ष आयात का उपयोग करना

पूर्ण आयात के लिए, आपको प्रोजेक्ट रूट फ़ोल्डर से अपने मॉड्यूल का संपूर्ण पथ जोड़ना होगा।

आइए अब देखें कि प्रत्येक मॉड्यूल में मौजूद फ़ंक्शन को संदर्भित करने के लिए निरपेक्ष आयात का उपयोग कैसे करें।

फ़ंक्शनmyfunc1 के साथ काम करने के लिए, आपको निम्न प्रकार से आयात करना होगा:

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

फ़ंक्शन myfunc3 के साथ काम करने के लिए आपको निम्न प्रकार से आयात करना होगा:

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

निरपेक्ष आयात का उपयोग करने के लाभ और हानियाँ

पूर्ण आयात का उपयोग करने के लाभ इस प्रकार हैं:

  • कोड जांच के लिए मॉड्यूल का पता लगाना आसान हो जाता है।
  • उपयोग करने में आसान और बहुत सीधा.
  • यदि परियोजना को किसी भिन्न पथ पर ले जाया जाता है, तो भी आयात वही रहेगा।

पूर्ण आयात का उपयोग करने के नुकसान

पूर्ण आयात का उपयोग करने के नुकसान इस प्रकार हैं:

नुकसान:

  • यदि मॉड्यूल नेस्टेड हैं, तथा मॉड्यूल का नाम लंबा है, तो आयात पथ बहुत लंबा हो सकता है।

सापेक्ष आयात का उपयोग करना

नीचे उल्लिखित समान फ़ोल्डर संरचना को ध्यान में रखते हुए, हम देखेंगे कि सापेक्ष आयातों का उपयोग करके इसे कैसे आयात किया जाए।

सापेक्ष आयात में, आयात किया जाने वाला मॉड्यूल वर्तमान स्थान के सापेक्ष होता है, अर्थात वह स्थान जहां आयात विवरण मौजूद होता है।

वाक्य - विन्यास

सापेक्ष आयातों में, आपको आयात करते समय मॉड्यूल नाम से पहले एक अवधि (.) जोड़ने की आवश्यकता होती है से.

यदि मॉड्यूल वर्तमान स्थान से एक स्तर ऊपर है तो यह मॉड्यूल नाम से पहले 2 अवधि (..) होगा।

ऊपर उल्लिखित फ़ोल्डर संरचना चित्र का संदर्भ लेते हुए, हमारे पास उनके कार्य के साथ निम्नलिखित मॉड्यूल हैं, जिन्हें हमें संदर्भित करने की आवश्यकता है।

  • मॉड्यूल1.py में, myfunc1 नामक एक फ़ंक्शन है।
  • मॉड्यूल2.py में, myfunc2 नामक एक फ़ंक्शन है।
  • मॉड्यूल 3.py में, myfunc3 नामक एक फ़ंक्शन है।
  • मॉड्यूल4.py में, myfunc4 नामक एक फ़ंक्शन है।

फ़ंक्शनmyfunc1 के साथ काम करने के लिए आपको निम्न प्रकार से आयात करना होगा:

from  .module1  import  myfunc1

फ़ंक्शन myfunc3 के साथ काम करने के लिए, आपको निम्न प्रकार से आयात करना होगा:

from  .subpkg.module3  import  myfunc3

सापेक्ष आयात के लाभ

लाभ:

  • सापेक्ष आयात के साथ काम करना आसान है।
  • वर्तमान स्थिति से, आयात को पूर्ण आयात की तुलना में कम किया जा सकता है।

सापेक्ष आयात के नुकसान

नुकसान:

  • सापेक्ष आयातों का उपयोग करके, यह पता लगाना कठिन है कि कोड कहां रहता है

सारांश

  • आयात करें Python आपको कोड को संदर्भित करने में मदद करता है, यानी, .functions/objects जो किसी अन्य फ़ाइल में लिखे गए हैं। इसका उपयोग उन पायथन लाइब्रेरीज़/पैकेज को आयात करने के लिए भी किया जाता है जो pip (पायथन पैकेज मैनेजर) का उपयोग करके इंस्टॉल किए जाते हैं, और आपको उन्हें अपने कोड में उपयोग करने की आवश्यकता होती है।
  • आयात कार्यक्षमता अन्य भाषाओं जैसे टाइपस्क्रिप्ट में भी उपलब्ध है, Javaस्क्रिप्ट, जावा, रूबी, आदि.
  • पायथन में मॉड्यूल फ़ाइल के अंदर लिखा गया कोड है, उदाहरण के लिए (test.py)। अपनी फ़ाइल के अंदर, आप अपने चर, फ़ंक्शन या अपनी क्लास परिभाषित कर सकते हैं। पूरी फ़ाइल एक मॉड्यूल बन जाती है और कोड को संदर्भित करने के लिए इसे किसी अन्य फ़ाइल के अंदर आयात किया जा सकता है।
  • मॉड्यूल कार्यक्षमता के साथ, आप अपने कोड को एक फ़ाइल के अंदर सब कुछ लिखने के बजाय अलग-अलग फ़ाइलों में विभाजित कर सकते हैं। Laterआयात का उपयोग करके, आप अपनी ज़रूरत की फ़ाइल के अंदर कोड को संदर्भित कर सकते हैं।
  • Python इसमें अंतर्निहित मॉड्यूल हैं, और बाहरी लाइब्रेरी/पैकेज भी हैं जो एक का उपयोग करके स्थापित किए गए हैं पायथन पैकेज प्रबंधक (पिप), उदाहरण के लिए, पांडा, न्यूमपी, आदि को मॉड्यूल कहा जाता है।
  • आप मॉड्यूल का केवल एक छोटा सा हिस्सा आयात कर सकते हैं, अर्थात, संपूर्ण कोड आयात करने के बजाय मॉड्यूल से केवल आवश्यक फ़ंक्शन और चर नाम।
  • आप मॉड्यूल नाम को उपनाम देकर उसे छोटे रूप में भी बदल सकते हैं। उपनाम कीवर्ड का उपयोग करके किया जा सकता है।
  • पैकेज एक निर्देशिका है जिसके अंदर सभी मॉड्यूल परिभाषित हैं। Python इंटरप्रेटर इसे पैकेज के रूप में मानता है, आपकी निर्देशिका में __init.py फ़ाइल होनी चाहिए। init.py निर्देशिका को पैकेज के रूप में बनाता है। यहाँ उस पैकेज का लेआउट है जिस पर हम काम करने जा रहे हैं।
  • निष्पादन के दौरान, जब python सामने आता है आयात मॉड्यूल नाम, इंटरप्रेटर मॉड्यूल का पता लगाने की कोशिश करता है। यह बिल्ट-इन मॉड्यूल सूची में मॉड्यूल खोजता है। Later कुल मिलाकर, sys.path के अंदर परिभाषित निर्देशिकाएँ।
  • पूर्ण आयात के लिए, आपको प्रोजेक्ट रूट फ़ोल्डर से अपने मॉड्यूल का संपूर्ण पथ जोड़ना होगा।
  • सापेक्ष आयात में, आयात किया जाने वाला मॉड्यूल वर्तमान स्थान के सापेक्ष होता है, अर्थात वह स्थान जहां आयात विवरण मौजूद होता है।