Python (и Python C API): __new__ против __init__

Разница в основном возникает с изменяемыми и неизменяемыми типами.

__new__ принимает тип в качестве первого аргумента и (обычно) возвращает новый экземпляр этого типа. Таким образом, он подходит для использования как с изменяемыми, так и с неизменяемыми типами.

__init__ принимает экземпляр в качестве первого аргумента и изменяет атрибуты этого экземпляра. Это не подходит для неизменяемого типа, поскольку позволяет изменять его после создания путем вызова obj.__init__(*args).

Сравните поведение tuple и list:

>>> x = (1, 2)
>>> x
(1, 2)
>>> x.__init__([3, 4])
>>> x # tuple.__init__ does nothing
(1, 2)
>>> y = [1, 2]
>>> y
[1, 2]
>>> y.__init__([3, 4])
>>> y # list.__init__ reinitialises the object
[3, 4]

Относительно того, почему они разделены (помимо простых исторических причин): __new__ методы требуют набора шаблонов для правильного выполнения (начальное создание объекта и последующее возвращение объекта в конце). __init__ методы, напротив, чрезвычайно просты, поскольку вы просто устанавливаете те атрибуты, которые вам нужно установить.

Помимо упрощения написания __init__ методов и отмеченного выше различия между изменяемым и неизменяемым, разделение также можно использовать для того, чтобы сделать вызов родительского класса __init__ в подклассах необязательным путем установки любых абсолютно необходимых инвариантов экземпляра в __new__. Как правило, это сомнительная практика - обычно проще просто вызвать __init__ методы родительского класса по мере необходимости.

Вероятно, есть и другие варианты использования __new__, но есть одно действительно очевидное: нельзя создать подкласс неизменяемого типа без использования __new__. Так, например, предположим, что вы хотите создать подкласс кортежа, который может содержать только целые значения от 0 до size.

class ModularTuple(tuple):
    def __new__(cls, tup, size=100):
        tup = (int(x) % size for x in tup)
        return super(ModularTuple, cls).__new__(cls, tup)

Вы просто не можете сделать это с __init__ - если вы попытаетесь изменить self в __init__, интерпретатор пожалуется, что вы пытаетесь изменить неизменяемый объект.

__new__() может возвращать объекты типов, отличных от класса, к которому он привязан. __init__() только инициализирует существующий экземпляр класса.

>>> class C(object):
...   def __new__(cls):
...     return 5
...
>>> c = C()
>>> print type(c)
<type 'int'>
>>> print c
5

Не полный ответ, но, возможно, что-то, что иллюстрирует разницу.

__new__ всегда будет вызываться при создании объекта. В некоторых ситуациях __init__ не получают вызова. Один из примеров: когда вы извлекаете объекты из файла pickle, они выделяются (__new__), но не инициализируются (__init__).

Просто хочу добавить пару слов о намерении (в отличие от поведения) определения __new__ по сравнению с __init__.

Я столкнулся с этим вопросом (среди прочего), когда пытался понять, как лучше всего определить фабрику классов. Я понял, что одним из аспектов, в котором __new__ концептуально отличается от __init__, является тот факт, что преимущество __new__ - это именно то, что было заявлено в вопросе:

Таким образом, единственным преимуществом метода __new__ является то, что переменная экземпляра будет начинаться с пустой строки, а не с NULL. Но почему это вообще полезно, ведь если бы мы позаботились о том, чтобы наши переменные экземпляра были инициализированы некоторым значением по умолчанию, мы могли бы просто сделать это в методе __init__?

Учитывая заявленный сценарий, мы заботимся о начальных значениях переменных экземпляра, когда экземпляр на самом деле является самим классом. Итак, если мы динамически создаем объект класса во время выполнения и нам нужно определить / контролировать что-то особенное в последующих экземплярах этого создаваемого класса, мы должны определить эти условия / свойства в __new__ методе метакласса.

Я был сбит с толку до тех пор, пока на самом деле не подумал о применении концепции, а не только о ее значении. Вот пример, который, мы надеемся, прояснит разницу:

a = Shape(sides=3, base=2, height=12)
b = Shape(sides=4, length=2)
print(a.area())
print(b.area())

# I want `a` and `b` to be an instances of either of 'Square' or 'Triangle'
# depending on number of sides and also the `.area()` method to do the right
# thing. How do I do that without creating a Shape class with all the
# methods having a bunch of `if`s ? Here is one possibility

class Shape:
    def __new__(cls, sides, *args, **kwargs):
        if sides == 3:
            return Triangle(*args, **kwargs)
        else:
            return Square(*args, **kwargs)

class Triangle:
    def __init__(self, base, height):
        self.base = base
        self.height = height

    def area(self):
        return (self.base * self.height) / 2

class Square:
    def __init__(self, length):
        self.length = length

    def area(self):
        return self.length*self.length

Обратите внимание, это просто наглядный пример. Есть несколько способов получить решение, не прибегая к подходу фабрики классов, как указано выше, и даже если мы решим реализовать решение таким образом, для краткости оставлены небольшие оговорки (например, явное объявление метакласса )

Если вы создаете обычный класс (он же неметакласс), тогда __new__ действительно не имеет смысла, если только это не особый случай, например, сценарий изменяемого и неизменяемого в ответ ncoghlan (который, по сути, является более конкретным примером концепции определения начальных значений / свойств класса / типа, создаваемого с помощью __new__, которые затем инициализируются с помощью __init__).

Одно из конкретных применений __new__ - сделать класс одноэлементным:

class SingletonClass(object):
  def __new__(cls):
    if not hasattr(cls, 'instance'):
      cls.instance = super(SingletonClass, cls).__new__(cls)
    return cls.instance 

(источник: Шаблон Singleton в Python - Полное руководство - GeeksforGeeks)