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

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

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