Классы и ООП: self — это аргумент, а атрибут класса — один на всех

На чём проверено: весь вывод в уроке — прогоны bench/oop/basics.py и bench/oop/practice.py на CPython 3.11.15, 3.12.3, 3.13.7 и 3.14.7, linux/amd64; блоки в тексте — запись на 3.13.7, расхождения версий — в «Истории версий». Цитаты документации сверены 14.10.2026. На эту дату вышел Python 3.15 (9 октября 2026); урок на нём не запускался.

База: класс — это объект с общими атрибутами

Класс объявляют так. Полный файл — импорты не нужны; запуск: python3 greeter.py.

class Greeter:
    def __init__(self, name):
        self.name = name
 
    def hello(self):
        return f"привет, {self.name}"
 
a = Greeter("Аня")
print(a.hello())        # привет, Аня

Greeter("Аня") создаёт экземпляр и вызывает у него __init__, который кладёт в экземпляр атрибут name. Метод hello лежит в классе, один на все экземпляры, а данные — name — в каждом экземпляре свои.

Ответ уровня Junior на «что такое класс»: класс описывает данные и поведение; данные лежат в экземплярах, поведение — методы — в классе, общее для всех. self — ссылка на экземпляр, с которым работает метод. Это верно, но за этим ответом сразу спрашивают, откуда берётся self и что будет, если положить данные не в экземпляр, а в класс. Об этом — механизмы ниже.

Наследование, инкапсуляция и полиморфизм в Python тоже есть, но устроены проще, чем в языках, где их проходят первыми: наследник ищет атрибут у родителя, «приватность» — соглашение об именах, а полиморфизм — просто вызов метода с тем же именем у объекта другого класса.

Механизм 1: self — обычный первый аргумент

self не ключевое слово и не магия. Документация описывает вызов метода так:

Прогон показывает это напрямую — вывод bench/oop/basics.py, раздел 1:

1) self — обычный первый аргумент
   a.hello()          -> привет, Аня
   Greeter.hello(a)   -> привет, Аня
   type(a.hello)      -> method
   a.hello is a.hello -> False
   a.hello == a.hello -> True
   a.hello.__self__ is a            -> True
   a.hello.__func__ is Greeter.hello -> True
   Greeter.hello()    -> TypeError: Greeter.hello() missing 1 required positional argument: 'self'
   a.broken()         -> TypeError: Greeter.broken() takes 0 positional arguments but 1 was given
   1000 обращений a.hello, разных объектов: 1000

Три вещи, которые отсюда стоит вынести.

• a.hello — связанный метод: маленький объект, который помнит функцию (__func__) и экземпляр (__self__). Вызов связанного метода вызывает функцию, подставив экземпляр первым аргументом.
• Он создаётся заново при каждом обращении: a.hello is a.hello — False, хотя они равны. Как именно функция в классе превращается в связанный метод, разобрано в уроке о дескрипторах; сколько это стоит и почему при вызове a.hello() объект обычно не создаётся вовсе — в статье о поиске атрибута.
• Забытый self ломается при первом вызове через экземпляр, и сообщение об ошибке говорит ровно об этом: функции, объявленной без параметров, передали один аргумент — экземпляр.

Механизм 2: атрибут класса и атрибут экземпляра

Документация формулирует правило в одном абзаце:

«Неожиданные результаты» выглядят так — вывод bench/oop/basics.py, раздел 2:

2) атрибут класса против атрибута экземпляра
   до присваивания: vars(c1) = {} | c1.total = 0
   после c1.total = 5: vars(c1) = {'total': 5}
   c1.total = 5 | c2.total = 0 | Counter.total = 0
   три экземпляра добавили по метке в tags класса:
   c1.tags = ['t0', 't1', 't2'] | c2.tags = ['t0', 't1', 't2']
   c1.tags is c2.tags -> True | vars(c2) = {}
   список в __init__: f1.tags = ['t0'] | f2.tags = []

Всё объясняется одним правилом с двумя половинами.

