शुरुआती के लिए पायथन में कक्षाएं और वस्तुएं

आज हम बात करने जा रहे हैं क्लासेज के बारे में। नहीं, हमारा मतलब स्कूल की कक्षाओं से नहीं है।

प्रोग्रामिंग में, कक्षाओं की अपनी परिभाषा होती है। एक वर्ग एक वस्तु के लिए एक कोडर द्वारा बनाया गया एक खाका है। यह उस डेटा को परिभाषित करता है जिसे किसी ऑब्जेक्ट में संग्रहीत किया जा सकता है और उस विशेष ऑब्जेक्ट पर किए जा सकने वाले तरीकों को परिभाषित करता है।

पायथन एक वस्तु-उन्मुख प्रोग्रामिंग भाषा है। इसका मतलब है कि यह विकास के एक पैटर्न का उपयोग करता है जहां डेटा स्टोर करने के लिए वस्तुओं और वर्गों का उपयोग किया जाता है।

ऑब्जेक्ट-ओरिएंटेड दृष्टिकोण आपके कोड में दोहराव को कम करने में मदद करता है, जिससे आपके कोड को पढ़ना और बनाए रखना आसान हो जाता है। कक्षाएं और वस्तुएं कई प्रोग्रामिंग भाषाओं का हिस्सा हैं, जैसे कि जावा, पायथन और सी ++।

इस गाइड में, हम चर्चा करने जा रहे हैं कि कौन सी कक्षाएं हैं, वे कैसे काम करती हैं, और आप इसे पायथन में कैसे घोषित कर सकते हैं। रास्ते में आपकी सहायता करने के लिए हम कुछ उदाहरणों के माध्यम से चलेंगे।

कक्षा क्या है?

एक वर्ग एक खाका है जिसका उपयोग आप किसी वस्तु को परिभाषित करने के लिए करते हैं।

कल्पना कीजिए कि आप एक घर के लिए एक खाका देख रहे हैं। वह खाका रेखांकित करेगा कि दरवाजे कहाँ जाएंगे, खिड़कियाँ कहाँ रखी जाएँगी, इत्यादि। प्रोग्रामिंग में एक वर्ग समान है। एक वर्ग डेटा पर एक ब्लूप्रिंट प्रदान करता है जिसे किसी ऑब्जेक्ट में संग्रहीत किया जा सकता है।

कक्षाएं class . का उपयोग करके परिभाषित की जाती हैं खोजशब्द। आइए प्लेयर नामक एक वर्ग को परिभाषित करके शुरू करें जिसमें दो कार्य हैं:

81% प्रतिभागियों ने कहा कि बूटकैंप में भाग लेने के बाद उन्हें अपनी तकनीकी नौकरी की संभावनाओं के बारे में अधिक आत्मविश्वास महसूस हुआ। आज ही एक बूटकैंप से मिलान करें।

बूटकैंप शुरू करने से लेकर अपनी पहली नौकरी खोजने तक, औसत बूटकैंप ग्रेड ने करियर संक्रमण में छह महीने से भी कम समय बिताया।

क्लास प्लेयर:

""" This is a class for a player """
	name = "Luke"

	def wield_sword(self):
		print("You have wielded your sword.")

	def drink_health_potion(self):
		print("You have consumed a health potion.")

यह वर्ग वीडियो गेम में खिलाड़ी का प्रतिनिधित्व करता है। इसमें विशेषताएँ और विधियाँ दोनों शामिल हैं। जब वे एक वर्ग के अंदर होते हैं तो गुण अक्सर आवृत्ति चर कहलाते हैं।

एक विधि आपको तलवार चलाने की अनुमति देती है और दूसरी विधि आपको एक स्वास्थ्य औषधि पीने की अनुमति देती है। कक्षा में एक वर्ग चर होता है:नाम। यह हमारे खिलाड़ी के लिए डिफ़ॉल्ट नाम संग्रहीत करता है।

ध्यान दें कि हम self . शब्द का उपयोग कर रहे हैं इस कोड में कुछ बार। स्वयं वह है जो ऐसा लगता है:स्वयं वर्ग का एक प्रतिनिधित्व। स्वयं में वे सभी मान होते हैं जो किसी विशेष वर्ग के भीतर संग्रहीत होते हैं, ताकि आप उन सभी को अपने तरीकों से एक्सेस कर सकें।

