Why is init always called after new

Question

I m just trying to streamline one of my classes and have introduced some functionality in the same style as the flyweight design pattern   However  I m a bit confused as to why   init   is always called after   new    I wasn t expecting this  Can anyone tell me why this is happening and how I can implement this functionality otherwise   Apart from putting the implementation into the   new   which feels quite hacky    Here s an example   class A object        dict   dict        def   new   cls           if  key  in A  dict              print  EXISTS              return A  dict  key           else              print  NEW              return super A  cls    new   cls       def   init   self           print  INIT          A  dict  key     self         print     a1   A   a2   A   a3   A     Outputs   NEW INIT  EXISTS INIT  EXISTS INIT   Why

User · Answer

One should look at   init   as a simple constructor in traditional OO languages  For example  if you are familiar with Java or C    the constructor is passed a pointer to its own instance implicitly  In the case of Java  it is the this variable  If one were to inspect the byte code generated for Java  one would notice two calls  The first call is to an  new  method  and then next call is to the init method  which is the actual call to the user defined constructor   This two step process enables creation of the actual instance before calling the constructor method of the class which is just another method of that instance   Now  in the case of Python    new   is a added facility that is accessible to the user  Java does not provide that flexibility  due to its typed nature  If a language provided that facility  then the implementor of   new   could do many things in that method before returning the instance  including creating a totally new instance of a unrelated object in some cases  And  this approach also works out well for especially for immutable types in the case of Python

User · Answer

class M type        dict           def   call   cls  key           if key in cls  dict              print  EXISTS              return cls  dict key          else              print  NEW              instance   super M  cls    call   key              cls  dict key    instance             return instance  class A object         metaclass     M      def   init   self  key           print  INIT          self key   key         print  a1   A  aaa   a2   A  bbb   a3   A  aaa     outputs   NEW INIT  NEW INIT  EXISTS   NB As a side effect M  dict property automatically becomes accessible from A as A  dict so take care not to overwrite it incidentally

User · Answer

I realize that this question is quite old but I had a similar issue  The following did what I wanted   class Agent object        agents   dict        def   new   cls   p           number   p 0          if not number in cls  agents              cls  agents number    object   new   cls          return cls  agents number       def   init   self  number           self number   number      def   eq   self  rhs           return self number    rhs number  Agent  a   is Agent  a      True   I used this page as a resource http   infohost nmt edu tcc help pubs python web new-new-method html

User · Answer

The simple reason is that the new is used for creating an instance  while init is used for initializing the instance  Before initializing  the instance should be created first  That s why new should be called before init

User · Answer

The   init   is called after   new   so that when you override it in a subclass  your added code will still get called   If you are trying to subclass a class that already has a   new    someone unaware of this might start by adapting the   init   and forwarding the call down to the subclass   init     This convention of calling   init   after   new   helps that work as expected   The   init   still needs to allow for any parameters the superclass   new   needed  but failing to do so will usually create a clear runtime error   And the   new   should probably explicitly allow for  args and    kw   to make it clear that extension is OK   It is generally bad form to have both   new   and   init   in the same class at the same level of inheritance  because of the behavior the original poster described

User · Answer

new   is static class method  while   init   is instance method     new   has to create the instance first  so   init   can initialize it  Note that   init   takes self as parameter  Until you create instance there is no self   Now  I gather  that you re trying to implement singleton pattern in Python  There are a few ways to do that   Also  as of Python 2 6  you can use class decorators    def singleton cls       instances          def getinstance            if cls not in instances              instances cls    cls           return instances cls      return getinstance   singleton class MyClass

User · Answer

However  I m a bit confused as to why   init   is always called after   new      I think the C   analogy would be useful here      new   simply allocates memory for the object  The instance variables of an object needs memory to hold it  and this is what the step   new   would do    init   initialize the internal variables of the object to specific values  could be default

User · Answer

I think the simple answer to this question is that  if   new   returns a value that is the same type as the class  the   init   function executes  otherwise it won t  In this case your code returns A  dict  key   which is the same class as cls  so   init   will be executed

User · Answer

