В чем разница между методами __new__ и __init__ в Python?

А, слушай, вот тебе история, которая многих вводит в ступор, как будто они впервые видят два одинаковых ключа от разных замков. Речь про __new__ и __init__. Это, блядь, основа основ, но люди их постоянно путают, а потом удивление пиздец — почему код работает как кот, сука, собака.

Представь себе такую картину. Ты приходишь на стройку. __new__ — это прораб, который получает чертёж (это класс, cls) и говорит: «Так, мужики, нам нужна одна хатка. Делаем фундамент, стены, крышу — вот вам готовая коробка». Он создаёт сам объект из ничего, как бог из глины. Это конструктор в чистом виде, он возвращает эту самую новую коробку-объект.

А потом в работу вступает __init__. Это уже дизайнер-отделочник. Он приходит в готовую пустую коробку (это self) и начинает там всё обустраивать: «Сюда диван, тут телевизор повесим, а на стену — фотку тёщи, чтобы пугаться». Он ничего не возвращает, он просто настраивает то, что ему передали.

Вот тебе живой пример, чтобы совсем мозг не взорвался:

class MyClass:
    def __new__(cls, *args, **kwargs):
        print(f"Ёпта, вызываю __new__. Создаю экземпляр для {cls.__name__}")
        # Всё, мужики, главная магия тут. Просим у базового object создать объект.
        instance = super().__new__(cls)
        return instance  # Возвращаем голую заготовку

    def __init__(self, value):
        print(f"А теперь __init__! Настраиваю объект, value={value}")
        self.value = value  # Вешаем табличку с номером

obj = MyClass(42)
# Выведет:
# Ёпта, вызываю __new__. Создаю экземпляр для MyClass
# А теперь __init__! Настраиваю объект, value=42

Видишь порядок? Сначала __new__ делает объект, потом __init__ его начиняет. Без первого — второго просто не будет, потому что инициализировать нечего, чистая пустота.

А зачем вообще этот __new__, если __init__ всегда был в деле? Вот тут начинается самое интересное. Обычному смертному в __new__ лезть не надо, но есть моменты, когда без него — просто никуда, ёперный театр.

1. Неизменяемые типы (immutable). Представь, ты делаешь свой собственный аналог кортежа. В __init__ ты уже не можешь поменять внутренности объекта, потому что он якобы неизменяемый. Вся логика по «упаковке» данных должна произойти в момент создания. Поэтому __new__ — твой единственный друг.
2. Паттерн Singleton (когда нужен один экземпляр на весь мир). Классика жанра, где __new__ становится хитрой жопой.

class Singleton:
    _instance = None  # Здесь будем хранить нашу одну-единственную копию

    def __new__(cls):
        if cls._instance is None:
            print("Создаю единственный экземпляр, бля!")
            cls._instance = super().__new__(cls)
        # А вот тут внимание, ядрёна вошь! Мы ВСЕГДА возвращаем один и тот же объект.
        return cls._instance

    def __init__(self):
        # ВАЖНОЕ ПРЕДУПРЕЖДЕНИЕ! __init__ будет вызываться КАЖДЫЙ РАЗ, когда ты пишешь Singleton()!
        print("Singleton __init__ called. Может быть много раз, осторожно!")

s1 = Singleton()  # Создаст объект и вызовет __init__
s2 = Singleton()  # Вернёт старый объект, но __init__ вызовется снова!
print(s1 is s2)  # Выведет True, потому что это один и тот же объект в памяти.

Видишь подвох? __init__ отрабатывает при каждом вызове Singleton(), даже если объект старый. Поэтому с такими паттернами надо быть осторожным, а то доверия ебать ноль к такому коду будет.

Итог простой, как три копейки:

• __new__(cls, ...) — волшебник, который материализует объект из воздуха. Вызывается первым, должен вернуть этот объект.
• __init__(self, ...) — хозяйственник, который обживает готовую квартиру. Вызывается вторым (если __new__ вернул объект этого класса), ничего не возвращает, только настраивает self.

Запоминай так: __new__ — это «что создать», __init__ — это «как инициализировать». Перепутаешь — получишь TypeError и полное недоумение, какого хуя ничего не работает.