कक्षाएं ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग के स्तंभ हैं । OOP कोड संगठन, पुन: प्रयोज्यता और इनकैप्सुलेशन के साथ अत्यधिक चिंतित है।
सबसे पहले, एक अस्वीकरण: OOP आंशिक रूप से कार्यात्मक प्रोग्रामिंग के विपरीत है , जो कि एक अलग प्रतिमान है जिसे पायथन में बहुत अधिक उपयोग किया जाता है। पायथन (या निश्चित रूप से अधिकांश भाषाओं) में प्रोग्राम करने वाले हर कोई OOP का उपयोग नहीं करता है। आप Java 8 में बहुत कुछ कर सकते हैं जो बहुत ऑब्जेक्ट ओरिएंटेड नहीं है। यदि आप OOP का उपयोग नहीं करना चाहते हैं, तो न करें। यदि आप डेटा को संसाधित करने के लिए सिर्फ एक-बंद स्क्रिप्ट लिख रहे हैं, जिसका उपयोग आप फिर कभी नहीं करेंगे, तो आप जिस तरह से हैं, उसे लिखते रहें।
हालाँकि, OOP का उपयोग करने के कई कारण हैं।
कुछ कारणों से:
संगठन: OOP कोड में डेटा और प्रक्रिया दोनों का वर्णन और परिभाषित करने के अच्छी तरह से ज्ञात और मानक तरीकों को परिभाषित करता है। डेटा और प्रक्रिया दोनों को परिभाषा के विभिन्न स्तरों (विभिन्न वर्गों में) में संग्रहीत किया जा सकता है, और इन परिभाषाओं के बारे में बात करने के मानक तरीके हैं। यही है, यदि आप एक मानक तरीके से OOP का उपयोग करते हैं, तो यह आपके बाद के स्वयं और दूसरों को आपके कोड को समझने, संपादित करने और उपयोग करने में मदद करेगा। इसके अलावा, एक जटिल, मनमाने ढंग से डेटा स्टोरेज मैकेनिज्म (डिकट्स या लिस्ट या डाइक या सेट के डाइक की लिस्ट या जो भी हो) का उपयोग करने के बजाय, आप डेटा संरचनाओं के टुकड़ों का नाम दे सकते हैं और आसानी से उनका उल्लेख कर सकते हैं।
राज्य: OOP आपको परिभाषित करने और राज्य का ट्रैक रखने में मदद करता है। उदाहरण के लिए, एक क्लासिक उदाहरण में, यदि आप एक ऐसा प्रोग्राम बना रहे हैं, जो छात्रों को संसाधित करता है (उदाहरण के लिए, एक ग्रेड प्रोग्राम), तो आप उन सभी सूचनाओं को रख सकते हैं जिनकी आपको उनके बारे में एक जगह (नाम, आयु, लिंग, ग्रेड स्तर), पाठ्यक्रम, ग्रेड, शिक्षक, साथियों, आहार, विशेष जरूरतों, आदि), और यह डेटा तब तक कायम है जब तक कि वस्तु जीवित है, और आसानी से सुलभ है।
एनकैप्सुलेशन : एनकैप्सुलेशन के साथ, प्रक्रिया और डेटा एक साथ संग्रहीत होते हैं। विधियों (कार्यों के लिए एक ओओपी शब्द) को उस डेटा के साथ सही परिभाषित किया जाता है जिसे वे संचालित और उत्पादन करते हैं। जावा जैसी भाषा में जो आपके नियंत्रण की अनुमति देता है , या आप अपने सार्वजनिक एपीआई का वर्णन कैसे करते हैं, इसके आधार पर पायथन में, इसका अर्थ है कि उपयोगकर्ता से तरीके और डेटा छिपाए जा सकते हैं। इसका मतलब यह है कि यदि आपको कोड बदलने की आवश्यकता है या आप कोड को लागू करना चाहते हैं, तो आप कर सकते हैं, लेकिन सार्वजनिक एपीआई को समान रखें।
इनहेरिटेंस : इनहेरिटेंस आपको डेटा और प्रक्रिया को एक स्थान पर (एक वर्ग में) परिभाषित करने की अनुमति देता है, और फिर बाद में उस कार्यक्षमता को ओवरराइड या विस्तारित करता है। उदाहरण के लिए, पायथन में, मैं अक्सर लोगों dictको अतिरिक्त कार्यक्षमता जोड़ने के लिए कक्षा के उप- वर्ग बनाने के लिए देखता हूं । एक सामान्य परिवर्तन उस विधि को ओवरराइड कर रहा है जो एक अपवाद को फेंक देता है जब एक कुंजी को एक शब्दकोश से अनुरोध किया जाता है जो एक अज्ञात कुंजी के आधार पर डिफ़ॉल्ट मान देने के लिए मौजूद नहीं है। यह आपको अपने स्वयं के कोड को अभी या बाद में विस्तारित करने की अनुमति देता है, दूसरों को आपके कोड का विस्तार करने की अनुमति देता है, और आपको अन्य लोगों के कोड का विस्तार करने की अनुमति देता है।
पुन: प्रयोज्य: इन सभी कारणों और दूसरों के लिए कोड की अधिक पुन: प्रयोज्य की अनुमति है। ऑब्जेक्ट ओरिएंटेड कोड आपको एक बार ठोस (परीक्षण) कोड लिखने की अनुमति देता है, और फिर से अधिक से अधिक पुन: उपयोग करता है। यदि आपको अपने विशिष्ट उपयोग के मामले के लिए कुछ ट्वीस्ट करने की आवश्यकता है, तो आप एक मौजूदा वर्ग से वारिस कर सकते हैं और मौजूदा व्यवहार को ओवरराइट कर सकते हैं। यदि आपको कुछ बदलने की आवश्यकता है, तो आप मौजूदा सार्वजनिक विधि हस्ताक्षर को बनाए रखते हुए इसे बदल सकते हैं, और कोई भी समझदार (उम्मीद) नहीं है।
फिर, OOP का उपयोग न करने के कई कारण हैं, और आपको इसकी आवश्यकता नहीं है। लेकिन सौभाग्य से पायथन जैसी भाषा के साथ, आप बस थोड़ा सा या बहुत उपयोग कर सकते हैं, यह आपके ऊपर है।
छात्र उपयोग के मामले का उदाहरण (कोड गुणवत्ता पर कोई गारंटी नहीं, सिर्फ एक उदाहरण):
वस्तु के उन्मुख
class Student(object):
def __init__(self, name, age, gender, level, grades=None):
self.name = name
self.age = age
self.gender = gender
self.level = level
self.grades = grades or {}
def setGrade(self, course, grade):
self.grades[course] = grade
def getGrade(self, course):
return self.grades[course]
def getGPA(self):
return sum(self.grades.values())/len(self.grades)
# Define some students
john = Student("John", 12, "male", 6, {"math":3.3})
jane = Student("Jane", 12, "female", 6, {"math":3.5})
# Now we can get to the grades easily
print(john.getGPA())
print(jane.getGPA())
स्टैंडर्ड डिक्ट
def calculateGPA(gradeDict):
return sum(gradeDict.values())/len(gradeDict)
students = {}
# We can set the keys to variables so we might minimize typos
name, age, gender, level, grades = "name", "age", "gender", "level", "grades"
john, jane = "john", "jane"
math = "math"
students[john] = {}
students[john][age] = 12
students[john][gender] = "male"
students[john][level] = 6
students[john][grades] = {math:3.3}
students[jane] = {}
students[jane][age] = 12
students[jane][gender] = "female"
students[jane][level] = 6
students[jane][grades] = {math:3.5}
# At this point, we need to remember who the students are and where the grades are stored. Not a huge deal, but avoided by OOP.
print(calculateGPA(students[john][grades]))
print(calculateGPA(students[jane][grades]))