इस लेक्चर में हम पाइथन में क्लासेज, कंस्ट्रक्टर्स और इनहेरिटेंस के बारे में जानेंगे।
ये अवधारणाएं एक बड़े कार्यक्रम में वास्तव में महत्वपूर्ण हैं जहां विभिन्न प्रकारों को परिभाषित करने की आवश्यकता होती है।
क्लासेज
प्रोग्रामिंग में कक्षाएं आवश्यक हैं और वे अजगर के लिए विशिष्ट नहीं हैं। अन्य कई प्रोग्रामिंग की भाषाएँ वर्गों की धारणा का समर्थन करते हैं। हम नए डेटा प्रकारों को परिभाषित करने के लिए कक्षाओं का उपयोग करते हैं।
अब तक, हमने पायथन में बुनियादी डेटा प्रकारों जैसे संख्याओं, स्ट्रिंग्स और बूलियन्स के बारे में सीखा है। ये पायथन में बुनियादी या सरल डेटा प्रकार हैं। हमने कुछ जटिल डेटा प्रकार जैसे सूचियाँ और शब्दकोश भी देखे हैं।
हालांकि ये प्रकार अत्यंत उपयोगी हैं, लेकिन इनका उपयोग हमेशा जटिल अवधारणाओं को मॉडल करने के लिए नहीं किया जा सकता है। उदाहरण के लिए, किसी बिंदु या शॉपिंग कार्ट के विचार के बारे में सोचें। शॉपिंग कार्ट कोई बूलियन या सूची नहीं है। यह एक अलग तरह का डेटा है। इसलिए हम वास्तविक अवधारणाओं को मॉडल करने के लिए नए प्रकारों को परिभाषित करने के लिए कक्षाओं का उपयोग कर सकते हैं।
अब, एक नए डेटा प्रकार को परिभाषित करते हैं जिसे बिंदु कहा जाता है। इस नए प्रकार में विधियाँ होने वाली हैं जैसा कि हमने पहले जाँच की थी।
आप इसे इस तरह से करेंगे:
हम "क्लास" कीवर्ड का उपयोग करके एक वर्ग को परिभाषित करके शुरू करते हैं और उसके ठीक बाद हम अपनी कक्षा को एक नाम देते हैं।
class Point
अब, मेरे द्वारा यहां उपयोग किए गए नामकरण परिपाटी को देखें। मैंने यहां पहला अक्षर कैपिटल किया है, इसे हम पास्कल नेमिंग कन्वेंशन कहते हैं। यह परिपाटी उस परंपरा से भिन्न है जिसका उपयोग हम अपने चरों और कार्यों के नामकरण के लिए करते हैं जिसके लिए हम हमेशा छोटे अक्षरों का उपयोग करते हैं और एक अंडरस्कोर का उपयोग करके कई शब्दों को अलग करते हैं। लेकिन कक्षाओं का नामकरण करते समय, हम कई शब्दों को अलग करने के लिए अंडरस्कोर का उपयोग नहीं करते हैं, हम प्रत्येक शब्द के पहले अक्षर को कैपिटल करते हैं।
हमारे वर्ग को परिभाषित करने के बाद, एक कोलन का उपयोग किया जाता है जिसका अर्थ है कि अब एक ब्लॉक परिभाषित किया गया है।
class Point:
def move (self):
इस खंड में, हम उन सभी कार्यों या विधियों को परिभाषित कर सकते हैं जो बिंदुओं से संबंधित हैं। उदाहरण के लिए, हम एक बिंदु को स्थानांतरित करने के लिए "चाल" नामक फ़ंक्शन को परिभाषित कर सकते हैं। ध्यान दें कि जैसे ही हम ओपन कोष्ठक टाइप करते हैं, PyCharm स्वचालित रूप से यहां "स्वयं" जोड़ता है। यह एक विशेष कीवर्ड है और मुझे इस पर शीघ्र ही वापस आने दें। आइए टर्मिनल पर "मूव" प्रिंट करें।
print("move")
आइए "ड्रा" जैसी दूसरी विधि को परिभाषित करें और इसे टर्मिनल पर प्रिंट करें।
def draw(self):
print("draw")
हम अपने "बिंदु" वर्ग की परिभाषा के साथ कर रहे हैं। इस नए प्रकार से हम नई वस्तुएँ बना सकते हैं। एक वर्ग केवल उन वस्तुओं को बनाने के लिए खाका या टेम्पलेट को परिभाषित करता है जो उस खाका के आधार पर वास्तविक उदाहरण हैं। ऑब्जेक्ट बनाने के लिए, हम अपनी कक्षा का नाम टाइप करते हैं और फिर इसे एक फ़ंक्शन की तरह कहते हैं। यह एक नई वस्तु बनाता है और फिर उसे वापस कर देता है। फिर हम उस ऑब्जेक्ट को एक वेरिएबल में स्टोर कर सकते हैं। चलो मैं तुम्हें दिखाती हूँ:
यहां हमने एक "बिंदु 1" परिभाषित किया है जो एक त्रि-आयामी बिंदु है। आप देख सकते हैं कि, हम टर्मिनल पर अलग-अलग निर्देशांक प्रिंट कर सकते हैं।
हम इस बिंदु के साथ "ड्रा" और "मूव" दो विधियों का उपयोग कर सकते हैं।
तो संक्षेप में, हम नए प्रकारों को परिभाषित करने के लिए कक्षाओं का उपयोग करते हैं और इन प्रकारों में ऐसे तरीके हो सकते हैं जिन्हें हम कक्षा के शरीर में परिभाषित करते हैं। कक्षाओं में ऐसी विशेषताएँ हो सकती हैं जिन्हें हम अपने कार्यक्रमों में कहीं भी सेट कर सकते हैं।
कंस्ट्रक्टर्स
अब तक, हमने सीखा कि कक्षाओं का उपयोग करके नए प्रकार कैसे बनाए जाते हैं। अब इस कार्यान्वयन में एक छोटी सी समस्या है। हम कक्षाओं का उपयोग करके x या y निर्देशांक के बिना एक बिंदु वस्तु बना सकते हैं और यह आदर्श नहीं है। चलो मैं तुम्हें दिखाती हूँ।
हम x निर्देशांक सेट करने से पहले एक बिंदु बनाते हैं और उसे प्रिंट करते हैं। हमारे प्रोग्राम को चलाने से इस तरह की विशेषता त्रुटि होती है:
इसका मतलब है कि बिंदु वस्तु में x नामक कोई विशेषता नहीं है। अब समस्या यह है कि x या y निर्देशांक के बिना एक बिंदु वस्तु होना संभव है। इसका कोई मतलब नहीं है क्योंकि जब भी हम किसी बिंदु के बारे में बात करते हैं, तो हमें यह जानना होता है कि वह बिंदु कहाँ स्थित है। इस समस्या को हल करने के लिए, हम एक कंस्ट्रक्टर का उपयोग करते हैं। कंस्ट्रक्टर एक ऐसा फंक्शन है जिसे ऑब्जेक्ट बनाते समय कॉल किया जाता है।
यहां बताया गया है कि हम कंस्ट्रक्टर का उपयोग कैसे करते हैं। सबसे पहले, उपरोक्त प्रोग्राम में x और y निर्देशांक मानों को पास करते हैं।
point = Point(10, 20)
print(point.x)
अब, हमें इस वर्ग में एक विशेष विधि जोड़ने की आवश्यकता है जिसे कंस्ट्रक्टर कहा जाता है। इसका सिंटैक्स इस प्रकार है:
def __init__(self, x, y):
init
इनिशियलाइज़ेशन के लिए छोटा है, और यह फंक्शन या मेथड है जिसे एक नया पॉइंट ऑब्जेक्ट बनाते समय कॉल किया जाता है। x और y को ठीक बाद में जोड़ा जाता है self
दो अतिरिक्त पैरामीटर जोड़ने के लिए।
उसके बाद, हमें x और y को पास किए गए मानों यानी 10 और 20 . पर मैप करना चाहिए
self.x = x
self.y = y
हम उपयोग self
वर्तमान ऑब्जेक्ट को संदर्भित करने के लिए और फिर हम x विशेषता को फ़ंक्शन "x" को दिए गए x तर्क पर सेट करते हैं। इस प्रकार का प्रयोग करते हुए init
विधि, हम अपनी वस्तुओं को इनिशियलाइज़ कर सकते हैं। इस विधि को कंस्ट्रक्टर कहा जाता है। चलिए अपना प्रोग्राम चलाते हैं।
अब, हम बाद में x और y निर्देशांक बदल सकते हैं। आइए x निर्देशांक अपडेट करें:
point = Point(10, 20)
point.x = 11
print(point.x)
अब, x निर्देशांक को मान 11 में अद्यतन किया जाता है।
व्यायाम
यहाँ आपके लिए एक दिलचस्प अभ्यास है।
मैं चाहता हूं कि आप एक नए प्रकार को परिभाषित करें जिसे व्यक्ति कहा जाता है। इन "व्यक्ति" वस्तुओं में "व्यक्ति" होना चाहिएname
"विशेषता के साथ-साथ"talk()
" तरीका।
यह एक सरल कार्य है और इसमें कुछ मिनटों से अधिक समय नहीं लगना चाहिए।
उपाय
इस तरह "व्यक्ति" वर्ग को परिभाषित करने के साथ शुरू करें:
class Person:
self.name = name
हम कंस्ट्रक्टर को बाद में परिभाषित करेंगे। अब, हम "व्यक्ति" वस्तु बना सकते हैं। चलो इसे जॉन कहते हैं
john = Person("John Smith")
print(john.name)
john.talk()
अब, कोड के पहले भाग पर जाएं और एक कंस्ट्रक्टर बनाएं।
def __init__(self, name):
अंतिम कोड इस तरह दिखेगा:
आप कक्षाओं और कंस्ट्रक्टरों के संयोजन में स्वरूपित स्ट्रिंग्स और अन्य अवधारणाओं का भी उपयोग कर सकते हैं।
विरासत
वंशानुक्रम कक्षाओं से जुड़ी एक और अवधारणा है जो आपको एक कोड का पुन: उपयोग करने देती है।
कोड के इस टुकड़े पर विचार करें।
class Dog:
def walk(self):
print("walk")
हमने "वॉक" विधि के साथ एक वर्ग "डॉग" बनाया है। इस पद्धति में, हम केवल टर्मिनल पर चलने वाले संदेश को प्रिंट कर रहे हैं। मान लीजिए, एक वास्तविक कार्यक्रम में, यहाँ केवल एक पंक्ति के बजाय कोड की 10 पंक्तियाँ हैं। भविष्य में, यदि किसी अन्य वर्ग को "वॉक" पद्धति की आवश्यकता है, तो हमें उस सभी कोड को दोहराना होगा। यह आदर्श नहीं है।
प्रोग्रामिंग में, हमारे पास डीआरवाई नामक एक सिद्धांत है जो खुद को दोहराने के लिए छोटा है। मान लीजिए कि भविष्य में किसी समय, हमें अपनी "वॉक" पद्धति के साथ एक समस्या का पता चलता है और यदि हमने इस पद्धति को कई अन्य स्थानों पर दोहराया या दोहराया है, तो हमें वापस आना होगा और उस समस्या को हर उस स्थान पर ठीक करना होगा जहां हमने इसे दोहराया है। कोड। इसलिए प्रोग्रामिंग में हमें किसी चीज को दो बार परिभाषित नहीं करना चाहिए।
इस समस्या को दूर करने के लिए अलग-अलग तरीके हैं लेकिन यहां हम एक सीखने जा रहे हैं जो शुरुआती लोगों के लिए आसान है और इसे विरासत कहा जाता है। इस मामले में, हम एक और वर्ग "स्तनपायी" बनाएंगे और उस वर्ग में हमारी "चलना" विशेषता को परिभाषित करेंगे।
class Mammal:
def walk(self):
print("walk")
हमारे "स्तनपायी" वर्ग को परिभाषित करने के बाद हम इस तरह की विशेषताओं को पारित करने के लिए विरासत का उपयोग कर सकते हैं:
कुत्ते और बिल्ली दोनों वर्ग अपने मूल वर्ग में परिभाषित सभी वर्ग विधियों को विरासत में प्राप्त कर रहे हैं। अब, हम कुत्तों के लिए विशिष्ट तरीके इस तरह जोड़ सकते हैं:
class Dog:
def bark(self):
print("bark")
लपेटें!
यह सभी वर्गों, कंस्ट्रक्टर्स और इनहेरिटेंस कॉन्सेप्ट वाली कक्षाओं में कोड का पुन: उपयोग करने के बारे में था। अब हम अपनी श्रृंखला के अंत के करीब हैं। इस बिंदु तक, आपको पायथन में अच्छे, पठनीय और संक्षिप्त कोड तैयार करने में सक्षम होना चाहिए।
हम अगले व्याख्यान में मॉड्यूल और पैकेज की अवधारणा देखेंगे।
एक जवाब लिखें