इस अध्याय में, हम इनकैप्सुलेशन (Encapsulation) और एब्स्ट्रैक्शन (Abstraction) के बारे में विस्तार से जानेंगे। इनकैप्सुलेशन ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) का एक महत्वपूर्ण सिद्धांत है जो डेटा को सुरक्षित और संरक्षित रखने का तरीका प्रदान करता है, जबकि एब्स्ट्रैक्शन जटिलताओं को छुपाने और केवल आवश्यक विवरण प्रस्तुत करने का तरीका है। हम इनकैप्सुलेशन का परिचय, प्राइवेट और पब्लिक विशेषताएँ, गेटर्स और सेटर्स, एब्स्ट्रैक्शन का परिचय, एब्स्ट्रैक्ट कक्षाएँ, और एब्स्ट्रैक्ट विधियाँ के बारे में जानेंगे। इसके अतिरिक्त, हम OOP के सर्वोत्तम प्रथाओं और उपयोगी टिप्स पर भी चर्चा करेंगे, जो कोड को अधिक संगठित, कुशल, और बनाए रखने योग्य बनाएंगी।
इनकैप्सुलेशन का परिचय (Introduction to Encapsulation)
इनकैप्सुलेशन डेटा को छुपाने और उसे सीधे एक्सेस करने से रोकने का तरीका है। इसका उद्देश्य डेटा को सुरक्षित रखना और उसे केवल आवश्यक विधियों के माध्यम से ही एक्सेस करना है। इनकैप्सुलेशन कक्षा के अंदर डेटा और विधियों को संकुचित करता है।
उदाहरण:
class Person:
def __init__(self, name, age):
self.__name = name # प्राइवेट विशेषता
self.__age = age # प्राइवेट विशेषता
def get_name(self): # गेटर विधि
return self.__name
def set_name(self, name): # सेटटर विधि
self.__name = name
def get_age(self): # गेटर विधि
return self.__age
def set_age(self, age): # सेटटर विधि
self.__age = age
प्राइवेट और पब्लिक विशेषताएँ (Private and Public Attributes)
पाइथन में, विशेषताएँ प्राइवेट या पब्लिक हो सकती हैं। पब्लिक विशेषताएँ सीधे एक्सेस की जा सकती हैं, जबकि प्राइवेट विशेषताएँ केवल कक्षा के अंदर से ही एक्सेस की जा सकती हैं।
उदाहरण:
class Car:
def __init__(self, brand, model):
self.brand = brand # पब्लिक विशेषता
self.__model = model # प्राइवेट विशेषता
def get_model(self): # गेटर विधि
return self.__model
def set_model(self, model): # सेटटर विधि
self.__model = model
# ऑब्जेक्ट का निर्माण
car = Car("Toyota", "Corolla")
# पब्लिक विशेषता को एक्सेस करना
print(car.brand) # आउटपुट: Toyota
# प्राइवेट विशेषता को एक्सेस करना (गेटर और सेटटर के माध्यम से)
print(car.get_model()) # आउटपुट: Corolla
car.set_model("Camry")
print(car.get_model()) # आउटपुट: Camry
गेटर्स और सेटर्स (Getters and Setters)
गेटर्स और सेटर्स प्राइवेट विशेषताओं को एक्सेस करने और संशोधित करने के लिए उपयोग की जाने वाली विधियाँ हैं। गेटर विधियाँ विशेषताओं के मान को प्राप्त करती हैं, जबकि सेटटर विधियाँ विशेषताओं के मान को सेट करती हैं।
उदाहरण:
class Employee:
def __init__(self, name, salary):
self.__name = name # प्राइवेट विशेषता
self.__salary = salary # प्राइवेट विशेषता
def get_name(self): # गेटर विधि
return self.__name
def set_name(self, name): # सेटटर विधि
self.__name = name
def get_salary(self): # गेटर विधि
return self.__salary
def set_salary(self, salary): # सेटटर विधि
self.__salary = salary
# ऑब्जेक्ट का निर्माण
emp = Employee("Alice", 50000)
# गेटर्स और सेटर्स का उपयोग
print(emp.get_name()) # आउटपुट: Alice
emp.set_name("Bob")
print(emp.get_name()) # आउटपुट: Bob
print(emp.get_salary()) # आउटपुट: 50000
emp.set_salary(60000)
print(emp.get_salary()) # आउटपुट: 60000
एब्स्ट्रैक्शन का परिचय (Introduction to Abstraction)
एब्स्ट्रैक्शन का उद्देश्य उपयोगकर्ताओं से जटिलताओं को छुपाना और केवल आवश्यक विवरण प्रस्तुत करना है। एब्स्ट्रैक्शन कक्षा के माध्यम से डेटा और विधियों को संक्षिप्त और संगठित बनाता है।
उदाहरण:
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
@abstractmethod
def perimeter(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def perimeter(self):
return 2 * (self.width + self.height)
एब्स्ट्रैक्ट कक्षाएँ (Abstract Classes)
एब्स्ट्रैक्ट कक्षा एक कक्षा है जो आंशिक रूप से कार्यान्वित होती है और इसे सबक्लास में पूर्ण किया जाना चाहिए। एब्स्ट्रैक्ट कक्षा को ABC (Abstract Base Class) से विरासत में लिया जाता है।
उदाहरण:
from abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
def sound(self):
pass
class Dog(Animal):
def sound(self):
return "Bark"
class Cat(Animal):
def sound(self):
return "Meow"
एब्स्ट्रैक्ट विधियाँ (Abstract Methods)
एब्स्ट्रैक्ट विधियाँ वे विधियाँ होती हैं जिन्हें एब्स्ट्रैक्ट कक्षा में परिभाषित किया जाता है लेकिन कार्यान्वित नहीं किया जाता। इन्हें सबक्लास में ओवरराइड और कार्यान्वित किया जाना चाहिए।
उदाहरण:
from abc import ABC, abstractmethod
class Vehicle(ABC):
@abstractmethod
def start_engine(self):
pass
class Car(Vehicle):
def start_engine(self):
print("Engine started")
class Bike(Vehicle):
def start_engine(self):
print("Bike engine started")
कोड का पुन: उपयोग (Code Reusability)
OOP के द्वारा, कक्षाएं और विधियाँ एक बार परिभाषित की जा सकती हैं और कई बार उपयोग की जा सकती हैं, जिससे कोड का पुन: उपयोग किया जा सकता है।
उदाहरण:
class Math:
def add(self, a, b):
return a + b
def multiply(self, a, b):
return a * b
math = Math()
print(math.add(3, 4)) # आउटपुट: 7
print(math.multiply(3, 4)) # आउटपुट: 12
कोड का संगठन (Code Organization)
OOP कोड को अधिक संगठित और संरचित बनाता है, जिससे कोड को पढ़ना, समझना, और बनाए रखना आसान होता है।
उदाहरण:
class Employee:
def __init__(self, name, position):
self.name = name
self.position = position
def display_info(self):
print(f"Name: {self.name}, Position: {self.position}")
कोड का विस्तार (Code Extensibility)
OOP के द्वारा, मौजूदा कक्षाओं को बिना संशोधित किए नई कक्षाओं को बना कर कोड का विस्तार किया जा सकता है।
उदाहरण:
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "Bark"
class Cat(Animal):
def speak(self):
return "Meow"
कोड का रखरखाव (Code Maintainability)
OOP कोड को अधिक संरचित और मॉड्यूलर बनाता है, जिससे कोड का रखरखाव और अद्यतन करना आसान होता है।
उदाहरण:
class BankAccount:
def __init__(self, balance):
self.balance = balance
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
account = BankAccount(1000)
account.deposit(500)
account.withdraw(200)
print(account.balance) # आउटपुट: 1300
DRY सिद्धांत (DRY Principle)
DRY (Don’t Repeat Yourself) सिद्धांत का मतलब है कि कोड को दोहराना नहीं चाहिए। प्रत्येक जानकारी और प्रक्रिया को कोड में केवल एक बार परिभाषित किया जाना चाहिए।
उदाहरण:
class Math:
def add(self, a, b):
return a + b
def multiply(self, a, b):
return a * b
math = Math()
print(math.add(3, 4)) # आउटपुट: 7
print(math.multiply(3, 4)) # आउटपुट: 12
सिंगल रेस्पॉन्सिबिलिटी प्रिंसिपल (Single Responsibility Principle)
सिंगल रेस्पॉन्सिबिलिटी प्रिंसिपल का मतलब है कि प्रत्येक कक्षा का केवल एक ही कारण होना चाहिए बदलने के लिए। कक्षाओं को केवल एक ही काम करना चाहिए।
उदाहरण:
class User:
def __init__(self, name, email):
self.name = name
self.email = email
def display_user(self):
print(f"Name: {self.name}, Email: {self.email}")
SOLID सिद्धांत (SOLID Principles)
SOLID सिद्धांत OOP के पांच महत्वपूर्ण सिद्धांतों का एक समूह है, जो कोड को अधिक संरचित और रखरखाव योग्य बनाते हैं।
उदाहरण:
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
class Square(Rectangle):
def __init__(self, side):
super().__init__(side, side)
रियल-वर्ल्ड उदाहरण (Real-World Examples)
OOP का उपयोग विभिन्न वास्तविक दुनिया की समस्याओं को हल करने के लिए किया जा सकता है।
उदाहरण:
class BankAccount:
def __init__(self, account_number, balance):
self.account_number = account_number
self.balance = balance
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
account = BankAccount("123456", 1000)
account.deposit(500)
account.withdraw(200)
print(account.balance) # आउटपुट: 1300
पाइथन कोड उदाहरण (Python Code Examples)
OOP के विभिन्न सिद्धांतों और प्रथाओं को पाइथन कोड के माध्यम से समझाया जा सकता है।
उदाहरण:
class Employee:
def __init__(self, name, position):
self.name = name
self.position = position
def display_info(self):
print(f"Name: {self.name}, Position: {self.position}")
class Manager(Employee):
def __init__(self, name, position, department):
super().__init__(name, position)
self.department = department
def display_info(self):
super().display_info()
print(f"Department: {self.department}")
# ऑब्जेक्ट्स का निर्माण
emp = Employee("Alice", "Developer")
mgr = Manager("Bob", "Manager", "IT")
emp.display_info()
# आउटपुट:
# Name: Alice, Position: Developer
mgr.display_info()
# आउटपुट:
# Name: Bob, Position: Manager
# Department: IT