• Чтение c1.имя ищет сначала в словаре экземпляра (vars(c1)), потом в классе. Пока у экземпляра своего атрибута нет, все экземпляры читают одно классовое значение.
• Присваивание c1.имя = … пишет в словарь экземпляра. После c1.total = 5 у c1 свой total, и он затеняет классовый; класс и остальные экземпляры не изменились.

Правило верно для обычных атрибутов — а таких в коде подавляющее большинство. Исключение одно, и о нём спрашивают на следующем шаге: если в классе под этим именем лежит дескриптор данных — например, property, — то и чтение, и запись идут через него, а не через словарь экземпляра. Это разобрано в уроке о дескрипторах. Отдельно стоит __slots__: имена из него документация реализует теми же дескрипторами, а словарь экземпляра он может убрать — но не всегда; условия — в разделе «Глубже: __slots__ убирает словарь не всегда» ниже.

Ловушка в том, что c1.tags.append(…) — не присваивание. Это чтение c1.tags, которое находит список в классе, и вызов метода у этого списка. Список один, поэтому меняется у всех. Лечится тем, что изменяемое значение создаётся в __init__: self.tags = [] — тогда у каждого экземпляра свой. Тот же механизм — значение вычислено один раз и общее для всех — стоит за изменяемым аргументом по умолчанию у функций, и в уроке о нём разобрано, как эту ошибку ловят датаклассы.

Механизм 3: три вида методов

Методы различаются тем, что получают первым аргументом:

Вывод bench/oop/basics.py, раздел 3:

3) три вида методов: что приходит первым аргументом
   describe получил экземпляр Dog
   who получил класс Dog | who получил класс Dog
   helper получил только x = 1 | helper получил только x = 2
   Animal.create() -> Animal
   Dog.create()    -> Dog
   Animal.describe() без экземпляра -> TypeError: Animal.describe() missing 1 required positional argument: 'self'
   MyDict.fromkeys('ab')         -> MyDict
   MyDateTime.fromtimestamp(0)   -> MyDateTime

Главное здесь — строки про create. Метод create объявлен в Animal и делает return cls(). Вызванный через Dog, он получает cls = Dog и создаёт собаку, хотя написан в родителе. Так же устроены фабрики стандартной библиотеки: последние две строки — dict.fromkeys и datetime.fromtimestamp, вызванные через наследников, вернули наследников. Если бы фабрика писала Animal() явно, наследник получал бы из неё объект родителя.

@staticmethod не получает ни экземпляра, ни класса. Вызывать его можно и через класс, и через экземпляр — ведёт он себя одинаково.

Механизм 4: наследование и super().__init__()

Наследник ищет у родителя всё, чего нет у него самого. Но если наследник объявил свой __init__, родительский сам не вызовется:

Вывод bench/oop/basics.py, раздел 4:

4) наследование и super().__init__()
   без super(): объект создан, vars = {'rate': 0.05}
   s1.balance -> AttributeError: 'SavingsForgot' object has no attribute 'balance'
   с super():   vars = {'owner': 'Ира', 'balance': 0, 'rate': 0.05}
   isinstance(s2, Account) -> True
   type(s2) is Account     -> False
   Savings.__mro__ -> ['Savings', 'Account', 'object']

Без super().__init__() объект создаётся без ошибки, и AttributeError появляется позже — при первом чтении атрибута родителя, далеко от места, где вызов забыли. Строки про isinstance и type(s2) is Account — разница между проверкой на принадлежность и сравнением типа: экземпляр наследника является экземпляром родителя, но его тип — не родитель. Поэтому проверяют через isinstance, если наследники должны проходить проверку.

Порядок, в котором Python ищет атрибут по цепочке классов, лежит в __mro__. Строит его алгоритм C3; при одиночном наследовании результат очевиден — класс, родитель, object, — а при множественном уже нет: это урок о MRO.

Механизм 5: _x и __x — соглашение, а не защита

Модификаторов доступа в Python нет. Есть два соглашения об именах:

• _x — «это внутреннее, снаружи не трогайте». Интерпретатор с этим ничего не делает: атрибут доступен как любой другой.
• __x внутри класса переименовывается (кроме имён, которые и заканчиваются двумя подчёркиваниями, — это магические методы вроде __init__) — the identifier __spam occurring in a class named Foo, _Foo or __Foo is transformed to _Foo__spam (идентификатор __spam, встретившийся в классе с именем Foo, _Foo или __Foo, превращается в _Foo__spam).

