Hogyan működnek az osztályok és objektumok a Pythonban?

Question

Accepted Answer

Az **osztály** egy tervrajz **objektumok** (példányok) létrehozásához, amely adatokat (attribútumok) és viselkedést (metódusok) köt össze. A Python OOP rugalmas és van néhány jellegzetes konvenciója, különösen az explicit `self`.

## Osztály definiálása

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

## Az explicit self

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

Sok nyelvtől eltérően, amelyeknek van implicit `this`, a Python az **`self`** paramétert igényli az összes instance metódus első explicit paramétereként — az instance-ra utal, amelyen a metódus meghívódik. Nem adja át manuálisan; a `d.bark()` automatikusan átadja a `d`-t `self`-ként.

## Osztály vs instance attribútumok

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

Az osztály attribútumok az összes instance között megosztottak; az instance attribútumok (`self.x =` által beállítva) objektumonkénti jellegűek.

## Metódus típusok

```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 konvenciók

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

A Pythonnak nincsenek valódi privát tagjai — a vezető aláhúzások konvenciók, amelyek szándékot jeleznek ("ne nyúlj ehhez"), nem pedig merev érvényre.

## Miért fontos

Az osztályok az a módszer, ahogy az entitásokat modellezed és a kódot szervezed az objektumorientált Pythonban — a kapcsolódó adatokat és viselkedéseket köt össze, amelyeket széles körben használnak keretrendszerekben, tartományi modellezésben és nagyobb alkalmazásokban.

A jellegzetes Python konvenciók megértése — az explicit `self`, a `__init__` konstruktor, az osztály vs instance attribútumok, a három metódus típus (`instance`/`@classmethod`/`@staticmethod`) és az aláhúzás alapú privát konvenciók — elengedhetetlen az objektumorientált Python írásához és olvasásához.

Ezek elég nagyban térnek el más nyelvektől (explicit self, konvenció alapú privátság), hogy ezen jól ismert lét megelőzi a gyakori félreértéseket.