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.

class pair(tuple): .... def __init__(self,a,b):
.... tuple.__init__(self, (a,b) )
.... a=pair(1,2) Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: tuple() takes at most 1 argument (2 given)

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

Simon Burton.

[Simon Burton]

On Mon, 18 Aug 2003 08:24:21 +0000, Duncan Booth wrote:

Simon Burton <si****@webone.com.au> wrote in
news:pa****************************@webone.com.au:

> class pair(tuple):

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

> a=pair(1,2)

Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: tuple() takes at most 1 argument (2 given)

>

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

You need to override __new__ instead of __init__:

:) I need to grow a brain. thanks Duncan.

Simon.

[Andrew Dalke]

Simon Burton:

class pair(tuple): ... 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__

class pair(tuple): .... def __new__(self, a, b):
.... return tuple((a, b))
....
pair(2,3) (2, 3) x=_
type(x) <type 'tuple'>

That should give you some pointers for additional searches.

Andrew
da***@dalkescientific.com

[Aahz]

In article <pa****************************@webone.com.au>,
Simon Burton <si****@webone.com.au> wrote:

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.

class pair(tuple):... def __init__(self,a,b):
... tuple.__init__(self, (a,b) )
... a=pair(1,2)Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: tuple() takes at most 1 argument (2 given)

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.
--
Aahz (aa**@pythoncraft.com) <*> http://www.pythoncraft.com/

This is Python. We don't care much about theory, except where it intersects
with useful practice. --Aahz

[Aahz]

In article <bh**********@slb3.atl.mindspring.net>,
Andrew Dalke <ad****@mindspring.com> wrote:

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__

class pair(tuple):... def __new__(self, a, b):
... return tuple((a, b))
...
pair(2,3)(2, 3) x=_
type(x)<type 'tuple'>

That should give you some pointers for additional searches.

This works better:

class pair(tuple):
def __new__(cls, *args):
return tuple.__new__(cls, args)
--
Aahz (aa**@pythoncraft.com) <*> http://www.pythoncraft.com/

This is Python. We don't care much about theory, except where it intersects
with useful practice. --Aahz

[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
da***@dalkescientific.com

[Michele Simionato]

"Andrew Dalke" <ad****@mindspring.com> wrote in message news:<bh**********@slb3.atl.mindspring.net>...

Simon Burton:

>> class pair(tuple):

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

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

On 18 Aug 2003 10:27:47 -0400, aa**@pythoncraft.com (Aahz) wrote:

In article <bh**********@slb3.atl.mindspring.net>,
Andrew Dalke <ad****@mindspring.com> wrote:

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__

> class pair(tuple):

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

>
> pair(2,3)

(2, 3)

> x=_
> type(x)

<type 'tuple'>

>

That should give you some pointers for additional searches.

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]

In article <bh**********@216.39.172.122>, Bengt Richter <bo**@oz.net> wrote:

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. ;-)
--
Aahz (aa**@pythoncraft.com) <*> http://www.pythoncraft.com/

This is Python. We don't care much about theory, except where it intersects
with useful practice. --Aahz