按条件将列表分成多个块

Question

I have a list like:

["asdf-1-bhd","uuu-2-ggg","asdf-2-bhd","uuu-1-ggg","asdf-3-bhd"]

that I want to split into the two groups who's elements are equal after I remove the number:

"asdf-1-bhd", "asdf-2-bhd", "asdf-3-bhd"
"uuu-2-ggg" , uuu-1-ggg"

I have been using itertools.groupby with

for key, group in itertools.groupby(elements, key= lambda x : removeIndexNumber(x)):

but this does not work when the elements to be grouped are not consecutive.

I have thought about using list comprehensions, but this seems impossible since the number of groups is not fixed.

tl;dr:

I want to group stuff, two problems:

1. I don't know the number of chunks I will obtain
2. I the elements that will be grouped into a chunk might not be consecutive

Answer 1

Why don't you think about it a bit differently. You can map everyting into a dict:

import re
from collections import defaultdict
regex = re.compile('([a-z]+\-)\d(\-[a-z]+)')

t = ["asdf-1-bhd","uuu-2-ggg","asdf-2-bhd","uuu-1-ggg","asdf-3-bhd"]

maps = defaultdict(list)

for x in t:
    parts = regex.match(x).groups()
    maps[parts[0]+parts[1]].append(x)

Output:

[['asdf-1-bhd', 'asdf-2-bhd', 'asdf-3-bhd'], ['uuu-2-ggg', 'uuu-1-ggg']]

This is really fast because you don't have to compare one thing to another.

Edit:

On Thinking differently

Your original approach was to iterate through each item and compare them to one another. This is overcomplicated and unnecessary.

Let's consider what my code does. First it gets the stripped down version:

"asdf-1-bhd" -> "asdf--bhd"
"uuu-2-ggg" -> "uuu--ggg"
"asdf-2-bhd" -> "asdf--bhd"
"uuu-1-ggg" -> "uuu--ggg"
"asdf-3-bhd" -> "asdf--bhd"

You can already start to see the groups, and we haven't compared anything yet!

We now do a sort of reverse mapping. We take everything thing on the right and make it a key, and anything on the left and put it in a list that is mapped by its value on the left:

'asdf--bhd' -> ['asdf-1-bhd', 'asdf-2-bhd', 'asdf-3-bhd']
'uuu--ggg' -> ['uuu-2-ggg', 'uuu-1-ggg']

And there we have our groups defined by their common computed value (key). This will work for any amount of elements and groups.

Answer 2

Ok, simple solution (it must be too late over here):

Use itertools.groupby , but first sort the list.

As for the example given above:

elements = ["asdf-1-bhd","uuu-2-ggg","asdf-2-bhd","uuu-1-ggg","asdf-3-bhd"]
elemens.sort(key = lambda  x : removeIndex(x))
for key, group in itertools.groupby(elements, key= lambda x : removeIndexNumber(x)):
     for element in group:
         # do stuff

As you can see, the condition for sorting is the same as for grouping. That way, the elements that will eventually have to be grouped are first put into consecutive order. After this has been done, itertools.groupy can work properly.