Python में क्लास और ऑब्जेक्ट कैसे काम करते हैं?

Question

Accepted Answer

एक **क्लास** **ऑब्जेक्ट** (उदाहरण) बनाने के लिए एक ब्लूप्रिंट है जो डेटा (विशेषताएँ) और व्यवहार (विधियों) को बंडल करता है। Python का OOP लचीला है और इसमें कुछ विशिष्ट परंपराएँ हैं, विशेष रूप से स्पष्ट `self`.

## क्लास को परिभाषित करना

```python
class Dog:
    species = "Canis familiaris"     # CLASS attribute (shared by all instances)

def __init__(self, name, age):   # the constructor — runs on creation
        self.name = name              # INSTANCE attributes (per object)
        self.age = age

def bark(self):                   # a method — `self` is the instance
        return f"{self.name} says woof"

d = Dog("Rex", 3)        # create an instance (calls __init__)
d.name                   # "Rex"
d.bark()                 # "Rex says woof"
```

## स्पष्ट self

```python
def bark(self):          # `self` is ALWAYS the first parameter of a method
    return self.name      # access instance data through self
```

अंतर्निहित `this` वाली कई भाषाओं के विपरीत, Python हर उदाहरण विधि के पहले स्पष्ट पैरामीटर के रूप में **`self`** की आवश्यकता है — यह उदाहरण को संदर्भित करता है जिस पर विधि को बुलाया जाता है। आप इसे मैन्युअल रूप से पास नहीं करते हैं; `d.bark()` स्वचालित रूप से `d` को `self` के रूप में पास करता है।

## क्लास बनाम उदाहरण विशेषताएँ

```python
Dog.species          # "Canis familiaris" — shared by all dogs
d.species            # also accessible from an instance
d.name               # "Rex" — unique to this instance
```

क्लास विशेषताएँ सभी उदाहरणों में साझा की जाती हैं; उदाहरण विशेषताएँ (`self.x =` के माध्यम से सेट) प्रति-ऑब्जेक्ट हैं।

## विधि प्रकार

```python
class Circle:
    def area(self): ...                    # instance method — needs self

@classmethod
    def from_diameter(cls, d):             # class method — receives the CLASS (cls)
        return cls(d / 2)                   # often used as alternative constructors

@staticmethod
    def pi(): return 3.14159               # static — no self/cls, just namespaced
```

## Encapsulation सम्मेलन

```python
self.public                # public
self._protected            # "internal use" by convention (not enforced)
self.__private             # name-mangled to _ClassName__private (stronger hiding)
```

Python के पास कोई वास्तविक निजी सदस्य नहीं हैं — अग्रणी अंडरस्कोर परंपराएँ हैं जो इरादे का संकेत देती हैं ("इससे दूर रहें"), कठोर प्रवर्तन नहीं।

## यह क्यों महत्वपूर्ण है

क्लास वह तरीका है जिससे आप Python में संस्थाओं को मॉडल करते हैं और कोड को व्यवस्थित करते हैं — संबंधित डेटा और व्यवहार को बंडल करते हुए, जिनका उपयोग ढांचे, डोमेन मॉडलिंग और बड़े अनुप्रयोगों में व्यापक रूप से किया जाता है।

विशिष्ट Python परंपराओं को समझना — स्पष्ट `self`, `__init__` निर्माता, क्लास बनाम उदाहरण विशेषताएँ, तीन विधि प्रकार (`instance`/`@classmethod`/`@staticmethod`), और अंडरस्कोर गोपनीयता परंपराएँ — object-oriented Python लिखने और पढ़ने के लिए आवश्यक है।

ये अन्य भाषाओं से काफी अलग हैं (स्पष्ट self, सम्मेलन-आधारित गोपनीयता) कि उन्हें अच्छी तरह से जानना सामान्य भ्रम को रोकता है।