पायथन अपनी स्थापना के बाद से एक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा रही है। क्लासेस और ऑब्जेक्ट्स OOP के दो मुख्य बिल्डिंग ब्लॉक्स हैं।
क्लास परिभाषित करना
# सबसे सरल क्लास
class Vehicle:
pass # खाली बॉडी
# इंस्टेंस बनाना
v = Vehicle()
print(v) # <__main__.Vehicle object at 0x...>
मेथड्स और self पैरामीटर
क्लास के अंदर मेथड्स का पहला पैरामीटर self होता है (कन्वेंशन), जो इंस्टेंस को संदर्भित करता है।
class Vehicle:
def car(self):
color = 'Red'
return color
v = Vehicle()
print(v.car()) # Red
self क्यों अनिवार्य है?
class MyClass:
def my_method(self): # self आवश्यक
return 'Hello'
obj = MyClass()
print(obj.my_method()) # Hello - self ऑटोमेटिकली पास होता है
# यदि self हटा दें:
# def my_method(): # TypeError: my_method() takes 0 positional arguments but 1 was given
इंस्टेंस एट्रिब्यूट्स
ऑब्जेक्ट-विशिष्ट एट्रिब्यूट्स, आमतौर पर __init__ में परिभाषित:
import random
class MyClass:
def set_random_attrs(self):
self.attr1 = random.randint(1, 11)
self.attr2 = random.randint(1, 21)
obj = MyClass()
obj.set_random_attrs()
print(obj.attr1, obj.attr2) # प्रत्येक ऑब्जेक्ट के अलग मान
कंस्ट्रक्टर: __init__
ऑब्जेक्ट बनाते समय ऑटोमेटिकली कॉल होता है, एट्रिब्यूट्स इनिशियलाइज़ करता है।
पैरामीटराइज़्ड कंस्ट्रक्टर
class Employee:
def __init__(self, name):
self.name = name
def display(self):
print(f"कर्मचारी नाम: {self.name}")
emp1 = Employee("Zack")
emp2 = Employee("Rajesh")
emp3 = Employee("Tashleem")
emp3.display() # कर्मचारी नाम: Tashleem
emp1.display() # कर्मचारी नाम: Zack
डिफ़ॉल्ट पैरामीटर्स के साथ
class Rectangle:
def __init__(self, length, breadth, unit_cost=0):
self.length = length
self.breadth = breadth
self.unit_cost = unit_cost
def area(self):
return self.length * self.breadth
def cost(self):
return self.area() * self.unit_cost
r = Rectangle(160, 120, 2000)
print(f"क्षेत्रफल: {r.area()} सेमी²")
print(f"लागत: ₹{r.cost()}")
एनकैप्सुलेशन (डेटा छुपाना)
पायथन में नाम मंगलिंग (name mangling) द्वारा प्राइवेट एट्रिब्यूट्स: डबल अंडरस्कोर __ प्रीफिक्स।
class Product:
def __init__(self):
self.__max_price = 1000 # प्राइवेट (नाम मंगलिंग: _Product__max_price)
self.__min_price = 1
def sell_price(self):
print(f"अधिकतम: {self.__max_price}, न्यूनतम: {self.__min_price}")
def set_max_price(self, price):
if price > 0:
self.__max_price = price
def set_min_price(self, price):
if price > 0:
self.__min_price = price
prod = Product()
prod.sell_price() # अधिकतम: 1000, न्यूनतम: 1
prod.__max_price = 1500 # नया पब्लिक एट्रिब्यूट बनाता है, प्राइवेट नहीं बदलता!
prod.sell_price() # अधिकतम: 1000, न्यूनतम: 1
prod.set_max_price(1500) # सही तरीका
prod.sell_price() # अधिकतम: 1500, न्यूनतम: 1
नाम मंगलिंग प्रदर्शन
prod = Product() print(prod._Product__max_price) # 1000 - वास्तविक प्राइवेट एट्रिब्यूट एक्सेस prod._Product__max_price = 2000 # सीधा एक्सेस (अनुशंसित नहीं) prod.sell_price() # अधिकतम: 2000
इनहेरिटेंस
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} आवाज करता है")
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name)
self.breed = breed
def speak(self): # ओवरराइडिंग
print(f"{self.name} भौंकता है!")
class Cat(Animal):
def speak(self):
print(f"{self.name} म्याऊँ करता है!")
animals = [Dog("रॉकी", "लैब्राडोर"), Cat("व्हिस्कर्स", "सियामीज")]
for animal in animals:
animal.speak() # पॉलीमॉर्फिज्म
आउटपुट
रॉकी भौंकता है! व्हिस्कर्स म्याऊँ करता है!
क्लास एट्रिब्यूट्स vs इंस्टेंस एट्रिब्यूट्स
class Dog:
species = "Canis familiaris" # क्लास एट्रिब्यूट (सभी शेयर करते हैं)
def __init__(self, name):
self.name = name # इंस्टेंस एट्रिब्यूट (प्रत्येक का अपना)
d1 = Dog("बडी")
d2 = Dog("मैक्स")
print(d1.species) # Canis familiaris
print(d2.species) # Canis familiaris
print(d1.name) # बडी
print(d2.name) # मैक्स
# क्लास एट्रिब्यूट बदलें
Dog.species = "Canis lupus familiaris"
print(d1.species) # बदला हुआ
print(d2.species) # बदला हुआ
मैजिक/डंडर मेथड्स
| मेथड | उद्देश्य | उदाहरण |
|---|---|---|
__init__ | इनिशियलाइज़ेशन | obj = MyClass() |
__str__ | स्ट्रिंग प्रतिनिधित्व (प्रिंट) | print(obj) |
__repr__ | डेवलपर प्रतिनिधित्व | repr(obj) |
__len__ | लंबाई | len(obj) |
__getitem__ | इंडेक्सिंग | obj[key] |
__add__ | + ऑपरेटर | obj1 + obj2 |
__eq__ | == तुलना | obj1 == obj2 |
class Vector:
def __init__(self, x, y):
self.x, self.y = x, y
def __str__(self):
return f"Vector({self.x}, {self.y})"
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __len__(self):
return int((self.x**2 + self.y**2)**0.5)
v1 = Vector(3, 4)
v2 = Vector(1, 2)
print(v1) # Vector(3, 4)
print(v1 + v2) # Vector(4, 6)
print(len(v1)) # 5
प्रॉपर्टी डेकोरेटर
class Circle:
def __init__(self, radius):
self._radius = radius
@property
def radius(self):
return self._radius
@radius.setter
def radius(self, value):
if value >= 0:
self._radius = value
else:
raise ValueError("त्रिज्या ऋणात्मक नहीं हो सकती")
@property
def area(self):
return 3.14159 * self._radius ** 2
c = Circle(5)
print(c.radius) # 5
print(c.area) # 78.54
c.radius = 10
print(c.area) # 314.16
# c.radius = -1 # ValueError
सारांश
पायथन OOP प्रदान करता है: क्लासेस, इनहेरिटेंस, एनकैप्सुलेशन, पॉलीमॉर्फिज्म, मैजिक मेथड्स, प्रॉपर्टीज - सभी के साथ सरल, पठनीय सिंटैक्स।