Python में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग: एक संपूर्ण गाइड

ऑब्जेक्ट्स इंस्टैंशिएट करना

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

ozzy = Dog()संचालित द्वारा

और इसे प्रिंट करें:

print(ozzy)संचालित द्वारा

<__main__.Dog object at 0x111f47278>संचालित द्वारा

क्लास में एट्रिब्यूट्स जोड़ना

ozzy को प्रिंट करने के बाद, यह स्पष्ट है कि यह ऑब्जेक्ट एक कुत्ता है। लेकिन आपने अभी तक कोई एट्रिब्यूट नहीं जोड़ा है। आइए Dog क्लास को फिर से लिखकर इसका नाम और उम्र दें:

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = ageसंचालित द्वारा

आप देख सकते हैं कि फ़ंक्शन अब self के बाद दो आर्ग्युमेंट्स लेता है: name और age। इन्हें क्रमशः self.name और self.age को असाइन किया जाता है। अब आप नाम और उम्र के साथ एक नया ozzy ऑब्जेक्ट बना सकते हैं:

ozzy = Dog("Ozzy", 2)संचालित द्वारा

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

print(ozzy.name)

print(ozzy.age)संचालित द्वारा

Ozzy
2संचालित द्वारा

इसे एक अधिक विस्तृत वाक्य में भी जोड़ा जा सकता है:

print(ozzy.name + " is " + str(ozzy.age) + " year(s) old.")
संचालित द्वारा

Ozzy is 2 year(s) old.संचालित द्वारा

यहाँ str() फ़ंक्शन का उपयोग age एट्रिब्यूट, जो कि एक इंटीजर है, को स्ट्रिंग में बदलने के लिए किया गया है, ताकि आप इसे print() फ़ंक्शन में उपयोग कर सकें।

क्लास में मेथड्स परिभाषित करें

अब जबकि आपके पास Dog क्लास है, इसमें नाम और उम्र तो हैं, जिन्हें आप ट्रैक कर सकते हैं, लेकिन यह वास्तव में कुछ करता नहीं है। यहीं पर इंस्टेंस मेथड्स काम आते हैं। आप क्लास को फिर से लिखकर अब उसमें bark() मेथड शामिल कर सकते हैं। ध्यान दें कि def कीवर्ड का फिर से उपयोग किया गया है, साथ ही self आर्ग्युमेंट भी।

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")संचालित द्वारा

bark मेथड अब एक नए ozzy ऑब्जेक्ट को इंस्टैंशिएट करने के बाद डॉट नोटेशन का उपयोग करके कॉल किया जा सकता है। मेथड को स्क्रीन पर "bark bark!" प्रिंट करना चाहिए। .bark() में कोष्ठकों पर ध्यान दें। मेथड कॉल करते समय इन्हें हमेशा उपयोग किया जाता है। इस मामले में ये खाली हैं, क्योंकि bark() मेथड कोई आर्ग्युमेंट नहीं लेता।

ozzy = Dog("Ozzy", 2)

ozzy.bark()
संचालित द्वारा

bark bark!संचालित द्वारा

याद है आपने पहले ozzy को कैसे प्रिंट किया था? नीचे दिया कोड अब इसी फंक्शनैलिटी को Dog क्लास में doginfo() मेथड के साथ लागू करता है। फिर आप अलग-अलग गुणों वाले कुछ ऑब्जेक्ट्स को इंस्टैंशिएट करते हैं और उन पर यह मेथड कॉल करते हैं।

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

ozzy = Dog("Ozzy", 2)
skippy = Dog("Skippy", 12)
filou = Dog("Filou", 8)

ozzy.doginfo()
skippy.doginfo()
filou.doginfo()संचालित द्वारा

Ozzy is 2 year(s) old.
Skippy is 12 year(s) old.
Filou is 8 year(s) old.संचालित द्वारा

जैसा कि आप देख सकते हैं, आप डॉट नोटेशन के साथ ऑब्जेक्ट्स पर doginfo() मेथड कॉल कर सकते हैं। अब प्रतिक्रिया इस पर निर्भर करती है कि आप किस Dog ऑब्जेक्ट पर यह मेथड कॉल कर रहे हैं।

चूँकि कुत्ते बड़े होते जाते हैं, तो अच्छा होगा यदि आप उनकी उम्र को उसी अनुसार समायोजित कर सकें। Ozzy अभी 3 साल का हुआ है, तो उसकी उम्र बदलते हैं।

