Question

Many functions of a library I use return generators instead of lists when the result is some collection.

Sometimes I just want to check if the result is empty of not, and of course I can’t write something like:

   result = return_generator()
   if result:
      print 'Yes, the generator did generate something!'

Now I come up with a one-liner that solve this problem without consuming the generator:

   result = return_generator()
   if zip("_", result):
      print 'Yes, the generator did generate something!'

I wonder if there are cleaner ways to solve this problem in one line?

Answer 1

This zip stuff eats the first item yielded, so it is not a good idea as well.

You can only detect if a generator has an item yielding by getting and keeping it until needed. The following class will help you to do so.

If needed, it gets an item from the iterator and keeps it.

If asked for emptyness (if myiterwatch: ...), it tries to get and returns if it could get one.

If asked for the next item, it will return the retrieved one or a new one.

class IterWatch(object):
    def __init__(self, it):
        self.iter = iter(it)
        self._pending = []
    @property
    def pending(self):
        try:
            if not self._pending:
                # will raise StopIteration if exhausted
                self._pending.append(next(self.iter))
        except StopIteration:
            pass # swallow this
        return self._pending
    def next(self):
        try:
            return self.pending.pop(0)
        except IndexError:
            raise StopIteration
    __next__ = next # for Py3
    def __iter__(self): return self
    def __nonzero__(self):
        # returns True if we have data.
        return not not self.pending
        # or maybe bool(self.pending)
    __bool__ = __nonzero__ # for Py3

---

This solves the problem in a very generic way. If you have an iterator which you just want to test, you can use

guard = object()
result = return_generator()
if next(result, guard) is not guard:
    print 'Yes, the generator did generate something!'

next(a, b) returns b if iterator a is exhausted. So if it returns the guard in our case, it didn’t generate something, otherwise it did.

But your zip() approach is perfectly valid as well…