या व्याख्यानात आपण पायथनमधील वर्ग, रचनाकार आणि वारसा याविषयी जाणून घेणार आहोत.
या संकल्पना एका मोठ्या प्रोग्राममध्ये खरोखर महत्वाच्या आहेत जेथे विविध प्रकार परिभाषित करणे आवश्यक आहे.
वर्ग
प्रोग्रामिंगमध्ये वर्ग आवश्यक आहेत आणि ते पायथनसाठी विशिष्ट नाहीत. इतर अनेक प्रोग्रामिंग भाषा वर्गांच्या कल्पनेचे समर्थन करा. आम्ही नवीन डेटा प्रकार परिभाषित करण्यासाठी वर्ग वापरतो.
आत्तापर्यंत, आपण पायथनमधील मूलभूत डेटा प्रकार जसे की संख्या, स्ट्रिंग्स आणि बुलियन्सबद्दल शिकलो आहोत. पायथनमधील हे मूलभूत किंवा साधे डेटा प्रकार आहेत. आम्ही याद्या आणि शब्दकोषांसारखे काही जटिल डेटा प्रकार देखील पाहिले आहेत.
जरी हे प्रकार अत्यंत उपयुक्त असले तरी, ते नेहमी जटिल संकल्पनांचे मॉडेल करण्यासाठी वापरले जाऊ शकत नाहीत. उदाहरणार्थ, पॉइंट किंवा शॉपिंग कार्टच्या कल्पनेबद्दल विचार करा. शॉपिंग कार्ट ही बुलियन किंवा सूची नसते. हा वेगळ्या प्रकारचा डेटा आहे. म्हणून आम्ही नवीन प्रकार परिभाषित करण्यासाठी वर्ग वापरू शकतो वास्तविक संकल्पना मॉडेल करण्यासाठी.
आता, पॉइंट नावाचा नवीन डेटा प्रकार परिभाषित करू. या नवीन प्रकारात आम्ही आधी तपासल्याप्रमाणे पद्धती असतील.
आपण हे कसे कराल:
आम्ही "वर्ग" कीवर्ड वापरून वर्ग परिभाषित करून सुरुवात करतो आणि त्यानंतर आम्ही आमच्या वर्गाला नाव देतो.
class Point
आता, मी येथे वापरलेले नामकरण नियम पहा. मी येथे पहिले अक्षर कॅपिटल केले आहे, यालाच आपण पास्कल नेमिंग कन्व्हेन्शन म्हणतो. हे संमेलन आम्ही आमच्या व्हेरिएबल्स आणि फंक्शन्सना नाव देण्यासाठी वापरतो त्यापेक्षा वेगळे आहे ज्यासाठी आम्ही नेहमी लोअरकेस अक्षरे वापरतो आणि अंडरस्कोर वापरून अनेक शब्द वेगळे करतो. परंतु वर्गांना नाव देताना, आम्ही त्याऐवजी अनेक शब्द वेगळे करण्यासाठी अंडरस्कोर वापरत नाही, आम्ही प्रत्येक शब्दाचे पहिले अक्षर कॅपिटल करतो.
आमचा वर्ग परिभाषित केल्यानंतर, कोलन वापरला जातो म्हणजे आता एक ब्लॉक परिभाषित केला जातो.
class Point:
def move (self):
या ब्लॉकमध्ये, आम्ही पॉइंट्सशी संबंधित सर्व फंक्शन्स किंवा पद्धती परिभाषित करू शकतो. उदाहरणार्थ, बिंदू हलवण्यासाठी आपण “move” नावाचे फंक्शन परिभाषित करू शकतो. लक्षात ठेवा की आपण ओपन कंस टाईप करताच, PyCharm येथे आपोआप "self" जोडते. हा एक विशेष कीवर्ड आहे आणि मी लवकरच यावर परत येऊ. टर्मिनलवर “move” प्रिंट करू.
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 ओळी कोड आहेत. भविष्यात, जर दुसर्या वर्गाला "चालणे" पद्धत आवश्यक असेल, तर आम्हाला ते सर्व कोड पुन्हा करावे लागतील. हे आदर्श नाही.
प्रोग्रामिंगमध्ये, आमच्याकडे DRY नावाचे तत्त्व आहे जे स्वतःला पुन्हा करू नका यासाठी लहान आहे. भविष्यात कधीतरी, आम्हाला आमच्या "चालणे" पद्धतीमध्ये समस्या आढळली आणि आम्ही ही पद्धत इतर अनेक ठिकाणी पुनरावृत्ती केली किंवा डुप्लिकेट केली असेल, तर आम्हाला परत यावे लागेल आणि आम्ही डुप्लिकेट केलेल्या प्रत्येक ठिकाणी ती समस्या सोडवावी लागेल. कोड म्हणूनच प्रोग्रामिंगमध्ये आपण काहीतरी दोनदा परिभाषित करू नये.
या समस्येचे निराकरण करण्यासाठी विविध पद्धती आहेत परंतु येथे आपण शिकणार आहोत जे नवशिक्यांसाठी सोपे आहे आणि त्याला वारसा म्हणतात. या प्रकरणात, आम्ही दुसरा वर्ग "सस्तन प्राणी" तयार करू आणि त्या वर्गात आमचे "चालणे" गुणधर्म परिभाषित करू.
class Mammal:
def walk(self):
print("walk")
आमचा "सस्तन प्राणी" वर्ग परिभाषित केल्यानंतर, आम्ही खालीलप्रमाणे गुणधर्म पास करण्यासाठी वारसा वापरू शकतो:
कुत्रा आणि मांजर या दोन्ही वर्गांना त्यांच्या पालक वर्गामध्ये परिभाषित केलेल्या सर्व वर्ग पद्धतींचा वारसा मिळतो. आता, आम्ही कुत्र्यांसाठी विशिष्ट पद्धती यासारख्या जोडू शकतो:
class Dog:
def bark(self):
print("bark")
गुंडाळणे!
हे सर्व वर्ग, कन्स्ट्रक्टर आणि वारसा संकल्पना असलेल्या वर्गांमध्ये कोडचा पुनर्वापर करण्याबद्दल होते. आता आमची मालिका संपत आली आहे. या टप्प्यापर्यंत, तुम्ही पायथनमध्ये चांगले, वाचनीय आणि संक्षिप्त कोड तयार करण्यास सक्षम असाल.
मॉड्यूल्स आणि पॅकेजेसची संकल्पना आपण पुढील लेक्चरमध्ये पाहू.
प्रत्युत्तर द्या