iterable

If I want the number of items in an iterable without caring about the elements themselves, what would be the pythonic way to get that? Right now, I would define def ilen(it): return sum(itertools.imap(lambda _: 1, it)) # or just map in Python 3 but I understand lambda is close to being considered harmful, and lambda _: 1 certainly isn't pretty. (The use case of this is counting the number of lines in a text file matching a regex, i.e. grep -c .) The usual way is sum(1 for i in it) Method that's meaningfully faster than sum(1 for i in it) when the iterable may be long (and not meaningfully

This question already has an answer here: Getting number of elements in an iterator in Python 15 answers What's the shortest way to count the number of items in a generator/iterator? 6 answers Python provides a nice method for getting length of an eager iterable, len(x) that is. But I couldn't find anything similar for lazy iterables represented by generator comprehensions and functions. Of course, it is not hard to write something like: def iterlen(x): n = 0 try: while True: next(x) n += 1 except StopIteration: pass return n But I can't get rid of a feeling that I'm reimplementing a bicycle.

Both of these interfaces define only one method public operator fun iterator(): Iterator<T> Documentation says Sequence is meant to be lazy. But isn't Iterable lazy too (unless backed by a Collection )? The key difference lies in the semantics and the implementation of the stdlib extension functions for Iterable<T> and Sequence<T> . For Sequence<T> , the extension functions perform lazily where possible, similarly to Java Streams intermediate operations. For example, Sequence<T>.map { ... } returns another Sequence<R> and does not actually process the items until a terminal operation like

In Java 8 we have the class Stream<T> , which curiously have a method Iterator<T> iterator() So you would expect it to implement interface Iterable<T> , which requires exactly this method, but that's not the case. When I want to iterate over a Stream using a foreach loop, I have to do something like public static Iterable<T> getIterable(Stream<T> s) { return new Iterable<T> { @Override public Iterator<T> iterator() { return s.iterator(); } }; } for (T element : getIterable(s)) { ... } Am I missing something here? There are already people asked the same on the mailing list ☺. The main reason is

Why does the Iterator interface not extend Iterable ? The iterator() method could simply return this . Is it on purpose or just an oversight of Java's designers? It would be convenient to be able to use a for-each loop with iterators like this: for(Object o : someContainer.listSomeObjects()) { .... } where listSomeObjects() returns an iterator. PaulJWilliams Because an iterator generally points to a single instance in a collection. Iterable implies that one may obtain an iterator from an object to traverse over its elements - and there's no need to iterate over a single instance, which is what