Question

我正在学习Python，我有一种情况，我想从迭代器中使用项目。棘手的部分是在某些条件下，我想“不迭代”。也就是说，在循环之前将项目放回到迭代器的前面。

例如，假设我从树上摘苹果。我的水果篮在需要清空之前只能容纳10公斤。但是我必须在我称之前挑选每个苹果并确定这个苹果是否会超过篮子的容量。

在像Perl这样的语言中，我可以unshift()将苹果重新放回树上，然后让循环表达式重新选择苹果：

while ($apple = shift(@tree)) {
  $wt = weight($apple);
  if ($wt + weight(@basket) > 10) {
    send(@basket);
    @basket = ();
    unshift(@tree, $apple);
  } else {
    push(@basket, $element);
  }
}

否则我也可以使用redo，它在块的顶部恢复处理，而不评估循环表达式。因此，在篮子被清空后，同样的苹果可以被重新加工。

while ($apple = shift(@tree)) {
  $wt = weight($apple);
  if ($wt + weight(@basket) > 10) {
    send(@basket);
    @basket = ();
    redo;
  } else {
    push(@basket, $apple);
  }
}

对于这类问题，最强 pythonic 解决方案是什么？

Answer 1

我正在学习Python，我有一种情况，我想从迭代器中使用项目。棘手的部分是在某些条件下，我想“不迭代”。也就是说，在循环之前将项目放回到迭代器的前面。

这是一个简单的解决方案：

class MyIterator(object):   # undo-able iterator wrapper
    def __init__(self, iterable):
        super(MyIterator, self).__init__()
        self.iterator = iter(iterable)
        self.stack = []

    def __iter__(self):
        return self

    def next(self):
        if self.stack:
            return self.stack.pop()
        return self.iterator.next()  # Raises StopIteration eventually

    def undo(self, item):
        self.stack.append(item)

for i in  MyIterator(xrange(5)): print i
0
1
2
3
4

rng = MyIterator(xrange(5))
rng.next()
0
rng.next()
1
rng.undo(1)
rng.next()
1

Answer 2

为什么要在总是发生else子句的情况下解除不适应？

for apple in tree:
    if (apple.weight + basket.weight) > 10:
       send(basket)
       basket.clear()
    basket.add(apple)

无论如何，我很确定Python没有你想要的那种行为。

Answer 3

我会说the most Pythonic solution is the simplest one。而不是试图将迭代器包装在允许你“回溯”或类似复杂的东西的生成器表达式中，使用while循环，就像在Perl中一样！ Iterators don't mix very nicely with mutation ，anywho。

简单翻译您的实施（忽略@Patrick的优化）：

while tree:
    apple = tree.pop(0)
    if apple.weight + basket.weight > 10:
        basket.send()
        basket.clear()
        tree.insert(0, apple) # Put it back.
    else:
        basket.append(apple)

或者，您可以使用具有有序序列索引的peek类功能：

while tree:
    apple = tree[0] # Take a peek at it.
    if apple.weight + basket.weight > 10:
        basket.send()
        basket.clear()
    else:
        basket.append(tree.pop(0))

如果您不喜欢“简单”参数，请查看上面（链接）主题中提到的collections.deque迭代器。

Answer 4

如果您不想遵循另一个只删除else子句的建议，您可以编写自己的unshift函数，该函数的工作方式与任何可迭代的perl类似：

class UnshiftableIterable(object):
    def __init__(self, iterable):
        self._iter = iter(iterable)
        self._unshifted = [] # empty list of unshifted stuff
    def __iter__(self):
        while True:
            if self._unshifted:
                yield self._unshifted.pop()
            else:
                yield self._iter.next()
    def unshift(self, item):
        self._unshifted.append(item)

然后在你的代码中：

it = UnshiftableIterable(tree)
for apple in tree:
    if weigth(basket) + weight(apple) > MAX_WEIGHT:
        send(basket)
        basket = []
        it.unshift(apple)
    else:
        basket.append(apple)

UnshiftableIterable的一些测试：

it = UnshiftableIterable(xrange(5))

for i in it:
    print '*',
    if i == 2:
        it.unshift(10)
    else:
        print i,
# output: * 0 * 1 * * 10 * 3 * 4

Answer 5

您正在寻找一个生成器，一个可以通过send（）方法接收对其内部状态的修改的迭代器

https://docs.python.org/howto/functional.html#passing-values-into-a-generator

Answer 6

在我写这篇文章的时候，@帕特里克已经提出了同样的建议。但是，自从我写完之后，我将粘贴代码，并在Patrick的代码标记方法中添加注释。

import random

apples=[random.randint(1,3) for j in range(10)]
print 'apples',apples

basket=[]
y=6
baskets=[]

for i in range(len(apples)):
    if sum(basket+[apples[i]])>y:
        #basket is full                                                                                                                                     
        baskets.append(basket)#basket.send()                                                                                                                
        basket=[]#basket.empty()                                                                                                                            
    basket.append(apples[i])#add apple to basket                                                                                                            

print 'baskets',baskets

虽然这不会弹出（）来自原始迭代器的苹果。请注意这是否也是一种理想的行为。

输出

apples [1, 1, 3, 3, 1, 1, 3, 3, 2, 3]
baskets [[1, 1, 3], [3, 1, 1], [3, 3]]

Answer 7

顺便说一句，你真正想要的是list.insert（0，yourObject）

Answer 8

没有办法在python中将值推送到迭代器中。堆栈或链表更适合。

如果您正在迭代列表或其他内容，当然可以手动将项目添加回列表。但是你也可以迭代无法以这种方式操纵的对象。

如果要使用python实现该算法，则必须选择允许您要使用的操作的数据结构。我建议使用.push()和.pop()方法将列表视为堆栈。

Pythonic相当于unshift或redo？

8 个答案: