Jak działają klasy i obiekty w Pythonie?

Question

Accepted Answer

**Klasa** to szablon do tworzenia **obiektów** (instancji), które łączą dane (atrybuty) i zachowanie (metody). Programowanie obiektowe w Pythonie jest elastyczne i ma kilka charakterystycznych konwencji, szczególnie jawny `self`.

## Dlaczego to ważne

Klasy to sposób, w jaki modelujesz jednostki i organizujesz kod w obiektowym Pythonie — łącząc powiązane dane i zachowanie, szeroko stosowane w frameworkach, modelowaniu domenowym i dużych aplikacjach.

Zrozumienie charakterystycznych konwencji Pythona — jawnego `self`, konstruktora `__init__`, atrybutów klasy a instancji, trzech typów metod (`instance`/`@classmethod`/`@staticmethod`) i konwencji prywatności ze znakiem podkreślenia — jest niezbędne do pisania i czytania obiektowego Pythona.

Różnią się one na tyle od innych języków (jawny self, prywatność oparta na konwencjach), że dobra znajomość ich zapobiega powszechnym nieporozumieniom.

## Definowanie klasy

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

## Jawny self

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

W przeciwieństwie do wielu języków z niejawnym `this`, Python wymaga **`self`** jako jawnego pierwszego parametru każdej metody instancji — odnosi się do instancji, na której metoda jest wywoływana. Nie przekazujesz go ręcznie; `d.bark()` automatycznie przekazuje `d` jako `self`.

## Atrybuty klasy a atrybuty instancji

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

Atrybuty klasy są wspólne dla wszystkich instancji; atrybuty instancji (ustawiane via `self.x =`) są dla każdego obiektu.

## Typy metod

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

## Konwencje enkapsulacji

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

Python nie ma prawdziwych prywatnych członków — wiodące podkreślenia to konwencje sygnalizujące intencję ("nie dotykaj tego"), a nie twarda egzekwucja.