Python मध्ये क्लास आणि ऑब्जेक्ट कसे काम करतात?

Question

Accepted Answer

A **class** हे **objects** (instances) तयार करण्यासाठी एक ब्लूप्रिंट आहे जे डेटा (attributes) आणि वर्तन (methods) एकत्र करते. 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 हे प्रत्येक instance method च्या स्पष्ट प्रथम पॅरामीटर म्हणून **`self`** आवश्यक आहे — हे method कॉल केलेल्या instance ला संदर्भित करते. आपण हे स्वयंपाक पारगमन करत नाही; `d.bark()` स्वयंचलितपणे `d` ला `self` म्हणून पारगमन करते.

## क्लास विरुद्ध instance attributes

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

क्लास attributes सर्व instances मध्ये सामायिक आहेत; instance attributes (`self.x =` द्वारे सेट केलेले) प्रति-ऑब्जेक्ट आहेत.

## Method प्रकार

```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 मध्ये कोणतेही खरे private सदस्य नाहीत — अग्रणी underscores हे संमेलने आहेत जे हेतू दर्शवितात ("हे स्पर्श करू नका"), कठोर अंमलबजावणी नाही.

## हे महत्वाचे का आहे

क्लास हे असे आहे की आपण ऑब्जेक्ट-ओरिएंटेड Python मध्ये संस्थाएं मॉडेल करता आणि कोड संघटित करता — संबंधित डेटा आणि वर्तन बंडल करा, frameworks, domain modeling, आणि मोठ्या अनुप्रयोगांमध्ये मोठ्या प्रमाणावर वापरले जाते.

Python च्या विशिष्ट संमेलनांची समज — स्पष्ट `self`, `__init__` constructor, क्लास विरुद्ध instance attributes, तीन method प्रकार (`instance`/`@classmethod`/`@staticmethod`), आणि underscore privacy संमेलने — object-oriented Python लिहिण्यासाठी आणि वाचण्यासाठी आवश्यक आहे.

हे इतर भाषांपेक्षा पुरेसे वेगळे आहेत (स्पष्ट self, संमेलन-आधारित privacy) जेणेकरून त्यांची चांगली समज सामान्य गोंधळ टाळते.