An update to  AntonyHatchkins answer  you probably want a separate dictionary of instances for each class of the metatype  meaning that you should have an   init   method in the metaclass to initialize your class object with that dictionary instead of making it global across all the classes   class MetaQuasiSingleton type       def   init   cls  name  bases  attibutes           cls  dict           def   call   cls  key           if key in cls  dict              print  EXISTS               instance   cls  dict key          else              print  NEW               instance   super     call   key              cls  dict key    instance         return instance  class A metaclass MetaQuasiSingleton       def   init   self  key           print  INIT          self key   key         print     I have gone ahead and updated the original code with an   init   method and  changed the syntax to Python 3 notation  no-arg call to super and metaclass in the class arguments instead of as an attribute    Either way  the important point here is that your class initializer    call   method  will not execute either   new   or   init   if the key is found  This is much cleaner than using   new    which requires you to mark the object if you want to skip the default   init   step

User · Answer

Referring to this doc       When subclassing immutable built-in types like numbers and strings    and occasionally in other situations  the static method new comes   in handy  new is the first step in instance construction  invoked   before init        The new method is called with the class as its   first argument  its responsibility is to return a new instance of that   class        Compare this to init  init is called with an instance   as its first argument  and it doesn t return anything  its   responsibility is to initialize the instance        There are situations   where a new instance is created without calling init  for example   when the instance is loaded from a pickle   There is no way to create   a new instance without calling new  although in some cases you can   get away with calling a base class s new     Regarding what you wish to achieve  there also in same doc info about Singleton pattern  class Singleton object           def   new   cls   args    kwds               it   cls   dict   get    it                 if it is not None                  return it             cls   it     it   object   new   cls              it init  args    kwds              return it         def init self   args    kwds               pass   you may also use this implementation from PEP 318  using a decorator  def singleton cls       instances          def getinstance            if cls not in instances              instances cls    cls           return instances cls      return getinstance   singleton class MyClass

User · Answer

Now I ve got the same problem  and for some reasons I decided to avoid decorators  factories and metaclasses  I did it like this   Main file  def  alt func       import functools      functools wraps func      def init self   p    k           if hasattr self   parent initialized                return         else              self parent initialized   True             func self   p    k       return init   class Parent        Empty dictionary  shouldn t ever be filled with anything else     parent cache           def   new   cls  n   args    kwargs              Checks if object with this ID  n  has been created         if n in cls parent cache                 It was  return it             return cls parent cache n           else                 Check if it was modified by this function             if not hasattr cls   parent modified                      Add the attribute                 cls parent modified   True                 cls parent cache                         Apply it                 cls   init      alt cls   init                   Get the instance             obj   super     new   cls                 Push it to cache             cls parent cache n    obj                Return it             return obj   Example classes  class A Parent        def   init   self  n           print  A   init     n    class B Parent        def   init   self  n           print  B   init     n    In use   gt  gt  gt  A 1  A   init   1    First A 1  initialized   lt   main   A object at 0x000001A73A4A2E48 gt   gt  gt  gt  A 1         Returned previous A 1   lt   main   A object at 0x000001A73A4A2E48 gt   gt  gt  gt  A 2  A   init   2    First A 2  initialized  lt   main   A object at 0x000001A7395D9C88 gt   gt  gt  gt  B 2  B   init   2    B class doesn t collide with A  thanks to separate cache  lt   main   B object at 0x000001A73951B080 gt     Warning  You shouldn t initialize Parent  it will collide with other classes - unless you defined separate cache in each of the children  that s not what we want  Warning  It seems a class with Parent as grandparent behaves weird   Unverified    Try it online

User · Answer

However  I m a bit confused as to why   init   is always called after   new      Not much of a reason other than that it just is done that way    new   doesn t have the responsibility of initializing the class  some other method does    call    possibly-- I don t know for sure       I wasn t expecting this  Can anyone tell me why this is happening and how I implement this functionality otherwise   apart from putting the implementation into the   new   which feels quite hacky     You could have   init   do nothing if it s already been initialized  or you could write a new metaclass with a new   call   that only calls   init   on new instances  and otherwise just returns   new

User · Answer

