Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.python > #5850 > unrolled thread

Python sets which support multiple same elements

Back to article view | Back to comp.lang.python

Contents

  Python sets which support multiple same elements ErichCart ErichCart <erichcart@gmail.com> - 2011-05-20 04:37 -0700
    RE: Python sets which support multiple same elements Andreas Tawn <andreas.tawn@ubisoft.com> - 2011-05-20 13:53 +0200
    Re: Python sets which support multiple same elements Chris Angelico <rosuav@gmail.com> - 2011-05-20 21:57 +1000

#5850 — Python sets which support multiple same elements

Many times when I am writing some program in python, I notice that I
could transform my list into set, then use the set methods like union,
intersection, set equality etc. , and it will solve my problem easily.
But then I realize that if I transform my list into set, it will
remove duplicates of elements in the list and so I will lose
information from my original list.

For example, I was writing a program to detect whether two strings are
anagrams of each other. I had to write it like this:

def isAnagram(w1, w2):
  w2=list(w2)
  for c in w1:
    if c not in w2:
      return False
    else:
      w2.remove(c)
  return True

But if there was a data structure in python which supported duplicate
elements(lets call it dset), then I could just write:

def inAnagram(w1,w2):
  return dset(w1)==dset(w2)

Example of some dset methods:
{1,2,3,3} intersection {4,1,2,3,3,3}  == {1,2,3,3}
{1,2,3,3} union {4,1,2,3,3,3} == {1,2,3,3,3,4}
{4,1,2,3,3,3} difference {1,2,3,3} == {4,3}

Do you think that it would be a good idea to add this kind of data
structure to python? Or did I overlook some other easy way to solve
this kind of problems?

[toc] | [next] | [standalone]

#5852

> For example, I was writing a program to detect whether two strings are
> anagrams of each other. I had to write it like this:
> 
> def isAnagram(w1, w2):
>   w2=list(w2)
>   for c in w1:
>     if c not in w2:
>       return False
>     else:
>       w2.remove(c)
>   return True
> 
> But if there was a data structure in python which supported duplicate
> elements(lets call it dset), then I could just write:
> 
> def inAnagram(w1,w2):
>   return dset(w1)==dset(w2)
> 
> Example of some dset methods:
> {1,2,3,3} intersection {4,1,2,3,3,3}  == {1,2,3,3}
> {1,2,3,3} union {4,1,2,3,3,3} == {1,2,3,3,3,4}
> {4,1,2,3,3,3} difference {1,2,3,3} == {4,3}
> 
> Do you think that it would be a good idea to add this kind of data
> structure to python? Or did I overlook some other easy way to solve
> this kind of problems?

Just to do the anagram problem you could do...

def isAnagram(w1, w2):
    return sorted(w1) == sorted(w2)

To do the set-like operations, I guess that unless there's some itertools witchcraft available, you'd have to make your own dset type that inherits from list. Then you can define your own intersection/union etc. methods.

Cheers,

Drea

[toc] | [prev] | [next] | [standalone]

#5853

On Fri, May 20, 2011 at 9:37 PM, ErichCart ErichCart
<erichcart@gmail.com> wrote:
> For example, I was writing a program to detect whether two strings are
> anagrams of each other. I had to write it like this:
>
> def isAnagram(w1, w2):
>  w2=list(w2)
>  for c in w1:
>    if c not in w2:
>      return False
>    else:
>      w2.remove(c)
>  return True

You may find it helpful to simply sort the lists, keeping them as
lists. If they're anagrams of each other, their sorted versions will
be equal.

Chris Angelico

[toc] | [prev] | [standalone]

Back to top | Article view | comp.lang.python

csiph-web