Как получить защищенный метод класса?

Защищенные методы в Python: доступ и использование

В Python нет истинной приватности на уровне языка. Вместо этого используется конвенция и механизм name mangling. Расскажу, как работают защищенные методы и как их правильно использовать.

Соглашения об обозначениях методов

class MyClass:
    # Публичный метод — для всех
    def public_method(self):
        return "Я публичный"
    
    # Защищенный метод (protected) — для подклассов и самого класса
    def _protected_method(self):
        return "Я защищенный"
    
    # Приватный метод (private) — только для этого класса
    def __private_method(self):
        return "Я приватный"

# Использование
obj = MyClass()
obj.public_method()          # OK
obj._protected_method()      # OK (но не рекомендуется)
obj.__private_method()       # AttributeError!
obj._MyClass__private_method()  # OK (но это нарушение инкапсуляции)

Защищенные методы (_method)

Это сигнал: "Это внутренний метод, но его могут переопределять подклассы".

class Animal:
    def __init__(self, name):
        self.name = name
    
    # Защищенный метод для переопределения подклассами
    def _make_sound(self):
        return "Generic sound"
    
    # Публичный метод использует защищенный
    def speak(self):
        return self._make_sound()

class Dog(Animal):
    # Переопределяем защищенный метод
    def _make_sound(self):
        return "Woof!"

dog = Dog("Buddy")
print(dog.speak())  # "Woof!"
print(dog._make_sound())  # "Woof!" (технически доступна, но не рекомендуется)

Доступ к защищенным методам

class Parent:
    def _helper(self):
        return "helper result"
    
    def public_operation(self):
        # Используем защищенный метод внутри класса
        return self._helper()

class Child(Parent):
    def public_operation(self):
        # В подклассе можем переопределить и вызвать родительский
        return super()._helper() + " modified"
    
    def _helper(self):
        return "child helper"

child = Child()
print(child.public_operation())  # "helper result modified"

Приватные методы (__method) и name mangling

class SecretClass:
    def __init__(self):
        self._secret = "protected"
        self.__top_secret = "private"
    
    # Приватный метод
    def __calculate(self):
        return self.__top_secret + " result"
    
    # Публичный метод вызывает приватный
    def get_result(self):
        return self.__calculate()

obj = SecretClass()

# Доступ к защищенному
print(obj._secret)  # "protected" (работает, но не рекомендуется)

# Доступ к приватному — прямой вызов НЕ работает
try:
    obj.__calculate()  # AttributeError
except AttributeError as e:
    print(f"Ошибка: {e}")

# Но можно обойти через name mangling
print(obj._SecretClass__calculate())  # Работает! Но НЕ ДЕЛАЙ ТАК!
print(obj.get_result())  # Правильный способ — через публичный интерфейс

Правильный паттерн: Template Method

class DataProcessor:
    """Шаблонный класс для обработки данных"""
    
    def process(self, data):
        """Публичный интерфейс"""
        raw = self._load_data(data)  # Вызываем защищенный метод
        cleaned = self._validate(raw)  # Вызываем защищенный метод
        return self._format_output(cleaned)  # Вызываем защищенный метод
    
    def _load_data(self, data):
        """Защищенный метод для переопределения"""
        return data
    
    def _validate(self, data):
        """Защищенный метод для переопределения"""
        if not isinstance(data, (list, str)):
            raise ValueError("Invalid data type")
        return data
    
    def _format_output(self, data):
        """Защищенный метод для переопределения"""
        return str(data)

class JSONProcessor(DataProcessor):
    import json
    
    def _load_data(self, data):
        return json.loads(data)
    
    def _validate(self, data):
        super()._validate(data)  # Проверяем основные правила
        return data
    
    def _format_output(self, data):
        return json.dumps(data)

# Использование
processor = JSONProcessor()
result = processor.process('{"name": "John"}')
print(result)

Получение списка защищенных методов

class MyClass:
    def public_method(self):
        pass
    
    def _protected_method(self):
        pass
    
    def __private_method(self):
        pass

# Получить все методы
obj = MyClass()
all_methods = [m for m in dir(obj) if callable(getattr(obj, m))]
print(all_methods)

# Только публичные
public_methods = [m for m in dir(obj) if not m.startswith('_') and callable(getattr(obj, m))]
print(public_methods)

# Только защищенные
protected_methods = [m for m in dir(obj) if m.startswith('_') and not m.startswith('__') and callable(getattr(obj, m))]
print(protected_methods)

# Только приватные (с name mangling)
private_methods = [m for m in dir(obj) if m.startswith('_MyClass__') and callable(getattr(obj, m))]
print(private_methods)

Использование @property для защиты

class BankAccount:
    def __init__(self, balance):
        self._balance = balance  # Защищенный атрибут
    
    @property
    def balance(self):
        """Публичное свойство для чтения"""
        return self._balance
    
    @balance.setter
    def balance(self, value):
        """Контролируемое изменение баланса"""
        if value < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = value
    
    def _apply_interest(self):
        """Защищенный метод"""
        self._balance *= 1.02  # 2% годовых
    
    def apply_monthly_interest(self):
        """Публичный метод"""
        self._apply_interest()

account = BankAccount(1000)
print(account.balance)  # 1000
account.balance = 1500
print(account.balance)  # 1500
account.balance = -100  # ValueError!

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

# ✅ Правильно
class GoodClass:
    def __init__(self):
        self._internal_state = []
    
    # Публичный интерфейс
    def add_item(self, item):
        self._add_to_state(item)
    
    # Защищенный метод для переопределения подклассами
    def _add_to_state(self, item):
        self._internal_state.append(item)
    
    # Не используй приватные методы без причины

# ❌ Неправильно
class BadClass:
    def __init__(self):
        self.__internal_state = []  # Слишком приватно
    
    def add_item(self, item):
        self.__add_to_state(item)  # Нельзя переопределить подклассу
    
    def __add_to_state(self, item):
        self.__internal_state.append(item)

Правило большого пальца

• Публичные методы: основной интерфейс класса
• Защищенные методы (_method): для переопределения в подклассах, не вызывай напрямую
• Приватные методы (__method): редко нужны, используй защищенные вместо них

В Python философия: "We are all adults here" (Мы все взрослые люди). Используй соглашения о стиле (_protected, __private), а не полагайся на enforcement языка.