Klasy w Pythonie: __init__, self, metody, dziedziczenie i dataclasses

Klasa łączy dane i to, co z nimi robisz

Klasa pozwala zdefiniować rodzaj rzeczy (użytkownika, konto bankowe, konfigurację, żądanie) oraz wszystko, co ta rzecz powinna umieć. Rzecz to instancja klasy. Działania nazywa się metodami.

Oto najprostsza możliwa klasa:

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def greet(self):
        print(f"Hi, I'm {self.name}. Reach me at {self.email}.")

user = User("Rosa", "rosa@example.com")
user.greet()

print(user.name)
print(user.email)

Po kolei:

• class User: rozpoczyna definicję klasy. Nazwy klas zapisuje się zwyczajowo w PascalCase.
• __init__ to inicjalizator. Uruchamia się automatycznie, gdy tworzysz nową instancję. Ustawia atrybuty instancji przez self.whatever = ....
• greet to metoda. Przez self metoda odwołuje się do instancji, na której ją wywołano.
• User("Rosa", "rosa@example.com") tworzy instancję. Python wywołuje __init__, ustawiając self na nową instancję i przekazując pozostałe argumenty.
• user.greet() wywołuje metodę. Python automatycznie przekazuje user jako self.

self to po prostu pierwszy argument

self nie jest słowem kluczowym. To nazwa, jaką nadaje się pierwszemu parametrowi metod instancji, czyli instancji, na której działa metoda. Nazwę można wybrać dowolnie, ale wszyscy używają self, bo tak robią wszyscy.

Każda metoda instancji przyjmuje self jako pierwszy parametr. Dzięki temu metoda wie, z której instancji czytać i którą modyfikować.

Dodawanie zachowania

Metody mogą odczytywać i zmieniać stan:

class BankAccount:
    def __init__(self, owner, opening_balance=0):
        self.owner = owner
        self.balance = opening_balance

    def deposit(self, amount):
        self.balance += amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount

    def __repr__(self):
        return f"BankAccount(owner={self.owner!r}, balance={self.balance})"

a = BankAccount("Rosa", 100)
a.deposit(50)
a.withdraw(30)
print(a)

__repr__ to kolejna metoda specjalna: punkt zaczepienia typu "jak pokazać ten obiekt przy wypisywaniu?". Dobra definicja bardzo się opłaca podczas debugowania.

Atrybuty klasy a atrybuty instancji

Atrybuty zdefiniowane w ciele klasy (poza __init__) są wspólne dla wszystkich instancji. Atrybuty przypisane do self należą do pojedynczej instancji:

class Dog:
    species = "Canis familiaris"   # atrybut klasy, wspólny

    def __init__(self, name):
        self.name = name           # atrybut instancji, osobny dla każdego psa

a = Dog("Rex")
b = Dog("Luna")

print(a.species, a.name)
print(b.species, b.name)

Dog.species = "Canis lupus familiaris"  # zmienia się dla każdej instancji
print(a.species, b.species)

Atrybutów klasy używaj do wartości naprawdę wspólnych: stałych, liczników, konfiguracji. Dane konkretnej instancji umieszczaj w __init__.

Dziedziczenie

Klasa może dziedziczyć po innej klasie, dostając za darmo jej metody i atrybuty oraz dodając lub nadpisując to, co trzeba:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} barks.")

class Cat(Animal):
    def speak(self):
        print(f"{self.name} meows.")

rex = Dog("Rex")
luna = Cat("Luna")
rex.speak()
luna.speak()

super() daje dostęp do klasy nadrzędnej. Często używa się go w __init__, by zainicjalizować atrybuty rodzica przed dodaniem własnych:

class Animal:
    def __init__(self, name):
        self.name = name

class LabeledDog(Animal):
    def __init__(self, name, tag_number):
        super().__init__(name)
        self.tag_number = tag_number

