Расскажи минусы Django по сравнению с другими фреймворками

Расскажи про три типа инкапсуляции в Python

В Python есть три уровня инкапсуляции (access modifiers) — способы контролировать доступ к методам и атрибутам. Это соглашения, а не строгие правила как в Java.

Уровни инкапсуляции

Python использует соглашение об именовании:

1. Public — name (без префикса)
2. Protected — _name (одно подчёркивание)
3. Private — __name (два подчёркивания)

Это не строгое разграничение, а сигнал для разработчиков.

1. Public (открытый доступ)

Public атрибуты и методы доступны везде. Это стандартное имя без префиксов.

class User:
    def __init__(self, name, email):
        self.name = name      # Public атрибут
        self.email = email    # Public атрибут
    
    def send_email(self):     # Public метод
        print(f"Email sent to {self.email}")

# Использование
user = User("John", "john@example.com")
print(user.name)           # ✅ Доступно
print(user.email)          # ✅ Доступно
user.send_email()          # ✅ Доступно

# Изменение
user.name = "Jane"         # ✅ Можно менять
user.email = "jane@example.com"

Когда использовать public:

• Данные, которые клиент должен читать/менять
• Основной API класса
• Свойства, которые часто используются

class Product:
    def __init__(self, name, price):
        self.name = name      # Public: часто читается
        self.price = price    # Public: часто используется
    
    def apply_discount(self, percent):
        self.price = self.price * (1 - percent / 100)

2. Protected (защищённый доступ)

Protected атрибуты обозначаются одним подчёркиванием _name. Это сигнал: "Это для внутреннего использования, не меняй напрямую".

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner         # Public
        self._balance = balance    # Protected: внутреннее состояние
    
    def deposit(self, amount):
        """Публичный способ увеличить баланс"""
        if amount > 0:
            self._balance += amount  # Изменяем через логику
    
    def withdraw(self, amount):
        """Публичный способ уменьшить баланс"""
        if amount > 0 and amount <= self._balance:
            self._balance -= amount
    
    def get_balance(self):
        """Публичный способ получить баланс"""
        return self._balance

# Правильное использование
account = BankAccount("John", 1000)
account.deposit(500)       # ✅ Правильно: используем метод
print(account.get_balance())  # ✅ Получаем через метод

# Неправильное использование (но технически работает)
account._balance = -999    # ❌ Работает, но это ПЛОХО!
                           # Нарушаем инвариант (баланс не может быть отрицательным)

Почему protected нужен:

class DataValidator:
    def __init__(self, rules):
        self._rules = rules        # Protected: деталь реализации
        self._errors = []          # Protected: внутренний статус
    
    def validate(self, data):
        """Public метод валидации"""
        self._errors = []           # Очищаем ошибки
        self._run_rules(data)       # Используем protected метод
        return len(self._errors) == 0
    
    def _run_rules(self, data):    # Protected метод
        """Внутренний метод для запуска правил"""
        for rule in self._rules:
            if not rule(data):
                self._errors.append(f"Failed: {rule}")

# Использование
validator = DataValidator([lambda x: len(x) > 0])
if validator.validate("test"):
    print("Valid")  # ✅ Правильно

# Не трогаем protected части
print(validator._errors)  # Технически работает, но это нарушает инкапсуляцию

Protected часто используется в наследовании:

class Animal:
    def __init__(self, name):
        self._name = name          # Protected: для наследников
    
    def _make_sound(self):         # Protected: могут переопределить
        return "Generic sound"
    
    def describe(self):
        sound = self._make_sound()  # Используем protected метод
        return f"{self._name} makes {sound}"

class Dog(Animal):
    def _make_sound(self):         # ✅ Переопределяем protected метод
        return "Woof"

dog = Dog("Buddy")
print(dog.describe())  # ✅ Buddy makes Woof

3. Private (приватный доступ)

Private атрибуты обозначаются двумя подчёркиваниями __name. Python "скрывает" их через name mangling.

class Card:
    def __init__(self, number, pin):
        self.number = number       # Public: можно читать
        self.__pin = pin           # Private: не покажется снаружи!
    
    def validate_pin(self, entered_pin):
        """Публичный способ проверить PIN"""
        return self.__pin == entered_pin

# Правильное использование
card = Card("1234-5678-9012-3456", "1234")
if card.validate_pin("1234"):
    print("PIN valid")  # ✅ Правильно

# ❌ Попытка доступа к __pin не работает
print(card.__pin)  # AttributeError: 'Card' object has no attribute '__pin'

# ❌ Даже это не работает (name mangling)
card.__pin = "0000"  # Создаёт НОВЫЙ атрибут, не изменяет __pin
print(card.validate_pin("1234"))  # Всё ещё True!

Name mangling объяснение:

class Secret:
    def __init__(self):
        self.__secret = "hidden"   # Private
    
    def reveal(self):
        return self.__secret

secret = Secret()

# Python переименовал __secret в _Secret__secret
print(secret._Secret__secret)     # ✅ Можно достать если очень захочешь
                                  # Но ты сам знаешь, что это плохая идея

