Python (и Python C API): новый против 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__ не будет вызван. Например, когда вы распаковываете объекты из файла рассола, они будут выделены (__new__), но не инициализирован (__init__).

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

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

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

учитывая изложенный сценарий, мы заботимся о начальных значениях переменных экземпляра, когда экземпляр на самом деле сам класс. Итак, если мы динамически создавая объект класса во время выполнения, и нам нужно определить / контролировать что-то особенное о последующих экземплярах этого создаваемого класса, мы определили бы эти условия/свойства в __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

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

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