जब हम अपना कोड चलाते हैं, तो कुछ नहीं होता है। क्या चल रहा है? याद रखें कि हमने कैसे कहा था कि एक वर्ग एक खाका था? यही कारण है कि कुछ नहीं हो रहा है। हमें अपने ब्लूप्रिंट के साथ कुछ करना होगा ताकि वह उपयोगी हो सके।

ऑब्जेक्ट क्या है?

एक वस्तु एक वर्ग का एकल उदाहरण है। इसे एक वर्ग द्वारा बनाए गए ब्लूप्रिंट का उपयोग करके परिभाषित किया गया है।

आइए हमारे खेल में एक नए खिलाड़ी के लिए एक वस्तु बनाएं, ल्यूक:

luke = Player()


हमने अभी-अभी ल्यूक नामक एक वस्तु बनाई है। हमारी वस्तु अब हमारी कक्षा में संग्रहीत सभी डेटा तक पहुँच सकती है, साथ ही साथ हमारी कक्षा से जुड़ी विधियाँ भी:

luke = Player()
print(luke.name)
luke.wield_sword()

हमारा कोड लौटाता है:

ल्यूक

तूने अपनी तलवार चलाई है।

हमारे कोड में, हमने name . का मान प्रिंट कर लिया है हमारे ल्यूक ऑब्जेक्ट में विशेषता। किसी वर्ग में विशेषताओं तक पहुँचने के लिए, आपको कक्षा का नाम, उसके बाद एक बिंदु, और फिर उस उदाहरण विशेषता का उल्लेख करना होगा जिसे आप एक्सेस करना चाहते हैं। इसे अक्सर dot notation . कहा जाता है .

डिफ़ॉल्ट रूप से, name . का मान ल्यूक पर सेट किया गया था। हम इस बारे में बात करेंगे कि इसे एक मिनट में कैसे बदला जाए।

हमने अपना wield_sword() . भी कहा है कक्षा। जब हमने इस वर्ग को बुलाया, तो wield_sword() . की सामग्री हमारे प्लेयर वर्ग के अंदर विधि निष्पादित की गई थी। इससे कंसोल पर एक संदेश छपा, जिसमें कहा गया था ""आपने अपनी तलवार चलाई है।"

आप किसी वर्ग की जितनी चाहें उतनी वस्तुओं की घोषणा कर सकते हैं:इसलिए कक्षाएं इतनी शक्तिशाली हैं। आप उन्हीं विधियों और डिफ़ॉल्ट मानों का पुन:उपयोग कर सकते हैं जो एक वर्ग के भीतर कई अलग-अलग वस्तुओं में संग्रहीत हैं।

कक्षा निर्माता

कंस्ट्रक्टर्स आपको एक क्लास के अंदर डेटा को इनिशियलाइज़ करने की अनुमति देते हैं। किसी विशेष वर्ग की वस्तु घोषित करने के तुरंत बाद एक कंस्ट्रक्टर विधि निष्पादित की जाती है।

कंस्ट्रक्टर का नाम है __init__() . आप अपने कोड में डबल अंडरस्कोर (__) वाले फंक्शन देखने के आदी हो सकते हैं। इन कार्यों को विशेष कार्य कहा जाता है क्योंकि इनका एक पूर्वनिर्धारित उद्देश्य होता है। इस मामले में, __init__ . का उद्देश्य हमारी कक्षा को प्रारंभ करना है।

इस पद्धति को कक्षा के शीर्ष पर शामिल करने के लिए पहले बनाए गए प्लेयर वर्ग को अपडेट करें:

def __init__(self):
	print("Your character has been created.")

आपकी कक्षा में किसी भी चर या विधियों को परिभाषित करने से पहले यह विधि आनी चाहिए। आइए अपना मुख्य कोड पहले से फिर से चलाएं:

luke = Player()
print(luke.name)
luke.wield_sword()

हमारा कोड लौटाता है:

आपका चरित्र बनाया गया है।

ल्यूक

