Question

如果符合要求，我想循环列表并删除元素。同时，我将转换已删除的元素并将转换结果添加到另一个列表中。

现在，我已通过以下代码实现了上述逻辑：

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)

代码不是那么简单，是否有更好的方法来实现逻辑？

Answer 1

你只能通过理解来做到这一点。

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]

Answer 2

不确定pythonic，但是如果python有一个类似于haskell的partition函数（或者你自己可以写一个简单的函数），那么代码就不需要迭代原始列表两次了（就像在Cat中一样）加'解决方案'。

我会使用以下内容：

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

Answer 3

你可以这样做以避免设置：

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

mylist[:] = part(mylist, another_list)

Answer 4

你可以这样做

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

然后您可能或可能不想反转another_list（或者您可以使用deque和appendleft）

Answer 5

>>> 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

Answer 6

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]]

Answer 7

前几天我需要类似的东西：

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)

或者这种一次性变化：

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)

什么应该是pythonic方式来实现以下逻辑？

7 个答案: