Перейти на PRO

Что такое property в Python и для чего он используется

Тип вопроса: ООП Вероятность: 10% Категория: Python Разработчик

Ответ

property — это встроенная функция в Python, которая чаще всего используется как декоратор для создания управляемых атрибутов (managed attributes). Она позволяет превратить методы класса в атрибуты, доступ к которым (чтение, запись, удаление) контролируется специальными методами (геттер, сеттер, делитер).

Основная цель — обеспечить инкапсуляцию, добавив логику при работе с атрибутами, не изменяя при этом публичный API класса.

Пример: Управление доступом к атрибуту

class Account:
    def __init__(self, initial_balance):
        # Приватный атрибут для хранения баланса
        self._balance = initial_balance

    @property
    def balance(self):
        """Геттер: возвращает значение баланса."""
        print("Вызван геттер для balance")
        return self._balance

    @balance.setter
    def balance(self, value):
        """Сеттер: проверяет значение перед установкой."""
        print("Вызван сеттер для balance")
        if value < 0:
            raise ValueError("Баланс не может быть отрицательным")
        self._balance = value

    @balance.deleter
    def balance(self):
        """Делитер: логика при удалении атрибута."""
        print("Вызван делитер для balance")
        del self._balance

# Использование
acc = Account(1000)

# Чтение (вызывает геттер)
current_balance = acc.balance 
print(f"Текущий баланс: {current_balance}")

# Запись (вызывает сеттер)
acc.balance = 1200

# Попытка установить неверное значение (вызовет ValueError)
try:
    acc.balance = -50
except ValueError as e:
    print(f"Ошибка: {e}")

# Удаление (вызывает делитер)
del acc.balance

Ключевые преимущества:

  1. Контролируемый доступ: Позволяет добавить валидацию или логирование при чтении/записи атрибутов.
  2. API Stability: Можно начать с простого публичного атрибута, а позже заменить его на property без изменения кода, который использует этот класс.
  3. "Вычисляемые" атрибуты: Геттер может возвращать не сохраненное значение, а результат вычислений на основе других атрибутов.

Ответ 18+ 🔞

Ну, слушай, смотри, вот есть у тебя класс Account, да? И там, допустим, баланс. Ну, _balance, приватный такой, подчеркивание, всё дела. А теперь представь, что тебе нужно, чтобы при каждом обращении к этому балансу что-то происходило. Например, логировалось, или проверялось, что значение не отрицательное. Или вообще на лету вычислялось.

Вот для этого, блядь, и есть @property. Это такая встроенная хуйня, которая превращает твой метод в атрибут. Выглядит как магия, но работает, сука, на удивление просто.

Смотри, как это бывает в жизни. Вот у тебя есть класс, и ты пишешь геттер. Раньше бы назвал get_balance(). Но это же некрасиво, каждый раз скобочки ставить. А с @property ты пишешь просто acc.balance — и вуаля, вызывается твой метод-геттер. Ебать, удобно!

class Account:
    def __init__(self, initial_balance):
        self._balance = initial_balance  # Спрятали, блядь, под капот

    @property
    def balance(self):
        """Геттер: возвращает значение баланса."""
        print("Вызван геттер для balance")  # Можешь тут хоть танцы с бубном устроить
        return self._balance

А теперь, внимание, самое интересное. Ты захотел не только читать, но и писать в этот атрибут с проверкой. Ну, чтобы какой-нибудь долбоёб не установил баланс в минус триллион. Для этого есть сеттер, ёпта! Ты пишешь @balance.setter — и всё, теперь при присваивании acc.balance = 100 вызовется твой метод.

    @balance.setter
    def balance(self, value):
        """Сеттер: проверяет значение перед установкой."""
        print("Вызван сеттер для balance")
        if value < 0:
            raise ValueError("Баланс не может быть отрицательным, мудила!")  # Вот так вот, нахуй
        self._balance = value

И, наконец, если ты совсем ебанутый и хочешь удалить атрибут с какой-то своей логикой — есть делитер. @balance.deleter. Хотя, честно говоря, это редко кто использует. Но пусть будет, для полноты картины, как аппендикс.

    @balance.deleter
    def balance(self):
        """Делитер: логика при удалении атрибута."""
        print("Вызван делитер для balance. Зачем ты это делаешь, а?")
        del self._balance

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

# Создаём аккаунт
acc = Account(1000)

# Читаем (вызывает геттер) — просто обращаемся, как к атрибуту!
current_balance = acc.balance
print(f"Текущий баланс: {current_balance}")

# Пишем (вызывает сеттер) — просто присваиваем!
acc.balance = 1200

# Попытка наебать систему и поставить минус
try:
    acc.balance = -50
except ValueError as e:
    print(f"Ошибка: {e}")  # Получишь по ебалу с сообщением

# Удаляем (вызывает делитер) — нафиг надо, но можно
del acc.balance

Так в чём же, блядь, соль?

  1. Контроль, ёпта! Ты можешь впихнуть любую логику в момент доступа к атрибуту. Валидацию, логирование, вычисления — что угодно. Это называется инкапсуляция, если по-умному.
  2. Стабильность API, мать его. Сначала можешь сделать просто публичный атрибут balance. Потом, когда понадобится логика, обернуть его в property. И весь существующий код, который обращался к acc.balance, продолжит работать! Ни один мудак даже не заметит подмены. Это гениально.
  3. Атрибуты-фантомы. Геттер может вообще не хранить значение, а на лету его вычислять из других полей. Например, @property def full_name(self): return f"{self.first} {self.last}". И все думают, что это атрибут, а это, сука, метод!

Короче, property — это мощный инструмент, чтобы сделать твой код не только безопаснее, но и красивее. Используй на здоровье, только не переборщи, а то заpropertyшь всё нахуй.

© ХакСобесов, 2026
support@hacksobesov.com