Ken Schutte wrote:
> Steven Bethard wrote:
>>
>> The __new__ method is for immutable types. So things like str and int
>> do their initialization in __new__. But for regular mutable types,
>> you should do your initialization in __init__::
>
> I see... So, is there a use for __new__ in mutable types? From my
> list-derirved class, it was obviously being called, but it's return
> value is totally ignored?
Not ignored, it's just having it's __init__ method called after your
__new__ method.
It might help for a moment to consider what happens when you call a
class object, e.g.::
c = C()
Just like any other object, when Python sees the ``()``, it looks for a
__call__ method on the object. Now classes are instances of the
``type`` type, which has a call method that looks something like::
def __call__(cls, *args, **kwargs):
result = cls.__new__(cls, *args, **kwargs)
if isinstance(result, cls):
result.__init__(*args, **kwargs)
return result
What's happening in your list case is that list.__init__ clears the list::
>>> l = [1, 2, 3]
>>> l.__init__()
>>> l
[]
So even though your __new__ method returns the object you want, the
__init__ method is clearing out all the items you've added and then
re-adding them as it normally would. To prove this to yourself, take a
look at what happens when we override __init__::
>>> class mylist(list):
... def __new__(cls, items):
... result = super(mylist, cls).__new__(cls)
... for item in items:
... result.append('%s_' % item)
... return result
...
>>> mylist([1, 2, 3])
[1, 2, 3]
>>> class mylist(list):
... def __new__(cls, items):
... result = super(mylist, cls).__new__(cls)
... for item in items:
... result.append('%s_' % item)
... return result
... def __init__(self, items):
... pass
...
>>> mylist([1, 2, 3])
['1_', '2_', '3_']
Of course, I've made __new__ work above, but the simpler solution is
just to override __init__ since that's where all the work's being done
anyway.
See Alex Martelli's response to answer your question "So, is there a use
for __new__ in mutable types?". You'd probably only want to override
__new__ if you were going to use the class as a factory to produce a
bunch of different types of objects.
STeVe
--
http://mail.python.org/mailman/listinfo/python-list
