Compare the memory use of a Python list comprehension with a generator expression.
The difference is large, and it comes down to eagerness. A list comprehension builds every value straight away, while a generator expression produces each one only when it is asked for.
import sys
data = range(1000000)
as_list = [number * 2 for number in data]
as_gen = (number * 2 for number in data)
print('list size in bytes:', sys.getsizeof(as_list))
print('generator size in bytes:', sys.getsizeof(as_gen))
print('values in the generator:', len(list(as_gen)))
The list takes roughly 8.4 megabytes just for the list of pointers, and that figure does not even count the million integer objects that it refers to. The generator object is only 200 bytes, because all that it holds is a reference to the range and a position inside it.
The last line is the catch. Turning the generator into a list gives you the same million values and the same 8 megabytes, so the memory was never saved. It was only put off for a while. The saving is real only when you consume the values and let them go as you go.
That is the honest way to describe it in an interview. A generator does not use less memory to hold the same data. It uses less memory because it never holds all the data at once, and that only helps you if you process the stream as it arrives instead of collecting it.