Jak sprawdzić, czy obiekt jest obiektem generatora w Pythonie?

Jak w Pythonie sprawdzić, czy obiekt jest obiektem generatora?

Próbuję tego -

>>> type(myobject, generator)

podaje błąd -

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

(Wiem, że mogę sprawdzić, czy obiekt ma nextmetodę, aby był generatorem, ale chcę mieć jakiś sposób, za pomocą którego mogę określić typ dowolnego obiektu, nie tylko generatorów.)

Możesz użyć GeneratorType z typów:

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

Masz na myśli funkcje generatora? używać inspect.isgeneratorfunction.

EDYTOWAĆ :

jeśli potrzebujesz obiektu generatora, możesz użyć inspect.isgenerator, jak wskazał JAB w swoim komentarzu.

Myślę, że ważne jest, aby dokonać rozróżnienia między funkcjami generatorów a generatorami (wynik funkcji generatora):

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

wywołanie funkcji generator_function nie przyniesie normalnego wyniku, nawet nie wykona żadnego kodu w samej funkcji, wynikiem będzie specjalny obiekt o nazwie generator :

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

więc nie jest to funkcja generatora, ale generator:

>>> inspect.isgeneratorfunction(generator)
False

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

a funkcja generatora nie jest generatorem:

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

tylko w celach informacyjnych, faktyczne wywołanie treści funkcji nastąpi poprzez zużycie generatora, np .:

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

Zobacz także Czy w pythonie istnieje sposób sprawdzenia, czy funkcja jest „funkcją generatora” przed jej wywołaniem?

inspect.isgeneratorFunkcja jest w porządku, jeśli chcesz sprawdzić czystych generatorów (czyli obiektów „generator” klasa). Jednak zwróci, Falsejeśli izipzaznaczysz na przykład iterowalny plik . Alternatywnym sposobem sprawdzenia generatora uogólnionego jest użycie tej funkcji:

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

Możesz użyć Iteratora lub dokładniej Generatora z modułu pisania .

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

wynik:

<class 'generator'>
True
True

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

Wiem, że mogę sprawdzić, czy obiekt ma następną metodę, aby był generatorem, ale chcę mieć jakiś sposób, za pomocą którego mogę określić typ dowolnego obiektu, nie tylko generatorów.

Nie rób tego. To po prostu bardzo, bardzo zły pomysł.

Zamiast tego zrób to:

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

W mało prawdopodobnym przypadku, gdy treść pętli for również ma TypeErrors, istnieje kilka możliwości: (1) zdefiniowanie funkcji ograniczającej zakres błędów lub (2) użycie zagnieżdżonego bloku try .

Lub (3) coś takiego, aby rozróżnić wszystkie te TypeErrorpływające wokół.

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`

Lub (4) napraw inne części aplikacji, aby odpowiednio zapewnić generatory. To często prostsze niż to wszystko.

Jeśli używasz serwera WWW tornado lub podobnego, być może zauważyłeś, że metody serwera są w rzeczywistości generatorami, a nie metodami. Utrudnia to wywoływanie innych metod, ponieważ yield nie działa wewnątrz metody i dlatego musisz zacząć zarządzać pulami połączonych obiektów generatora. Prostą metodą zarządzania pulami połączonych generatorów jest utworzenie funkcji pomocy, takiej jak

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

Teraz piszemy generatory łańcuchowe, takie jak

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

Produkuje wynik

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

Co prawdopodobnie jest tym, czego chcesz, jeśli chcesz używać generatorów jako alternatywy dla wątku lub podobnej.

(Wiem, że to stary post.) Nie ma potrzeby importowania modułu, możesz zadeklarować obiekt do porównania na początku programu:

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