Wie überprüfe ich, ob ein Objekt ein Generatorobjekt in Python ist?

Wie überprüfe ich in Python, ob ein Objekt ein Generatorobjekt ist?

Ich versuche das -

>>> type(myobject, generator)

gibt den Fehler -

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

(Ich weiß, ich kann überprüfen, ob das Objekt eine hat next Methode hat, um ein Generator zu sein, aber ich möchte eine Möglichkeit, mit der ich den Typ eines Objekts bestimmen kann, nicht nur Generatoren.)

Sie können GeneratorType aus folgenden Typen verwenden:

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

Du meinst Generatorfunktionen? verwendeninspect.isgeneratorfunction .

EDIT:

Wenn Sie ein Generatorobjekt möchten, können Sie inspect.isgenerator verwenden, wie von JAB in seinem Kommentar hervorgehoben.

Ich denke, es ist wichtig, zwischen Generatorfunktionen und Generatoren zu unterscheiden (Ergebnis der Generatorfunktion):

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

Der Aufruf von generator_function liefert kein normales Ergebnis, führt sogar keinen Code in der Funktion selbst aus. Das Ergebnis ist ein spezielles Objekt namens generator :

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

Es handelt sich also nicht um eine Generatorfunktion, sondern um einen Generator:

>>> inspect.isgeneratorfunction(generator)
False

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

und Generatorfunktion ist nicht Generator:

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

Nur als Referenz wird der tatsächliche Aufruf des Funktionskörpers durch den Verbrauch eines Generators erfolgen, z.

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

Siehe auch In Python gibt es eine Möglichkeit zu überprüfen, ob eine Funktion eine "Generatorfunktion" ist, bevor sie aufgerufen wird?

Die inspect.isgeneratorFunktion ist in Ordnung, wenn Sie nach reinen Generatoren suchen möchten (dh nach Objekten der Klasse "Generator"). Es wird jedoch zurückgegeben, Falsewenn Sie beispielsweise ein izipiterables Element überprüfen . Eine alternative Möglichkeit zur Suche nach einem verallgemeinerten Generator ist die Verwendung dieser Funktion:

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

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

Ich weiß, dass ich überprüfen kann, ob das Objekt eine nächste Methode hat, um ein Generator zu sein, aber ich möchte eine Möglichkeit, mit der ich den Typ eines Objekts bestimmen kann, nicht nur Generatoren.

Tu das nicht. Es ist einfach eine sehr, sehr schlechte Idee.

Tun Sie stattdessen Folgendes:

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

Für den unwahrscheinlichen Fall, dass der Hauptteil der for- Schleife auch TypeErrors enthält, gibt es mehrere Möglichkeiten: (1) Definieren Sie eine Funktion, um den Umfang der Fehler zu begrenzen, oder (2) verwenden Sie einen verschachtelten try- Block.

Oder (3) so etwas, um all diese TypeErrors zu unterscheiden, die herumschweben.

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`

Oder (4) die anderen Teile Ihrer Anwendung reparieren, um Generatoren entsprechend bereitzustellen. Das ist oft einfacher als das alles.

Sie können den Iterator oder genauer gesagt den Generator aus dem Typisierungsmodul verwenden .

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

Ergebnis:

<class 'generator'>
True
True

Wenn Sie einen Tornado-Webserver oder einen ähnlichen verwenden, haben Sie möglicherweise festgestellt, dass Servermethoden tatsächlich Generatoren und keine Methoden sind. Dies macht es schwierig, andere Methoden aufzurufen, da Yield innerhalb der Methode nicht funktioniert und Sie daher mit der Verwaltung von Pools verketteter Generatorobjekte beginnen müssen. Eine einfache Methode zum Verwalten von Pools verketteter Generatoren besteht darin, eine Hilfefunktion wie z

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

Schreiben Sie jetzt verkettete Generatoren wie

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

Erzeugt Ausgabe

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

Welches ist wahrscheinlich, was Sie wollen, wenn Sie Generatoren als Thread-Alternative oder ähnliches verwenden möchten.

(Ich weiß, dass es ein alter Beitrag ist.) Es ist nicht erforderlich, ein Modul zu importieren. Sie können zu Beginn des Programms ein Objekt zum Vergleich deklarieren:

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