Что определяет иммутабельность класса в Python?

А, вот эта тема про иммутабельность, да? Ну, слушай, тут такая история, как с Герасимом и Муму, блядь. Ты думаешь, если у класса есть атрибуты — он уже как бы «зафиксированный»? Хуй там! Это как сказать: «Вот собачка, она теперь твоя, и она всегда будет вот такой». А потом ты ей в миску еды подсыпал — и всё, пиздец, она уже другая, блядь! Состояние изменилось.

Иммутабельность — это когда ты создал объект, и он как гранитная хуйня, вротберунчик. Ни тронуть, ни изменить. Почему это важно? Ну, представь, ты в многопоточном аду работаешь, и у тебя десять потоков пытаются одну переменную на все дыры давалка. Если объект изменяемый — будет пиздец, они друг другу значения перетрут, и ты потом три дня будешь искать, где же эта сука ошибка. А если он иммутабельный — расслабься, хоть сто потоков, он как был, так и есть, ни хуя себе, предсказуемо.

Как сделать класс по-настоящему крепким, чтобы его не сломать? Есть варианты, конечно.

1. Ручной режим, как у деда в гараже. Переопределяешь __setattr__, чтобы он на любое «дай поменять» кричал: «Иди нахуй, мудак!» И __slots__ в помощь, чтобы новых атрибутов с потолка не навешивали.
2. Лёгкий путь, для умных. Берёшь dataclasses с frozen=True (Пайтон 3.7+, не будь динозавром) — и вуаля, тебе сделали всё, зашибись.

Смотри, вот пример класса, который ведёт себя как распиздяй — всё меняет, когда захочет:

class MutablePoint:
    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y

point = MutablePoint(1, 2)
print(f"Исходная точка: ({point.x}, {point.y})") # Вывод: (1, 2)
point.x = 10 # Атрибут можно изменить
print(f"Измененная точка: ({point.x}, {point.y})") # Вывод: (10, 2)

Видишь? Только создали точку (1, 2), а она уже стала (10, 2). Ну ёпта, кто так строит, блядь? Хитрая жопа.

А вот пример, где мы сами всё контролируем, как Герасим, который решил, что так будет правильно:

class ImmutablePoint:
    __slots__ = ('_x', '_y') # Используем __slots__ и префикс '_' для внутренних атрибутов

    def __init__(self, x: int, y: int):
        # Для инициализации атрибутов в иммутабельном классе нужно обойти __setattr__
        # или использовать super().__setattr__
        super().__setattr__('_x', x)
        super().__setattr__('_y', y)

    @property
    def x(self) -> int:
        return self._x

    @property
    def y(self) -> int:
        return self._y

    def __setattr__(self, name, value):
        # Запрещаем изменение любых атрибутов после инициализации
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}' or is immutable")

    def __repr__(self):
        return f"ImmutablePoint(x={self.x}, y={self.y})"

point = ImmutablePoint(1, 2)
print(f"Исходная точка: {point}") # Вывод: ImmutablePoint(x=1, y=2)
try:
    point.x = 10 # Попытка изменить атрибут вызовет ошибку
except AttributeError as e:
    print(f"Ошибка при попытке изменения: {e}") # Вывод: Ошибка при попытке изменения: 'ImmutablePoint' object has no attribute 'x' or is immutable

Вот! Попробовал изменить — получил, сука, по ебалу с ошибкой. Максимализм, блядь, но работает.

Но самый, блядь, элегантный способ — это dataclasses. Просто, модно, молодёжно:

from dataclasses import dataclass

@dataclass(frozen=True) # frozen=True делает класс иммутабельным
class FrozenPoint:
    x: int
    y: int

point = FrozenPoint(1, 2)
print(f"Исходная точка: {point}") # Вывод: FrozenPoint(x=1, y=2)
try:
    point.x = 10 # Попытка изменить атрибут вызовет ошибку
except Exception as e: # dataclasses.FrozenInstanceError
    print(f"Ошибка при попытке изменения: {type(e).__name__}: {e}") # Вывод: FrozenInstanceError: cannot assign to field 'x'

Вот и всё, ебать мои старые костыли. frozen=True — и объект заморожен, как собачка Муму в озере, блядь. Ни тронуть, ни изменить. Красота, да и только.

Так что запомни: наличие атрибутов — это просто наличие, а иммутабельность — это когда ты на них поставил, блядь, замок и сказал: «Всё, пиздец, ни шагу назад».