问题
import contextlib
import time
@contextlib.contextmanager
def time_print(task_name):
t = time.time()
try:
yield
finally:
print task_name, "took", time.time() - t, "seconds."
def doproc():
x=1+1
with time_print("processes"):
[doproc() for _ in range(500)]
# processes took 15.236166954 seconds.
when does doproc get executed when using this decorator?
回答1:
yield
expression returns control to the whatever is using the generator. The generator pauses at this point, which means that the @contextmanager
decorator knows that the code is done with the setup part.
In other words, everything you want to do in the context manager __enter__
phase has to take place before the yield
.
Once your context exits (so the block under the with
statement is done), the @contextmanager
decorator is called for the __exit__
part of the context manager protocol and will do one of two things:
If there was no exception, it'll resume your generator. So your generator unpauses at the
yield
line, and you enter the cleanup phase, the partIf there was an exception, the decorator uses
generator.throw()
to raise that exception in the generator. It'll be as if theyield
line caused that exception. Because you have afinally
clause, it'll be executed before your generator exits because of the exception.
So, in your specific example the sequence is as follows:
with time_print("processes"):
This creates the context manager and calls
__enter__
on that.The generator starts execution,
t = time.time()
is run.The
yield
expression pauses the generator, control goes back to the decorator. This takes whatever was yielded and returns that to thewith
statement, in case there is anas target
part. HereNone
is yielded (there is only a plainyield
expression).[doproc() for _ in range(500)]
is run and completes.The context manager
__exit__
method is run, no exception is passed in.The decorator resumes the generator, it continues where it left off.
The
finally:
block is entered andprint task_name, "took", time.time() - t, "seconds."
is executed.The generator exits, the decorator
__exit__
method exits, all is done.
回答2:
Excellent explanation by @Martijn Pieters. Since the yield is redundant in your case, you can achieve the same by creating your own context manager (without yield and contextlib.contextmanager). This is simpler and more readable. So in your case you can implement something as follows.
import time
class time_print(object):
def __init__(self, task_name):
self.task_name = task_name
def __enter__(self):
self.t = time.time()
def __exit__(self):
print self.task_name, "took", time.time() - self.t, "seconds."
def doproc():
x=1+1
with time_print("processes"):
# __enter__ is called
[doproc() for _ in range(500)]
# __exit__ is called
Internally contextlib.contextmanager calls these __enter__ and __exit__ magic functions as explained by @Martijun Pieters. Hope this helps!
来源:https://stackoverflow.com/questions/35489844/what-does-yield-without-value-do-in-context-manager