Pythonic эквивалент unshift или redo?

Зачем беспокоиться об отсутствии сдвига, если всегда должно быть условие else?

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

В любом случае, я совершенно уверен, что Python не имеет того поведения, которое вы ищете.

Нет общего способа передать значение в итератор в python. Для этого лучше подходят стек или связанный список.

Если вы перебираете список или что-то в этом роде, конечно, вы можете вручную добавить элемент обратно в список. Но вы также можете перебирать объекты, которыми нельзя манипулировать таким образом.

Если вы хотите использовать python для реализации этого алгоритма, вам нужно будет выбрать структуру данных, которая позволяет выполнять операции, которые вы хотите использовать. Я предлагаю методы .push() и .pop(), которые позволяют обрабатывать списки как стеки.

I'm learning Python, and I have a situation where I want to consume items from an iterator. The tricky part is that under certain conditions, I want to "un-iterate." That is, put an item back onto the front of the iterator before I loop.

Вот простое решение:

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

Пока я писал это, @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]]

Вы ищете генератор, итератор, который может получать изменения своего внутреннего состояния с помощью метода send ().

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

Я бы сказал, что самое питоническое решение - самое простое. Вместо того, чтобы пытаться обернуть итератор в выражение генератора, которое позволяет «вернуться» или что-то подобное сложное, используйте цикл while, как в Perl! Итераторы не очень хорошо сочетаются с мутацией, кто угодно.

Простой перевод вашей реализации (без учета оптимизации @Патрик):

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, упомянутыми в вышеупомянутой (связанной) ветке.

Если вы не хотите следовать предложению другого просто удалить предложение 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

Кстати, вам действительно нужен list.insert (0, yourObject)

Возвращаясь к исходному вопросу об имплементации unshift, operator.delitem можно использовать для реализации простой не-объектно-ориентированной функции:

from operator import delitem

def unshift(l,idx):
    retval = l[0]
    delitem(l,0)
    return retval

x = [2,4,6,8]

firstval = unshift(x,0)

print firstval,x

2 [4, 6, 8]