Вывод bench/oop/basics.py, раздел 5:

5) _x и __x: соглашение и переименование
   vars(w) = {'_cash': 10, '_Wallet__pin': 1234}
   w._cash -> 10
   w.__pin -> AttributeError: 'Wallet' object has no attribute '__pin'
   w._Wallet__pin -> 1234
   наследник с тем же __pin: vars = {'_cash': 10, '_Wallet__pin': 1234, '_StrictWallet__pin': 0}
   sw.pin_ok(1234) -> True

Переименование не прячет атрибут — w._Wallet__pin читается свободно. Оно защищает от другого: от случайного совпадения имён в наследнике. Наследник объявил свой __pin, и он лёг рядом с родительским, а не поверх: метод родителя pin_ok по-прежнему видит свой _Wallet__pin. Это и есть ответ на «есть ли в Python private»: нет, есть защита от коллизий.

Глубже: __init__ — не конструктор, а __eq__ отключает хеш

Два магических метода, вокруг которых на собеседовании чаще всего ошибаются.

__init__ получает уже созданный объект. Документация: called after the instance has been created (by __new__()), but before it is returned to the caller (вызывается после того, как экземпляр создан (методом __new__()), но до того, как он возвращён вызывающему). Конструктор в привычном смысле — пара: __new__ создаёт объект, __init__ заполняет его. __new__ переопределяют редко: документация называет два случая — наследники неизменяемых типов вроде int, str и tuple и метаклассы.

__eq__ без __hash__ делает объект нехешируемым.

Вывод bench/oop/basics.py, раздел 6:

6) магические методы: __new__, __init__, __eq__, __hash__
   __new__ создаёт объект
   __init__ заполняет уже созданный объект, x = 1
   Plain(1, 2) == Plain(1, 2) -> False
   Point(1, 2) == Point(1, 2) -> True
   Point.__hash__ is None     -> True
   {Point(1, 2)}              -> TypeError: unhashable type: 'Point'
   {Point(1, 2): 'x'}         -> TypeError: unhashable type: 'Point'
   len({HPoint(1, 2), HPoint(1, 2)}) -> 1
   repr(Plain(1, 2)) начинается с -> <__main__.Plain object
   @dataclass: DPoint.__hash__ is None -> True
   @dataclass(frozen=True): len({FPoint(1, 2), FPoint(1, 2)}) -> 1

Логика у правила простая. Хеш по умолчанию считается от тождества объекта — id(), в CPython это адрес, — а словарь и множество требуют, чтобы равные объекты имели равный хеш. Как только равенство стало «по значению», хеш «по адресу» стал бы ему противоречить — и Python его отключает, вместо того чтобы молча сломать словарь. Без __eq__ объекты сравниваются по тождеству: Plain(1, 2) == Plain(1, 2) — False. Если объекту нужно быть ключом, __hash__ пишут по тем же полям, что и __eq__, — тогда множество из двух равных точек содержит одну. И поля эти не должны меняться, пока объект лежит в словаре.

На 3.14 сообщение об ошибке другое и называет роль объекта — cannot use 'Point' as a set element (unhashable type: 'Point') и cannot use 'Point' as a dict key (unhashable type: 'Point'); смысл тот же.

Глубже: __slots__ убирает словарь не всегда

__slots__ — атрибут класса со списком имён, которые будут у экземпляров. Частый пересказ — «у класса со __slots__ нет словаря экземпляра» — верен только при условиях. Документация говорит осторожнее: slots reserves space for the declared variables and prevents the automatic creation of __dict__ and __weakref__ for each instance (резервирует место под объявленные переменные и предотвращает автоматическое создание __dict__ и __weakref__ у каждого экземпляра), и тут же оговаривает: When inheriting from a class without __slots__, the __dict__ and __weakref__ attribute of the instances will always be accessible (при наследовании от класса без __slots__ атрибут __dict__ и __weakref__ экземпляров будет доступен всегда). Второй путь к словарю — перечислить "__dict__" в самих slots.

