# Пример проблемы: Открытый атрибут, уязвимый для некорректных данных
class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance  # Публичный атрибут

# Использование
account = BankAccount("Alice", 1000)
print(f"Баланс: {account.balance}")

# Злоумышленник или ошибка в коде может сделать баланс отрицательным!
account.balance = -50000
print(f"Новый баланс: {account.balance}") # Система сломана

# Антипаттерн: Java-стиль в Python
class Person:
    def __init__(self, name):
        # Защищенный атрибут (по конвенции)
        self._name = name
        
    # Явный геттер
    def get_name(self):
        print("Вызов метода get_name")
        return self._name
        
    # Явный сеттер с валидацией
    def set_name(self, value):
        print("Вызов метода set_name")
        if not isinstance(value, str):
            raise TypeError("Имя должно быть строкой!")
        if len(value) < 2:
            raise ValueError("Имя слишком короткое!")
        self._name = value

# Использование (выглядит неестественно для Python)
user = Person("Ivan")
print(user.get_name())
user.set_name("Alex")
# user.set_name(123)  # Вызовет TypeError

# Старый способ: использование встроенной функции property()
class Product:
    def __init__(self, name, price):
        self._name = name
        self.set_price(price) # Используем сеттер сразу в init
        
    def get_price(self):
        print("Лог: Чтение цены")
        return self._price
        
    def set_price(self, value):
        print("Лог: Установка цены")
        if value < 0:
            raise ValueError("Цена не может быть отрицательной!")
        self._price = value
        
    # Магия происходит здесь! Мы связываем методы с атрибутом price
    price = property(fget=get_price, fset=set_price)

# Использование: выглядит как обычный атрибут!
item = Product("Laptop", 1500)
print(item.price)  # Автоматически вызывает get_price()
item.price = 1800  # Автоматически вызывает set_price(1800)
# item.price = -50 # Вызовет ValueError

# Современный Pythonic way: декоратор @property для геттера
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
        
    @property
    def area(self):
        """Вычисляет площадь прямоугольника на лету."""
        print("Вычисляем площадь...")
        return self.width * self.height
        
    @property
    def is_square(self):
        """Проверяет, является ли прямоугольник квадратом."""
        return self.width == self.height

# Использование
rect = Rectangle(10, 5)
print(f"Ширина: {rect.width}")
print(f"Площадь: {rect.area}") # Выглядит как обращение к переменной, но вызывает метод!

# Попытка изменить read-only свойство
# rect.area = 100 # Ошибка: AttributeError: can't set attribute

