I read several articles on
asyncio python module. Watched several conf talks on it. But once I had to deal with it - I was confused. I have solid knowledge of python and can say that I'm a bit used to async programming with node. But it wasn't easy for me to get my hands wet with
asyncio. That's why I'd like to share a simple but clear example of how it can be used and some basics of it.
What we'll be looking at
Let's assume we are developing a sort of CI script that should build frontend project (install dependencies, compile/transpile, bundle, other stuff). We assume that our frontend project uses at least 2 package managers (
bower - btw don't use bower for new projects), so we have to install all dependencies first and then run bundler (e.g.
So even that's a bit artificial example, but it's not that mystic and should be clear for those who know a bit about frontend stuff. With that said let's start.
Initially, we can write everything sequentially. This way we'll first install
npm dependencies, then
bower dependencies and then run
webpack to bundle our project.
It can be fast if you have a really short list of dependencies in both package managers, fast internet connection, and enough luck. But if you have
bower already installed (as well as
npm) - they are not dependent and can be run in parallel, or at least not block each other's execution.
Let's add some
Well even though it actually uses
asyncio, we added 2 asynchronous functions, but run them synchronously as we did without any additional library. But we can see what changed in the file.
- Marked npm & bower functions with
awaitbefore those functions
- Added getting of the event loop and run
mainuntil it's finished withing that
event loopwith method
Getting things right
This time let's get it right. We want processes of installing
npm dependencies to be asynchronous and wait for both to finish, only after doing so we want to start with
webpack. We can use gather method to generate awaitable (future) object from several async methods.
Now you can see that functions that use some async stuff or should get a result from async function or wait for an async function to execute should be marked as
async def. To wait for a result of async function
result = await is used (if you don't want to store result - just
Hope this example will give you some minimal understanding of how things from
asyncio library work.