როგორ მუშაობს კლასები და ობიექტები 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 საჭიროებს **`self`**-ს, როგორც ყოველი instance method-ის აშკარა პირველი პარამეტრი — ეს მიუთითებს ინსტანციაზე, რომელზეც method გამოიძახება. თქვენ ხელით არ გადაცემთ მას; `d.bark()` თავისთავად გადაცემს `d`-ს როგორც `self`.

## კლასის attribute-ები მეთ instance attribute-ები

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

კლასის attribute-ები გაზიარებული ყველა 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__` კონსტრუქტორი, კლასის attribute-ები მეთ instance attributes, სამი method ტიპი (`instance`/`@classmethod`/`@staticmethod`) და underscore privacy კონვენციები — აუცილებელია ობიექტ-ორიენტირებული Python-ის ჩაწერისა და წაკითხვისთვის.

ეს საკმაოდ განსხვავდება სხვა ენებისგან (აშკარა self, კონვენცია-ზე დაფუძნებული privacy), ამიტომ მათი კარგი გაგება თავიდან აცილებს ჩვეულებრივ დაბნეულობას.