Come verificare se un oggetto è un oggetto generatore in Python?

In Python, come posso verificare se un oggetto è un oggetto generatore?

Provando questo -

>>> type(myobject, generator)

dà l'errore -

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

(So ​​che posso verificare se l'oggetto ha un nextmetodo per essere un generatore, ma voglio in qualche modo usare il quale posso determinare il tipo di qualsiasi oggetto, non solo i generatori.)

È possibile utilizzare GeneratorType dai tipi:

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

Intendi le funzioni del generatore? usare inspect.isgeneratorfunction.

MODIFICARE :

se vuoi un oggetto generatore puoi usare inspect.isgenerator come sottolineato da JAB nel suo commento.

Penso che sia importante fare una distinzione tra funzioni del generatore e generatori (risultato della funzione del generatore):

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

la chiamata a generator_function non produrrà un risultato normale, nemmeno eseguirà alcun codice nella funzione stessa, il risultato sarà un oggetto speciale chiamato generator :

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

quindi non è la funzione generatore, ma generatore:

>>> inspect.isgeneratorfunction(generator)
False

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

e la funzione generatore non è generatore:

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

solo per riferimento, l'effettivo richiamo del corpo della funzione avverrà consumando il generatore, ad esempio:

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

Vedi anche In python c'è un modo per verificare se una funzione è una "funzione generatore" prima di chiamarla?

La inspect.isgeneratorfunzione va bene se si desidera verificare la presenza di generatori puri (ovvero oggetti della classe "generatore"). Tuttavia, verrà restituito Falsese si seleziona, ad esempio, un izipiterabile. Un modo alternativo per verificare la presenza di un generatore generalizzato è utilizzare questa funzione:

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

È possibile utilizzare l'Iteratore o, più specificamente, il generatore dal modulo di digitazione .

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

risultato:

<class 'generator'>
True
True

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

So di poter verificare se l'oggetto ha un metodo successivo per essere un generatore, ma voglio in qualche modo utilizzare il quale posso determinare il tipo di qualsiasi oggetto, non solo i generatori.

Non farlo È semplicemente una pessima idea.

Invece, fai questo:

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

Nel caso improbabile che il corpo del ciclo for abbia anche TypeErrors, ci sono diverse scelte: (1) definire una funzione per limitare l'ambito degli errori o (2) usare un blocco di prova nidificato .

O (3) qualcosa del genere per distinguere tutte queste cose TypeErrorche fluttuano intorno.

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`

Oppure (4) correggere le altre parti dell'applicazione per fornire i generatori in modo appropriato. Questo è spesso più semplice di tutto questo.

Se stai usando un server web tornado o simile potresti aver scoperto che i metodi server sono in realtà generatori e non metodi. Ciò rende difficile chiamare altri metodi perché il rendimento non funziona all'interno del metodo e quindi è necessario iniziare a gestire pool di oggetti generatori concatenati. Un metodo semplice per gestire gruppi di generatori concatenati è quello di creare una funzione di aiuto come

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

Ora scrivendo generatori concatenati come

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

Produce output

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

Che è probabilmente quello che vuoi se stai cercando di usare i generatori come alternativa al thread o simili.

(So ​​che è un vecchio post.) Non è necessario importare un modulo, puoi dichiarare un oggetto per il confronto all'inizio del programma:

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