Как работают private методы?

# Private методы в Python

В Python концепция "private" методов отличается от языков вроде Java или C++. Python использует соглашения и механизм name mangling вместо строгих ограничений доступа.

1. Single Underscore (_method) — внутренний API

Это соглашение, которое говорит: "это метод для внутреннего использования":

class DatabaseConnection:
    def __init__(self, host):
        self.host = host
        self._connection = None
    
    def _establish_connection(self):
        """Внутренний метод, не для публичного использования."""
        self._connection = self._create_socket()
        print("Connection established")
    
    def _create_socket(self):
        """Вспомогательный приватный метод."""
        return f"Socket to {self.host}"
    
    def connect(self):
        """Публичный метод."""
        self._establish_connection()

db = DatabaseConnection("localhost")
db.connect()  # OK
db._establish_connection()  # Работает, но не рекомендуется

Важно: Python НЕ запретит вам вызвать _establish_connection(). Это просто соглашение: разработчик говорит, что это деталь реализации, и ты обращаешься на свой риск.

2. Double Underscore (__method) — name mangling

Двойное подчёркивание включает механизм name mangling, который переименовывает атрибут:

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Приватный атрибут
    
    def __get_balance(self):
        """Приватный метод."""
        return self.__balance
    
    def __withdraw(self, amount):
        """Приватный метод."""
        if amount <= self.__balance:
            self.__balance -= amount
            return True
        return False
    
    def withdraw_money(self, amount):
        """Публичный метод."""
        if self.__withdraw(amount):
            print(f"Withdrawn: {amount}")
        else:
            print("Insufficient funds")
    
    def show_balance(self):
        """Публичный метод."""
        return self.__get_balance()

account = BankAccount(1000)
account.withdraw_money(200)  # OK
print(account.show_balance())  # 800

# Попытка прямого доступа — НЕ РАБОТАЕТ
# print(account.__balance)  # AttributeError

# Но Python переименовал атрибут во внутренний!
# Это можно найти через name mangling:
print(account._BankAccount__balance)  # 800 — работает!

Как работает name mangling

Когда Python видит __method, он переименовывает его в _ClassName__method:

class Example:
    def __private_method(self):
        return "secret"
    
    def public_method(self):
        return self.__private_method()  # Работает внутри класса

obj = Example()
obj.public_method()  # OK

# Это что-то вроде:
print(dir(obj))  # Увидишь _Example__private_method
obj._Example__private_method()  # Работает, но плохая идея

Зачем нужен name mangling?

Защита от случайного переопределения в подклассах

class Parent:
    def __private_method(self):
        return "parent private"
    
    def public_method(self):
        return self.__private_method()

class Child(Parent):
    def __private_method(self):
        # Это НЕ переопределит родительский __private_method
        # Это будет _Child__private_method
        return "child private"
    
    def another_method(self):
        # Но public_method всё ещё вызывает _Parent__private_method
        return self.public_method()

child = Child()
print(child.public_method())  # parent private — не child private!
print(child.another_method())  # parent private

Именно это — основная причина name mangling. Он защищает от случайного переопределения в подклассах.

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

Пример 1: Валидация приватными методами

class User:
    def __init__(self, email, password):
        self.email = self.__validate_email(email)
        self.__password = self.__hash_password(password)
    
    def __validate_email(self, email):
        """Приватный метод валидации."""
        if '@' not in email:
            raise ValueError("Invalid email")
        return email
    
    def __hash_password(self, password):
        """Приватный метод хеширования."""
        import hashlib
        return hashlib.sha256(password.encode()).hexdigest()
    
    def check_password(self, password):
        """Публичный метод проверки."""
        return self.__hash_password(password) == self.__password

user = User("test@example.com", "secret123")
print(user.check_password("secret123"))  # True
# print(user.__password)  # AttributeError

Пример 2: Кэширование

class DataFetcher:
    def __init__(self):
        self.__cache = {}  # Приватный кэш
    
    def __fetch_from_api(self, url):
        """Приватный метод получения данных."""
        print(f"Fetching from {url}")
        # Имитация запроса
        return {"data": "result"}
    
    def __cache_result(self, key, value):
        """Приватный метод кэширования."""
        self.__cache[key] = value
    
    def get_data(self, url):
        """Публичный метод с кэшированием."""
        if url in self.__cache:
            return self.__cache[url]
        
        result = self.__fetch_from_api(url)
        self.__cache_result(url, result)
        return result

fetcher = DataFetcher()
print(fetcher.get_data("api.example.com"))  # Fetching from api.example.com
print(fetcher.get_data("api.example.com"))  # Из кэша, нет печати

Single vs Double underscore

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

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

• Вспомогательных методов
• Внутренних функций обработки
• Когда класс не предполагает наследование
• В простых случаях

class SimpleUtil:
    def _helper_method(self):
        return "internal"
    
    def public_method(self):
        return self._helper_method()

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

• Защиты от переопределения в подклассах
• Базовых классов в иерархии
• Когда нужна действительно приватная логика

class BaseModel:
    def __initialize_db(self):
        # Подкласс не может случайно переопределить это
        pass
    
    def setup(self):
        self.__initialize_db()

class CustomModel(BaseModel):
    def __initialize_db(self):
        # Это другой метод! Не переопределяет родителя
        pass

Важные замечания

1. Python не запретит доступ — это соглашение, не ограничение
2. Читай документацию — правильная документация лучше, чем подчёркивания
3. Не переусложняй — большинство классов в Python используют _single_underscore
4. Name mangling — не шифрование — это не делает данные безопасными
5. В библиотеках важнее — при написании фреймворков name mangling полезен

Резюме

В Python private методы — это скорее социальный контракт, чем технологическое ограничение. Разработчик говорит: "не трогай это, это деталь реализации". Если ты всё же решишь потрогать — Python тебе позволит, но ты берёшь ответственность за это на себя.