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`గా పంపుతుంది.

## క్లాస్ లక్షణాలు vs ఉదాహరణ లక్షణాలు

```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
```

## ఎన్‌క్యాప్సులేషన్ సంప్రదాయాలు

```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`), మరియు అండర్‌స్కోర్ గోప్యతా సంప్రదాయాలు — ఆబ్జెక్ట్-ఆధారిత Python ను రాయడానికి మరియు చదవడానికి చాలా ముఖ్యం.

ఇవి ఇతర భాషల నుండి సరిపోతాయి (స్పష్ట self, సంప్రదాయ-ఆధారిత గోప్యత) ఆ విధంగా వాటిని బాగా చేතిలో ఉంచడం సాధారణ గందరగోళాన్ని నిరోధిస్తుంది.