Understanding Generator Functions in Python

The primary distinction that sets a generator function apart from a normal function in Python is its usage of the yield statement. This means that the correct answer to the quiz question is: "It uses the 'yield' statement".

To elaborate, a generator function behaves like an iterator, meaning it can be used in a loop to generate a series of results, instead of computing them all at once and returning them in an array (for instance). This functionality is brought about through the use of the yield keyword.

How Does The 'Yield' Statement Work?

In Python, the yield statement is used in defining a generator function. This statement replaces the return statement of a normal function.

When the yield statement is encountered, Python records the local state of the function. This includes any local variables, the instruction pointer, the internal stack, and any exception handling. This allows the function to be resumed right where it left off when __next__() is called on the generator object.

Here's an example to illustrate this.

def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

Here, count_up_to is a generator function because it uses the 'yield' statement. We can make use of it as follows.

for number in count_up_to(5):
    print(number)

The function above will output the numbers 1 to 5, each on a new line. The yield statement is causing the function to generate a value, return it to the caller, and then suspend its state so it can continue right where it left off during the subsequent iterations.

The Efficiency of Generator Functions

A significant advantage of using generator functions is optimization of memory usage. As the values are yielded one at a time, a generator function only requires enough memory to generate one value at a time, instead of storing all the values in memory at once. This makes it particularly effective when dealing with large data sets.

However, it should be noted that generator functions do not necessarily execute faster than normal functions. Instead, their strength lies in providing the same functionality while using significantly less memory.