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

नीचे दिए गए अनुभाग मॉड्यूल, पैकेज, विभिन्न आयात शैलियों और निरपेक्ष और सापेक्ष आयात कैसे काम करते हैं, इसकी व्याख्या करते हैं। Python.

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

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

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

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

एक फ़ाइल को मॉड्यूल माना जाता है Pythonइस मॉड्यूल का उपयोग करने के लिए, आपको इसे आयात करना होगा। आयात कीवर्ड। फ़ाइल के अंदर मौजूद फ़ंक्शन या वैरिएबल को मॉड्यूल को इम्पोर्ट करके किसी दूसरी फ़ाइल में इस्तेमाल किया जा सकता है। यह कार्यक्षमता अन्य भाषाओं में भी उपलब्ध है, जैसे कि TypeScript, Javaलिखी हुई कहानी, 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 फ़ाइल के अंदर, test.py मॉड्यूल फ़ाइल को आयात करें, जैसा कि नीचे दिखाया गया है:

import test

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

चरण 5) फिर आप display.py के अंदर test.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 कमांड का उपयोग करके आप मॉड्यूल के नाम के बाद import कमांड का उपयोग करके पूरे मॉड्यूल को आयात कर सकते हैं, यानी उपयोग की जाने वाली फ़ाइल का नाम या लाइब्रेरी का नाम।

सिंटेक्स:

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)

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

आउटपुट:

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() एक अंतर्निर्मित फ़ंक्शन है Pythondir() फ़ंक्शन दिए गए ऑब्जेक्ट के सभी गुणों और विधियों को लौटाता है, जिसमें ऑब्जेक्ट के अंतर्निहित गुण भी शामिल हैं।

इसलिए जब मॉड्यूल पर 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 फ़ाइल डायरेक्टरी को पैकेज बनाती है। यहाँ उस पैकेज का लेआउट दिया गया है जिस पर हम काम करने जा रहे हैं।

पैकेज का नाम है मेरा पैकेजपैकेज के साथ काम शुरू करने के लिए, mypackage/ नाम की एक डायरेक्टरी बनाएं। इस डायरेक्टरी के अंदर, __init__.py नाम की एक खाली फ़ाइल बनाएं। तीन और फ़ाइलें 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इसी प्रकार, आप mypackage से अन्य मॉड्यूल 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 सामने आता है आयात मॉड्यूल नामइंटरप्रेटर मॉड्यूल का पता लगाने की कोशिश करता है। यह मॉड्यूल को बिल्ट-इन मॉड्यूल सूची में खोजता है, और फिर 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']

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

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

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

सिंटेक्स:

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

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

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

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

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

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

• module1.py में myfunc1 नाम का एक फ़ंक्शन है।
• module2.py में myfunc2 नाम का एक फ़ंक्शन है।
• module3.py में myfunc3 नाम का एक फ़ंक्शन है।
• module4.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()  

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

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

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

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

एब्सोल्यूट इंपोर्ट का उपयोग करने के नुकसान इस प्रकार हैं:

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

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

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

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

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

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

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

ऊपर उल्लिखित फ़ोल्डर संरचना आकृति को देखें तो, हमारे पास निम्नलिखित मॉड्यूल और उनके कार्य हैं, जिनका हमें संदर्भ लेना होगा।

• module1.py में myfunc1 नाम का एक फ़ंक्शन है।
• module2.py में myfunc2 नाम का एक फ़ंक्शन है।
• module3.py में myfunc3 नाम का एक फ़ंक्शन है।
• module4.py में myfunc4 नाम का एक फ़ंक्शन है।

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

from  .module1  import  myfunc1

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

from  .subpkg.module3  import  myfunc3

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

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

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

• सापेक्ष आयात का उपयोग करके, यह मुश्किल है tracवापस वहीं जाएं जहां कोड मौजूद है।

अक्सर पूछे जाने वाले प्रश्न