Dismiss Notice
Join Physics Forums Today!
The friendliest, high quality science and math community on the planet! Everyone who loves science is here!

Python: Old-style to New-style Class Conversion Causes Error

  1. Dec 11, 2012 #1
    I'm trying to convert my __init__ to __new__, but I can't find any docs on how the syntax differs or anything really, that pertains to how this bug could be caused by it. What am I doing wrong here?

    Code (Text):
    import copy;

    class grid(list):
        def __new__(self, size):
            self.size = size;
            for i in range(size):
                temp = list();
                for j in range(size):

    # Other methods that aren't being used and aren't in the trace.

    test = grid(2);
    It works perfectly like this. When I substitute __new__ for __init__, I get this:
    Thanks for your time and help,
  2. jcsd
  3. Dec 11, 2012 #2

    D H

    User Avatar
    Staff Emeritus
    Science Advisor

    Why do you want to do that? __new__ and __init__ are different things. __new__ is a static method. It does not take self as an argument; self doesn't exist yet. The __new__ method instead takes the class as its first argument and creates (but does not necessarily initialize) a new instance of the class. The __new__ method returns this newly created instance.

    Initializing a new member of a class is a job of the __init__ method.


    Note the final paragraph on __new__:
    __new__() is intended mainly to allow subclasses of immutable types (like int, str, or tuple) to customize instance creation. It is also commonly overridden in custom metaclasses in order to customize class creation.​
    You normally don't override __new__.
  4. Dec 11, 2012 #3
    Why would you change __init__() to __new__(). Bad idea! They are not the same and init is the way to go! __new__() is an ugly hack to make inheritance from immutable types work.

    Normal inheritance works like this:

    Code (Text):

    class a:
       def __init__(self,par):
       def somefunction(self):
          print "wakka wakka "+str(self.foo)

    class b(a):
       def __init__(self,par1,par2):
       def someotherfunction(self):
          print "wikki wikki "+str(self.bar)
    so b can access the methods of a

    Code (Text):

    >>> x=b("gaga","haha")
    >>> x.someotherfunction()
    wakka wakka gaga
    wikki wikki haha
    >>> x.somefunction()
    wakka wakka gaga
    Class declarations are also objects and you can modify them. For example if you want to know how many instances of class b have ever been created you could put a counter in b
    Code (Text):

    >>> class b(a):
    ...    def __init__(self,par1,par2):
    ...       b.instance_counter+=1
    ...       self.foo=par1
    ...       self.bar=par2
    >>> b.instance_counter=0
    >>> e=b("","")
    >>> f=b("","")
    >>> g=b("","")
    >>> print b.instance_counter
    You see that instance_counter is a member of b not of any instance of b. You can also add functions that are not member functions (without "self") to b this way.

    So what happens when you create a class instance, is that python builds some empty object with the respective member functions, and hands it to the __init__() function, and then it can get modified by init. With immutable types __init__() cannot do its job. After python has created the immutable object, init functions cannot modify it anymore. So __new__() was invented which steps in before init. And it does not receive a pre build self object but a class! So when you use __new__(), you call __new__() of the immutable type that you want to inherit from, giving it the unchangeable value that you want. When you are done creating that object __init__ gets called with the created object as self.

    Let's go through your code:
    Code (Text):

    import copy;#you don't use copy anywhere in your example

    class grid(list):
        def __new__(self, size): #self points to the class grid now not to any object
            self.size = size; #add a size variable to grid class declaration just like instance_number
            for i in range(size):
                temp = list(); # Aaaargh why do you use semicolons this is not c!
                for j in range(size):
                    temp.append(False); #fill the list with False
                self.append(temp);  #call the function grid.append() I don't even know what it is
                                     # it is not an object of grid but the of the grid declaration itself!
    To make a long argument short. Just don't ever use __new__() it's for people who smell of java, and think sub classing integers is cool.
  5. Dec 11, 2012 #4
    I use the copy module later, in code I removed to reduce the amount you have to read. [STRIKE]The reason I'm using new at all is because I read that __init__ is going to be removed in 3.0+.[/STRIKE]
    EDIT: Nevermind. Either I misunderstood what I read or I didn't remember it correctly. I now know that __init__ isn't depreciated in 3+
    [STRIKE]So, if this is my class, how do I make it 3+ compatible?[/STRIKE]
    Code (Text):
    class grid(list):
        def __init__(self, size):
            self.size = size;
            for i in range(size):
                temp = list();
                for j in range(size):
    Also, just for the sake of understanding (I get that it almost always isn't pythonic), how would you use __new__ to, eg, subclass string or some other immutable type.
    Last edited: Dec 11, 2012
  6. Dec 12, 2012 #5
Share this great discussion with others via Reddit, Google+, Twitter, or Facebook