On Apr 20, 1:38 am, DillonCo <[EMAIL PROTECTED]> wrote:
> On Thursday 19 April 2007, Bill Jackson wrote:
>
> > Martin v. Löwis wrote the following on 04/19/2007 02:43 PM:
> > > Bill Jackson schrieb:
> > >> I have a dictionary of dictionaries where the keys are typically very
> > >> long tuples and repeated in each inner dictionary.
>
> > > What I don't understand here: you say the keys are tuples, yet later,
> > > you show that the keys are strings. Which one is it?
>
> > Sorry, I was just lazy. The keys will always be tuples...tuple of
> > strings, tuples of numbers, tuples of objects....simply tuples.
>
> That'll change things a bit because intern only works with strings.
>
> Of course, It's not so big a deal, but you will have to put together a class
> to implement interning.
> I wrote one for fun:
>
> class ITuple(tuple):
> _interns={}
> def __new__(cls, tup):
> if tup not in cls._interns:
> itup=tuple.__new__(cls, tup)
> cls._interns[tup]=itup
> return cls._interns[tup]
> def __init__(self, *args):
> #Prevent multiple calls to __init__
> if hasattr(self, "_inited"): return
> tuple.__init__(self, *args)
> self._inited=True
> def __eq__(self, o):
> #If the other is an ITuple, self==o iff self is o
> if isinstance(o, ITuple):
> return self is o
> return tuple.__eq__(self, o)
>
> >>> t1=(1,2,3,4); t2=(1,2,3,4)
> >>> ti1=ITuple(t1); ti2=ITuple(t2)
> >>> print t1==t2, t1 is t2
> True False
> >>> print ti1==ti2, ti1 is ti2
>
> True True
>
> That seems to work. Something to note is that the call overhead of the __eq__
> function is large enough that unless you have a slow comparing tuple,
> comparisons will be faster without it. Comparisons are fast if they are done
> internally; so between builtin objects or identical (" is ") objects.
>
> For an example, suppose you have:
>
> class TTT(object):
> def __eq__(self, o): return True
> a,b=TTT(),TTT()
>
> Then the follow comparisons are fast:
> (1,2,3)==(1,2,3)
> (1,2,3,a)==(1,2,3,a)
> (0,0,0,a)==(1,2,3,b)
>
> The following are slow:
> (1,2,3,a)==(1,2,3,b)
>
> Note that the only slow case is the one where a.__eq__(b) is called. However,
> a.__eq__(b) is assumed True is "a is b" is True. So chances are you'll want
> to comment out the __eq__ function.
Hi DillonCo,
Martins earlier local_intern function would work for tuples as well as
strings.
- Paddy.
--
http://mail.python.org/mailman/listinfo/python-list
