En python, ¿hay alguna forma de comprobar si una función es una "función del generador" antes de llamarla?

Question

Digamos que tengo dos funciones:

def foo(): 
    return 'foo' 

def bar(): 
    yield 'bar' 

El primero de ellos es una función normal, y la segunda es una función de generador. Ahora quiero escribir algo como esto:

def run(func): 
    if is_generator_function(func): 
    gen = func() 
    gen.next() 
    #... run the generator ... 
    else: 
    func() 

¿Cómo será una aplicación directa de is_generator_function() parece? Usando el paquete types puedo probar si gen es un generador, pero deseo hacerlo antes de invocar func().

Ahora consideremos el siguiente caso:

def goo(): 
    if False: 
    yield 
    else: 
    return 

Una invocación de goo() devolverá un generador. Supongo que el analizador de Python sabe que la función goo() tiene una declaración de rendimiento, y me pregunto si es posible obtener esa información fácilmente.

Gracias!

Answer 1

>>> import inspect 
>>> 
>>> def foo(): 
... return 'foo' 
... 
>>> def bar(): 
... yield 'bar' 
... 
>>> print inspect.isgeneratorfunction(foo) 
False 
>>> print inspect.isgeneratorfunction(bar) 
True 

• Nueva versión en Python 2,6

Answer 2

>>> def foo(): 
... return 'foo' 
... 
>>> def bar(): 
... yield 'bar' 
... 
>>> import dis 
>>> dis.dis(foo) 
    2   0 LOAD_CONST    1 ('foo') 
       3 RETURN_VALUE   
>>> dis.dis(bar) 
    2   0 LOAD_CONST    1 ('bar') 
       3 YIELD_VALUE   
       4 POP_TOP    
       5 LOAD_CONST    0 (None) 
       8 RETURN_VALUE   
>>> 

Como se ve, la diferencia clave es que el código de bytes para bar contendrá al menos un código de operación YIELD_VALUE. Recomiendo usar el módulo dis (redireccionando su salida a una instancia de StringIO y comprobando getvalue, por supuesto) porque esto proporciona una medida de robustez sobre los cambios en los códigos de bytes: los valores numéricos exactos de los códigos de operación cambiarán, pero el valor simbólico desmontado se mantendrá bastante estable ;-).

Answer 3

En realidad, me pregunto cuán útil sería realmente un hipotético is_generator_function(). Considere:

def foo(): 
    return 'foo' 
def bar(): 
    yield 'bar' 
def baz(): 
    return bar() 
def quux(b): 
    if b: 
     return foo() 
    else: 
     return bar() 

¿Qué debe is_generator_function() cambio de baz y quux? baz() devuelve un generador pero no es uno en sí mismo, y quux() puede devolver un generador o no.

Answer 4

he implementado un decorador que se engancha en la función decorada regresado valor/cedido. Su básico va:

import types 
def output(notifier): 
    def decorator(f): 
     def wrapped(*args, **kwargs): 
      r = f(*args, **kwargs) 
      if type(r) is types.GeneratorType: 
       for item in r: 
        # do something 
        yield item 
      else: 
       # do something 
       return r 
    return decorator 

Funciona porque la función del decorador se llama incondicionalmente: es el valor de retorno que se prueba.

---

EDIT: Siguiendo el comentario de Robert Lujo, terminé con algo como:

def middleman(f): 
    def return_result(r): 
     return r 
    def yield_result(r): 
     for i in r: 
      yield i 
    def decorator(*a, **kwa): 
     if inspect.isgeneratorfunction(f): 
      return yield_result(f(*a, **kwa)) 
     else: 
      return return_result(f(*a, **kwa)) 
    return decorator