Schedule a callback for execution in the next iteration of the event loop.

Expresses the intention to defer execution of a callback until the event loop is ready, yielding control back to the loop.

When you need to schedule a callback to run soon without blocking the current coroutine or callback, e.g., after scheduling I/O, to wake up the loop, or to defer cleanup.

Inside asyncio event loop callbacks, protocol/transport callbacks, or any code running within the event loop where you want to schedule another callback to run soon.

loop.call_soon(callback, *args)

loop.call_soon(..., ...)

loop: asyncio.AbstractEventLoop instance, callback: callable, args: zero or more positional arguments passed to callback

• asyncio.get_event_loop()
• loop
• callback
• functools.partial
• lambda
• *args
• call_soon_threadsafe
• call_later.

• loop.call_later(delay
• callback
• *args) for delayed scheduling
• loop.call_soon_threadsafe for thread‑safe scheduling
• loop.create_task for fire‑and‑forget coroutines.

Assuming the callback runs immediately; passing a non‑callable as callback; forgetting *args and missing arguments; calling from a non‑event‑loop thread without using the thread‑safe variant.

loop.call_later schedules after a delay; loop.call_soon_threadsafe schedules from another thread; asyncio.create_task schedules a coroutine as a Task.

Coming from Python: assuming call_soon executes immediately → it actually runs after the current yield to the event loop; confusing call_soon with call_later → use call_later for delayed scheduling; using call_soon from a non‑event‑loop thread → use call_soon_threadsafe for thread‑safe scheduling.

• asyncio event loop scheduling methods

Do not use call_soon when you need a guaranteed delay or precise timing; it introduces negligible overhead, merely queuing a callback; the exact order among already‑queued callbacks depends on their queue position and is not guaranteed if other callbacks are added concurrently.

Signals that the callback should be deferred, allowing the current task to yield and letting the event loop process other events first.

"Call soon" – think of asking the loop to call you back shortly after it finishes the current task.

The callback receives the arguments passed via *args in the order they appear; keyword arguments are not supported by call_soon.

Consider loop.call_later for delayed execution, asyncio.create_task for fire‑and‑forget coroutines, or loop.call_soon_threadsafe for cross‑thread safety.