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

[TylerH]

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?

import copy;

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

# 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:

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "C:\Python27\lib\site-packages\spyderlib\widgets\externalshell\sitecustomize.py", line 487, in runfile
execfile(filename, namespace)
File "C:\Python27\Scripts\Grid\grid.py", line 64, in <module>
test = grid(2);
File "C:\Python27\Scripts\Grid\grid.py", line 10, in __new__
self.append(temp);
TypeError: append() takes exactly one argument (0 given)

Thanks for your time and help,
Tyler

 

[D H]

I'm trying to convert my __init__ to __new__

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.

but I can't find any docs on how the syntax differs

http://docs.python.org/2/reference/datamodel.html#object.__new__

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__.

 

[0xDEADBEEF]

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:

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

class b(a):
   def __init__(self,par1,par2):
      self.foo=par1
      self.bar=par2
   
   def someotherfunction(self):
      self.somefunction()
      print "wikki wikki "+str(self.bar)

so b can access the methods of a

>>> 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

>>> 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
3

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:

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.

 

[TylerH]

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]

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

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.

 

[0xDEADBEEF]

This example might help you http://stackoverflow.com/questions/2673651/inheritance-from-str-or-int