Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

पायथन में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP)

पायथन अपनी स्थापना के बाद से एक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा रही है। क्लासेस और ऑब्जेक्ट्स 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 प्रदान करता है: क्लासेस, इनहेरिटेंस, एनकैप्सुलेशन, पॉलीमॉर्फिज्म, मैजिक मेथड्स, प्रॉपर्टीज - सभी के साथ सरल, पठनीय सिंटैक्स।

  1. Python में मेटाक्लास के साथ मेटाप्रोग्रामिंग Python में मेटाक्लास के साथ मेटाप्रोग्रामिंग

    मेटाप्रोग्रामिंग शब्द उस कंप्यूटर प्रोग्रामिंग को संदर्भित करता है जहां कंप्यूटर प्रोग्राम स्वयं को हेरफेर करने या उसके बारे में ज्ञान रखने का प्रयास करते हैं। Python मेटाक्लास नामक एक नए प्रकार के क्लास के माध्यम से क्लास के लिए मेटाप्रोग्रामिंग का समर्थन करता है। Python में मेटाक्लास के माध्यम स

  1. - Python ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में repr() फंक्शन क्या करता है?

    आधिकारिक Python डॉक्यूमेंटेशन के अनुसार, __repr__() किसी ऑब्जेक्ट का आधिकारिक स्ट्रिंग रिप्रेजेंटेशन कंप्यूट करने के लिए उपयोग किया जाता है। repr() बिल्ट-इन फंक्शन ऑब्जेक्ट प्रदर्शित करने के लिए __repr__() का उपयोग करता है। __repr__() ऑब्जेक्ट का प्रिंटेबल रिप्रेजेंटेशन लौटाता है, इस ऑब्जेक्ट को बना

  1. - Python में ऑब्जेक्ट-ओरिएंटेड कॉन्सेप्ट्स को संक्षेप में समझाएं

    Python में OOP कॉन्सेप्ट्स Python एक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा है। हम Python में आसानी से क्लासेस और ऑब्जेक्ट्स बना और उपयोग कर सकते हैं। Python प्रोग्रामिंग भाषा के प्रमुख ऑब्जेक्ट-ओरिएंटेड कॉन्सेप्ट्स नीचे दिए गए हैं: ऑब्जेक्ट क्लास मेथड इनहेरिटेंस पॉलीमॉर्फिज्म डेटा एब्स्ट्रैक्शन एनकैप