Why doesn't Python call instance method __init__() on instance creation but calls class-provided __init__() instead?

Question

I'm overring the __new__() method of a class to return a class instance which has a specific __init__() set. Python seems to call the class-provided __init__() method instead of the instance-specific method, although the Python documentation at

http://docs.python.org/reference/datamodel.html

says:

Typical implementations create a new instance of the class by invoking the superclass’s __new__() method using super(currentclass, cls).__new__(cls[, ...]) with appropriate arguments and then modifying the newly-created instance as necessary before returning it.

If __new__() returns an instance of cls, then the new instance’s __init__() method will be invoked like __init__(self[, ...]), where self is the new instance and the remaining arguments are the same as were passed to __new__().

Here's my test code:

#!/usr/bin/env python

import new

def myinit(self, *args, **kwargs):
    print "myinit called, args = %s, kwargs = %s" % (args, kwargs)


class myclass(object):
    def __new__(cls, *args, **kwargs):
        ret = object.__new__(cls)

        ret.__init__ = new.instancemethod(myinit, ret, cls)
        return ret

    def __init__(self, *args, **kwargs):
        print "myclass.__init__ called, self.__init__ is %s" % self.__init__
        self.__init__(*args, **kwargs)

a = myclass()

which outputs

$ python --version
Python 2.6.6
$ ./mytest.py
myclass.__init__ called, self.__init__ is <bound method myclass.myinit of <__main__.myclass object at 0x7fa72155c790>>
myinit called, args = (), kwargs = {}

It seems the only way to get myinit() to run, is to call it explicitly as self.__init__() inside myclass.__init__().

Answer 1

Special methods on new-style classes are looked up on the instance's type, not on the instance itself. This is documented behaviour:

For new-style classes, implicit invocations of special methods are only guaranteed to work correctly if defined on an object’s type, not in the object’s instance dictionary. That behaviour is the reason why the following code raises an exception (unlike the equivalent example with old-style classes):

>>> class C(object):
...     pass
...
>>> c = C()
>>> c.__len__ = lambda: 5
>>> len(c)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'C' has no len()

Answer 2

Various special methods (including __init__, but also operator overloads such as __add__, etc.) are always accessed via the class rather than the instance. Not only that, but they can't be accessed via a __getattr__ or __getattribute__ method on the class or metaclass, they have to be on the class directly. This is for reasons of efficiency:

Bypassing the __getattribute__() machinery in this fashion provides significant scope for speed optimisations within the interpreter, at the cost of some flexibility in the handling of special methods (the special method must be set on the class object itself in order to be consistently invoked by the interpreter).

It's not entirely clear what you're trying to accomplish, but one thing you could do here is to subclass myclass within the __new__ method:

class myclass(object):
    def __new__(cls, *args, **kwargs):
        class subcls(cls):
            def __new__(cls, *args, **kwargs):
                return object.__new__(cls)
        subcls.__init__ = myinit
        return subcls(*args, **kwargs)

Answer 3

Why doesn't Python call instance method init() on instance creation but calls class-provided init() instead?

Check out this example.

class C:
   one = 42
   def __init__(self,val):
        self.two=val
ci=C(50)
print(ci.__dict__)
print(C.__dict__)

---

The result will be like this:

{'two': 50}
{'__module__': '__main__', 'one': 42, '__init__': <function C.__init__ at 0x00000213069BF6A8>, '__dict__': <attribute '__dict__' of 'C' objects>, '__weakref__': <attribute '__weakref__' of 'C' objects>, '__doc__': None}

Note that only the value {'two': 50} is part of the instance dict.

'one': 42 belongs to a class C dict. The same is with the __init__ method.

This is per design.