Asynchronous for loop in python?

The subject is very complex and extensive, but I will try to give an answer.

asyncis a keyword introduced together with awaitin Python 3.5 and that allows to define native coroutines.

Let's imagine that we have an application that requests data from several different servers, the request to the server can take an indeterminate time to complete. Under normal conditions the interpreter executes certain orders sequentially waiting for the current one to complete before moving on to the next one, in our case this would mean waiting for the server to return before sending the request to the next one, a waiting time that is wasted.

Instead of waiting for the response, we could go on to send the request to the next server or process the return of another one in the meantime and later when the previous one returns we process its return. This way we don't have the thread doing nothing while a blocking I/O task returns. This is the essence of an asynchronous program.

Asynchronous is classically associated with multiprocessing or multithreading. Simplifying a lot, when you have multiple threads running, each CPU core can run only one thread at a time. In order to allow all threads/processes to share resources, the CPU performs an operation called a context switch. Let's say at a random interval, you save all the context information for one thread and switch to another thread, then load the context and continue with the previous thread...

Threads and processes have certain problems, two of them are that they can be heavy and expensive to deploy and they are susceptible to race conditions, since if they are not synchronized correctly, the change from one thread to another is not determined.

One way to do asynchronous programming without resorting to threads or processes is by implementing an event loop . Basically we have an event/job queue and a loop that just constantly pulls jobs from the queue and runs them. We are going to call these jobs coroutines, which would be a small set of instructions that can also include new events that must be queued again. In this case we have application controlled context switches , while waiting for some blocking I/O to complete, there are no CPU level context switches. Everything is executed in the same thread , only one routine is executed at a time andit switches context only at points that are explicitly defined (eg await). Coroutines therefore allow cooperative multitasking operations in which each coroutine relinquishes control at certain points and voluntarily.

A few key concepts are:

• Coroutine (coroutine) : is a special function that can give control to its caller without losing its state. This sounds a lot like a generator to us, in fact coroutines were implemented using generators and the use of yield/ yield frominitially (generator-based coroutines). Actually a coroutine is a consumer, an extension of a generator function that can generate values ​​and accept external values . The advantage of using a coroutine is that we can pause the execution of a function and resume it later since it maintains its context. Count a coroutine is called, it doesn't actually run, but will return a coroutine object that can be passed to the event loop to run immediately or later.

• Future (Future) : It is like a placeholder for a value that will materialize in the future but that does not exist right now. It is similar to what in JS is known as promises. This terminology is perhaps clearer, it is essentially a promise that it will give us a return value when the asynchronous operation completes, we keep this future object or promise and when it is fulfilled we can call a method to retrieve the actual result.

• Tasks (task): they are schedulers for the coroutines, wrappers for the coroutines. It is a subclass of Future. The gist is that they allow you to keep track of when they finish processing, other coroutines can wait for a task, and you can also grab the result of a task when it has finished processing. Tasks are therefore used to schedule concurrent coroutines.

• Event loop: It is the central core in asyncio. None of the above makes sense without it. There are several configurations and types of event loops that can be used within the asyncio module .

An example basic way of proceeding would be:

• We have an event loop running in a single thread
• The loop receives tasks from the queue
• Each task calls the next step of a coroutine.
• If the coroutine calls another coroutine ( await co-rutina_2), the current coroutine is suspended and a context switch occurs. The context of the current coroutine is saved (variables, state, ...) and the context of the called coroutine is loaded
• If a coroutine encounters a blocking code (I/O, sleep, etc), it is suspended and control is returned to the event loop.

As for your three usage examples of async:

• async def funcname():

  It is the way to define a native coroutine since Python 3.5 (PEP 492), at which time native coroutines were introduced, with async/ await. This replaces the generator-based coroutines ( @asyncio.coroutine, yield from, yield), which will be removed in a future Python 3.10.

  import asyncio
  
  async def io_operation(ident):
      print(f'La operación {ident} ha comenzado')
      await asyncio.sleep(1) # Solo para emular una operación I/O bloqueante
      print(f'La operación {ident} ha terminado')
  
  async def main():
      await asyncio.gather(
          io_operation('A'),
          io_operation('B'),
          )
  
  if __name__ == '__main__':
      loop = asyncio.get_event_loop() # Ciclo de eventos
      loop.run_until_complete(main())
  

  Operation A has started
  Operation B has started
  Operation A has finished
  Operation B has finished

  As already mentioned, calling a coroutine does not execute its content, just like a generator:

  >>> io_operation("A")
  <coroutine object io_operation at 0x7f13eac1fa48>)  
  

• async with expr as var

  It is the expression to make use of the asynchronous context manager of an object that implements it, that is, it can suspend execution in its __enter__and methods __exit__.

  import asyncio
  
  class Foo:
      async def __aenter__(self):
          print("Entrando en el contexto")
          await asyncio.sleep(1)
  
      async def __aexit__(self, exc_type, exc, tb):
          print("Saliendo del contexto")
          await asyncio.sleep(1)
  
  async def main():
      async with Foo() as foo:  # <<<<<<<<<<<<<<<<<<<<<<<<<
          print("Algo ocurre en medio...") 
  
  if __name__ == '__main__':
      loop = asyncio.get_event_loop() # Ciclo de eventos
      loop.run_until_complete(main())
  

  Entering the context
  Something happens in the middle…
  Leaving the context

• async for target in iter

  It is the expression to iterate over an async iterable (you can call async code in its ₎ method __iter__) and over an async iterator (you can call async code in its __next__₎.

  import asyncio
  
  class IterableAsincrono:
      def __init__(self, n):
          self._n = n
  
      def __aiter__(self):
          return self
  
      async def __anext__(self):
          item = await self.get_next()
          if item:
              return item
          else:
              raise StopAsyncIteration
  
      async def get_next(self):
          if self._n > 0:
              await asyncio.sleep(1)
              self._n -= 1
              return self._n
  
  async def main():
      async for item in IterableAsincrono(5):  # <<<<<<<<<<<<<<<<
          print(item) 
  
  if __name__ == '__main__':
      loop = asyncio.get_event_loop() # Ciclo de eventos
      loop.run_until_complete(main())
  

async fromand async withcan only be used within the body of a coroutine.

Do not try to make sense of the examples, they are very simple and do not represent real uses. The only intention is to show the general operation and that they are executable with the minimum code.

It should be made clear that coroutines are executed concurrently, but never in parallel. In CPython, threads cannot execute in parallel either because of the GIL, so coroutines are alternatives to consider in many cases in which we could use threads in situations where we have blocking input/output operations (typically a network request). They provide a very high level of concurrency with very little overhead and memory usage.