Python 3, an Illustrated Tour Transcripts
Chapter: Asynchronous Programming
Lecture: Coroutine Requirements

Login or purchase this course to watch this video and the rest of the course contents.
0:00 Let's talk about what's found in a coroutine. Again, you need to declare a coroutine with async before the def
0:06 any non blocking code, you need to call await before it in Python 3.6 and again, this allows you to do that context switch
0:14 from one green thread to another you can't call await in functions, they can only be called in coroutines. anything that has an async def.
0:22 If you want to return a value, there's a couple ways that you can return a value we can pass in this future that we saw and just say future.set result,
0:29 we can also return from a coroutine. And then when we say run until complete we will get a future as a result and we can call result on that
0:40 to pull off the result of what's returned. So those are a couple ways to return a value. Typically, I find myself using futures because it seems for me
0:49 to make it a little bit more clear because you need to pack all these things into the event loop and typically you have multiple things running
0:56 and so my code seems to have futures rather than just returning the result from the gathered future from every coroutine that I'm collecting together.
1:06 These coroutines need to be put into the event loop and so to put them into the event loop we can say asyncio wait
1:12 or asyncio gather or we can just pass in a coroutine directly into that run until complete wait and gather allow us to take multiple coroutines
1:21 and make a new future out of those to pass into our loop. Let's look at the interface for future and what we can do with the future.
1:30 So there are a couple ways to create futures. You can call the constructor, but I'd advise against that
1:35 rather I would call, if you're creating a future loop create future. This allows you if you're using an alternate event loop,
1:43 they can create their own future that has an alternate implementation rather than hard coding it to the asyncio future that's in there.
1:49 So there could be some optimizations that alternate event loops that you could plug in as using, but this is the interface for futures
1:55 once we have a future we can call await on it and that waits until result arrives, we can call set result on it, we can call set exception on it,
2:03 we can have a call back on it. We can pass in a function and that function will be called with the future when the callback is done.
2:11 We can call exception to get the returned exception and we can call result to get the returned result.
2:17 Note that if the future does not yet have a result, this will raise an invalid state error.
2:22 It could also return a cancelled error if the future was canceled. So typically, we don't like go into a loop and call if f result and try
2:30 and see if there's an error there rather we use this code right here, result is equal to yield from f and that will give us our result.
2:39 We don't have to go into a loop or anything. If we want to cancel our future, we can say cancel
2:43 and we can get the status of whether it's done or canceled.

Talk Python's Mastodon Michael Kennedy's Mastodon