Comment vérifier si un objet est un objet générateur en python?

En python, comment vérifier si un objet est un objet générateur?

Essayer ça -

>>> type(myobject, generator)

donne l'erreur -

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'generator' is not defined

(Je sais que je peux vérifier si l'objet a une nextméthode pour qu'il soit un générateur, mais je veux un moyen qui me permette de déterminer le type de n'importe quel objet, pas seulement des générateurs.)

Vous pouvez utiliser GeneratorType à partir des types:

>>> import types
>>> types.GeneratorType
<class 'generator'>
>>> gen = (i for i in range(10))
>>> isinstance(gen, types.GeneratorType)
True

Vous voulez dire des fonctions de générateur? utiliser inspect.isgeneratorfunction.

ÉDITER :

si vous voulez un objet générateur, vous pouvez utiliser inspect.isgenerator comme indiqué par JAB dans son commentaire.

Je pense qu'il est important de faire la distinction entre les fonctions du générateur et les générateurs (résultat de la fonction du générateur):

>>> def generator_function():
...     yield 1
...     yield 2
...
>>> import inspect
>>> inspect.isgeneratorfunction(generator_function)
True

appeler generator_function ne donnera pas de résultat normal, il n'exécutera même pas de code dans la fonction elle-même, le résultat sera un objet spécial appelé générateur :

>>> generator = generator_function()
>>> generator
<generator object generator_function at 0x10b3f2b90>

donc ce n'est pas une fonction de générateur, mais un générateur:

>>> inspect.isgeneratorfunction(generator)
False

>>> import types
>>> isinstance(generator, types.GeneratorType)
True

et la fonction de générateur n'est pas générateur:

>>> isinstance(generator_function, types.GeneratorType)
False

juste pour une référence, l'appel réel du corps de la fonction se produira en consommant un générateur, par exemple:

>>> list(generator)
[1, 2]

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

La inspect.isgeneratorfonction est très bien si vous voulez vérifier des générateurs purs (c'est-à-dire des objets de la classe "générateur"). Cependant, il reviendra Falsesi vous cochez, par exemple, un izipitérable. Une autre façon de rechercher un générateur généralisé est d'utiliser cette fonction:

def isgenerator(iterable):
    return hasattr(iterable,'__iter__') and not hasattr(iterable,'__len__')

Vous pouvez utiliser l'itérateur ou plus précisément le générateur à partir du module de saisie .

from typing import Generator, Iterator
g = (i for i in range(1_000_000))
print(type(g))
print(isinstance(g, Generator))
print(isinstance(g, Iterator))

résultat:

<class 'generator'>
True
True

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

Je sais que je peux vérifier si l'objet a une méthode suivante pour qu'il soit un générateur, mais je veux un moyen qui me permette de déterminer le type de n'importe quel objet, pas seulement des générateurs.

Ne fais pas ça. C'est simplement une très, très mauvaise idée.

À la place, faites ceci:

try:
    # Attempt to see if you have an iterable object.
    for i in some_thing_which_may_be_a_generator:
        # The real work on `i`
except TypeError:
     # some_thing_which_may_be_a_generator isn't actually a generator
     # do something else

Dans le cas peu probable où le corps de la boucle for aurait également TypeErrors, il y a plusieurs choix: (1) définir une fonction pour limiter la portée des erreurs, ou (2) utiliser un bloc try imbriqué .

Ou (3) quelque chose comme ça pour distinguer tous ces TypeErrors qui flottent.

try:
    # Attempt to see if you have an iterable object.
    # In the case of a generator or iterator iter simply 
    # returns the value it was passed.
    iterator = iter(some_thing_which_may_be_a_generator)
except TypeError:
     # some_thing_which_may_be_a_generator isn't actually a generator
     # do something else
else:
    for i in iterator:
         # the real work on `i`

Ou (4) corrigez les autres parties de votre application pour fournir des générateurs de manière appropriée. C'est souvent plus simple que tout cela.

Si vous utilisez le serveur Web tornado ou similaire, vous avez peut-être constaté que les méthodes serveur sont en fait des générateurs et non des méthodes. Cela rend difficile l'appel d'autres méthodes car yield ne fonctionne pas à l'intérieur de la méthode et vous devez donc commencer à gérer des pools d'objets générateurs chaînés. Une méthode simple pour gérer des pools de générateurs chaînés consiste à créer une fonction d'aide telle que

def chainPool(*arg):
    for f in arg:
      if(hasattr(f,"__iter__")):
          for e in f:
             yield e
      else:
         yield f

Écrivant maintenant des générateurs chaînés tels que

[x for x in chainPool(chainPool(1,2),3,4,chainPool(5,chainPool(6)))]

Produit une sortie

[1, 2, 3, 4, 5, 6]

C'est probablement ce que vous voulez si vous cherchez à utiliser des générateurs comme alternative au thread ou similaire.

(Je sais que c'est un ancien post.) Il n'est pas nécessaire d'importer un module, vous pouvez déclarer un objet pour comparaison au début du programme:

gentyp= type(1 for i in "")                                                                                          
       ...
type(myobject) == gentyp