Question about exausted iterators

[Christophe]

Is there a good reason why when you try to take an element from an
already exausted iterator, it throws StopIteration instead of some other
exception ? I've lost quite some times already because I was using a lot
of iterators and I forgot that that specific function parameter was one.

Exemple :

def f(i): .... print list(i)
.... print list(i)
.... f(iter(range(2) )) [0, 1]
[]

This is using Python 2.4.2

[Mel Wilson]

ya*****@gmail.c om wrote:

Consider this example:

X = range(5)
Y = iter(X)
Z = iter(Y)
As you can see, X is a container, and Y is an iterator.
They are simliar in that "iter" works on them both.

Cristoph claims that this causes confusion.
Why? Because "iter" doesn't have the same meaning for both of them.
For X it always returns an iterator that yields the same set of values.
For Y it returns an iterator yielding different values each time.
As an aside, perhaps iter(Y) should be returning a deeper
copy of Y. As it stands, I see 'Z=Y' giving the same effect:

y=iter(x)
z=iter(y)
zip(y, z) [(0, 1), (2, 3)] y=iter(x)
z=y
zip(y, z)

[(0, 1), (2, 3)]

[ ... ]
But changing "iter" to have the same meaning for containers and
iterables is impossible.
You cannot, conceptually, reiterate an iterator.
So what Cristoph is suggesting - is to add an exception for the cases
in which iterators and collections behave differently.
Somewhat similar to this:

But the end, raising StopIteration is not where the
difference is. The difference is in iter(some_objec t).

iter(some_conta iner) creates a brand new iterator, standing
at the starting line and ready to run.

iter(some_listi terator), it seems, just returns a reference
to some_listiterat or, with some of its history possibly
behind it.

Iterators are used in the same syntactic places as general
iterables, but especially once people start giving them
names and handing them around, the real differences show up.

The short-range solution is Know What You're Doing. Duck
typing is a fine thing, but it works best for programmers
who keep scrupulous track of their objects' types.

Cheers, Mel.

[Marc 'BlackJack' Rintsch]

In <44************ **********@news .free.fr>, Christophe wrote:

Well, the main reason for such change is and will always be to catch
bugs. The fact is, using duct typing is something very common with the
Python language.

Duct typing? I guess you mean duct taping, or duck taping [1] or maybe
duck typing. :-)

SCNR,
Marc 'BlackJack' Rintsch

[1] http://www.cybersalt.org/cleanlaugh/...3/ducktape.htm