पायथन में क्लासेस और ऑब्जेक्ट्स: शुरुआती लोगों के लिए गाइड

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

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

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

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

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

क्लास क्या है?

एक क्लास एक ब्लूप्रिंट है जिसका उपयोग आप एक ऑब्जेक्ट को परिभाषित करने के लिए करते हैं।

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

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

class Player:
    """ 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.")

यह क्लास एक वीडियो गेम में एक खिलाड़ी को दर्शाता है। इसमें एट्रिब्यूट्स और मेथड्स दोनों शामिल हैं। जब एट्रिब्यूट्स एक क्लास के अंदर होते हैं तो उन्हें अक्सर इंस्टेंस वेरिएबल्स कहा जाता है।

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

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

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

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

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

आइए अपने गेम में एक नए खिलाड़ी, ल्यूक के लिए एक ऑब्जेक्ट बनाते हैं:

luke = Player()

हमने अभी ल्यूक नामक एक ऑब्जेक्ट बनाया है। हमारा ऑब्जेक्ट अब हमारे क्लास के भीतर स्टोर किए गए सभी डेटा के साथ-साथ हमारे क्लास से जुड़े मेथड्स को एक्सेस कर सकता है:

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

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

Luke
You have wielded your sword.

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

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

हमने अपने wield_sword() क्लास को भी कॉल किया है। जब हमने इस क्लास को कॉल किया, तो हमारे Player क्लास के अंदर wield_sword() मेथड की सामग्री निष्पादित की गई। इसने कंसोल पर एक संदेश प्रिंट किया जिसमें कहा गया था "You have wielded your sword."

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

क्लास कंस्ट्रक्टर्स

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

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

उन मेथड को Player क्लास में अपडेट करें जिसे हमने पहले बनाया था ताकि यह क्लास के शीर्ष पर इस मेथड को शामिल करे:

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

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

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

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

Your character has been created.
Luke
You have wielded your sword.

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

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

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

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

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

class Player:
    def __init__(self, name):
        self.name = name
    def get_name(self):
        print("Your name is " + self.name)

आइए लीह नामक एक खिलाड़ी के लिए हमारे Player क्लास का एक नया उदाहरण बनाते हैं:

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

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

Your name is Leah.

हमने अपने ऑब्जेक्ट में 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 क्लास दो पैरामीटर्स का समर्थन करता है। एक खिलाड़ी के नाम को दर्शाता है (name) और दूसरा उस खिलाड़ी के प्रकार को दर्शाता है (player_type)। आइए इस क्लास का एक ऑब्जेक्ट बनाते हैं:

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

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

Your name is Leah.
Leah is a Mage.

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

निष्कर्ष

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

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