Что такое модификатор доступа?

Модификаторы доступа в Python

Модификаторы доступа (access modifiers) — это механизм управления видимостью и доступностью членов класса (атрибутов и методов). В Python подход отличается от других ООП языков: нет строгих ограничений, есть соглашения.

Python философия: "Мы все взрослые"

В отличие от Java/C++ с ключевыми словами public, private, protected, Python использует соглашения об именовании.

# ✅ Питоническая философия
class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance  # Public атрибут (соглашение: может быть изменён)
        self._internal = []     # Protected (соглашение: не трогай напрямую)
        self.__private = None   # Private (name mangling)

# Все три варианта технически доступны!
account = BankAccount(1000)
print(account.balance)       # OK
print(account._internal)     # OK, но браузер скажет "стоп!"
print(account._BankAccount__private)  # OK, но это обходится name mangling

1. Public атрибуты (без подчеркивания)

class Car:
    def __init__(self, brand, color):
        self.brand = brand      # Public
        self.color = color      # Public
    
    def start(self):           # Public метод
        return f"{self.brand} начинает работу"

my_car = Car("Toyota", "red")
print(my_car.brand)    # ✅ OK: доступ к public
my_car.color = "blue"  # ✅ OK: изменение public
print(my_car.start())  # ✅ OK: вызов public метода

Соглашение: Public члены — это часть публичного API класса. Другой код может их использовать без риска.

2. Protected атрибуты (один подтеркивание)

class BankAccount:
    def __init__(self, balance=0):
        self._balance = balance  # Protected: соглашение "не трогай напрямую"
    
    def _calculate_interest(self, rate=0.05):
        """Protected метод: внутренняя логика класса"""
        return self._balance * rate
    
    def get_balance(self):
        """Public метод для безопасного доступа"""
        return self._balance
    
    def deposit(self, amount):
        """Public метод для безопасного изменения"""
        if amount > 0:
            self._balance += amount
        else:
            raise ValueError("Сумма должна быть положительной")

# Использование
account = BankAccount(1000)
print(account.get_balance())   # ✅ OK: через public метод
account.deposit(500)           # ✅ OK: через public метод
print(account._balance)        # ✅ Технически работает!
                               # ⚠️ Но IDE/linter предупредит
print(account._calculate_interest())  # ⚠️ Можешь, но не надо

Соглашение: Protected члены используются подклассами и внутри класса. Внешний код должен использовать public интерфейс.

3. Private атрибуты (двойное подтеркивание) — Name mangling

class SecurePassword:
    def __init__(self, password):
        self.__password = password  # Private: name mangling
    
    def __validate_strength(self):  # Private метод
        """Внутренняя валидация"""
        return len(self.__password) >= 8
    
    def set_password(self, new_password):
        """Public метод для безопасного изменения"""
        if len(new_password) >= 8:
            self.__password = new_password
        else:
            raise ValueError("Пароль должен быть не менее 8 символов")
    
    def check_password(self, password):
        return self.__password == password

# Использование
secure = SecurePassword("mySecure123")
print(secure.check_password("mySecure123"))  # ✅ OK

# Попытка доступа к private
print(secure.__password)     # ❌ AttributeError!

# Но можешь обойти через name mangling
print(secure._SecurePassword__password)  # "mySecure123"
# ☝️ Это name mangling - Python переименовывает __private в _ClassName__private

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

class Example:
    def __init__(self):
        self.__private = 42
        self._protected = 50
        self.public = 60

obj = Example()

# Внутри класса
print(obj.__private)           # ❌ AttributeError
print(obj._protected)          # ✅ OK
print(obj.public)              # ✅ OK

# Python переименовывает __private на _Example__private
print(obj._Example__private)   # ✅ 42 - name mangling!
print(dir(obj))                # ['_Example__private', '_protected', 'public']

Почему не использовать двойное подтеркивание везде?

# ❌ ПЛОХО: чрезмерное использование __private
class Calculator:
    def __init__(self):
        self.__result = 0
        self.__memory = []
    
    def __add(self, a, b):        # ❌ Зачем private?
        return a + b
    
    def __get_result(self):       # ❌ Зачем private?
        return self.__result

# Проблемы:
# 1. Name mangling усложняет отладку
# 2. Сложнее наследование (нельзя переопределить в подклассе)
# 3. Сложнее тестирование (нельзя замокировать __private методы)

# ✅ ХОРОШО: используй _ для внутренних членов
class Calculator:
    def __init__(self):
        self._result = 0
        self._memory = []
    
    def _add(self, a, b):
        """Внутренний метод для сложения"""
        return a + b
    
    def _get_result(self):
        """Внутренний метод получения результата"""
        return self._result
    
    def calculate(self, expression):
        """Public метод для вычисления"""
        # Использует внутренние _methods
        parts = expression.split('+')
        return self._add(int(parts[0]), int(parts[1]))

