En la práctica, ¿cuáles son los principales usos de la nueva sintaxis "yield from" en Python 3.3?

¿Cuáles son las situaciones en las que "yield from" es útil?

Cada situación donde tienes un bucle como este:

for x in subgenerator:
  yield x

Como describe el PEP, este es un intento bastante ingenuo de usar el subgenerador, le faltan varios aspectos, especialmente el manejo adecuado de la .throw()/.send()/.close() mecanismos introducidos por PEP 342. Para hacer esto correctamente, es necesario un código bastante complicado.

¿Cuál es el uso clásico ¿case?

Considere que desea extraer información de una estructura de datos recursiva. Digamos que queremos obtener todos los nodos de la hoja en un árbol:

def traverse_tree(node):
  if not node.children:
    yield node
  for child in node.children:
    yield from traverse_tree(child)

Aún más importante es el hecho de que hasta el yield from, no había un método simple de refactorizar el código del generador. Supongamos que usted tiene un generador (sin sentido) como este:

def get_list_values(lst):
  for item in lst:
    yield int(item)
  for item in lst:
    yield str(item)
  for item in lst:
    yield float(item)

Ahora decides factorizar estos bucles en generadores separados. Sin yield from, esto es feo, hasta el punto en que pensarás dos veces si realmente quieres hacerlo. Con yield from, es realmente agradable de ver:

def get_list_values(lst):
  for sub in [get_list_values_as_int, 
              get_list_values_as_str, 
              get_list_values_as_float]:
    yield from sub(lst)

¿Por qué se compara con micro-hilos?

Creo que de lo que esta sección en el PEP está hablando es de que cada generador tiene su propio contexto de ejecución aislado. Junto con el hecho de que la ejecución se cambia entre el generador-iterador y la persona que llama usando yield y __next__(), respectivamente, esto es similar a los subprocesos, donde el sistema operativo cambia el subproceso de ejecución de vez en cuando, junto con el contexto de ejecución (pila, registros,...).

El efecto de esto también es comparable: Tanto el generador-iterador como el llamador progresan en su estado de ejecución al mismo tiempo, sus ejecuciones están intercaladas. Por ejemplo, si el generador hace algún tipo de cálculo y la persona que llama imprime los resultados, verá los resultados tan pronto como estén disponibles. Esta es una forma de concurrencia.

Esa analogía sin embargo, no es nada específico de yield from - es más bien una propiedad general de los generadores en Python.

Donde quiera que invoque un generador desde dentro de un generador, necesita una "bomba" para re-yield los valores: for v in inner_generator: yield v. Como señala el PEP, hay complejidades sutiles en esto que la mayoría de la gente ignora. El control de flujo no local como throw() es un ejemplo dado en el PEP. La nueva sintaxis yield from inner_generator se usa siempre que haya escrito el bucle explícito for antes. Sin embargo, no es simplemente azúcar sintáctica: Maneja todos los casos de esquina que son ignorados por el bucle for. Ser "azucarado" anima a las personas a usarlo y así obtener los comportamientos correctos.

Este mensaje en el hilo de discusión habla de estas complejidades:

Con las características adicionales del generador introducidas por PEP 342, eso no es más largo el caso: como se describe en el PEP de Greg, iteración simple no soporta send() y throw () correctamente. La gimnasia necesaria para apoyar send () y throw() en realidad no son tan complejos cuando los rompes abajo, pero no son triviales bien.

No puedo hablar de una comparación con micro-hilos, aparte de observar que los generadores son un tipo de paralelismo. Puede considerar que el generador suspendido es un subproceso que envía valores a través de yield a un subproceso de consumo. La implementación real puede no ser nada como esto (y la implementación real es obviamente de gran interés para los desarrolladores de Python), pero esto no concierne a los usuarios.

La nueva sintaxis yield from no añade ningún elemento adicional capacidad para el lenguaje en términos de enhebrado, solo hace que sea más fácil usar las características existentes correctamente. O más precisamente, hace que sea más fácil para un novato consumidor de un generador interno complejo escrito por un experto pasar a través de ese generador sin romper ninguna de sus características complejas.

Un breve ejemplo le ayudará a entender uno de los casos de uso de yield from: obtener valor de otro generador

def flatten(sequence):
    """flatten a multi level list or something
    >>> list(flatten([1, [2], 3]))
    [1, 2, 3]
    >>> list(flatten([1, [2], [3, [4]]]))
    [1, 2, 3, 4]
    """
    for element in sequence:
        if hasattr(element, '__iter__'):
            yield from flatten(element)
        else:
            yield element

print(list(flatten([1, [2], [3, [4]]])))

yield from básicamente encadena iteradores de una manera eficiente:

# chain from itertools:
def chain(*iters):
    for it in iters:
        for item in it:
            yield item

# with the new keyword
def chain(*iters):
    for it in iters:
        yield from it

Como puedes ver, elimina un bucle Python puro. Eso es casi todo lo que hace, pero encadenar iteradores es un patrón bastante común en Python.

Los hilos son básicamente una característica que le permite saltar fuera de funciones en puntos completamente aleatorios y volver al estado de otra función. El supervisor de subprocesos hace esto muy a menudo, por lo que el programa parece ejecutar todas estas funciones al mismo tiempo. El el problema es que los puntos son aleatorios, por lo que debe usar el bloqueo para evitar que el supervisor detenga la función en un punto problemático.

Los generadores son bastante similares a los hilos en este sentido: Te permiten especificar puntos específicos (siempre que yield) donde puedes entrar y salir. Cuando se usa de esta manera, los generadores se llaman corrutinas.

Lee estos excelentes tutoriales sobre corrutinas en Python para más detalles

En el uso aplicado para la coroutina de IO asíncrona , yield from tiene un comportamiento similar a await en una función de coroutina . Ambos se utilizan para suspender la ejecución de la corrutina.

• yield from es utilizado por la corrutina basada en generadores .

• await se utiliza para async def corutina. (desde Python 3.5+)

Para Asyncio, si no hay necesidad de soportar una versión anterior de Python (i. e. >3.5), async def/await es la sintaxis recomendada para definir una corrutina. Por lo tanto, yield from ya no es necesario en una corrutina.

Pero en general fuera de asyncio, yield from <sub-generator> todavía tiene algún otro uso en la iteración del subgenerador como se mencionó en la respuesta anterior.