En Python, ¿hay alguna manera de verificar si una función es una "función generadora" antes de llamarla?

function generator

Question

Digamos que tengo dos funciones:

def foo():
return ''foo''
def bar():
yield ''bar''

El primero es una función normal, y el segundo 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 se verá una implementación directa de is_generator_function() ? Usando el paquete de types puedo probar si gen es un generador, pero deseo hacerlo antes de invocar func() .

Ahora considere 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

En realidad, me pregunto cuán útil sería realmente esa función hipotética is_generator_function() . Considerar:

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

¿Qué debería is_generator_function() devolver para baz y quux ? baz() devuelve un generador pero no es uno en sí mismo, y es posible que quux() devuelva un generador o no.

Answer 2

Implementé un decorador que se engancha en la función decorada devuelta / arrojó valor. 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 de decorador se llama de forma incondicional: es el valor de retorno que se prueba.

EDITAR: 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

Answer 3

>>> 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 puede ver, la diferencia clave es que el bytecode para la bar contendrá al menos un YIELD_VALUE operación YIELD_VALUE . Recomiendo usar el módulo dis (redireccionando su salida a una instancia de StringIO y comprobando su valor de getvalue , por supuesto) porque esto le proporciona una medida de solidez frente a los cambios en los getvalue de getvalue ; los valores numéricos exactos de los getvalue de getvalue cambiarán, pero el valor simbólico desmontado se mantendrá bastante estable ;-).

Answer 4

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

• Nuevo en Python versión 2.6