Skip to content

Class parameter self - self как поле экземпляра ​

В методах класса self — это ссылка на текущий экземпляр объекта. Благодаря ему у каждого экземпляра появляется собственное пространство для хранения атрибутов и доступа к методам класса.

Кто такой self?

  • Внутри любого метода экземпляра первым параметром всегда идёт self.
  • По соглашению его называют именно так, но технически это просто имя переменной.

self видимость атрибутов вне класса ​

self определяет видимость объявленных свойств экземпляра класса, делая их доступными через объект.

python
class ParcelBox:
    material = 'cardboard'   # class attribute

    def __init__(self, weight: float = 1.0):
        self.weight = weight                            # visible instance attribute
        hidden_volume = 10                              # local variable
        self.label = f"Parcel, {self.weight} kg, {hidden_volume} dm3"

box = ParcelBox(2.5)
print(f"{box = }")
print(f"{box.__dict__ = }")
print(f"{box.material = }")
print(f"{box.weight = }")
# print(f"{box.hidden_volume = }")   # AttributeError
print(f"{box.label = }")

Пояснение работы кода ​

  • material — это свойство класса. Оно хранится в пространстве имён самого класса и доступно всем экземплярам.
  • Внутри __init__ создаются свойства экземпляра self.weight и self.label.
  • Локальная переменная hidden_volume живёт только во время выполнения конструктора и не сохраняется.
  • box.__dict__ показывает все свойства, объявленные через self.
  • Доступ к box.material и box.weight работает без ошибок.
  • При попытке box.hidden_volume возникнет ошибка AttributeError.
  • Итоговое свойство label содержит в себе и видимые, и скрытые значения, но при этом скрытую часть он захватил и сохранил в строке.

Вывод в консоль:

box = <__main__.ParcelBox object at 0x...>
box.__dict__ = {'weight': 2.5, 'label': 'Parcel, 2.5 kg, 10 dm3'}
box.material = 'cardboard'
box.weight = 2.5
box.label = 'Parcel, 2.5 kg, 10 dm3'

Создание свойств в нескольких методах ​

В Python можно динамически добавлять атрибуты в любом методе, но это может привести к непредсказуемому поведению.

python
class ParcelBox:
    material = 'cardboard'   # class attribute

    def __init__(self, weight: float = 1.0):
        note_local_init = "Hidden local note"
        self.weight = weight

    def add_note(self, text):
        note_local_any = "Hidden local note"
        self.note = text                                          # warning

box = ParcelBox(2.5)
print(f"{box = }")
print(f"{box.__dict__ = }")
print(f"{box.weight = }")
# print(f"{box.note = }")                                         # error
box.add_note('fragile')
print(f"{box.note = }")
# print(f"{box.note_local_init = }")                              # error
# print(f"{box.note_local_any = }")                               # error

Пояснение работы кода с учётом warning и errors ​

  • После box = ParcelBox(2.5) в __init__ создаётся только self.weight.
  • Словарь box.__dict__ содержит один ключ: weight.
  • Пометка # warning указывает на потенциальную проблему: динамическое добавление атрибутов вне конструктора может запутать логику, если методы вызываются не последовательно.
  • Метод add_note не вызывался, поэтому self.note не появился, и попытка к нему обратиться также приведёт к ошибке (если метод не был вызван).
  • Вызов метода box.add_note('fragile') — инициализирует свойство self.note, поэтому в дальнейшем свойство доступно для работы.
  • Локальные переменные методов скрыты и никак не влияют на состояние экземпляра.

Вывод в консоль:

box = <__main__.ParcelBox object at 0x...>
box.__dict__ = {'weight': 2.5}
box.weight = 2.5
box.note = 'fragile'

self обращение к атрибутам внутри класса ​

С помощью self методы класса могут читать и менять состояние свойств экземпляра внутри класса.

python
class ParcelBox:
    def __init__(self, weight: float = 1.0):
        self.weight = weight
        self.label = f"Parcel, {self.weight} kg"

    def weigh_again(self, new_weight):
        self.weight = new_weight
        self.label = f"Parcel, {self.weight} kg"

