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, மரபு-ভিত্தியான தனியுரிமை) ஆகையால் அவற்றை நன்றாக அறிவது பொதுவான குழப்பத்தைத் தவிர்க்கிறது.