तूने अपनी तलवार चलाई है।

हमने __init__ . को कॉल नहीं किया हमारे मुख्य कार्यक्रम में विधि लेकिन यह वैसे भी चला। ऐसा इसलिए है क्योंकि जब आप किसी वर्ग का ऑब्जेक्ट बनाते हैं तो कंस्ट्रक्टर स्वचालित रूप से निष्पादित हो जाते हैं।

इससे पहले, हमने name . का मान दिया था ल्यूक के लिए हमारी कक्षा में परिवर्तनशील। हालांकि यह उपयोगी है अगर हम अपने खिलाड़ी ल्यूक को कॉल करना चाहते हैं, तो यह व्यावहारिक नहीं है कि खिलाड़ियों के अलग-अलग नाम हो सकते हैं।

यहीं से कंस्ट्रक्टर आते हैं। आइए एक कंस्ट्रक्टर बनाएं जो हमें अपने प्लेयर को एक नाम असाइन करने की अनुमति देता है:

class Player:
	def __init__(self, name):
		self.name = name

यह कोड हमें प्रत्येक प्लेयर ऑब्जेक्ट में एक पैरामीटर पास करने की अनुमति देता है। यह पैरामीटर खिलाड़ी के नाम का प्रतिनिधित्व करेगा। फिर हम एक ऐसा तरीका तैयार करेंगे जो हमें हमारे खिलाड़ी का नाम बताए:

class Player:
	def __init__(self, name):
		self.name = name

	def get_name(self):
		print("Your name is " + self.name)

आइए लीह नामक खिलाड़ी के लिए हमारे प्लेयर वर्ग का एक नया उदाहरण बनाएं:

leah = Player("Leah")
leah.get_name()

हमारा कोड लौटाता है:

आपका नाम लिआ है।

हमने name . का मान निर्दिष्ट किया है लिआह के लिए हमारी वस्तु में परिवर्तनशील। इसका मतलब यह है कि हम अपनी कक्षा में जहां कहीं भी इसका संदर्भ देते हैं, उसका मूल्य लिआह होता है। जैसे ही हम अपनी कक्षा का ऑब्जेक्ट बनाते हैं, कंस्ट्रक्टर निष्पादित हो जाता है, इसलिए हमें इसे कॉल करने के बारे में चिंता करने की आवश्यकता नहीं है।

फिर हम इस विधि को get_name() . कहते हैं जो हमारे प्लेयर से जुड़े नाम को प्रिंट करता है।

आप एक वर्ग में जितने चाहें उतने पैरामीटर जोड़ सकते हैं:

class Player:
	def __init__(self, name, player_type):
		self.name = name
		self.player_type = player_type

	def get_name(self):
		print("Your name is " + self.name)

	def get_player_type(self):
		print(self.name + " is a " + self.player_type + ".")

इस उदाहरण में, हमारा प्लेयर वर्ग दो मापदंडों का समर्थन करता है। एक खिलाड़ी (नाम) के नाम का प्रतिनिधित्व करता है और दूसरा उस खिलाड़ी के प्रकार का प्रतिनिधित्व करता है (player_type ) आइए इस वर्ग का एक ऑब्जेक्ट बनाएं:

leah = Player("Leah", "Mage")
leah.get_name()
leah.get_player_type()

हमारा कोड लौटाता है:

आपका नाम लिआ है।

लिआ एक जादूगर है।

हमारे द्वारा निर्दिष्ट दोनों प्रारंभिक मान हमारी कक्षा में उपलब्ध हैं।

निष्कर्ष

कक्षाएं आपको अपने कोड में दोहराव को कम करने की अनुमति देती हैं। एक बार जब आप एक वर्ग को परिभाषित कर लेते हैं, तो आप जितनी चाहें उतनी वस्तुओं को परिभाषित करने के लिए इसकी संरचना का उपयोग कर सकते हैं। कम दोहराव के परिणामस्वरूप, आपका कोड पढ़ने में आसान होना चाहिए, और इसलिए बनाए रखना आसान होना चाहिए।

अब आप एक विशेषज्ञ की तरह अपनी खुद की पायथन कक्षाएं लिखना शुरू करने के लिए तैयार हैं!