How to len(generator()) [duplicate]

The conversion to list that's been suggested in the other answers is the best way if you still want to process the generator elements afterwards, but has one flaw: It uses O(n) memory. You can count the elements in a generator without using that much memory with:

sum(1 for x in generator)

Of course, be aware that this might be slower than len(list(generator)) in common Python implementations, and if the generators are long enough for the memory complexity to matter, the operation would take quite some time. Still, I personally prefer this solution as it describes what I want to get, and it doesn't give me anything extra that's not required (such as a list of all the elements).

Also listen to delnan's advice: If you're discarding the output of the generator it is very likely that there is a way to calculate the number of elements without running it, or by counting them in another manner.

Generators have no length, they aren't collections after all.

Generators are functions with a internal state (and fancy syntax). You can repeatedly call them to get a sequence of values, so you can use them in loop. But they don't contain any elements, so asking for the length of a generator is like asking for the length of a function.

if functions in Python are objects, couldn't I assign the length to a variable of this object that would be accessible to the new generator?

Functions are objects, but you cannot assign new attributes to them. The reason is probably to keep such a basic object as efficient as possible.

You can however simply return (generator, length) pairs from your functions or wrap the generator in a simple object like this:

class GeneratorLen(object):    def __init__(self, gen, length):        self.gen = gen        self.length = length    def __len__(self):         return self.length    def __iter__(self):        return self.geng = some_generator()h = GeneratorLen(g, 1)print len(h), list(h)

Suppose we have a generator:

def gen():    for i in range(10):        yield i

We can wrap the generator, along with the known length, in an object:

import itertoolsclass LenGen(object):    def __init__(self,gen,length):        self.gen=gen        self.length=length    def __call__(self):        return itertools.islice(self.gen(),self.length)    def __len__(self):        return self.lengthlgen=LenGen(gen,10)

Instances of LenGen are generators themselves, since calling them returns an iterator.

Now we can use the lgen generator in place of gen, and access len(lgen) as well:

def new_gen():    for i in lgen():        yield float(i)/len(lgen)for i in new_gen():    print(i)