Join us and get access to thousands of tutorials and a community of expert Pythonistas.

This lesson is for members only. Join us and get access to thousands of tutorials and a community of expert Pythonistas.

Unlock This Lesson

The asyncio Event Loop

Hands-On Python 3 Concurrency With the asyncio Module Chyld Medford 08:43

In this lesson, youâll learn about the Event Loop. Youâll see what it is and how to define one. The Event Loop is used to:

perform IO tasks
run asynchronous tasks
run callbacks

In addition to learning about what it is, youâll see how to change a normal main() function into an event loop. Youâll see how to create numerous coroutines using Future objects and gather(). In the last section of the lesson, youâll see an example demonstrating how using an asynchronous approach can make your code run faster.

00:00 Now, if I try and run this,

00:05 you can see I got another error message. It says coroutine 'main' was never awaited. Whatâs going on here? Well, what needs to happen is I need to actually create whatâs called an event loop, and the event loop is whatâs going to actually run these coroutines.

00:21 So youâre probably asking yourself âWhatâs an event loop?â Well, the event loop is the core of every async IO application. And what do event loops do? Well, they run asynchronous tasks, like thisâthey run these things. They run callbacks.

00:39 They perform network operations, IO operations, and other subprocesses. So you can basically think of the event loop as something that runs these callbacks, okay? And any IO associated with them, all right? Great.

00:55 So I need an event loop, and the event loop is going to allow us to run this asynchronous task right here, this coroutine. But how do I actually create the event loop?

01:08 What weâre going to do is weâre going to come down here into "__main__" and Iâm going to say asyncio.run(main()).

01:24 And this little bit of code right here creates the event loop, and it says, âOkay, now that you have an event loop, I want you to run any task associated with main() inside this event loop.â Okay? All right, so letâs see what happens now.

01:39 Letâs come back here and rerun it,

01:45 and it looks like we got an actual response. The random number we got was 6. Now, youâre probably looking at this and youâre going âWell, was there really any difference? I mean, this still took roughly 3 seconds.â Itâs like, what was the benefit of all that talk and all this?

02:03 So, I think the best way to do this is by running some timings. What Iâm going to do is Iâm going to say, start, the start time, is equal to time.âIâm going to create a perf_counter(). Okay.

02:15 This will give me a start time and then weâll have a stop time, and then weâll look at the difference between the two. Okay? Iâm going to do that.

02:25 And Iâm going to create an elapsed time,

02:32 which is time.perf_counter(), and weâll just subtract the start time from that. Okay. And then letâs print out the r value that I just got back, the random value that I just got,

02:53 and how long it took. Weâll say, f'{r} took {} seconds', like that. And what is this? Itâs the elapsed, and then weâll round it to just to 2 decimal points.

03:11 Okay, so itâs going to start a timer, itâs going to do this, itâs going to wait. So this await, what itâs going to do is itâs not going to run these two lines of code, 23 and 24, until 22 is finished, okay?

03:25 So letâs see how long that takes. And it will probably take around 3 seconds, but letâs just see.

03:34 And indeed, it took 3.00 seconds exactly. So that was great. Now letâs do this again, but letâs do it more than just one time. So Iâm basically just going to copy this code,

03:53 paste it right here.

03:58 And now I want to do this a lot of times. I want to call randn() a lot of times, or numerous times, and so a way you can do that is you could await this thing, asyncio.gather(),

04:18 and in this I can create numerous randn() coroutines. Let me show you an example. I could say randn(), randn(), like that. So there was two of them, maybe letâs do one more.

04:40 I created three of these things and then the response is going to go into râyou could also think of r as randomâand yeah.

04:46 So weâre going to do another start, weâre going to do this, and then weâre going to do a stop, and then weâre going to print this out. Now, how long do you think this is going to take? You may think, âWell, it took 3 seconds to do this one up hereâthereâs three of themâso itâll probably take 3 * 3 is 9.

05:02 And thatâs how long the synchronous version took, right? It took 9 seconds. Letâs see how long the async version takes.

