This issue results in redundant memory consumption for e.g. in this case:

================================================
from itertools import *

def test_islice():

    items, lookahead = tee(repeat(1, int(1e9)))
    lookahead = islice(lookahead, 10)

    for item in lookahead:
        pass

    for item in items:
        pass

if __name__ == "__main__":
    test_islice()
================================================
This demo is taken from real case where one needs to look ahead input stream before processing it. For my PC this demo stops with 'Segmentation fault' message after exhausting all PC memory, while running it with patched python consumes only 0.1% of memory till the end.

When one uses pure pythonic implementation of itertools.islice() (taken from docs), the issue goes away as well, since this implementation doesn't store redundant reference to source iterator.

================================================
def islice(iterable, *args):
    s = slice(*args)
    it = iter(xrange(s.start or 0, s.stop or sys.maxint, s.step or 1))
    nexti = next(it)
    for i, element in enumerate(iterable):
        if i == nexti:
            yield element
            nexti = next(it)
================================================

Attaching patch for this issue. Have to change '__reduce__()' method since now unpickling of exhausted 'islice()' object cannot return old source iterator.

Added patch for 2.7 version (no need to change '__reduce__()' method since it's not implemented).

The ref-counts in the islice_reduce code don't look to be correct at first glance.

Hi Raymond,
do you mean allocation exceptions handling should be more accurate?
Attaching fixed version for 3.4 branch.

Haven't reviewed the patch, but you should definitely add a unit test for the bugfix.

Hi Antoine,
I have no found a way to check resource usage in test infrastructure and I don't think it could be done carefully. The only method I found to test issue is straightforward: just to check source iterator is not referenced from itertools.islice() after the latter has been exhausted:

================================================
a = [random.random() for i in range(10)]
before = sys.getrefcount(a)
b = islice(a, 5)
for i in b: pass
after = sys.getrefcount(a)
self.assertEqual(before, after)
================================================

Attaching "issue21321_2.7_e3217efa6edd_3.diff" and "issue21321_3.4_8c8315bac6a8_3.diff" patches with this test included in "Lib/test/test_itertools.py".

Anton, the test is wrong: it is taking a reference to the iterable object (the list), not the iterator.

To check the reference to the original iterator is released, something like this would work:

>>> import itertools, weakref
>>> it = (x for x in (1, 2))
>>> wr = weakref.ref(it)
>>> it = itertools.islice(it, 1)
>>> wr() is None
False
>>> list(it)
[1]
>>> wr() is None  # returns True with the patch, False without
True

(note I haven't looked at the C part of the patch)

Hi Antoine,
my test works for me. It can be either
>>> a = [1, 2, 3]
or
>>> a = iter([1, 2, 3])
, no matter: both objects will be +1 referenced after taking
>>> b = islice(a, 1)
. 
My test failed without patch and passed with one.

But your test is more straightforward, thanks.
Attaching patches with your test.

Thanks. Could you also add a test for the islice_reduce additions? Or is it already tested?
I suspect there's a reference leak there: after calling PyObject_GetIter, you should always Py_DECREF(empty_list).
Also, with the "O" code, Py_BuildValue will take a new reference to empty_it, so you should use the "N" code instead.

Hi Antoine,
oops you are right about leaks: fixed them in new attached patch.
As for testing changes in "reduce()": they are already covered by "self.pickletest(islice(range(100), *args))". Function "pickletest()" covers case for pickle dumping/loading of exhausted iterator.

For the record, checks such as:

        self.assertEqual(wr() is None, False)

are better written:

        self.assertIsNotNone(wr())

No need to upload a new patch, I'm gonna make the change while committing :-)

New changeset b795105db23a by Antoine Pitrou in branch '3.4':
Issue #21321: itertools.islice() now releases the reference to the source iterator when the slice is exhausted.
http://hg.python.org/cpython/rev/b795105db23a

New changeset a627b3e3c9c8 by Antoine Pitrou in branch 'default':
Issue #21321: itertools.islice() now releases the reference to the source iterator when the slice is exhausted.
http://hg.python.org/cpython/rev/a627b3e3c9c8

Patch committed, thank you!
If you want to provide a patch for 2.7, please say so, otherwise I'll close the issue.

Antoine, not sure about 2.7. The issue first arose for me at Python 2.7, so I would prefer "issue21321_2.7_e3217efa6edd_4.diff" patch be applied.

New changeset 8ee76e1b5aa6 by Antoine Pitrou in branch '2.7':
Issue #21321: itertools.islice() now releases the reference to the source iterator when the slice is exhausted.
http://hg.python.org/cpython/rev/8ee76e1b5aa6

Ok, then I've committed to 2.7 too. Thank you very much for contributing!