box = ParcelBox(2.5)
print(f"{box = }")
print(f"{box.__dict__ = }")
print(f"{box.label = }")
box.weigh_again(3.0)
print(f"{box.label = }")

Пояснение работы кода ​

  • После конструктора в box.__dict__ есть два ключа: weight и label.
  • Внутри weigh_again через self обновляются self.weight и self.label.
  • При каждом вызове метода состояние экземпляра изменяется, и новые значения доступны извне через box.label.

Вывод в консоль

box = <__main__.ParcelBox object at 0x...>
box.__dict__ = {'weight': 2.5, 'label': 'Parcel, 2.5 kg'}
box.label = 'Parcel, 2.5 kg'
box.label = 'Parcel, 3.0 kg'

Локальные переменные vs свойства экземпляра ​

Персистентность — это продолжительность жизни переменной или атрибута, то есть время, в течение которого оно хранится и остаётся доступным:

  • Локальная переменная живёт только внутри одного вызова метода (временная).
  • Атрибут self.x сохраняется в instance.__dict__ до момента удаления экземпляра (долговременная на время жизни объекта).
  • Свойство класса хранится в пространстве имён самого класса и существует ровно до момента выгрузки класса (едино для всех экземпляров).
Тип переменнойЖивёт вДоступ извнеПерсистентность
Локальная (x = ...)Внутри методаНетПока работает метод
Поле объекта self.x = ...instance.__dict__Да (instance.x)Пока существует объект
Поле классаВнутри классаДа (instance.prop)Пока существует класс

self - итог ​

self - пространство имён экземпляра. Переменные, объявленные через self, становятся полями конкретного объекта: они доступны внутри всех методов класса и извне через obj.имя, а данные разных экземпляров изолированы друг от друга.

Дополнительные замечания:

  • Всегда объявляйте основные атрибуты экземпляра в __init__, чтобы не допускать ошибок в классе.
  • Придерживайтесь соглашения именования: не меняйте self на что-то другое, чтобы код оставался понятным.

Дальше ​

Дальше разберём поля интроспекции __dict__ и __dir__, которые мы уже встречали в примерах. А ещё позже посмотрим вторую сторону self — вызов методов класса изнутри: self.метод().

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

❓Что такое `self` в методах класса?
❓Почему `box.hidden_volume` из примера урока недоступен извне?
❓В чём риск динамического создания атрибутов вне `__init__` (пометка warning)?
❓Почему `weight = weight` в `__init__` (без `self.`) не создаёт атрибут экземпляра?
❓Сколько живёт атрибут, созданный через `self.x = ...`?
❓Почему не стоит переименовывать `self` (например, в `this` или `me`)?

Упражнения ​

  1. Создайте класс Person с атрибутами name и age, инициализируемыми в __init__ через self:

    • создайте person = Person('Bob', 24) и выведите person.__dict__;
    • измените person.age извне и убедитесь, что __dict__ обновилось;
    • создайте второй экземпляр Person('Ann', 30) и проверьте, что изменение person.age не затронуло его (изоляция экземпляров).
  2. Создайте класс ParcelBox, где __init__ задаёт только self.weight:

    • создайте box_a и box_b, выведите оба __dict__ до и после динамического добавления атрибутов извне (box_a.material = 'cardboard', box_b.fragile = True);
    • попробуйте прочитать box_a.fragile и зафиксируйте ошибку (AttributeError): атрибут, добавленный на один экземпляр, не появляется на другом;
    • объясните в двух предложениях, чем динамическое добавление поля отличается от объявления в __init__.
  3. Создайте класс Box с атрибутом класса material = 'cardboard' и атрибутом экземпляра self.weight в __init__:

    • создайте box_a = Box(2.0) и box_b = Box(3.0);
    • измените box_a.weight = 5.0 и убедитесь, что box_b.weight осталось 3.0 (поля экземпляров изолированы);
    • измените Box.material = 'wood' и убедитесь, что box_a.material и box_b.material оба вернули новое значение (поле класса общее для всех экземпляров).