In Python is faster using "yield from" than yield in a loop?

I tried multiple ranges for this example I let above:

import time


def reader():
    for a in range(100000000):
        yield a


def reader_wrapper(gen):
    for i in gen:
        yield i


def reader_wrapper_enhanced(gen):
    yield from gen


wrap = reader_wrapper_enhanced(reader())

start = time.perf_counter()

for i in wrap:
    ...

print("LAST: %s " % (time.perf_counter() - start))


wrap = reader_wrapper(reader())

start = time.perf_counter()

for i in wrap:
    ...

print("LAST: %s " % (time.perf_counter() - start))

My main question is that yield from is actually faster than a normal yield using loop.

Result for ranges:

Note: First result is the yield from and the second the yield.

In case it is faster, should not we always just use it in this kind of cases?

>Solution :

Yes, it’s faster when the inputs are long enough (though not by much, as you’ve seen), and yes, you may as well let Python do the work of yielding from the delegate iterator by default.

The one time you wouldn’t want to do this is when you are delegating to a generator that you don’t want to receive values from the caller sent with .send or .throw; when using plain yield, your generator receives them, when using yield from, the delegate generator receives them (usually the latter is what you want, and it’s the primary reason yield from exists in the first place).