En python existe-t-il un moyen de vérifier si une fonction est une "fonction génératrice" avant de l'appeler?

Question

permet de dire I ont deux fonctions:

def foo(): 
    return 'foo' 

def bar(): 
    yield 'bar' 

La première est une fonction normale, et la deuxième est une fonction de générateur. Maintenant, je veux écrire quelque chose comme ceci:

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

Quelle sera une mise en œuvre simple de is_generator_function() ressembler? En utilisant le paquet types je peux tester si gen est un générateur, mais je souhaite le faire avant d'appeler func().

Considérons maintenant le cas suivant:

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

Une invocation de goo() retourne un générateur. Je suppose que l'analyseur python sait que la fonction goo() a une déclaration de rendement, et je me demande s'il est possible d'obtenir facilement cette information.

Merci!

Answer 1

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

• Nouveau dans la version 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   
>>> 

Comme vous le voyez, la principale différence est que le bytecode pour bar contiendra au moins un YIELD_VALUE opcode. Je recommande d'utiliser le module dis (en redirigeant sa sortie vers une instance StringIO et en vérifiant ses getvalue, bien sûr) car cela vous fournit une mesure de robustesse par rapport aux changements de bytecode - les valeurs numériques exactes des opcodes vont changer, mais la valeur symbolique désassemblée restera très stable ;-).

Answer 3

En fait, je me demande à quel point cette hypothétique is_generator_function() serait vraiment utile. Considérez:

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

Que dois-is_generator_function() retour pour baz et quux? baz() renvoie un générateur mais n'en est pas un lui-même et quux() peut renvoyer un générateur ou non.

Answer 4

J'ai mis en place un décorateur qui accroche la fonction décorée de retour/valeur donné. Sa base 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 

Cela fonctionne parce que la fonction de décorateur est appelé inconditionnellement: il est la valeur de retour qui est testée.

---

EDIT: Suite au commentaire de Robert Lujo, j'ai fini avec quelque chose comme:

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