In most well-known OO languages  an expression like SomeClass arg1  arg2  will allocate a new instance  initialise the instance s attributes  and then return it   In most well-known OO languages  the  initialise the instance s attributes  part can be customised for each class by defining a constructor  which is basically just a block of code that operates on the new instance  using the arguments provided to the constructor expression  to set up whatever initial conditions are desired  In Python  this corresponds to the class    init   method   Python s   new   is nothing more and nothing less than similar per-class customisation of the  allocate a new instance  part  This of course allows you to do unusual things such as returning an existing instance rather than allocating a new one  So in Python  we shouldn t really think of this part as necessarily involving allocation  all that we require is that   new   comes up with a suitable instance from somewhere   But it s still only half of the job  and there s no way for the Python system to know that sometimes you want to run the other half of the job    init    afterwards and sometimes you don t  If you want that behavior  you have to say so explicitly   Often  you can refactor so you only need   new    or so you don t need   new    or so that   init   behaves differently on an already-initialised object  But if you really want to  Python does actually allow you to redefine  the job   so that SomeClass arg1  arg2  doesn t necessarily call   new   followed by   init    To do this  you need to create a metaclass  and define its   call   method   A metaclass is just the class of a class  And a class    call   method controls what happens when you call instances of the class  So a metaclass    call   method controls what happens when you call a class  i e  it allows you to redefine the instance-creation mechanism from start to finish  This is the level at which you can most elegantly implement a completely non-standard instance creation process such as the singleton pattern  In fact  with less than 10 lines of code you can implement a Singleton metaclass that then doesn t even require you to futz with   new   at all  and can turn any otherwise-normal class into a singleton by simply adding   metaclass     Singleton   class Singleton type       def   init   self   args    kwargs           super Singleton  self    init    args    kwargs          self   instance   None     def   call   self   args    kwargs           if self   instance is None              self   instance   super Singleton  self    call    args    kwargs          return self   instance   However this is probably deeper magic than is really warranted for this situation

User · Answer

new   should return a new  blank instance of a class    init   is then called to initialise that instance  You re not calling   init   in the  NEW  case of   new    so it s being called for you  The code that is calling   new   doesn t keep track of whether   init   has been called on a particular instance or not nor should it  because you re doing something very unusual here   You could add an attribute to the object in the   init   function to indicate that it s been initialised  Check for the existence of that attribute as the first thing in   init   and don t proceed any further if it has been

User · Answer

Use   new   when you need to control   the creation of a new instance        Use     init   when you need to control initialization of a new instance         new   is the first step of instance creation   It s called first  and is   responsible for returning a new   instance of your class         In contrast      init   doesn t return anything  it s only responsible for initializing the   instance after it s been created       In general  you shouldn t need to   override   new   unless you re   subclassing an immutable type like   str  int  unicode or tuple    From April 2008 post  When to use   new   vs    init    on mail python org   You should consider that what you are trying to do is usually done with a Factory and that s the best way to do it  Using   new   is not a good clean solution so please consider the usage of a factory  Here you have a good factory example

User · Answer

To quote the documentation      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     does not return an instance of cls  then the new   instance s   init     method will not be invoked         new     is intended mainly to allow subclasses of immutable   types  like int  str  or tuple  to customize instance creation

User · Answer

When   new   returns instance of the same class    init   is run afterwards on returned object  I e  you can NOT use   new   to prevent   init   from being run  Even if you return previously created object from   new    it will be double  triple  etc     initialized by   init   again and again   Here is the generic approach to Singleton pattern which extends vartec answer above and fixes it   def SingletonClass cls       class Single cls             doc     cls   doc            initialized   False          instance   None          def   new   cls   args    kwargs               if not cls  instance                  cls  instance   super Single  cls    new   cls   args    kwargs              return cls  instance          def   init   self   args    kwargs               if self  initialized                  return             super Single  self    init    args    kwargs              self   class    initialized   True    Its crucial to set this variable on the class      return Single   Full story is here   Another approach  which in fact involves   new   is to use classmethods   class Singleton object         initialized   False      def   new   cls   args    kwargs           if not cls   initialized              cls   init    args    kwargs              cls   initialized   True         return cls   class MyClass Singleton        classmethod     def   init   cls  x  y           print  init is here        classmethod     def do cls           print  doing stuff    Please pay attention  that with this approach you need to decorate ALL of your methods with  classmethod  because you ll never use any real instance of MyClass

User · Answer

Digging little deeper into that   The type of a generic class in CPython is type and its base class is Object  Unless you explicitly define another base class like a metaclass   The sequence of low level calls can be found here  The first method called is the type call which then calls tp new and then tp init    The interesting part here is that tp new will call the Object s  base class  new method object new which does a tp alloc  PyType GenericAlloc  which allocates the memory for the object     At that point the object is created in memory and then the   init   method gets called  If   init   is not implemented in your class then the object init gets called and it does nothing     Then type call just returns the object which binds to your variable

[python] Why is init() always called after new()?

Examples related to python

Examples related to design-patterns

Examples related to class-design

[python] Why is __init__() always called after __new__()?

Examples related to python

Examples related to design-patterns

Examples related to class-design

[python] Why is init() always called after new()?