# Полный цикл: Геттер и Сеттер с использованием декораторов
class Employee:
    def __init__(self, name, salary):
        self.name = name
        # Используем сеттер при инициализации для валидации начальных данных
        self.salary = salary 

    # 1. Сначала определяем геттер (обязательно!)
    @property
    def salary(self):
        """Зарплата сотрудника."""
        return self._salary

    # 2. Затем определяем сеттер. Имя декоратора = имя_геттера.setter
    @salary.setter
    def salary(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError("Зарплата должна быть числом.")
        if value < 30000:
            raise ValueError("Зарплата не может быть ниже МРОТ (30000)!")
        # Сохраняем в защищенный атрибут
        self._salary = value

# Использование
worker = Employee("Bob", 50000)
print(worker.salary)  # Вызывает геттер, возвращает 50000

worker.salary = 60000 # Вызывает сеттер, проверки пройдены, сохраняет 60000
# worker.salary = 20000 # Вызовет ValueError: Зарплата не может быть ниже МРОТ!

# Осторожно: Код, вызывающий RecursionError!
class Trap:
    def __init__(self, data):
        self.data = data
        
    @property
    def data(self):
        # ОШИБКА ЗДЕСЬ: попытка вернуть свойство вызовет геттер снова
        # Правильно: return self._data
        return self.data 
        
    @data.setter
    def data(self, value):
        print("Сеттер вызван!")
        # ОШИБКА ЗДЕСЬ: присвоение свойству вызовет этот же сеттер снова!
        # Правильно: self._data = value
        self.data = value 

# Если раскомментировать код ниже, программа упадет с ошибкой RecursionError
# t = Trap("Test")
# t.data = "New Test"

# Использование полного арсенала: getter, setter, deleter
class UserProfile:
    def __init__(self, username):
        self.username = username
        self._avatar = None # Ленивая загрузка аватара

    @property
    def avatar(self):
        if self._avatar is None:
            print("[Система] Загрузка тяжелого изображения из сети...")
            self._avatar = f"image_data_for_{self.username}.png"
        return self._avatar

    @avatar.setter
    def avatar(self, new_image):
        print(f"[Система] Установка нового аватара: {new_image}")
        self._avatar = new_image

    @avatar.deleter
    def avatar(self):
        print("[Система] Удаление аватара. Освобождение памяти.")
        # Сбрасываем кэш, не удаляя сам атрибут из объекта
        self._avatar = None

# Использование
user = UserProfile("Neo")
print(user.avatar) # Спровоцирует загрузку
print(user.avatar) # Вернет из кэша (мгновенно)

user.avatar = "custom_pic.jpg" # Перезапишет кэш

del user.avatar # Вызовет deleter, очистит кэш
print(user.avatar) # Снова спровоцирует загрузку

# Иллюстрация того, что @property - это дескриптор класса
class Demo:
    @property
    def my_prop(self):
        return "Значение"

# Посмотрим, чем является свойство на уровне класса, а не экземпляра
print(type(Demo.my_prop))  # <class 'property'>

# У объекта property есть методы, с которыми мы работаем через декораторы
print(hasattr(Demo.my_prop, 'setter'))  # True
print(hasattr(Demo.my_prop, 'deleter')) # True
print(hasattr(Demo.my_prop, '__get__')) # True - доказательство, что это дескриптор!

demo_instance = Demo()
# Когда мы вызываем это от экземпляра, срабатывает __get__ дескриптора
print(demo_instance.my_prop) # Выводит: Значение

class SecureBankAccount:
    def __init__(self, owner, initial_balance=0):
        # Используем сеттер для валидации имени
        self.owner = owner  
        
        # Прямая валидация для скрытого атрибута (нет сеттера)
        if initial_balance < 0:
            raise ValueError("Начальный баланс не может быть отрицательным")
        self._balance = initial_balance

    # Геттер для владельца
    @property
    def owner(self):
        return self._owner

    # Сеттер для владельца с бизнес-логикой
    @owner.setter
    def owner(self, name):
        if not isinstance(name, str) or not name.strip():
            raise ValueError("Имя владельца должно быть непустой строкой.")
        if not name.replace(" ", "").isalpha(): # Разрешаем пробелы, но не цифры
            raise ValueError("Имя может содержать только буквы.")
        self._owner = name.title() # Автоматически делаем с большой буквы

    # Read-only геттер для баланса
    @property
    def balance(self):
        return self._balance

    # Публичные методы для изменения состояния (вместо сеттера)
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Сумма депозита должна быть положительной.")
        self._balance += amount
        print(f"Внесено {amount}. Новый баланс: {self.balance}")

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("Сумма снятия должна быть положительной.")
        if amount > self._balance:
            raise ValueError("Недостаточно средств на счете.")
        self._balance -= amount
        print(f"Снято {amount}. Новый баланс: {self.balance}")

# Тестирование
acc = SecureBankAccount("john doe", 500)
print(acc.owner)     # Выведет: John Doe (сработал title())
print(acc.balance)   # Выведет: 500

acc.deposit(200)     # Новый баланс: 700
# acc.balance = 1000 # Ошибка! AttributeError: can't set attribute
# acc.owner = "John123" # Ошибка! ValueError: Имя может содержать только буквы.

class TemperatureSensor:
    def __init__(self, celsius=0):
        # Инициализируем через сеттер Цельсия для удобства
        self.celsius = celsius

    # ЕДИНЫЙ ИСТОЧНИК ИСТИНЫ (Кельвины)
    @property
    def kelvin(self):
        return self._kelvin
        
    @kelvin.setter
    def kelvin(self, value):
        if value < 0:
            raise ValueError("Температура не может быть ниже абсолютного нуля (0 K)!")
        self._kelvin = value

    # ВЫЧИСЛЯЕМОЕ СВОЙСТВО: Цельсий
    @property
    def celsius(self):
        return self.kelvin - 273.15
        
    @celsius.setter
    def celsius(self, value):
        # Переводим в Кельвины и используем базовый сеттер (там есть валидация!)
        self.kelvin = value + 273.15

    # ВЫЧИСЛЯЕМОЕ СВОЙСТВО: Фаренгейт
    @property
    def fahrenheit(self):
        return (self.celsius * 9/5) + 32
        
    @fahrenheit.setter
    def fahrenheit(self, value):
        # Сначала переводим Фаренгейты в Цельсии, потом в Кельвины
        self.celsius = (value - 32) * 5/9

# Тестирование системы конвертации
sensor = TemperatureSensor(celsius=25)
print(f"Цельсий: {sensor.celsius}")
print(f"Фаренгейт: {sensor.fahrenheit:.2f}")
print(f"Кельвин: {sensor.kelvin:.2f}")

print("\n--- Изменяем температуру через Фаренгейт ---")
sensor.fahrenheit = 100
print(f"Новый Цельсий: {sensor.celsius:.2f}")
print(f"Новый Кельвин: {sensor.kelvin:.2f}")

# Проверка физической защиты
# sensor.celsius = -300 # Вызовет ValueError из сеттера kelvin!

import time
from functools import cached_property

class DataAnalyzer:
    def __init__(self, dataset):
        self.dataset = dataset

    @cached_property
    def complex_metrics(self):
        """Симуляция очень долгих вычислений."""
        print("\n[Начало] Анализ данных запущен. Пожалуйста, подождите...")
        # Имитируем тяжелую задачу (например, нейросеть)
        time.sleep(2) 
        result = sum(self.dataset) / len(self.dataset) * 3.14
        print("[Конец] Вычисления завершены!")
        return result

analyzer = DataAnalyzer([10, 20, 30, 40, 50])

# Первый вызов: Функция выполняется (занимает 2 секунды)
start_time = time.time()
val1 = analyzer.complex_metrics
print(f"Значение: {val1}. Время 1 вызова: {time.time() - start_time:.4f} сек")

# Второй вызов: Значение берется из кэша (моментально!)
start_time = time.time()
val2 = analyzer.complex_metrics
print(f"Значение: {val2}. Время 2 вызова: {time.time() - start_time:.4f} сек")

# Очистка кэша, если данные изменились
del analyzer.complex_metrics
# Следующий вызов снова займет 2 секунды