Реальный пример: правильное использование модификаторов

from typing import Optional
from datetime import datetime, UTC

class User:
    """Класс пользователя с правильным использованием модификаторов"""
    
    def __init__(self, username: str, email: str):
        # Public API
        self.username = username
        self.email = email
        
        # Protected: используется подклассами и внутри класса
        self._created_at = datetime.now(UTC)
        self._updated_at = datetime.now(UTC)
        self._login_attempts = 0
        
        # Private: строго внутренние детали реализации
        self.__password_hash = None
    
    def set_password(self, password: str) -> None:
        """Public метод для установки пароля"""
        if not self._validate_password(password):
            raise ValueError("Пароль не соответствует требованиям")
        self.__password_hash = self._hash_password(password)
        self._updated_at = datetime.now(UTC)
    
    def verify_password(self, password: str) -> bool:
        """Public метод для проверки пароля"""
        if self.__password_hash is None:
            return False
        return self._hash_password(password) == self.__password_hash
    
    def _validate_password(self, password: str) -> bool:
        """Protected: валидация пароля, может переопределиться в подклассе"""
        return len(password) >= 8 and any(c.isdigit() for c in password)
    
    def _hash_password(self, password: str) -> str:
        """Protected: хеширование пароля"""
        import hashlib
        return hashlib.sha256(password.encode()).hexdigest()
    
    def _record_failed_login(self) -> None:
        """Protected: внутренний метод для логирования попыток"""
        self._login_attempts += 1
        if self._login_attempts > 5:
            self.is_locked = True
    
    def __str__(self) -> str:
        return f"User({self.username})"

# Использование
user = User("john", "john@example.com")
user.set_password("SecurePass123")      # ✅ Public API
print(user.verify_password("SecurePass123"))  # ✅ True
print(user.username)                    # ✅ Public доступ
print(user._created_at)                 # ⚠️ Protected, но IDE предупредит
# print(user.__password_hash)           # ❌ AttributeError - это приватное!

Наследование и модификаторы доступа

class Animal:
    def __init__(self, name):
        self.name = name                    # Public
        self._species = "Unknown"           # Protected
        self.__internal_id = id(self)       # Private
    
    def _make_sound(self):                 # Protected
        return "Some sound"
    
    def speak(self):                       # Public
        return self._make_sound()

class Dog(Animal):
    def _make_sound(self):                 # ✅ Переопределить protected!
        return "Woof!"
    
    def __private_dog_method(self):       # ⚠️ Новый __private для Dog
        pass
    
    # def __internal_id(self):              # ❌ Не может переопределить
    #     # Это не поможет! Будет свой __internal_id
    #     # А родительский останется как _Animal__internal_id

dog = Dog("Rex")
print(dog.speak())                      # ✅ OK: "Woof!"
print(dog._species)                     # ✅ OK: "Unknown" - inherited protected
print(dog._make_sound())                # ✅ OK: вызвать переопределённый protected
# print(dog.__internal_id)               # ❌ Родительский __private недоступен!
print(dog._Animal__internal_id)         # ✅ Можешь через name mangling

Сравнение с другими языками

Best practices для модификаторов

# ✅ ПРАВИЛЬНО
1. Используй public (без подтеркивания) для части API
2. Используй protected (_) для внутренней логики
3. Используй private (__) редко, только когда нужна защита от случайного использования
4. Документируй public API в docstrings
5. В protected методах объясни, почему они protected

# ❌ НЕПРАВИЛЬНО
1. Не чрезмерно используй __ (усложняет наследование)
2. Не полагайся на __ как на真настоящую приватность
3. Не используй __ в подклассах для скрытия базовых членов
4. Не забывай, что это соглашение, не правило

Использование свойств (properties) для инкапсуляции

# ✅ Лучший способ: properties + protected _attribute
class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius
    
    @property
    def celsius(self):
        """Public getter"""
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        """Public setter с валидацией"""
        if value < -273.15:
            raise ValueError("Температура ниже абсолютного нуля!")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

temp = Temperature(0)
temp.celsius = 25           # ✅ Выглядит как обычный атрибут
print(temp.fahrenheit)      # ✅ Вычисляется через property
temp.celsius = -300         # ❌ Валидация срабатывает

Вывод

Модификаторы доступа в Python — это соглашения об именовании:

• public: нет подтеркивания, часть API
• protected: _, внутреннее использование и подклассы
• private: __, редко, name mangling

В отличие от Java/C++ с жёсткими правилами, Python полагается на дисциплину и соглашения. Это даёт гибкость, но требует ответственности. Помните: "Мы все взрослые в Python!" — это значит используй эти соглашения умно.