Какие методы используются для снижения сложности системы, чтобы повысить надёжность?

Методы доступа к атрибутам объектов в Python

В Python существует несколько механизмов для управления доступом к атрибутам объекта. Это мощная система, позволяющая контролировать и модифицировать поведение при чтении, записи и удалении атрибутов.

1. Прямой доступ к атрибутам

class User:
    def __init__(self, name):
        self.name = name

user = User("Alice")
print(user.name)  # Чтение: Alice
user.name = "Bob"  # Запись
print(user.name)  # Bob

Это самый простой способ, но без контроля валидации.

2. getattribute() — управление ЛЮБЫМ доступом

class User:
    def __init__(self, name):
        object.__setattr__(self, '_name', name)
    
    def __getattribute__(self, name):
        print(f"Getting attribute: {name}")
        return object.__getattribute__(self, name)

user = User("Alice")
print(user._name)
# Getting attribute: _name
# Alice

Особенности:

• Вызывается для КАЖДОГО доступа к атрибуту
• Работает даже для встроенных атрибутов
• Осторожно: рекурсия, если неправильно использовать

3. getattr() — доступ к несуществующим атрибутам

class DynamicObject:
    def __init__(self):
        self.existing = "value"
    
    def __getattr__(self, name):
        # Вызывается ТОЛЬКО если атрибут не найден обычным способом
        print(f"Attribute {name} not found, creating default")
        return f"default_{name}"

obj = DynamicObject()
print(obj.existing)  # value (обычный атрибут)
print(obj.missing)   # default_missing (__getattr__ вызвана)

Использование: динамические объекты, миграции параметров, API клиенты.

4. setattr() — контролируемая запись

class ValidatedUser:
    def __setattr__(self, name, value):
        if name == 'age':
            if not isinstance(value, int) or value < 0:
                raise ValueError(f"Invalid age: {value}")
        elif name == 'email':
            if '@' not in value:
                raise ValueError(f"Invalid email: {value}")
        
        object.__setattr__(self, name, value)

user = ValidatedUser()
user.age = 25  # OK
user.email = "alice@example.com"  # OK
# user.age = -5  # ValueError: Invalid age: -5

5. delattr() — контроль удаления

class ProtectedObject:
    protected_attrs = {'id', 'created_at'}
    
    def __delattr__(self, name):
        if name in self.protected_attrs:
            raise AttributeError(f"Cannot delete protected attribute: {name}")
        object.__delattr__(self, name)

obj = ProtectedObject()
obj.id = 1
obj.description = "Some text"

del obj.description  # OK
# del obj.id  # AttributeError: Cannot delete protected attribute: id

6. Property декоратор (@property)

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        """Getter"""
        print(f"Getting radius")
        return self._radius
    
    @radius.setter
    def radius(self, value):
        """Setter с валидацией"""
        if value <= 0:
            raise ValueError("Radius must be positive")
        print(f"Setting radius to {value}")
        self._radius = value
    
    @radius.deleter
    def radius(self):
        """Deleter"""
        print("Deleting radius")
        del self._radius

circle = Circle(5)
print(circle.radius)  # Getting radius, 5
circle.radius = 10     # Setting radius to 10
del circle.radius      # Deleting radius

Преимущества:

• Синтаксис как обычный атрибут
• Легко добавлять валидацию
• Защита от неправильных присваиваний

7. Descriptors (дескрипторы) — самый мощный инструмент

class ValidatedString:
    def __init__(self, field_name):
        self.field_name = field_name
    
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.field_name, None)
    
    def __set__(self, obj, value):
        if not isinstance(value, str):
            raise TypeError(f"{self.field_name} must be string")
        if len(value) < 3:
            raise ValueError(f"{self.field_name} too short")
        obj.__dict__[self.field_name] = value
    
    def __delete__(self, obj):
        del obj.__dict__[self.field_name]

class User:
    name = ValidatedString('name')
    email = ValidatedString('email')
    
    def __init__(self, name, email):
        self.name = name
        self.email = email

user = User("Alice", "alice@example.com")
print(user.name)  # Alice
# user.name = "ab"  # ValueError: name too short

Использование: ORM (SQLAlchemy), валидация, lazy loading.

8. getitem() и setitem() — доступ через []

class CustomDict:
    def __init__(self):
        self._data = {}
    
    def __getitem__(self, key):
        print(f"Getting {key}")
        return self._data.get(key, "Not found")
    
    def __setitem__(self, key, value):
        print(f"Setting {key} = {value}")
        self._data[key] = value
    
    def __delitem__(self, key):
        print(f"Deleting {key}")
        del self._data[key]

obj = CustomDict()
obj['name'] = "Alice"  # Setting name = Alice
print(obj['name'])     # Getting name, Alice
del obj['name']        # Deleting name

9. @classmethod для доступа на уровне класса

class User:
    _instances = {}
    
    def __init__(self, user_id, name):
        self.user_id = user_id
        self.name = name
    
    @classmethod
    def get_or_create(cls, user_id, name):
        if user_id not in cls._instances:
            cls._instances[user_id] = cls(user_id, name)
        return cls._instances[user_id]

user1 = User.get_or_create(1, "Alice")
user2 = User.get_or_create(1, "Bob")  # Вернёт существующий
print(user1 is user2)  # True

10. @staticmethod для независимых методов

class Utils:
    @staticmethod
    def format_email(name):
        return f"{name.lower()}@example.com"

print(Utils.format_email("Alice"))  # alice@example.com

11. slots для оптимизации памяти

class Point:
    __slots__ = ['x', 'y']  # Только эти атрибуты разрешены
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

point = Point(1, 2)
# point.z = 3  # AttributeError: 'Point' object has no attribute 'z'

Использование:

• Экономия памяти (в 40-50% случаев)
• Защита от случайных атрибутов
• Улучшение производительности

12. hasattr(), getattr(), setattr(), delattr() — встроенные функции

class Config:
    def __init__(self):
        self.debug = True

config = Config()

# hasattr — проверка наличия
if hasattr(config, 'debug'):
    print("debug exists")

# getattr — чтение с дефолтом
value = getattr(config, 'timeout', 30)  # 30 если нет timeout
print(value)  # 30

# setattr — запись
setattr(config, 'timeout', 60)

# delattr — удаление
delattr(config, 'debug')

13. dir() — контроль над dir()

class SmartObject:
    def __init__(self):
        self.public = "visible"
        self._private = "hidden"
    
    def __dir__(self):
        # Контролируем, что показывает dir()
        return ['public']  # Скрываем _private

obj = SmartObject()
print(dir(obj))  # ['public']
print(obj._private)  # Но можно получить доступ, если знаешь имя

14. getstate() и setstate() — сериализация

class User:
    def __init__(self, name, password):
        self.name = name
        self.password = password
    
    def __getstate__(self):
        state = self.__dict__.copy()
        del state['password']  # Не сохраняем пароль
        return state
    
    def __setstate__(self, state):
        self.__dict__.update(state)
        self.password = None  # Пароль не восстанавливается

import pickle
user = User("Alice", "secret123")
serialized = pickle.dumps(user)
restored = pickle.loads(serialized)
print(restored.password)  # None (пароль не восстановлен)

Сравнение методов

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

1. Используй @property для простых случаев — валидация и вычисления
2. Используй descriptors для ORM и сложной логики
3. Избегай getattribute без необходимости — может убить производительность
4. Используй slots для больших коллекций объектов — существенная экономия памяти
5. Всегда предоставляй fallback в getattr — помогает при отладке

Профессиональный код использует комбинацию этих методов в зависимости от требований.