Kaip Python veikia klasės ir objektai?

Question

Accepted Answer

**Klasė** yra šablonas **objektams** (instancijoms) kurti, kuriuose sujungiami duomenys (atributai) ir elgsena (metodai). Python OOP yra lanksti ir turi kai kurias būdingus susitarimus, ypač aiškų `self`.

## Klasės apibrėžimas

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

## Aiškus self

```python
def bark(self):          # `self` is ALWAYS the first parameter of a method
    return self.name      # access instance data through self
```

Skirtingai nuo daugelio kalbų su nuomatuotu `this`, Python reikalauja **`self`** kaip aiškią kiekvieno egzemplioriaus metodo pirmąjį parametrą — jis nurodo egzempliorių, kuriam yra iškviečiamas metodas. Jūs negalite jo perduoti rankiniu būdu; `d.bark()` automatiškai perduoda `d` kaip `self`.

## Klasės ir egzemplioriaus atributai

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

Klasės atributai yra bendrinti visose instancijose; egzemplioriaus atributai (nustatyti per `self.x =`) yra atskiram objektui.

## Metodų tipai

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

## Zapakavimo susitarimai

```python
self.public                # public
self._protected            # "internal use" by convention (not enforced)
self.__private             # name-mangled to _ClassName__private (stronger hiding)
```

Python neturi tikrų privačių narių — vedantys pabraukimai yra susitarimai, kurie žymi ketinimą ("nelieskite to"), o ne griežtas įgyvendinimas.

## Kodėl tai svarbu

Klasės yra tai, kaip jūs modeliuojate objektus ir organizuojate kodą objektiškai orientuotoje Python — sujungdami susijusius duomenis ir elgseną, plačiai naudojamas struktūrose, domeno modeliavime ir didelėse programose.

Supratimas apie būdingus Python susitarimus — aiškų `self`, `__init__` konstruktorių, klasės ir egzemplioriaus atributus, tris metodų tipus (`instance`/`@classmethod`/`@staticmethod`) ir pabraukimo privatumo susitarimus — yra būtinas norint rašyti ir skaityti objektiškai orientuotą Python.

Šie dalykai gana skiriasi nuo kitų kalbų (aiškus self, susitarimo pagrįstas privatumas), todėl gerai juos žinant išvengiama įprasto painiojimo.