05:13 So the first one, it got a 6, I took 3.00 seconds. And the second one, [1, 5, 1], and it also took 3.00 seconds. So, hm, thatâs pretty interesting, right?

05:22 I did essentially three times the work and the amount of time it took was still 3 seconds. Now I could do this even more. Instead of doing this, letâs create a list comprehension, and I could say randn() for _ in range(10). So, 10 of these,

05:53 and they are 3 seconds each, so you would think, âWell, it would probably take about 30 seconds,â right? If this was a synchronous version, you would think it would take about 30 seconds. So Iâm going to do 10 of these, but I need to unpack this thing, so Iâm going to do star (*) and actually Iâm just going to do the round braces here.

06:16 Youâre probably wondering, âWhat does that do?â The square braces makes it a list comprehension. The round bracesâyouâre probably thinking the round braces makes it a tuple. In this case here, it actually doesnât make it a tuple. It actually turns it into a generator, which is one of those things we created initially, right? Up here.

06:35 The odds() was a generator. And so, yeah, when you do round braces it actually produces a generator, and the * causes the generator to run, and then Iâm unpacking those results.

06:45 So basically, Iâm creating 10 of these. Iâm creating 10 randn() coroutines and theyâre all going to run, okay? So letâs see what happens. So, will this take 3 seconds orâlike, if this was the synchronous version, it would take 30 seconds, but letâs see how long it takes.

07:08 So here it is, the codeâs running. I got a 5, it took 3.00 seconds long, and now Iâm going to do 10. Look, thereâs 10 values there, and it took 3.01 seconds. So, once again, you can see this asyncio thing is actually doing something pretty interesting.

07:21 Itâs actually running all this stuffâyou could think of it as if itâs running it in parallel, because it only took 3 seconds. Now, itâs not technically running it in parallel.

07:30 Whatâs happening is itâs actually only running on one thread, so thereâs a processâa Python process. Inside that Python process, thereâs one thread, and this is running on that one thread.

07:42 But whatâs happening is itâs telling the systemâi.e. the computerâto sleep, and so the computer is handling the sleeping. And then once itâs finished, the computer comes backâlike, the operating system comes backâand says, âHey, Python, Iâm done.â And it says, âIâm done,â on all these 10 tasks at basically the same amount of time, and then Python processes those.

08:03 So the sleeping doesnât really happen in Pythonâit happens outside of Python inside the operating system. So, something that could have taken 30 seconds instead only took 3 seconds because it was happening in the background. Python really wasnât taking care of that.

08:21 So, we went from this synchronous version to the asynchronous version. This all looks pretty good. The next thing that I want to do is I want to show you how to take these generators and these coroutines, and put them together and make whatâs called an asynchronous generator.

08:39 Okay, so thatâs next.

dgoodson12722 on March 3, 2020

You are an awesome instructor with the gift of making asyncio seem easy! Please, do more videos like this, please!

Angad on Aug. 6, 2020

Awesome instructor . Thank you . Please post more lessons on realpython.

himanshudhar6 on Feb. 15, 2021

Explained in a very confusing manner

Luis on March 7, 2021

I feel like the course is missing an explanation on what callbacks are.

Bartosz ZaczyÅski RP Team on March 8, 2021

@Luis Whenever you find an unfamiliar term, you can try looking it up in the Python glossary, which usually has a brief answer:

callback

A subroutine function which is passed as an argument to be executed at some point in the future.

For an in-depth explanation, you can usually find a Wikipedia article that goes into much more detail.

Let me know if you have any specific questions. I’ll be happy to help!

vijay singh on April 14, 2023

Is the code to this topic intentionally not made available in the ‘supporting materials’ section?

Martin Breuss RP Team on April 14, 2023

@vijay singh thanks for noting this! It looks like the original authors didn’t provide the code materials, we’ll work on fetching them from the associated tutorial and adding them here as a ZIP file as well.

In the meantime, you could copy the code you’re looking for from the source tutorial.

junw on July 20, 2024

very confusing for beginner

junw on July 22, 2024

Understand now with some basic knowledge.

al on May 25, 2025

Wow… for this section to be confusing, it would have to actually improve A LOT!

Become a Member to join the conversation.