ozzy.age = 3

print(ozzy.age)संचालित द्वारा

3संचालित द्वारा

यह उतना ही आसान है जितना कि एट्रिब्यूट को नया मान असाइन करना। आप इसे Dog क्लास में birthday() मेथड के रूप में भी लागू कर सकते हैं:

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

ozzy = Dog("Ozzy", 2)

print(ozzy.age)संचालित द्वारा

2संचालित द्वारा

ozzy.birthday()

print(ozzy.age)संचालित द्वारा

3संचालित द्वारा

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

मेथड्स को आर्ग्युमेंट्स पास करना

आप चाहेंगे कि हमारे कुत्तों का एक बडी (साथी) हो। यह वैकल्पिक होना चाहिए क्योंकि सभी कुत्ते इतने मिलनसार नहीं होते।

नीचे दिए गए setBuddy() मेथड पर नज़र डालें। यह सामान्य रूप से self और साथ में buddy को आर्ग्युमेंट्स के रूप में लेता है। इस मामले में, buddy एक अन्य Dog ऑब्जेक्ट होगा। self.buddy एट्रिब्यूट को buddy पर सेट करें, और buddy.buddy एट्रिब्यूट को self पर।

इसका मतलब है कि रिश्ता पारस्परिक है; आप अपने बडी के बडी हैं। इस मामले में, Filou Ozzy का बडी होगा, जिसका अर्थ है कि Ozzy अपने-आप Filou का बडी बन जाता है।

आप इन एट्रिब्यूट्स को मेथड परिभाषित करने के बजाय मैन्युअली भी सेट कर सकते हैं, लेकिन तब जब भी आप बडी सेट करना चाहेंगे, अधिक काम (एक की बजाय दो लाइनें) लिखनी पड़ेंगी।

ध्यान दें कि Python में आपको आर्ग्युमेंट के प्रकार को निर्दिष्ट करने की आवश्यकता नहीं होती। यदि यह Java होता, तो यह आवश्यक होता।

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

    def setBuddy(self, buddy):
        self.buddy = buddy
        buddy.buddy = selfसंचालित द्वारा

अब आप डॉट नोटेशन के साथ मेथड कॉल कर सकते हैं और इसे एक अन्य Dog ऑब्जेक्ट पास कर सकते हैं। इस मामले में, Ozzy का बडी Filou होगा:

ozzy = Dog("Ozzy", 2)
filou = Dog("Filou", 8)

ozzy.setBuddy(filou)संचालित द्वारा

यदि अब आप Ozzy के बडी के बारे में कुछ जानकारी प्राप्त करना चाहते हैं, तो आप डॉट नोटेशन को दो बार उपयोग कर सकते हैं: पहले, Ozzy के बडी को संदर्भित करने के लिए, और दूसरी बार उसके एट्रिब्यूट को संदर्भित करने के लिए।

print(ozzy.buddy.name)
print(ozzy.buddy.age)संचालित द्वारा

Filou
8संचालित द्वारा

ध्यान दें कि यह Filou के लिए भी इसी तरह किया जा सकता है।

print(filou.buddy.name)
print(filou.buddy.age)संचालित द्वारा

Ozzy
2संचालित द्वारा

बडी के मेथड्स भी कॉल किए जा सकते हैं। doginfo() को जो self आर्ग्युमेंट पास होता है, वह अब ozzy.buddy है, जो कि filou है।

ozzy.buddy.doginfo()संचालित द्वारा

Filou is 8 year(s) old.संचालित द्वारा

Python OOP उदाहरण

Python में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग का एक उदाहरण जहाँ काम आ सकता है, हमारा Python For Finance: Algorithmic Trading ट्यूटोरियल है। इसमें, हम किसी स्टॉक पोर्टफोलियो के लिए ट्रेडिंग रणनीति सेट करना समझाते हैं।

ट्रेडिंग रणनीति किसी स्टॉक प्राइस के मूविंग एवरेज पर आधारित है। यदि signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:] पूरा होता है, तो एक सिग्नल बनाया जाता है। यह सिग्नल स्टॉक की भविष्य की प्राइस चेंज का अनुमान है।

