Geek Answers Handbook

What should be the pythonic way to implement the following logic?

I would like to create a loop and remove the element if it meets the requirement. At the same time, I would convert the deleted item and add the conversion result to another list.

Right now, I have completed the above logic by executing the following code:

delete_set = set([])

for item in my_list:
   if meet_requirement(item):
      another_list.append = transform(item)
      delete_set.add(item)

my_list = filter(lambda x:x not in delete_set, my_list)

The code is not so straightforward, is there a better way to implement the logic?

+5
source share
7 answers

You can only do this with concepts.

delete_set = set(I for I in my_list if meet_requirement(I))
another_list.extend(transform(I) for I in delete_set)
# or extend(transform(I) for I in my_list if I in delete_set), if duplicates/order matter
my_list = [I for I in my_list if I not in delete_set]
+6
source

I'm not sure about pythonic, but if python had a function partitionsimilar to haskell (or you could write a simple one) yourself, for this code you would not need to iterate over the original list twice (as in Cat Plus) of the solution).

- :

new_my_list, deleted_list = partition(my_list, meet_requirement)
deleted_list = [transform(e) for e in deleted_list]
+3

, :

def part(items, others):
    for item in items:
        if meet_requirement(item):
            others.append(item)
        else:
            yield item

mylist[:] = part(mylist, another_list)
+1

for i in reversed(xrange(len(my_list))):
    if meet_requirement(my_list[i]):
        another_list.append(transform(my_list.pop(i)))

then you may or may not want to cancel another_list(or you can use dequeand appendleft)

+1
source 
>>> another_list = []
>>> new_list = []
>>> 
>>> for item in my_list:
...     (another_list if meet_requirement(item) else new_list).append(item)
... 
>>> another_list = map(transform, another_list)
>>> my_list = new_list
0
source 
zipped = zip(*[(item, transform(item)) for item in my_list \
                                                if meet_requirement(item)])
another_list = zipped[1]
my_list = [item for item in my_list if item not in zipped[0]]
0
source

I need something similar the other day:

def partition(pred, iterable):
    result = ([], [])
    for each in iterable:
        result[pred(each)].append(each)
    return result

xs = some_list    
ys, xs[:] = partition(meet_some_requirement, xs)
ys = map(do_some_transformation, ys)

Or is this a one-pass change:

def partition_and_transform(pred, iterable, *transform):
    result = ([], [])
    for each in iterable:
        v = pred(each)
        result[v].append(transform[v](each))
    return result

ys, xs[:] = partition_and_transform(meet_some_reqirement, xs, do_some_transformation, lambda x:x)
0
source

More articles:


All Articles