Вывод bench/oop/basics.py, раздел 7:

7) __slots__: когда у экземпляра нет __dict__, а когда есть
   OnlySlots: hasattr(o, '__dict__') -> False
   OnlySlots: o.extra = 1 -> AttributeError: 'OnlySlots' object has no attribute 'extra' and no __dict__ for setting new attributes
   Child(Base), __slots__ = (): c.extra = 1 -> vars(c) = {'extra': 1}
   Child(Base): hasattr(c, '__dict__') -> True
   __slots__ = ('x', '__dict__'): s.extra = 1 -> vars(s) = {'extra': 1}

Три класса из прогона:

• OnlySlots со __slots__ = ("x",), базовый класс — только object, и "__dict__" в slots нет. Здесь словаря у экземпляра действительно нет, и присвоить имя, которого нет в slots, нельзя.
• Child(Base) со __slots__ = (), где Base — обычный класс без slots. Словарь экземпляру даёт родитель: c.extra = 1 проходит и ложится в vars(c).
• SlotsWithDict с "__dict__" в slots: словарь включён явно.

Отсюда точная формулировка: у класса со __slots__, у которого ни один базовый класс не даёт словаря экземпляра и в slots нет "__dict__", экземпляры не получают __dict__. А сами имена из slots, по документации, are implemented at the class level by creating descriptors for each variable name (реализованы на уровне класса созданием дескрипторов для каждого имени переменной) — это и есть оговорка механизма 2 о дескрипторах; подробно — в уроке о дескрипторах.

Как отвечать на собеседовании

Короткий ответ: класс хранит общие для экземпляров атрибуты и методы, экземпляр обычного класса — свои данные в собственном словаре. Метод — функция в классе, self — её первый аргумент: a.m() равносильно A.m(a). Чтение обычного атрибута ищет в экземпляре, потом в классе; присваивание через экземпляр пишет в экземпляр. @classmethod получает класс, @staticmethod — ничего.

Этого достаточно, чтобы ответить верно. Дальше — то, что добавляют, если собеседник копает.

Если интервьюер копает глубже

На «что такое self». «Обычный первый параметр. a.hello — связанный метод: объект, который помнит функцию и экземпляр и при вызове подставляет экземпляр первым аргументом. У меня a.hello() и Greeter.hello(a) дали одно и то же, а a.hello is a.hello — False: объект каждый раз новый».

На «атрибут класса против атрибута экземпляра» — ловушка. «Список, объявленный в теле класса, один на все экземпляры: три экземпляра добавили по метке — каждый видит три. c1.tags.append — это чтение, а не присваивание. Изменяемое состояние создают в __init__».

На «зачем classmethod». «Он получает класс, через который вызван. Фабрика create с return cls(), объявленная в родителе, через наследника создаёт наследника — у меня Dog.create() вернул Dog».

На «есть ли private». «Нет. _x — соглашение. __x переименовывается в _Класс__x, и это защита от совпадения имён в наследнике, а не от доступа».

На «__init__ — конструктор?». «Нет, объект к этому моменту уже создан __new__. И если переопределить __eq__, а объект должен быть ключом словаря, надо определить и __hash__: иначе он станет None».

На «у класса со __slots__ нет __dict__?». «Только если ни один базовый класс не даёт словаря и "__dict__" нет в slots. Наследник обычного класса со __slots__ = () словарь получает от родителя — у меня c.extra = 1 прошёл, и vars(c) стал {'extra': 1}».

Дальше спросят

Частые заблуждения

История версий

Практика

Две задачи. Сначала ответьте, потом сверьтесь с настоящим выводом: в обеих правильный ответ взят из прогона скрипта, а не назначен.

class Cart:
  items = []

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


a = Cart()
b = Cart()
a.add("apple")
b.add("pear")
print(len(a.items), len(b.items), a.items is b.items)

2 2 True

1 1 False

1 1 True

2 0 True

Проверьте себя

Чем измерено

Выводы этого урока получены этими скриптами. Каждый открывается прямо отсюда — вместе с записью прогона: на чём запускали и что получилось.

• bench/oop/basics.py
• bench/oop/practice.py