В чем разница между private и protected методами?

Разница между private и protected методами

В Python нет встроенного механизма уровней доступа как в Java или C++, но существуют соглашения и приемы для обозначения видимости методов. Это важно понимать для написания правильного объектно-ориентированного кода.

Python нет жестких ограничений доступа

В отличие от других ООП языков, Python полагается на соглашения (conventions), а не на жесткие правила:

# Все это работает, но имеет разное значение по смыслу
class DataProcessor:
    def public_method(self):  # Публичный
        pass
    
    def _protected_method(self):  # Protected (одно подчеркивание)
        pass
    
    def __private_method(self):  # Private (два подчеркивания)
        pass

processor = DataProcessor()
processor.public_method()  # OK — вызывается нормально
processor._protected_method()  # OK — работает, но это сигнал "не трогай!"
processor.__private_method()  # Техически работает через name mangling

Protected методы (одно подчеркивание _)

Protected метод начинается с одного подчеркивания. Это соглашение, которое говорит: "используй только в подклассах и не снаружи".

class Parent:
    def _protected_method(self):
        """Метод для внутреннего использования в классе и подклассах."""
        return "Protected"
    
    def public_method(self):
        return self._protected_method()

class Child(Parent):
    def override_protected(self):
        # OK — подклассы должны использовать protected методы
        return self._protected_method() + " from child"

# Использование
parent = Parent()
print(parent.public_method())  # OK
print(parent._protected_method())  # Технически работает, но не рекомендуется

child = Child()
print(child.override_protected())  # OK — подкласс использует protected

Характеристики protected:

• Одно подчеркивание в начале: _method_name
• Это СОГЛАШЕНИЕ, не правило
• Предназначен для подклассов
• Python не запретит прямой доступ снаружи
• IDE и linters дадут warning

class BankAccount:
    def __init__(self, balance):
        self._balance = balance  # Protected атрибут
    
    def _validate_balance(self):  # Protected метод
        return self._balance >= 0
    
    def withdraw(self, amount):
        if self._validate_balance() and amount <= self._balance:
            self._balance -= amount
            return True
        return False

class SavingsAccount(BankAccount):
    def get_interest(self):
        # OK — подкласс использует protected метод
        if self._validate_balance():
            return self._balance * 0.05
        return 0

# Снаружи
account = SavingsAccount(1000)
print(account._balance)  # Работает, но IDE будет подсвечивать
print(account._validate_balance())  # Работает, но не рекомендуется

Private методы (два подчеркивания __)

Private метод начинается с двух подчеркиваний. Python применяет "name mangling" — переименовывает метод внутри класса.

class SecurePassword:
    def __init__(self, password):
        self.__password = password  # Private атрибут
    
    def __hash_password(self):  # Private метод
        """Хеширование пароля (только для внутреннего использования)."""
        import hashlib
        return hashlib.sha256(self.__password.encode()).hexdigest()
    
    def set_password(self, new_password):
        self.__password = new_password
        return self.__hash_password()  # OK — используется внутри класса
    
    def verify_password(self, password):
        return password == self.__password

# Использование
secure = SecurePassword("secret123")
secure.set_password("newpassword")

# Попытка прямого доступа
secure.__password  # AttributeError: 'SecurePassword' object has no attribute '__password'
secure.__hash_password()  # AttributeError

# Но через name mangling можно получить доступ (хотя это не рекомендуется)
print(secure._SecurePassword__password)  # newpassword
print(secure._SecurePassword__hash_password())  # Работает!

Характеристики private:

• Два подчеркивания в начале: __method_name
• Python переименовывает в _ClassName__method_name (name mangling)
• Невозможно получить доступ из подклассов напрямую
• Доступ снаружи класса технически возможен через name mangling, но это нарушение инкапсуляции

Сравнительная таблица

Практические примеры

Пример 1: Публичный API с защищенными методами

class DatabaseConnection:
    def __init__(self, host, port):
        self.host = host  # Public
        self.port = port  # Public
        self._connection = None  # Protected
    
    def _establish_connection(self):  # Protected
        """Установить соединение (для подклассов)."""
        print(f"Connecting to {self.host}:{self.port}")
        self._connection = f"Connection to {self.host}"
    
    def connect(self):  # Public API
        """Публичный метод для подключения."""
        self._establish_connection()
        return self._connection

class PostgreSQLConnection(DatabaseConnection):
    def _establish_connection(self):  # Override protected
        print("PostgreSQL specific connection")
        super()._establish_connection()
        print("PostgreSQL connected")

# Использование
db = PostgreSQLConnection("localhost", 5432)
db.connect()  # Публичный интерфейс

Пример 2: Private для полной инкапсуляции

class CreditCard:
    def __init__(self, card_number, cvv):
        self.__card_number = card_number  # Private
        self.__cvv = cvv  # Private
    
    def __validate_cvv(self):  # Private метод
        return len(str(self.__cvv)) == 3
    
    def __mask_card(self):  # Private метод
        return self.__card_number[-4:].zfill(16)
    
    def make_payment(self, amount):
        if not self.__validate_cvv():
            raise ValueError("Invalid CVV")
        print(f"Payment of ${amount} with card ****{self.__mask_card()}")
    
    def get_masked_card(self):
        """Публичный метод для получения замаскированного номера."""
        return self.__mask_card()

# Использование
card = CreditCard("1234567890123456", "123")
card.make_payment(100)  # OK
print(card.get_masked_card())  # 3456

# Попытка доступа
card.__card_number  # AttributeError
card.__validate_cvv()  # AttributeError

# Name mangling — не рекомендуется
print(card._CreditCard__card_number)  # 1234567890123456 — работает, но нарушает инкапсуляцию

Пример 3: Когда использовать что

class BankingSystem:
    def __init__(self):
        self.accounts = []  # Public API
        self._transaction_log = []  # Protected — для подклассов
        self.__master_key = "secret_key_12345"  # Private — максимальная защита
    
    def create_account(self, name):  # Public
        account = {"name": name, "balance": 0}
        self._log_transaction(f"Created account for {name}")  # Protected метод
        return account
    
    def _log_transaction(self, message):  # Protected
        """Логирование для подклассов (AuditLog может это переопределить)."""
        self._transaction_log.append(message)
    
    def _validate_transaction(self, amount):  # Protected
        return amount > 0
    
    def __encrypt_data(self, data):  # Private
        """Шифрование — никогда не должно быть видимо снаружи."""
        import hashlib
        return hashlib.sha256(data.encode()).hexdigest()

class AuditedBankingSystem(BankingSystem):
    def _log_transaction(self, message):  # Override protected
        super()._log_transaction(message)
        print(f"AUDIT: {message}")

# Использование
bank = AuditedBankingSystem()
bank.create_account("Alice")  # Public API
bank._log_transaction("Manual log")  # Protected (можно, но не рекомендуется)
# bank.__encrypt_data("secret")  # Не работает — инкапсуляция защищена

Best Practices

1. По умолчанию используй public — только если явно нужна инкапсуляция
2. Protected для подклассов — если класс предназначен для наследования
3. Private для критичного кода — шифрование, валидация, внутренние алгоритмы
4. Помни: Python полагается на честность — это соглашение, не закон
5. Используй properties — вместо __private, используй @property для контролируемого доступа

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
temp.celsius = 25  # Валидация через setter
print(temp.fahrenheit)  # 77

Заключение

В Python нет жестких ограничений доступа. Вместо этого используются соглашения: публичный (no prefix), защищенный (_single), приватный (__double). Выбор зависит от архитектуры: используй защищенные методы для наследования и приватные для абсолютной инкапсуляции критичного кода.