overriding a tuple's __init__

[Simon Burton]

Python 2.2.2 (#2, Nov 24 2002, 11:41:06)
[GCC 3.2 20020903 (Red Hat Linux 8.0 3.2-7)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
.... def __init__(self,a,b):
.... tuple.__init__(self, (a,b) )
.... Traceback (most recent call last):

What gives? (yes it works with a list, but i need immutable/hashable)

Simon Burton.

 

[Aahz]

Python 2.2.2 (#2, Nov 24 2002, 11:41:06)
[GCC 3.2 20020903 (Red Hat Linux 8.0 3.2-7)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
... def __init__(self,a,b):
... tuple.__init__(self, (a,b) )
... Traceback (most recent call last):

What gives? (yes it works with a list, but i need immutable/hashable)

You need to define __new__(); __init__() gets called *after* object
creation, when it's already immutable.

 

[Simon Burton]

You need to override __new__ instead of __init__:

I need to grow a brain. thanks Duncan.

Simon.

 

[Andrew Dalke]

Simon Burton:

... def __init__(self,a,b):
... tuple.__init__(self, (a,b) )

What gives? (yes it works with a list, but i need immutable/hashable)

The problem is the immutability. This one one of the
new changes in 2.3 I still don't fully understand, but I do
know the solution is __new__
.... def __new__(self, a, b):
.... return tuple((a, b))
....
That should give you some pointers for additional searches.

Andrew
(e-mail address removed)

 

[Aahz]

The problem is the immutability. This one one of the
new changes in 2.3 I still don't fully understand, but I do
know the solution is __new__

... def __new__(self, a, b):
... return tuple((a, b))
...

That should give you some pointers for additional searches.

This works better:

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

 

[Andrew Dalke]

Aahz:

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

Right. cls instead of self because it isn't passed the instance.

It would help me learn this new part of Python if I had
any use for it.

Though *args likely isn't what the OP wanted - I assume
that 'pair' takes only two elements.

Andrew
(e-mail address removed)

 

[Michele Simionato]

Simon Burton:


The problem is the immutability. This one one of the
new changes in 2.3

<nitpick mode> Actually this was a change in 2.2 </nitpick mode>

__new__ is needed to acts on the creation of immutable objects and this
is the right way to use it; unfortunaly it gives room to plenty of abuses:

class YouThinkIamAString(str):
def __new__(cls,arg):
return 42

print YouThinkIamAString("What's the answer?")

Yes, in Python you cannot modify the builtins, but still you have plenty
of rope to shoot in your foot



Michele

 

[Bengt Richter]

This works better:

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

so far, just

class pair(tuple): pass

should do it, no? Unless you want to take the name as suggesting that
length 2 should be enforced. Don't know what other methods are planned,
but ISTM you get the vanilla __new__ for free. Or am I missing something?

Regards,
Bengt Richter

 

[Aahz]

so far, just

class pair(tuple): pass

should do it, no? Unless you want to take the name as suggesting that
length 2 should be enforced. Don't know what other methods are planned,
but ISTM you get the vanilla __new__ for free. Or am I missing something?

Certainly; I'm just illustrating the principle if you wanted to do
something useful. ;-)