[Python-Dev] Unordered tuples/lists

[Gustavo Narea]

Hello, Oleg.


> class UnorderedList(list):
>    def __eq__(self, other):
>        if not isinstance(other, UnorderedList):
>            return False
>        return sorted(self) == sorted(other)
>
>    def __ne__(self, other):
>        return not self.__eq__(other)
>
>   Do you need more than that?
>
> Oleg.



That's what I had in mind.

I think it'd be useful enough to go in the standard library. Now that
there's a sample implementation, should I still try to demonstrate why I
believe it's worth adding to the stdlib and get support?

Cheers,

 - Gustavo.


On Tue, May 18, 2010 at 11:13 PM, Gustavo Narea <me at gustavonarea.net> wrote:

> Hello, everybody.
>
> I've been searching for a data structure like a tuple/list *but* unordered
> --
> like a set, but duplicated elements shouldn't be removed. I have not even
> found a recipe, so I'd like to write an implementation and contribute it to
> the "collections" module in the standard library.
>
> This is the situation I have: I have a data structure that represents an
> arithmetic/boolean operation. Operations can be commutative, which means
> that
> the order of their operands don't change the result of the operation. This
> is,
> the following operations are equivalent:
>    operation(a, b, c) == operation(c, b, a) == operation(b, a, c)
>    operation(a, b, a) == operation(a, a, b) == operation(b, a, a)
>    operation(a, a) == operation(a, a)
>
> So, I need a type to store the arguments/operands so that if two of these
> collections have the same elements with the same multiplicity, they are
> equivalent, regardless of the order.
>
> A multiset is not exactly what I need: I still need to use the elements in
> the
> order they were given. For example, the logical conjuction (aka "and"
> operator) has a left and right operands; I need to evaluate the first/left
> one
> and, if it returned True, then call the second/right one. They must not be
> evaluated in a random order.
>
> To sum up, it would behave like a tuple or a list, except when it's
> compared
> with another object: They would be equivalent if they're both unordered
> tuples/lists, and have the same elements. There can be mutable and
> immutable
> editions (UnorderedList and UnorderedTuple, respectively).
>
> I will write a PEP to elaborate on this if you think it'd be nice to have.
> Or,
> should I have written the PEP first?
>
> Cheers,
> --
> Gustavo Narea <xri://=Gustavo>.
> | Tech blog: =Gustavo/(+blog)/tech  ~  About me: =Gustavo/about |
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-dev/attachments/20100519/217907d1/attachment.html>