ਪਾਈਥਨ ਵਿੱਚ ਕਲਾਸਾਂ ਅਤੇ ਆਬਜੈਕਟ ਕਿਵੇਂ ਕਾਰ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

ਇੱਕ **ਕਲਾਸ** ਇੱਕ ਬਲੂਪ੍ਰਿੰਟ ਹੈ **ਆਬਜੈਕਟ** (ਇਨਸਟੈਂਸਾਂ) ਨੂੰ ਬਣਾਉਣ ਲਈ ਜੋ ਡੇਟਾ (ਐਟ੍ਰਿਬਿਊਟਸ) ਅਤੇ ਵਿਵਹਾਰ (ਮੈਥਡਸ) ਨੂੰ ਬੰਡਲ ਕਰਦੇ ਹਨ। ਪਾਈਥਨ ਦਾ 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` ਹੈ, ਪਾਈਥਨ ਨੂੰ **`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)
```

ਪਾਈਥਨ ਦੇ ਕੋਲ ਕੋਈ ਸੱਚੀ ਪ੍ਰਾਈਵੇਟ ਮੈਂਬਰਾਂ ਨਹੀਂ ਹਨ — ਮੁਖੀ ਅੰਡਰਸਕੋਰ ਪ੍ਰਥਾਵਾਂ ਹਨ ਜੋ ਇਰਾਦੇ ਨਾ ਦਿਉਣ ਵਾਲੇ ਹਨ ("ਇਸ ਨੂੰ ਛੱਡ ਦਿਓ"), ਸਖ਼ਤ ਪ੍ਰਵਰਤਨ ਨਹੀਂ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਕਲਾਸਾਂ ਉਹ ਹਨ ਜਿਸ ਦੁਆਰਾ ਤੁਸੀਂ ਔਬਜੈਕਟ-ਮੁਖੀ ਪਾਈਥਨ ਵਿੱਚ ਇਕਾਈਆਂ ਨੂੰ ਮਾਡਲ ਕਰਦੇ ਹੋ ਅਤੇ ਕੋਡ ਨੂੰ ਸੰਗਠਿਤ ਕਰਦੇ ਹੋ — ਸੰਬੰਧਿਤ ਡੇਟਾ ਅਤੇ ਵਿਵਹਾਰ ਨੂੰ ਬੰਡਲ ਕਰਕੇ, frameworks, ਡੋਮੇਨ ਮਾਡਲਿੰਗ, ਅਤੇ ਵੱਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਪਾਈਥਨ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ ਪ੍ਰਥਾਵਾਂ ਨੂੰ ਸਮਝਨਾ — ਸਪੱਸ਼ਟ `self`, `__init__` ਕਨਸਟਰਕਟਰ, ਕਲਾਸ ਬਨਾਮ ਇਨਸਟੈਂਸ ਐਟ੍ਰਿਬਿਊਟਸ, ਤਿੰਨ ਮੈਥਡ ਕਿਸਮਾਂ (`instance`/`@classmethod`/`@staticmethod`), ਅਤੇ ਅੰਡਰਸਕੋਰ ਪ੍ਰਾਈਵੇਟ ਪ੍ਰਥਾਵਾਂ — ਔਬਜੈਕਟ-ਮੁਖੀ ਪਾਈਥਨ ਲਿਖਣ ਅਤੇ ਪੜ੍ਹਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਇਹ ਦੂਸਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਕਾਫ਼ੀ ਵੱਖਰੇ ਹਨ (ਸਪੱਸ਼ਟ self, ਪ੍ਰਥਾ-ਅਧਾਰਤ ਪ੍ਰਾਈਵੇਟ) ਕਿ ਉਨ੍ਹਾਂ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਣਨਾ ਆਮ ਦਿੱਸ ਭ੍ਰਮ ਨੂੰ ਰੋਕਦਾ ਹੈ।