¿Cómo verificar si un objeto es un objeto generador en Python?

En python, ¿cómo verifico si un objeto es un objeto generador?

Intentando esto

>>> type(myobject, generator)

da el error

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

(Sé que puedo verificar si el objeto tiene un nextmétodo para que sea un generador, pero quiero usar algún método para determinar el tipo de cualquier objeto, no solo los generadores).

Puede usar GeneratorType de tipos:

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

¿Te refieres a las funciones del generador? uso inspect.isgeneratorfunction.

EDITAR:

si desea un objeto generador, puede usar inspect.isgenerator como lo señala JAB en su comentario.

Creo que es importante hacer una distinción entre las funciones del generador y los generadores (resultado de la función del generador):

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

llamar a generator_function no producirá un resultado normal, incluso no ejecutará ningún código en la función en sí, el resultado será un objeto especial llamado generador :

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

entonces no es función del generador, sino generador:

>>> inspect.isgeneratorfunction(generator)
False

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

y la función del generador no es generador:

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

solo como referencia, la llamada real del cuerpo de la función ocurrirá al consumir el generador, por ejemplo:

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

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

La inspect.isgeneratorfunción está bien si desea buscar generadores puros (es decir, objetos de la clase "generador"). Sin embargo, volverá Falsesi marca, por ejemplo, un izipiterable. Una forma alternativa de verificar un generador generalizado es usar esta función:

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

Puede usar el iterador o más específicamente, el generador del módulo de escritura .

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))

resultado:

<class 'generator'>
True
True

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

Sé que puedo verificar si el objeto tiene un próximo método para que sea un generador, pero quiero usar alguna forma para determinar el tipo de cualquier objeto, no solo los generadores.

No hagas esto. Es simplemente una muy, muy mala idea.

En cambio, haz esto:

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

En el improbable caso de que el cuerpo del bucle for también tenga TypeErrors, hay varias opciones: (1) definir una función para limitar el alcance de los errores, o (2) usar un try anidado bloque .

O (3) algo como esto para distinguir todos estos TypeErrors que están flotando.

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`

O (4) arregle las otras partes de su aplicación para proporcionar generadores adecuadamente. Eso es a menudo más simple que todo esto.

Si está utilizando un servidor web tornado o similar, es posible que haya encontrado que los métodos del servidor son en realidad generadores y no métodos. Esto hace que sea difícil llamar a otros métodos porque el rendimiento no funciona dentro del método y, por lo tanto, debe comenzar a administrar grupos de objetos generadores encadenados. Un método simple para administrar grupos de generadores encadenados es crear una función de ayuda como

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

Ahora escribiendo generadores encadenados como

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

Produce salida

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

Que es probablemente lo que desea si está buscando utilizar generadores como una alternativa de hilo o similar.

(Sé que es una publicación anterior). No es necesario importar un módulo, puede declarar un objeto para comparar al comienzo del programa:

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