Классы в Python: __init__, self, методы, наследование и dataclasses

Класс оборачивает данные и то, что ты с ними делаешь

Класс позволяет определить тип сущности - пользователя, банковский счёт, конфигурацию, запрос - и всё, что эта сущность умеет. Сама сущность - экземпляр класса. Действия называются методами.

Простейший возможный класс:

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)

Разбираем:

• class User: открывает определение класса. Имена классов по соглашению в PascalCase.
• __init__ - инициализатор. Он вызывается автоматически при создании нового экземпляра и задаёт атрибуты через self.whatever = ....
• greet - метод. self - то, через что метод обращается к экземпляру, на котором его позвали.
• User("Rosa", "rosa@example.com") создаёт экземпляр. Python вызывает __init__ с self, равным новому экземпляру, и остальными аргументами.
• user.greet() вызывает метод. Python передаёт user как self автоматически.

self - просто первый аргумент

self - не ключевое слово. Это имя, которое Python даёт первому параметру методов экземпляра, - самого экземпляра, на котором метод работает. Формально можно назвать как угодно; все используют self, потому что все используют self.

Каждый метод экземпляра берёт self первым параметром. Так метод знает, из какого экземпляра читать и что менять.

Добавляем поведение

Методы умеют читать и изменять состояние:

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__ - ещё один специальный метод, хук «как мне показаться при печати». Хорошая реализация окупается во время отладки.

Атрибуты класса vs атрибуты экземпляра

Атрибуты, определённые в теле класса (вне __init__), делятся между всеми экземплярами. Атрибуты, присваиваемые self, - у каждого свои:

class Dog:
    species = "Canis familiaris"   # class attribute, shared

    def __init__(self, name):
        self.name = name           # instance attribute, per-dog

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

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

Dog.species = "Canis lupus familiaris"  # changes for every instance
print(a.species, b.species)

Используй атрибуты класса для по-настоящему общих значений - констант, счётчиков, конфигов. Всё, что специфично экземпляру, - в __init__.

Наследование

Класс может наследовать другой, получая его методы и атрибуты даром, и добавлять или переопределять по нужде:

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() даёт доступ к родителю - часто используется внутри __init__, чтобы инициализировать родительские атрибуты перед добавлением своих:

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)

Наследование полезно, но легко пере-использовать. Начинающий питонист часто тянется к нему, когда композиция - держать объект как атрибут - понятнее. Начинай с плоской структуры классов и вводи наследование только при настоящем отношении «is-a».

Dataclasses: более приятный дефолт для записей

Когда класс в основном нужен для пары атрибутов с нормальным равенством и репрезентацией, @dataclass избавляет от бойлерплейта:

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 handle equality automatically
print(p.x, p.y)

Сравни с ручной записью __init__, __repr__ и __eq__. Dataclass - правильный первый выбор, когда иначе ты написал бы class Thing только с __init__, проставляющим атрибуты.

Property: вычисляемые атрибуты

Иногда хочется «атрибут», который на самом деле вычисляется. @property делает это похожим на обращение к атрибуту:

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)       # called like an attribute, not c.area()

Используй property, когда ты написал бы obj.get_something(), - замена на property делает API естественнее. Не прячь за ним дорогие операции: пользователь ожидает, что обращение к атрибуту - быстрое.

Приватное по соглашению

В Python нет настоящей приватности. По соглашению атрибуты с ведущим подчёркиванием предполагаются приватными - читатель не должен трогать их снаружи класса:

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)

Имена с двойным подчёркиванием (__name) включают name mangling: к атрибуту добавляется имя класса. Это инструмент против коллизий при наследовании, а не защита.

Когда класс не нужен

Если у тебя просто набор связанных данных - сойдёт dataclass, обычный словарь или namedtuple. Если у тебя одна функция - ей не нужен класс-обёртка. Тянись к классам, когда у тебя и состояние, и поведение связаны вместе - особенно если будет много экземпляров одного рода.

Финальный пример

Маленький файло-подобный лог-буфер:

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

Обрати внимание на __len__ - ещё один магический метод. Его определение делает len(logger) работающим, потому что len(x) - это на самом деле вызов x.__len__(). В Python десятки таких хуков; подбирай по мере надобности.

Дальше: генераторы

Классы связывают данные и поведение. Следующая глава смотрит на другой вид абстракции - итерацию - начиная с генераторов: функций, которые выдают значения по одному, делая паузы между ними. Они прекрасно сочетаются с оператором with и контекстными менеджерами, которые встретим сразу после.