In Python functions, we might have seen ‘return’ or ‘yield’ statements. What does the ‘return’ and ‘yield’ statement do?
Let’s look at this in detail in this article.
‘return’ statement
The ‘return’ statement terminates the function call and returns the value to the caller. ‘return’ statement occurs only inside the function.
Syntax
return [expression_list]
expression_list is evaluated and it can return a tuple/list/dict/set or a single value.
1) return a single value
2) ‘return’ →List
3) return →a tuple
If the expression list contains at least one comma, it returns a tuple.
4) return →dict
Multiple return statements
When we have multiple return statements, the function call is terminated when it reaches the first return statement.
‘yield’ statement
If a function has a ‘yield’ statement instead of a ‘return ‘ statement, it is known as generator functions or generators.
‘yield statement’ won’t terminate the function during the function call. During multiple calls, it will generate successive output.
The generator function will return a generator object. Generator objects are single active iterators. They only support one active iteration. We can access the generator object using for loop, list(),next()
1. Generators
During a function call, the generator function will return a generator object which yields one result at a time.
Generators are memory efficient.
2. Using next()
We can access the result one by one from the generator object using next(). It will yield value one by one.
When the object is exhausted, it will raise “Stop Iteration”
3. Using for loop
We can access the generator object using for loop also. It will loop through the result. To overcome “StopIteration”, we can use for loop to access the elements from the generation object.
4. Using list() constructor
We can convert the generator object into a list using the list() constructor.
‘yield’ statement vs ‘return’ statement
The generator object will yield one value at a time. It’s like resuming function.
‘return’ statement will return all the values at one time.
Difference between Normal function and Generator Function
- Normal function when called, compute the value and return it.
The generator function returns a generator object which is an iterator. - A normal function has a ‘return’ statement.
Generator function has ‘yield statement - ‘return’ stops the execution but ‘yield’ pauses the execution and resumes at the same point.
- Generators are memory efficient.
Conclusion
In this article, I have covered the differences between the ‘return’ statement and ‘yield’ statement. In normal function,’ return’ is used but ‘yield’ is used in the generator function. I hope you all like it, thanks for reading!
The return statement in Python exits a function and provides a value or result back to the caller. This allows you to use the function’s result in other parts of your program.
In Python, you can return multiple values by separating them with commas. Python automatically packs these values into a tuple. For example:
def get_coordinates():
return 10, 20
x, y = get_coordinates()
Use the return statement at the end of a function to output results or data. Here’s an example:
def add_numbers(a, b):
return a + b
result = add_numbers(3, 4)
print(result) # Output: 7
In Python, the yield keyword is used within generators to pause the function’s execution and send back a value. Unlike return, a function using yield can resume later to produce more values.
Yield pauses a function’s execution and returns a value temporarily. This allows the function to produce multiple values over time without completely exiting.
Yield works by creating a generator, a special function type. Each time the generator’s next item is requested, it resumes from where it paused (after the last yield statement), allowing efficient memory use especially for large datasets or streams.
The key difference is that return exits a function completely after giving back a single value, while yield pauses the function, returning one value at a time and allowing the function to resume where it left off. This makes yield ideal for generators and large data sequences.
