Yes, it is still a generator. An empty return or return None can be used to end a generator function. It is equivalent to raising a StopIteration (see @NPE's answer for details). Note that a return with non-None arguments is a SyntaxError in Python versions prior to 3.3.
Python provides a generator to create your own iterator function. A generator is a special type of function which does not return a single value, instead, it returns an iterator object with a sequence of values. In a generator function, a yield statement is used rather than a return statement.
When you use a yield keyword inside a generator function, it returns a generator object instead of values. In fact, it stores all the returned values inside this generator object in a local state.
Yield is generally used to convert a regular Python function into a generator. Return is generally used for the end of the execution and “returns” the result to the caller statement. It replace the return of a function to suspend its execution without destroying local variables.
This is a new feature in Python 3.3 (as a comment notes, it doesn't even work in 3.2). Much like return
in a generator has long been equivalent to raise StopIteration()
, return <something>
in a generator is now equivalent to raise StopIteration(<something>)
. For that reason, the exception you're seeing should be printed as StopIteration: 3
, and the value is accessible through the attribute value
on the exception object. If the generator is delegated to using the (also new) yield from
syntax, it is the result. See PEP 380 for details.
def f():
return 1
yield 2
def g():
x = yield from f()
print(x)
# g is still a generator so we need to iterate to run it:
for _ in g():
pass
This prints 1
, but not 2
.
The return value is not ignored, but generators only yield values, a return
just ends the generator, in this case early. Advancing the generator never reaches the yield
statement in that case.
Whenever a iterator reaches the 'end' of the values to yield, a StopIteration
must be raised. Generators are no exception. As of Python 3.3 however, any return
expression becomes the value of the exception:
>>> def gen():
... return 3
... yield 2
...
>>> try:
... next(gen())
... except StopIteration as ex:
... e = ex
...
>>> e
StopIteration(3,)
>>> e.value
3
Use the next()
function to advance iterators, instead of calling .__next__()
directly:
print(next(x))
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With