# Обычно никто так не делает
print(dir(secret))  # Видим _Secret__secret

Когда использовать private:

class Database:
    def __init__(self, connection_string):
        self.__conn = None                  # Private: деталь реализации
        self.__connection_string = connection_string  # Private: секретные данные
    
    def _connect(self):                     # Protected: для наследников
        self.__conn = self._create_connection()  # Используем private
    
    def query(self, sql):
        """Public API"""
        if self.__conn is None:
            self._connect()
        return self.__conn.execute(sql)
    
    def __get_credentials(self):            # Private: только для этого класса
        """Распарсить credentials из connection_string"""
        parts = self.__connection_string.split(":")
        return {"user": parts[0], "pass": parts[1]}
    
    def _create_connection(self):           # Protected для переопределения
        """Создать подключение"""
        creds = self.__get_credentials()    # Используем private метод
        # ... создаём подключение
        pass

Сравнение трёх уровней

Практический пример с тремя уровнями

class PaymentProcessor:
    """Обработчик платежей с разными уровнями инкапсуляции"""
    
    def __init__(self, api_key):
        # Public: состояние, которое клиент может читать
        self.transaction_count = 0
        self.last_amount = 0
        
        # Protected: детали реализации для наследников
        self._api_key = api_key
        self._base_url = "https://api.payment.com"
        self._timeout = 30
        
        # Private: полностью скрытые детали
        self.__session = None
        self.__retry_count = 3
    
    def process_payment(self, amount):
        """Public метод для обработки платежа"""
        if amount <= 0:
            raise ValueError("Amount must be positive")
        
        self.__validate_payment(amount)     # Используем private
        result = self._send_request(amount)  # Используем protected
        
        self.last_amount = amount
        self.transaction_count += 1
        return result
    
    def _send_request(self, amount):       # Protected для переопределения
        """Отправить запрос к API (может переопределить наследник)"""
        for attempt in range(self.__retry_count):
            try:
                self.__ensure_session()    # Используем private
                return self.__session.post(
                    f"{self._base_url}/charge",
                    json={"amount": amount}
                )
            except Exception as e:
                if attempt == self.__retry_count - 1:
                    raise
    
    def __validate_payment(self, amount):  # Private: внутренняя логика
        """Валидировать платёж перед отправкой"""
        if amount > 100000:
            raise ValueError("Amount exceeds limit")
    
    def __ensure_session(self):            # Private: техническая деталь
        """Убедиться, что сессия инициализирована"""
        if self.__session is None:
            import requests
            self.__session = requests.Session()
            self.__session.headers["Authorization"] = f"Bearer {self._api_key}"

# Использование
processor = PaymentProcessor("secret-key")

# ✅ Public доступ
processor.process_payment(100)
print(processor.transaction_count)  # ✅ Читаем public атрибут
print(processor.last_amount)        # ✅ Читаем public атрибут

# ⚠️ Protected доступ (не рекомендуется, но возможен)
print(processor._api_key)  # ⚠️ Работает, но плохая практика

# ❌ Private доступ не работает
processor.__validate_payment(50)  # ❌ AttributeError
print(processor.__session)         # ❌ AttributeError

Свойства (Properties) как альтернатива

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius    # Protected переменная
    
    @property
    def celsius(self):             # Public property
        """Получить температуру в Цельсиях"""
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):      # Контроль при установке
        if value < -273.15:
            raise ValueError("Temperature below absolute zero")
        self._celsius = value
    
    @property
    def fahrenheit(self):          # Вычисляемое свойство
        return self._celsius * 9/5 + 32

# Использование
temp = Temperature(20)
print(temp.celsius)        # ✅ 20 (через property)
temp.celsius = 25          # ✅ Через setter с валидацией
print(temp.fahrenheit)     # ✅ 77 (вычисленное значение)
temp.celsius = -500        # ❌ ValueError (валидация в setter)

Лучшие практики

✅ Используй public для:

• Основного API
• Часто используемых данных
• Логических свойств

class User:
    def __init__(self, email):
        self.email = email  # Public: это часть контракта класса

✅ Используй protected для:

• Деталей реализации, которые могут переопределить наследники
• "Внутренних" атрибутов, которые не в API

class Repository:
    def __init__(self, db):
        self._db = db  # Protected: могут переопределить наследники

✅ Используй private для:

• Полностью внутренних деталей
• Данных, которые должны быть защищены от доступа
• Реализационных подробностей

class APIClient:
    def __init__(self, token):
        self.__token = token  # Private: никто не должен трогать

Вывод

Три типа инкапсуляции в Python:

1. Public name — полный доступ, основной API
2. Protected _name — сигнал для наследников, не для клиентов
3. Private __name — полная защита через name mangling

Это соглашения, а не строгие правила. Python доверяет разработчикам, что они будут уважать инкапсуляцию. Но если кто-то трогает _private или __very_private атрибуты, это их ответственность.