d = LabeledDog("Rex", tag_number=42)
print(d.name, d.tag_number)

Dziedziczenie jest przydatne, ale łatwo go nadużyć. Początkujący programiści Pythona często sięgają po dziedziczenie tam, gdzie kompozycja (przechowywanie obiektu jako atrybutu) byłaby czytelniejsza. Zacznij od płaskiej struktury klas, a dziedziczenie wprowadzaj dopiero przy prawdziwej relacji "jest rodzajem".

Strona o dziedziczeniu w Pythonie idzie dalej: rozszerzanie metody rodzica przez super(), isinstance i issubclass, abstrakcyjne klasy bazowe, wielodziedziczenie i kolejność rozwiązywania metod.

Dataclasses: wygodniejszy wybór dla rekordów

Gdy klasa ma głównie przechowywać kilka atrybutów z porównywaniem i czytelną reprezentacją, @dataclass oszczędza mnóstwo powtarzalnego kodu:

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

p = Point(3.0, 4.0)
q = Point(3.0, 4.0)

print(p)
print(p == q)     # True, dataclasses same obsługują porównywanie
print(p.x, p.y)

Porównaj to z ręcznym pisaniem __init__, __repr__ i __eq__. Dataclasses to właściwy pierwszy wybór, gdy alternatywą jest class Thing, w której jest tylko __init__ ustawiający atrybuty.

Właściwości: atrybuty obliczane

Czasem chcesz "atrybutu", który tak naprawdę jest obliczany. @property sprawia, że wygląda to jak zwykły dostęp do atrybutu:

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def area(self):
        return 3.14159 * self.radius ** 2

c = Circle(5)
print(c.area)       # wywoływane jak atrybut, a nie c.area()

Używaj właściwości tam, gdzie pojawiłoby się obj.get_something(): zamiana na właściwość sprawia, że API jest bardziej naturalne. Nie ukrywaj za nimi kosztownych operacji, bo użytkownik oczekuje, że dostęp do atrybutu jest szybki.

Prywatne umownie

Python nie ma prawdziwej prywatności. Umownie atrybuty zaczynające się od podkreślenia są przeznaczone do użytku wewnętrznego, a czytelnicy nie powinni ich ruszać spoza klasy:

class Cache:
    def __init__(self):
        self._store = {}

    def put(self, key, value):
        self._store[key] = value

    def get(self, key, default=None):
        return self._store.get(key, default)

Nazwy z podwójnym podkreśleniem (__name) włączają name mangling, które dokleja nazwę klasy do atrybutu. To narzędzie do unikania kolizji przy dziedziczeniu, a nie zabezpieczenie.

Kiedy nie używać klasy

Jeśli masz tylko zestaw powiązanych danych, wystarczy dataclass, zwykły słownik albo named tuple. Jeśli masz tylko jedną funkcję, nie potrzebuje ona klasy. Po klasy sięgaj, gdy masz jednocześnie stan i zachowanie, które są ze sobą związane, zwłaszcza gdy będziesz mieć wiele instancji tego samego rodzaju.

Przykład na koniec

Mały bufor logów przypominający plik:

from datetime import datetime

class Logger:
    def __init__(self, name):
        self.name = name
        self._entries = []

    def log(self, message):
        timestamp = datetime.now().strftime("%H:%M:%S")
        self._entries.append(f"[{timestamp}] {self.name}: {message}")

    def dump(self):
        return "\n".join(self._entries)

    def __len__(self):
        return len(self._entries)

logger = Logger("api")
logger.log("starting")
logger.log("ready")
logger.log("shutting down")

print(logger.dump())
print(len(logger))

Zwróć uwagę na __len__, kolejną metodę magiczną. Jej zdefiniowanie sprawia, że działa len(logger), bo len(x) to w rzeczywistości wywołanie x.__len__(). Python ma dziesiątki takich punktów zaczepienia, a poznasz je, gdy będą potrzebne.