Какой синтаксис у private параметра?

Private параметры в Python — двойное подчёркивание

В Python нет истинного приватного доступа, но есть соглашение по именованию для обозначения приватных атрибутов. Главный инструмент — двойное подчёркивание (__) в начале имени.

Синтаксис: __attribute

Параметры и методы, начинающиеся с двойного подчёркивания, обрабатываются специально:

class MyClass:
    def __init__(self):
        self.public = 'Публичный атрибут'
        self._protected = 'Защищённый (условно приватный)'
        self.__private = 'Приватный атрибут'
    
    def __private_method(self):
        return 'Приватный метод'

obj = MyClass()

print(obj.public)        # Публичный атрибут — работает
print(obj._protected)    # Защищённый (условно приватный) — работает, но не рекомендуется
print(obj.__private)     # AttributeError — не существует!

Name Mangling (преобразование имён)

При использовании двойного подчёркивания Python применяет name mangling (преобразование имён). Атрибут автоматически переименовывается в формат _ClassName__attribute:

class MyClass:
    def __init__(self):
        self.__private = 'Приватный'
    
    def __private_method(self):
        return 'Метод'

obj = MyClass()

# Правильное имя внутри класса
print(obj._MyClass__private)  # Приватный — работает через переименование
print(obj.__dict__)            # {'_MyClass__private': 'Приватный'}

# Неправильное имя не работает
print(obj.__private)  # AttributeError

Три уровня доступа

Примеры использования

Пример 1: Инкапсуляция данных

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # Приватный атрибут
    
    def get_balance(self):
        '''Публичный метод для получения баланса'''
        return self.__balance
    
    def deposit(self, amount):
        '''Публичный метод для пополнения'''
        if amount > 0:
            self.__balance += amount
        else:
            raise ValueError('Сумма должна быть положительной')
    
    def __verify_password(self, password):
        '''Приватный метод'''
        return password == 'secret'

account = BankAccount('Alice', 1000)
print(account.get_balance())  # 1000 — работает
account.deposit(500)          # Работает
print(account.__balance)      # AttributeError — нельзя прямой доступ

# Но можно обойти через name mangling (плохая практика!)
print(account._BankAccount__balance)  # 1500 — работает, но не делай так!

Пример 2: Защита внутренней логики

class DatabaseConnection:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.__connection = None  # Приватное соединение
    
    def connect(self):
        '''Публичный метод для подключения'''
        if self.__connection is None:
            self.__connection = self.__create_connection()
        return self.__connection
    
    def __create_connection(self):
        '''Приватный метод создания соединения'''
        return f'Connection to {self.host}:{self.port}'
    
    def __execute_query(self, query):
        '''Приватный метод выполнения запроса'''
        return f'Executing: {query}'

db = DatabaseConnection('localhost', 5432)
print(db.connect())           # Connection to localhost:5432
print(db.__connection)        # AttributeError
print(db.__create_connection())  # AttributeError

Пример 3: Наследование и name mangling

class Parent:
    def __init__(self):
        self.__private = 'Parent private'
    
    def __private_method(self):
        return 'Parent method'

class Child(Parent):
    def __init__(self):
        super().__init__()
        self.__private = 'Child private'
    
    def show(self):
        # Это разные приватные атрибуты!
        print(self._Parent__private)  # Parent private
        print(self._Child__private)   # Child private

child = Child()
child.show()
# Вывод:
# Parent private
# Child private

Одно подчёркивание: _attribute

Одно подчёркивание — это условное обозначение защищённого атрибута. Python не скрывает его, но это предупреждение:

class Example:
    def __init__(self):
        self._internal = 'Условно приватный'

obj = Example()
print(obj._internal)  # Работает, но не рекомендуется использовать

Главные отличия от других языков

В отличие от Java или C++, в Python НЕТ истинной приватности:

class Secret:
    def __init__(self):
        self.__secret = 'password123'

obj = Secret()

# Python позволяет обойти private через name mangling
print(obj._Secret__secret)  # password123 — легко взламывается!

# Также можно динамически добавить атрибут
obj.__hack = 'hacked'
print(obj._Secret__hack)  # Не сработает, т.к. переименование только при определении

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

1. Используй _attribute для условно приватных атрибутов (внутренняя реализация)
2. Используй __attribute только если нужно предотвратить случайное переиспользование в подклассах
3. Документируй приватные члены в docstring
4. Не полагайся на приватность для безопасности — это просто соглашение
5. Предпочтитай свойства (properties) для контроля доступа:

class Good:
    def __init__(self):
        self._value = 0
    
    @property
    def value(self):
        return self._value
    
    @value.setter
    def value(self, val):
        if val < 0:
            raise ValueError('Отрицательное значение')
        self._value = val

obj = Good()
obj.value = 10  # Работает
obj.value = -5  # ValueError

Ключевые моменты

• __attribute — двойное подчёркивание для приватных атрибутов
• Python применяет name mangling (_ClassName__attribute) к таким атрибутам
• _attribute — одно подчёркивание для условной защиты
• Истинной приватности в Python нет — это соглашение
• Используй @property для контроля доступа к атрибутам