467,912 Members | 1,430 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 467,912 developers. It's quick & easy.

Question: Inheritance from a buil-in type

Hi there,

A simple but important question:

How can I initialize a super class (like dict) correctly in my subclass constructor?

A sample:

class MyClass(dict):
def __init__(self):
dict.__init__(self)
...
Is there a general rule to do this for all buil-in types?

Thanks for help.

Thomas
Jul 18 '05 #1
  • viewed: 9387
Share:
4 Replies
"T. Kaufmann" <me****@snafu.de> wrote in news:3F**************@snafu.de:
A simple but important question:

How can I initialize a super class (like dict) correctly in my
subclass constructor?

A sample:

class MyClass(dict):
def __init__(self):
dict.__init__(self)
...
Is there a general rule to do this for all buil-in types?


There are two rules. Generally, immutable objects get their initial values
from the constructor (__new__) while mutable objects are constructed with a
default value (e.g. empty list or dict) and are then set by the initialiser
(__init__) method. A few types which you might expect to be immutable are
actually mutable (e.g. property).

Mutable example (use for list, dict, property, etc.):

class MyClass(dict):
def __init__(self, *args, **kw):
dict.__init__(self, *args, **kw)

Immutable example (use for tuple, int, etc.):

class MyClass(tuple):
def __new__(cls, *args, **kw):
return tuple.__new__(cls, *args, **kw)

If there is any chance of your class being subclassed with multiple
inheritance involved, you should consider using super instead of naming the
baseclass directly, but most of the time you can get away with a direct
call to the baseclass.

--
Duncan Booth du****@rcp.co.uk
int month(char *p){return(124864/((p[0]+p[1]-p[2]&0x1f)+1)%12)["\5\x8\3"
"\6\7\xb\1\x9\xa\2\0\4"];} // Who said my code was obscure?
Jul 18 '05 #2
T. Kaufmann wrote:
Hi there,

A simple but important question:

How can I initialize a super class (like dict) correctly in my subclass
constructor?
Generally, you also want to override __new__ -- not in all cases can
you do all you want in __init__ by itself (e.g., it's far too late
when you inherit from immutable types, such as numbers, str, tuple).

A sample:

class MyClass(dict):
def __init__(self):
dict.__init__(self)
...
Yeah, you can do this, but the dict.__init__ call with just the
self parameter is actually redundant (it wouldn't be if there
WERE arguments -- either keyword ones, or a sequence of pairs,
or both -- with which to actually initialize a non-empty dict...).

Is there a general rule to do this for all buil-in types?


Generally, the super built-in may be advisable if you think you
may ever be involved in a multiple-inheritance graph. But that
is no different whether built-in types are involved, or not. I'm
not sure what "general rule" may be different for built-in types
than for others -- offhand, I don't think there are such differences.
Alex

Jul 18 '05 #3
Duncan Booth <du****@NOSPAMrcp.co.uk> wrote in message news:<Xn***************************@127.0.0.1>...

There are two rules. Generally, immutable objects get their initial values
from the constructor (__new__) while mutable objects are constructed with a
default value (e.g. empty list or dict) and are then set by the initialiser
(__init__) method. A few types which you might expect to be immutable are
actually mutable (e.g. property).


What is the thinking behind that? I mean you /can/ pass initial values
to a mutable using __new__, eg

class MyList (list) :
def __new__(cls, *args, **kwargs) :
return list.__new__(cls, *args, **kwargs)

or __init__ to pass values to a newly created immutable, eg

class MyTuple (tuple) :
def __init__(self, *args, **kwargs) :
return super(tuple, self).__init__(*args, **kwargs)

can't you? What's the pitfall?
Jul 18 '05 #4
af*****@yahoo.co.uk (Asun Friere) wrote in
news:38**************************@posting.google.c om:
Duncan Booth <du****@NOSPAMrcp.co.uk> wrote in message
news:<Xn***************************@127.0.0.1>...

There are two rules. Generally, immutable objects get their initial
values from the constructor (__new__) while mutable objects are
constructed with a default value (e.g. empty list or dict) and are
then set by the initialiser (__init__) method. A few types which you
might expect to be immutable are actually mutable (e.g. property).


What is the thinking behind that? I mean you /can/ pass initial values
to a mutable using __new__, eg

class MyList (list) :
def __new__(cls, *args, **kwargs) :
return list.__new__(cls, *args, **kwargs)

or __init__ to pass values to a newly created immutable, eg

class MyTuple (tuple) :
def __init__(self, *args, **kwargs) :
return super(tuple, self).__init__(*args, **kwargs)

can't you? What's the pitfall?

The pitfall is that these aren't doing what you think. In both cases you
just passed the original arguments straight through, so the list also got
the arguments it expected in its __init__ method, and the tuple got its
expected arguments in __new__. If you modify the arguments in any way
you'll find that your code still only sees the original arguments.

list.__init__ and tuple.__new__ act on their arguments.
list.__new__ and tuple.__init__ ignore their arguments.

Take the tuple example. tuple() takes 0 or 1 arguments, so you can't write:

tuple(1, 2, 3)

So define a class to do this:
class MyTuple(tuple): def __new__(cls, *args):
return tuple.__new__(cls, args)

MyTuple(1, 2, 3) (1, 2, 3)

Now try this with __init__ and the default __new__ will complain:
class MyTuple(tuple): def __init__(self, *args):
tuple.__init__(self, args)

MyTuple(1, 2, 3) Traceback (most recent call last):
File "<pyshell#73>", line 1, in ?
MyTuple(1, 2, 3)
TypeError: tuple() takes at most 1 argument (3 given)
If you try subclassing list, then this example shows clearly that the
arguments to __new__ are actually ignored:
class MyList (list) : def __new__(cls, *args, **kwargs) :
return list.__new__(cls, *args, **kwargs)
def __init__(self, *args, **kwargs):
print "list before init",self
list.__init__(self, *args, **kwargs)

print MyList([1, 2, 3])

list before init []
[1, 2, 3]
--
Duncan Booth du****@rcp.co.uk
int month(char *p){return(124864/((p[0]+p[1]-p[2]&0x1f)+1)%12)["\5\x8\3"
"\6\7\xb\1\x9\xa\2\0\4"];} // Who said my code was obscure?
Jul 18 '05 #5

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

17 posts views Thread by Andrew Koenig | last post: by
2 posts views Thread by JustSomeGuy | last post: by
2 posts views Thread by Tony Johansson | last post: by
3 posts views Thread by Luis Diego Fallas | last post: by
12 posts views Thread by Meya-awe | last post: by
6 posts views Thread by relient | last post: by
14 posts views Thread by petermichaux | last post: by
13 posts views Thread by barcaroller | last post: by
4 posts views Thread by sip.address | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.