W miarę rozrastania się skryptu kończy się przekazywanie tej samej grupy zmiennych między funkcjami i trudno jest określić, które dane należą do której logiki. Klasy i obiekty Pythona rozwiązują ten problem, łącząc dane i zachowania w jedną całość.

W tym samouczku krok po kroku budujemy małe konto bankowe i dodajemy każdy pomysł OOP tylko wtedy, gdy rozwiązuje problem. Każdy przykład uruchomiliśmy w Pythonie 3.13 i pokazane dane wyjściowe pochodzą z tego uruchomienia. Jeśli dopiero zaczynasz przygodę z tym językiem, przeczytaj najpierw nasz samouczek Pythona dla początkujących.

Czym są klasy i obiekty?

Klasa opisuje, czym coś jest i co może zrobić. obiekt, zwany także instancją, to konkretny obiekt utworzony na podstawie tego opisu. „Konto” to klasa, natomiast konto Ashy i konto Bena to dwa obiekty.

Przez cały czas używałeś przedmiotów. W Pythonie ciągi znaków, listy, a nawet funkcje są obiektami, dlatego możesz pisać "hello".upper().

Twoje pierwsze zajęcia

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

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount
        return self.balance

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ uruchamia się automatycznie za każdym razem, gdy tworzysz obiekt i ustawia stan początkowy. Depozyt w a nie dotyczył b, ponieważ każdy obiekt ma swoje własne dane. Należy zauważyć, że metoda ta chroni także wagę przed złą wartością. Nasz przewodnik po obsłudze wyjątków w Pythonie wyjaśnia raise bardziej szczegółowo.

Czym jest jaźń?

self to po prostu obiekt, nad którym pracuje metoda. Kiedy piszesz a.deposit(50), Python skutecznie wywołuje Account.deposit(a, 50), przekazując obiekt jako pierwszy argument. W ten sposób jedna definicja metody może obsłużyć każdy obiekt.

Nazwa self to silna konwencja, a nie słowo kluczowe, ale zawsze jej używaj. Zapomnienie o tym w definicji metody jest najczęstszym błędem początkujących i powoduje mylący komunikat dotyczący liczby argumentów.

Atrybuty klas a atrybuty instancji

Atrybut ustawiony bezpośrednio w treści klasy jest wspólny dla wszystkich obiektów. Jeden zestaw na self należy tylko do tego obiektu. Ten przykład pokazuje, jak zachowują się wyszukiwania:

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Ta ostatnia linijka zaskakuje ludzi. Przypisanie poprzez a nie zmieniło wspólnej wartości. Utworzono nowy atrybut instancji w a, który ukrywa klasę. Python najpierw patrzy na obiekt, a następnie na klasę.

Metody specjalne (dunder).

Metody z podwójnym podkreśleniem umożliwiają obiektom współpracę z wbudowanymi funkcjami Pythona. Bez nich wydruk konta pokazuje bezużyteczny adres pamięci. Dodanie dwóch daje czytelną formę:

    def __str__(self):
        return f"{self.owner}: {self.balance}"

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

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

Dziedziczenie

Dziedziczenie pozwala nowej klasie ponownie wykorzystać istniejącą i zmienić tylko to, co się różni. Tutaj Savings to Account z dodatkowym ustawieniem:

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() wywołuje wersję rodzica, więc logika konfiguracji nie jest powtarzana. deposit zostało odziedziczone w dotychczasowej postaci, a __str__ zostało zastąpione w celu dodania etykiety. Dziedziczenia używaj tylko w przypadku prawdziwej relacji „jest”. Jeśli klasa po prostu czegoś potrzebuje, na przykład samochodu wymagającego silnika, nadaj jej ten obiekt jako atrybut. Nazywa się to kompozycją i jest zwykle bardziej elastyczne niż głębokie łańcuchy dziedziczenia.

Polimorfizm

Polimorfizm oznacza, że różne obiekty mogą odpowiadać na to samo wywołanie metody na swój własny sposób. Kod wywołujący nie musi znać dokładnego typu:

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Te dwie klasy nie mają nawet wspólnego rodzica. Python dba tylko o to, aby obiekt miał metodę area, czyli podejście znane jako wpisywanie kaczek. Dodanie Triangle później nie wymagałoby żadnych zmian w pętli.

Hermetyzacja i właściwości

Python nie ma prawdziwie prywatnych atrybutów i zamiast tego opiera się na konwencjach. Pojedyncze podkreślenie, jak w _price, mówi innym programistom „to sprawa wewnętrzna, proszę nie dotykać”. Aby sprawdzić wartości po ich ustawieniu, użyj właściwości, która z zewnątrz wygląda jak zwykły atrybut:

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Oznacza to, że możesz zacząć od zwykłego atrybutu i później dodać weryfikację bez zmiany kodu korzystającego z tej klasy. Nie pisz więc z przyzwyczajenia metod get_price() i set_price(), jak w Javie. Składnia @ to dekorator, który wyjaśnimy w Wyjaśnienie dekoratorów Pythona.

Metody klasowe i metody statyczne

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Klasy danych

Kiedy klasa przechowuje głównie dane, ręczne pisanie __init__, __repr__ i __eq__ jest uciążliwe. @dataclass generuje je na podstawie adnotacji typu:

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Typowe błędy

Używanie modyfikowalnego atrybutu klasy

To klasyczny błąd. Lista jest zdefiniowana w klasie, więc wszystkie wózki ją udostępniają:

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Utwórz go w __init__ za pomocą self.items = [], aby każdy obiekt otrzymał własną listę.

Inne typowe błędy

• Zapominanie self. Wpisz self.balance, a nie balance, metody wewnętrzne.
• Zapominanie super().__init__(). Dziecko wówczas pomija atrybuty ustawione przez rodzica.
• Budowanie ogromnych klas. Trudno przetestować klasę, która robi wszystko. Podziel to według odpowiedzialności.
• Głębokie dziedziczenie. Dwa poziomy zwykle wystarczą, a kompozycja jest często wyraźniejsza.
• Nie piszę testów. Zajęcia z regułami są łatwe do przetestowania, jak pokazuje nasz samouczek dotyczący testów Pythona przy użyciu małego wózka.

Podsumowanie

Python zorientowany obiektowo sprowadza się do grupowania danych według zachowania, które je chroni. Zacznij od __init__, metod i __str__, a następnie dodaj dziedziczenie i właściwości, gdy trafisz na problem, który rozwiązują. Następnym krokiem będzie skrypt przekazujący wszędzie te same zmienne i zamień je w jedną małą klasę.

Najczęstsze pytania

Ucz się dalej