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 માં entity મોડેલ કરો અને કોડ ગોઠવો — સંબંધિત ડેટા અને વર્તન ને બાંધીને, જે ફ્રેમવર્ક, ડોમેન મોડેલિંગ અને વિશાળ અપ્લિકેશનમાં વ્યાપકપણે ઉપયોગ થાય છે.

વિશિષ્ટ Python સંમેલનોને સમજવું — સ્પષ્ટ `self`, `__init__` કન્સ્ટ્રક્ટર, વર્ગ વિ દાખલો લક્ષણો, ત્રણ પદ્ધતિ પ્રકારો (`instance`/`@classmethod`/`@staticmethod`), અને અંડરસ્કોર ગોપનીયતા સંમેલનો — object-oriented Python લખવા અને વાંચવા માટે આવશ્યક છે.

તેઓ અન્ય ભાષાઓથી પૂરતી અલગ છે (સ્પષ્ટ self, સંમેલન-આધારિત ગોપનીયતા) કે તેમને સારીથી જાણવો સામાન્ય મોહની રોકે છે.