Что делает property для класса?

Что делает property для класса

Property — это встроенный дескриптор Python, который превращает метод в атрибут с контролируемым доступом. Это один из самых важных инструментов для создания чистого и безопасного API класса.

Базовое понимание

Property позволяет:

• Читать значение атрибута через getter
• Устанавливать значение через setter
• Удалять значение через deleter
• Валидировать данные перед присваиванием
• Вычислять значения на лету

Простой пример

class User:
    def __init__(self, name):
        self._name = name  # Приватный атрибут
    
    @property
    def name(self) -> str:
        """Getter: позволяет читать значение"""
        print("Чтение имени пользователя")
        return self._name
    
    @name.setter
    def name(self, value: str) -> None:
        """Setter: позволяет устанавливать значение с валидацией"""
        if not value or len(value) < 2:
            raise ValueError("Имя должно быть минимум 2 символа")
        print(f"Установка имени на {value}")
        self._name = value
    
    @name.deleter
    def name(self) -> None:
        """Deleter: удаление атрибута"""
        print("Удаление имени")
        del self._name

# Использование
user = User("Alice")
print(user.name)  # Вызывает getter
user.name = "Bob"  # Вызывает setter
del user.name  # Вызывает deleter

Зачем нужны property: Инкапсуляция

Property реализует инкапсуляцию — скрывает внутреннюю реализацию и предоставляет контролируемый интерфейс:

# БЕЗ property (открытое изменение)
class BadBankAccount:
    def __init__(self, balance):
        self.balance = balance  # Прямой доступ

account = BadBankAccount(1000)
account.balance = -999  # Ошибка: баланс может быть отрицательным!

# С property (контролируемый доступ)
class GoodBankAccount:
    def __init__(self, balance):
        self._balance = balance
    
    @property
    def balance(self) -> float:
        return self._balance
    
    @balance.setter
    def balance(self, value: float) -> None:
        if value < 0:
            raise ValueError("Баланс не может быть отрицательным")
        self._balance = value
    
    def deposit(self, amount: float) -> None:
        """Правильный способ изменить баланс"""
        self.balance += amount

account = GoodBankAccount(1000)
account.balance = -999  # ValueError! Защита валидации

Property для вычисления значений

Property может вычислять значения на основе других атрибутов:

class Rectangle:
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height
    
    @property
    def area(self) -> float:
        """Площадь вычисляется автоматически"""
        return self.width * self.height
    
    @property
    def perimeter(self) -> float:
        """Периметр вычисляется автоматически"""
        return 2 * (self.width + self.height)

rect = Rectangle(4, 5)
print(rect.area)  # 20
print(rect.perimeter)  # 18

# Изменение width автоматически меняет area
rect.width = 10
print(rect.area)  # 50

Кэширование с property

Property может кэшировать дорогостоящие вычисления:

from functools import cached_property

class DataProcessor:
    def __init__(self, data):
        self.data = data
    
    @cached_property
    def processed_data(self):
        """Вычисляется один раз, затем кэшируется"""
        print("Дорогостоящее вычисление...")
        # Сложная обработка данных
        return [x * 2 for x in self.data]

processor = DataProcessor([1, 2, 3])
print(processor.processed_data)  # Вычисляется
print(processor.processed_data)  # Из кэша (без печати)

Property в API: маскирование внутренней реализации

Property позволяет изменить внутреннюю реализацию без изменения публичного API:

# v1: Простое хранилище
class Product_v1:
    def __init__(self, price):
        self.price = price

# v2: Добавляем налог, но API остаёт без изменений
class Product_v2:
    def __init__(self, base_price):
        self._base_price = base_price
        self.tax_rate = 0.1
    
    @property
    def price(self):
        """Цена включает налог"""
        return self._base_price * (1 + self.tax_rate)
    
    @price.setter
    def price(self, value):
        """Устанавливаем базовую цену без налога"""
        self._base_price = value / (1 + self.tax_rate)

# Код, использующий класс, не изменился
product = Product_v2(100)
print(product.price)  # 110 (с налогом)

Property vs методы: когда использовать?

# ПЛОХО: метод для простого доступа
class BadUser:
    def get_age(self):
        return 2024 - self.birth_year

user = BadUser()
age = user.get_age()  # Похоже на вычисление, но синтаксис как метод

# ХОРОШО: property для простого доступа
class GoodUser:
    @property
    def age(self):
        return 2024 - self.birth_year

user = GoodUser()
age = user.age  # Читается как атрибут, но может быть вычисленным

Правило: Если это выглядит как атрибут (не требует аргументов) — используй property.

Сложный пример: Lazy loading

class User:
    def __init__(self, user_id):
        self.user_id = user_id
        self._profile = None  # Будет загружена лениво
    
    @property
    def profile(self):
        """Профиль загружается только когда нужен"""
        if self._profile is None:
            print(f"Загружаем профиль пользователя {self.user_id}...")
            # Имитация запроса в БД
            self._profile = {
                'bio': 'Python разработчик',
                'followers': 100
            }
        return self._profile

user = User(1)
print("Объект создан")  # Профиль ещё не загружен
print(user.profile)  # Теперь загружается
print(user.profile)  # Уже в памяти, не загружается заново

Практические применения в реальных проектах

1. ORM (SQLAlchemy)

   user = User.query.get(1)
   user.email = "new@example.com"  # Setter отследит изменение
   db.session.commit()  # Сохранит в БД
   

2. Dataclasses с валидацией

   @dataclass
   class Product:
       _price: float
       
       @property
       def price(self):
           return self._price
       
       @price.setter
       def price(self, value):
           if value < 0:
               raise ValueError("Цена не может быть отрицательной")
           self._price = value
   

3. Вычисляемые свойства в API ответах

   class UserResponse:
       def __init__(self, user):
           self.user = user
       
       @property
       def display_name(self):
           return f"{self.user.first_name} {self.user.last_name}"
       
       @property
       def is_premium(self):
           return self.user.subscription_level == 'premium'
   

Выводы

Property — это не просто синтаксический сахар. Это инструмент для:

• Инкапсуляции — скрывает детали реализации
• Валидации — защищает данные от неправильных значений
• Вычисления — предоставляет атрибуты как вычисляемые значения
• Эволюции API — позволяет менять реализацию без изменения интерфейса
• Ленивой загрузки — загружает данные только когда нужны

Property делает Python код более читаемым, безопасным и гибким — это основная причина его широкого использования в профессиональных проектах.