asynchronous programming in python

Question

Is there a generic notion of asynchronous programming in python? Could I assign a callback to a function, execute it and return to the main program flow immediately, no matter how long the execution of that function would take?

Answer 1

What you describe (the main program flow resuming immediately while another function executes) is not what's normally called "asynchronous" (AKA "event-driven") programming, but rather "multitasking" (AKA "multithreading" or "multiprocessing"). You can get what you described with the standard library modules threading and multiprocessing (the latter allows actual concurrent execution on multi-core machines).

Asynchronous (event-driven) programming is supported in the standard Python library in the asyncore and asynchat modules, which are very oriented to networking tasks (indeed they internally use the select module, which, on Windows, only supports sockets -- though on Unixy OSs it can also support any file descriptor).

For a more general (though also mostly networking oriented, but not limited to that) support for asynchronous (event-driven) programming, check out the twisted third-party package.

Answer 2

Take a look here:

Asynchronous Programming in Python

An Introduction to Asynchronous Programming and Twisted

Worth checking out:

asyncio (previously Tulip) has been checked into the Python default branch

Edited on 14-Mar-2018

Today Python has asyncIO — Asynchronous I/O, event loop, coroutines and tasks built in.

Description taken from the link above:

The asyncIO module provides infrastructure for writing single-threaded concurrent code using coroutines, multiplexing I/O access over sockets and other resources, running network clients and servers, and other related primitives. Here is a more detailed list of the package contents:

1. a pluggable event loop with various system-specific implementations;
2. transport and protocol abstractions (similar to those in Twisted);
3. concrete support for TCP, UDP, SSL, subprocess pipes, delayed calls, and others (some may be system-dependent);
4. a Future class that mimics the one in the concurrent.futures module, but adapted for use with the event loop;
5. coroutines and tasks based on yield from (PEP 380), to help write concurrent code in a sequential fashion;
6. cancellation support for Futures and coroutines;
7. synchronization primitives for use between coroutines in a single thread, mimicking those in the threading module;
8. an interface for passing work off to a threadpool, for times when you absolutely, positively have to use a library that makes blocking I/O calls.

Asynchronous programming is more complex than classical “sequential” programming: see the Develop with asyncio page which lists common traps and explains how to avoid them. Enable the debug mode during development to detect common issues.

Also worth checking out:

A guide to asynchronous programming in Python with asyncIO