नीचे दिए गए कोड में, आप देखेंगे कि पहले इनिशियलाइज़ेशन है, फिर मूविंग एवरेज कैलकुलेशन और सिग्नल जेनरेशन। चूँकि यह ऑब्जेक्ट-ओरिएंटेड कोड नहीं है, यह एक बड़ा ब्लॉक है जो एक साथ निष्पादित होता है।

ध्यान दें कि हम उदाहरण में aapl का उपयोग कर रहे हैं, जो Apple का स्टॉक टिकर है। यदि आप किसी अन्य स्टॉक के लिए यह करना चाहते, तो आपको कोड फिर से लिखना पड़ता।

# Initialize
short_window = 40
long_window = 100
signals = pd.DataFrame(index=aapl.index)
signals['signal'] = 0.0

# Create short simple moving average over the short window
signals['short_mavg'] = aapl['Close'].rolling(window=short_window, min_periods=1, center=False).mean()

# Create long simple moving average over the long window
signals['long_mavg'] = aapl['Close'].rolling(window=long_window, min_periods=1, center=False).mean()

# Create signals
signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:], 1.0, 0.0)   

# Generate trading orders
signals['positions'] = signals['signal'].diff()

# Print `signals`
print(signals)संचालित द्वारा

ऑब्जेक्ट-ओरिएंटेड अप्रोच में, आपको इनिशियलाइज़ेशन और सिग्नल जेनरेशन कोड केवल एक बार लिखने की आवश्यकता होती है।

फिर आप हर उस स्टॉक के लिए, जिस पर आप रणनीति गणना करना चाहते हैं, एक नया ऑब्जेक्ट बना सकते हैं और उस पर generate_signals() मेथड कॉल कर सकते हैं। ध्यान दें कि OOP कोड ऊपर के कोड से बहुत मिलता-जुलता है, जिसमें self का अतिरिक्त उपयोग है।

class MovingAverage():

    def __init__(self, symbol, bars, short_window, long_window):
        self.symbol = symbol
        self.bars = bars
        self.short_window = short_window
        self.long_window = long_window

    def generate_signals(self):
        signals = pd.DataFrame(index=self.bars.index)
        signals['signal'] = 0.0

        signals['short_mavg'] = self.bars['Close'].rolling(window=self.short_window, min_periods=1, center=False).mean()
        signals['long_mavg'] = bars['Close'].rolling(window=self.long_window, min_periods=1, center=False).mean()

        signals['signal'][self.short_window:] = np.where(signals['short_mavg'][self.short_window:] > signals['long_mavg'][self.short_window:], 1.0, 0.0)   

        signals['positions'] = signals['signal'].diff()   

        return signalsसंचालित द्वारा

अब आप केवल अपनी मनचाही पैरामीटर्स के साथ एक ऑब्जेक्ट इंस्टैंशिएट कर सकते हैं और उसके लिए सिग्नल जेनरेट कर सकते हैं।

apple = MovingAverage('aapl', aapl, 40, 100)
print(apple.generate_signals())संचालित द्वारा

इसे किसी दूसरे स्टॉक के लिए करना बहुत आसान हो जाता है। यह सिर्फ एक अलग स्टॉक सिंबल के साथ नया ऑब्जेक्ट इंस्टैंशिएट करने की बात है।

microsoft = MovingAverage('msft', msft, 40, 100)
print(microsoft.generate_signals())संचालित द्वारा

अंतिम विचार

हमने Python में कुछ प्रमुख OOP अवधारणाएँ कवर कर ली हैं। अब आप जानते हैं कि क्लास और मेथड्स कैसे डिक्लेयर करें, ऑब्जेक्ट्स कैसे इंस्टैंशिएट करें, उनके एट्रिब्यूट्स कैसे सेट करें, और इंस्टेंस मेथड्स कैसे कॉल करें। ये कौशल आपकी डेटा साइंटिस्ट की भविष्य की करियर में काम आएँगे।

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

OOP के साथ, जैसे-जैसे आपका प्रोग्राम बड़ा होगा, आपका कोड जटिलता में बढ़ेगा। आपके पास विभिन्न क्लासेज़, सबक्लासेज़, ऑब्जेक्ट्स, इनहेरिटेंस, इंस्टेंस मेथड्स, और बहुत कुछ होगा। जटिल इनहेरिटेंस परिदृश्यों के लिए, मल्टीपल इनहेरिटेंस और super() के बारे में जानें।