title in python plot

En Python, ¿cómo puedo determinar si un objeto es iterable?

Question

¿Hay un método como isiterable ? La única solución que he encontrado hasta ahora es llamar

hasattr(myObj, ''__iter__'')

Pero no estoy seguro de cuán infalible es esto.

Answer 1

Escribiendo pato

try:
iterator = iter(theElement)
except TypeError:
# not iterable
else:
# iterable
# for obj in iterator:
# pass

Verificación de tipos

Usa las clases base abstractas . Necesitan al menos Python 2.6 y funcionan solo para clases de nuevo estilo.

from collections.abc import Iterable # import directly from collections for Python < 3.3
if isinstance(theElement, Iterable):
# iterable
else:
# not iterable

Sin embargo, iter() es un poco más confiable como lo describe la documentación :

Al verificar isinstance(obj, Iterable) detecta las clases que están registradas como Iterable o que tienen un __iter__() , pero no detecta las clases que se repiten con el método __getitem__() . La única forma confiable de determinar si un objeto es iterable es llamar a iter(obj) .

Answer 2

1. La comprobación de __iter__ funciona en tipos de secuencia, pero fallaría en, por ejemplo, cadenas en Python 2 . También me gustaría saber la respuesta correcta, hasta entonces, aquí hay una posibilidad (que también funcionaría en cadenas):

   try:
   some_object_iterator = iter(some_object)
   except TypeError as te:
   print some_object, ''is not iterable''

   El iter incorporado comprueba el método __iter__ o, en el caso de cadenas, el método __getitem__ .

2. Otro enfoque pitónico general es asumir un iterable, luego fallar con gracia si no funciona en el objeto dado. El glosario de Python:

   Estilo de programación Pythonic que determina el tipo de un objeto mediante la inspección de su método o firma de atributo en lugar de hacerlo mediante una relación explícita con algún tipo de objeto ("Si se parece a un pato y a los curanderos como a un pato , debe ser un pato ".) Enfatizando las interfaces En lugar de tipos específicos, el código bien diseñado mejora su flexibilidad al permitir la sustitución polimórfica. Duck-typing evita las pruebas que usan type () o isinstance (). En su lugar, generalmente emplea el estilo de programación EAFP (Más fácil de perdonar que el permiso).

   ...

   try:
   _ = (e for e in my_object)
   except TypeError:
   print my_object, ''is not iterable''

3. El módulo de collections proporciona algunas clases básicas abstractas, que permiten preguntar clases o instancias si proporcionan una funcionalidad particular, por ejemplo:

   import collections
   if isinstance(e, collections.Iterable):
   # e is iterable

   Sin embargo, esto no comprueba las clases que son iterables a través de __getitem__ .

Answer 3

A menudo me parece conveniente, dentro de mis scripts, definir una función iterable . (Ahora incorpora la simplificación sugerida de Alfe):

import collections
def iterable(obj):
return isinstance(obj, collections.Iterable):

para que pueda probar si algún objeto es iterable en una forma muy legible

if iterable(obj):
# act on iterable
else:
# not iterable

Como lo harías con la función callable .

EDITAR: si tiene instalado Numpy, puede hacerlo simplemente: desde numpy import iterable , que es simplemente algo como

def iterable(obj):
try: iter(obj)
except: return False
return True

Si no tiene un número, simplemente puede implementar este código, o el anterior.

Answer 4

Aparte del intento regular y, excepto, podrías ejecutar la ayuda.

temp= [1,2,3,4]
help(temp)

La ayuda brindaría todos los métodos que podrían ejecutarse en ese objeto (podría ser cualquier objeto y no ser una lista como en el ejemplo), que es temporal en este caso.

Nota: Esto sería algo que harías manualmente.

Answer 5

De acuerdo con el Glosario de Python 2 , los iterables son

todos los tipos de secuencia (como list , str y tuple ) y algunos tipos que no son de secuencia como dict y file y objetos de cualquier clase que defina con un __iter__() o __getitem__() . Los iterables se pueden usar en un bucle for y en muchos otros lugares donde se necesita una secuencia (zip (), map (), ...). Cuando un objeto iterable se pasa como un argumento a la función incorporada iter (), devuelve un iterador para el objeto.

Por supuesto, dado el estilo de codificación general para Python basado en el hecho de que es "Más fácil pedir perdón que permiso", la expectativa general es usar

try:
for i in object_in_question:
do_something
except TypeError:
do_something_for_non_iterable

Pero si necesita verificarlo explícitamente, puede probar un iterable por hasattr(object_in_question, "__iter__") or hasattr(object_in_question, "__getitem__") . __iter__ verificar ambos, porque las __iter__ no tienen un método __iter__ (al menos no en Python 2, en Python 3) y porque los objetos generator no tienen un método __getitem__ .

Answer 6

Desde Python 3.5 puede usar el módulo de typing de la biblioteca estándar para cosas relacionadas con el tipo:

from typing import Iterable
...
if isinstance(my_item, Iterable):
print(True)

Answer 7

En Python <= 2.5, no puedes y no debes, iterable era una interfaz "informal".

Pero desde Python 2.6 y 3.0 puede aprovechar la nueva infraestructura ABC (clase base abstracta) junto con algunos ABCs incorporados que están disponibles en el módulo de colecciones:

from collections import Iterable
class MyObject(object):
pass
mo = MyObject()
print isinstance(mo, Iterable)
Iterable.register(MyObject)
print isinstance(mo, Iterable)
print isinstance("abc", Iterable)

Ahora, si esto es deseable o realmente funciona, es solo una cuestión de convenciones. Como puede ver, puede registrar un objeto no iterable como iterable, y generará una excepción en el tiempo de ejecución. Por lo tanto, isinstance adquiere un significado "nuevo": solo comprueba la compatibilidad de tipo "declarada", que es una buena forma de utilizar Python.

Por otro lado, si su objeto no satisface la interfaz que necesita, ¿qué va a hacer? Tomemos el siguiente ejemplo:

from collections import Iterable
from traceback import print_exc
def check_and_raise(x):
if not isinstance(x, Iterable):
raise TypeError, "%s is not iterable" % x
else:
for i in x:
print i
def just_iter(x):
for i in x:
print i
class NotIterable(object):
pass
if __name__ == "__main__":
try:
check_and_raise(5)
except:
print_exc()
print
try:
just_iter(5)
except:
print_exc()
print
try:
Iterable.register(NotIterable)
ni = NotIterable()
check_and_raise(ni)
except:
print_exc()
print

Si el objeto no satisface lo que usted espera, simplemente lanza un TypeError, pero si se ha registrado el ABC correcto, su cheque es inútil. Por el contrario, si el método __iter__ está disponible, Python reconocerá automáticamente que el objeto de esa clase es iterable.

Entonces, si solo esperas un iterable, itéralo y olvídalo. Por otro lado, si necesita hacer cosas diferentes según el tipo de entrada, puede encontrar la infraestructura ABC bastante útil.

Answer 8

En lugar de verificar el atributo __iter__ , puede verificar el atributo __len__ , que es implementado por cada iterable Python integrado, incluidas las cadenas.

>>> hasattr(1, "__len__")
False
>>> hasattr(1.3, "__len__")
False
>>> hasattr("a", "__len__")
True
>>> hasattr([1,2,3], "__len__")
True
>>> hasattr({1,2}, "__len__")
True
>>> hasattr({"a":1}, "__len__")
True
>>> hasattr(("a", 1), "__len__")
True

Los objetos no iterables no implementarían esto por razones obvias. Sin embargo, no detecta los iterables definidos por el usuario que no lo implementan, ni tampoco las expresiones generadoras, con las que iter puede lidiar. Sin embargo, esto se puede hacer en una línea, y la adición de una comprobación simple or expresión para los generadores solucionaría este problema. (Tenga en cuenta que el type(my_generator_expression) == generator escritura type(my_generator_expression) == generator generaría un NameError . Consulte this respuesta en su lugar).

Puedes usar GeneratorType desde tipos:

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

--- respuesta aceptada por utdemir

(Esto lo hace útil para verificar si puedes llamar a len en el objeto).

Answer 9

Esto no es suficiente: el objeto devuelto por __iter__ debe implementar el protocolo de iteración (es decir, el next método). Consulte la sección correspondiente en la documentation .

En Python, una buena práctica es "probar y ver" en lugar de "verificar".

Answer 10

He encontrado una buena solución here :

isiterable = lambda obj: isinstance(obj, basestring) /
or getattr(obj, ''__iter__'', False)

Answer 11

La forma más fácil, respetando la tipificación del pato de Python, es detectar el error (Python sabe perfectamente qué espera de un objeto para convertirse en un iterador):

class A(object):
def __getitem__(self, item):
return something
class B(object):
def __iter__(self):
# Return a compliant iterator. Just an example
return iter([])
class C(object):
def __iter__(self):
# Return crap
return 1
class D(object): pass
def iterable(obj):
try:
iter(obj)
return True
except:
return False
assert iterable(A())
assert iterable(B())
assert iterable(C())
assert not iterable(D())

Notas :

1. Es irrelevante la distinción entre si el objeto no es iterable o __iter__ se implementó un buggy __iter__ , si el tipo de excepción es el mismo: de todos modos, no podrá iterar el objeto.

2. Creo que entiendo su preocupación: ¿Cómo se puede callable si puedo confiar en la tipificación de pato para generar un __call__ AttributeError si __call__ no está definido para mi objeto, pero ese no es el caso para una verificación iterable?

   No sé la respuesta, pero puede implementar la función que di (y otros usuarios), o simplemente detectar la excepción en su código (su implementación en esa parte será como la función que escribí; solo asegúrese de aislar la Creación del iterador del resto del código para que pueda capturar la excepción y distinguirla de otro TypeError .

Answer 12

La función isiterable en el siguiente código devuelve True si el objeto es iterable. si no es iterable devuelve False

def isiterable(object_):
return hasattr(type(object_), "__iter__")

ejemplo

fruits = ("apple", "banana", "peach")
isiterable(fruits) # returns True
num = 345
isiterable(num) # returns False
isiterable(str) # returns False because str type is type class and it''s not iterable.
hello = "hello dude !"
isiterable(hello) # returns True because as you know string objects are iterable

Answer 13

La mejor solución que he encontrado hasta ahora:

hasattr(obj, ''__contains__'')

que básicamente comprueba si el objeto implementa el operador in .

Ventajas (ninguna de las otras soluciones tiene las tres):

• es una expresión (funciona como un lambda , a diferencia del intento ... excepto la variante)
• está (debería) implementarse en todos los iterables, incluidas las cadenas (a diferencia de __iter__ )
• Funciona en cualquier Python> = 2.5

Notas:

• la filosofía de Python de "pedir perdón, no permiso" no funciona bien, por ejemplo, en una lista tiene iterables y no iterables y necesita tratar cada elemento de manera diferente según su tipo (trata los iterables en try y non). iterables en excepto funcionaría, pero se vería feo y engañoso)
• las soluciones a este problema que intentan iterar realmente sobre el objeto (por ejemplo, [x para x en obj]) para comprobar si es iterable pueden generar importantes penalizaciones en el rendimiento para iterables grandes (especialmente si solo necesita los primeros elementos de iterable, por ejemplo) ejemplo) y debe evitarse

Answer 14

Me gustaría __iter__ un poco más la interacción de iter , __iter__ y __getitem__ y lo que sucede detrás de las cortinas. Con ese conocimiento, podrá comprender por qué lo mejor que puede hacer es

try:
iter(maybe_iterable)
print(''iteration will probably work'')
except TypeError:
print(''not iterable'')

Primero enumeraré los hechos y luego haré un recordatorio rápido de lo que sucede cuando emplea un bucle for en python, seguido de una discusión para ilustrar los hechos.

Hechos

1. Puede obtener un iterador de cualquier objeto o llamando a iter(o) si al menos una de las siguientes condiciones se cumple:
   
   a) o tiene un método __iter__ que devuelve un objeto iterador. Un iterador es cualquier objeto con un __iter__ y __next__ (Python 2: next ).
   
   b) o tiene un método __getitem__

2. Verificar una instancia de Iterable o Sequence , o verificar el atributo __iter__ no es suficiente.

3. Si un objeto o implementa solo __getitem__ , pero no __iter__ , iter(o) construirá un iterador que intenta obtener elementos de o por índice entero, comenzando en el índice 0. El iterador detectará cualquier IndexError (pero no otros errores) que sea StopIteration y luego plantea StopIteration sí.

4. En el sentido más general, no hay forma de comprobar si el iterador devuelto por iter es más que de prueba.

5. Si un objeto o implementa __iter__ , la función iter se asegurará de que el objeto devuelto por __iter__ sea ​​un iterador. No hay comprobación de validez si un objeto solo implementa __getitem__ .

6. __iter__ gana. Si un objeto o implementa tanto __iter__ como __getitem__ , iter(o) llamará __iter__ .

7. Si desea que sus propios objetos sean iterables, siempre implemente el método __iter__ .

for bucles

Para seguir adelante, necesita comprender lo que sucede cuando emplea un bucle for en Python. Siéntase libre de pasar directamente a la siguiente sección si ya lo sabe.

Cuando se usa for item in o para algún objeto iterable, Python llama iter(o) y espera un objeto iterador como valor de retorno. Un iterador es cualquier objeto que implementa un __next__ (o next en Python 2) y un método __iter__ .

Por convención, el método __iter__ de un iterador debe devolver el objeto en sí (es decir, return self ). Python luego llama al next iterador hasta que se StopIteration . Todo esto sucede implícitamente, pero la siguiente demostración lo hace visible:

import random
class DemoIterable(object):
def __iter__(self):
print(''__iter__ called'')
return DemoIterator()
class DemoIterator(object):
def __iter__(self):
return self
def __next__(self):
print(''__next__ called'')
r = random.randint(1, 10)
if r == 5:
print(''raising StopIteration'')
raise StopIteration
return r

Iteración sobre un DemoIterable :

>>> di = DemoIterable()
>>> for x in di:
... print(x)
...
__iter__ called
__next__ called
9
__next__ called
8
__next__ called
10
__next__ called
3
__next__ called
10
__next__ called
raising StopIteration

Discusión e ilustraciones.

En los puntos 1 y 2: obtener un iterador y cheques no confiables

Considere la siguiente clase:

class BasicIterable(object):
def __getitem__(self, item):
if item == 3:
raise IndexError
return item

Llamar a iter con una instancia de BasicIterable devolverá un iterador sin ningún problema porque BasicIterable implementa __getitem__ .

>>> b = BasicIterable()
>>> iter(b)
<iterator object at 0x7f1ab216e320>

Sin embargo, es importante tener en cuenta que b no tiene el atributo __iter__ y no se considera una instancia de Iterable o Sequence :

>>> from collections import Iterable, Sequence
>>> hasattr(b, ''__iter__'')
False
>>> isinstance(b, Iterable)
False
>>> isinstance(b, Sequence)
False

Esta es la razón por la cual Fluent Python de Luciano Ramalho recomienda llamar a iter y manejar el posible TypeError como la forma más precisa de verificar si un objeto es iterable. Citando directamente del libro:

A partir de Python 3.4, la forma más precisa de verificar si un objeto x es iterable es llamar a iter(x) y manejar una excepción TypeError si no lo es. Esto es más preciso que usar isinstance(x, abc.Iterable) , porque iter(x) también considera el método heredado __getitem__ , mientras que Iterable ABC no lo hace.

En el punto 3: Iterar sobre objetos que solo proporcionan __getitem__ , pero no __iter__

La iteración sobre una instancia de BasicIterable funciona como se esperaba: Python construye un iterador que intenta obtener elementos por índice, comenzando desde cero, hasta que se IndexError un IndexError . El método __getitem__ del objeto de demostración simplemente devuelve el item que fue suministrado como argumento a __getitem__(self, item) por el iterador devuelto por iter .

>>> b = BasicIterable()
>>> it = iter(b)
>>> next(it)
0
>>> next(it)
1
>>> next(it)
2
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

Tenga en cuenta que el iterador genera StopIteration cuando no puede devolver el siguiente elemento y que el IndexError que se IndexError para el item == 3 se maneja internamente. Esta es la razón por la que el bucle sobre un BasicIterable con un bucle for funciona como se espera:

>>> for x in b:
... print(x)
...
0
1
2

Aquí hay otro ejemplo para llevar a casa el concepto de cómo el iterador devuelto por iter intenta acceder a los elementos por índice. WrappedDict no hereda de dict , lo que significa que las instancias no tendrán un método __iter__ .

class WrappedDict(object): # note: no inheritance from dict!
def __init__(self, dic):
self._dict = dic
def __getitem__(self, item):
try:
return self._dict[item] # delegate to dict.__getitem__
except KeyError:
raise IndexError

Tenga en cuenta que las llamadas a __getitem__ se delegan a dict.__getitem__ para las cuales la notación de corchete es simplemente una forma abreviada.

>>> w = WrappedDict({-1: ''not printed'',
... 0: ''hi'', 1: '''', 2: ''!'',
... 4: ''not printed'',
... ''x'': ''not printed''})
>>> for x in w:
... print(x)
...
hi
!

En los puntos 4 y 5: iter busca un iterador cuando llama __iter__ :

Cuando se llama a iter(o) para un objeto o , iter se asegurará de que el valor de retorno de __iter__ , si el método está presente, sea un iterador. Esto significa que el objeto devuelto debe implementar __next__ (o next en Python 2) y __iter__ . iter no puede realizar comprobaciones de integridad para los objetos que solo proporcionan __getitem__ , porque no tiene forma de verificar si los elementos del objeto son accesibles por el índice entero.

class FailIterIterable(object):
def __iter__(self):
return object() # not an iterator
class FailGetitemIterable(object):
def __getitem__(self, item):
raise Exception

Tenga en cuenta que la construcción de un iterador a partir de instancias FailIterIterable falla inmediatamente, mientras que la construcción de un iterador a partir de FailGetItemIterable tiene éxito, pero arrojará una excepción en la primera llamada a __next__ .

>>> fii = FailIterIterable()
>>> iter(fii)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: iter() returned non-iterator of type ''object''
>>>
>>> fgi = FailGetitemIterable()
>>> it = iter(fgi)
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/path/iterdemo.py", line 42, in __getitem__
raise Exception
Exception

En el punto 6: __iter__ gana

Este es sencillo. Si un objeto implementa __iter__ y __getitem__ , iter llamará __iter__ . Considera la siguiente clase

class IterWinsDemo(object):
def __iter__(self):
return iter([''__iter__'', ''wins''])
def __getitem__(self, item):
return [''__getitem__'', ''wins''][item]

y la salida cuando se realiza un bucle en una instancia:

>>> iwd = IterWinsDemo()
>>> for x in iwd:
... print(x)
...
__iter__
wins

En el punto 7: sus clases iterables deberían implementar __iter__

Podría preguntarse por qué la mayoría de las secuencias __iter__ como list implementan un método __iter__ cuando __getitem__ sería suficiente.

class WrappedList(object): # note: no inheritance from list!
def __init__(self, lst):
self._list = lst
def __getitem__(self, item):
return self._list[item]

Después de todo, la iteración sobre las instancias de la clase anterior, que delega las llamadas a __getitem__ para list.__getitem__ (usando la notación entre corchetes), funcionará bien:

>>> wl = WrappedList([''A'', ''B'', ''C''])
>>> for x in wl:
... print(x)
...
A
B
C

Las razones por las que sus iterables personalizados deben implementar __iter__ son las siguientes:

1. Si implementa __iter__ , las instancias se considerarán como iterables y la isinstance(o, collections.Iterable) devolverá True .
2. Si el objeto devuelto por __iter__ no es un iterador, iter fallará inmediatamente y generará un TypeError .
3. El manejo especial de __getitem__ existe por razones de compatibilidad hacia atrás. Citando de nuevo desde Fluent Python:

Es por eso que cualquier secuencia de Python es iterable: todos implementan __getitem__ . De hecho, las secuencias estándar también implementan __iter__ , y las suyas también deberían hacerlo, porque el manejo especial de __getitem__ existe por razones de compatibilidad con versiones anteriores y puede desaparecer en el futuro (aunque no está en desuso cuando escribo esto).

Answer 15

Podrías probar esto:

def iterable(a):
try:
(x for x in a)
return True
except TypeError:
return False

Si podemos hacer un generador que se repita sobre él (pero nunca lo use para que no ocupe espacio), es iterable. Parece una especie de "duh". ¿Por qué necesitas determinar si una variable es iterable en primer lugar?

Answer 16

Siempre me ha eludido por qué python tiene que ser callable(obj) -> bool pero no iterable(obj) -> bool ...
seguramente es más fácil hacer hasattr(obj,''__call__'') incluso si es más lento.

Ya que casi todas las demás respuestas recomiendan el uso de try / except TypeError , donde la prueba de excepciones generalmente se considera una mala práctica en cualquier idioma, aquí hay una implementación de iterable(obj) -> bool me ha gustado más y que uso con frecuencia:

Para Python 2, usaré un lambda solo para aumentar el rendimiento ...
(en Python 3 no importa lo que uses para definir la función, def tiene aproximadamente la misma velocidad que lambda )

iterable = lambda obj: hasattr(obj,''__iter__'') or hasattr(obj,''__getitem__'')

Tenga en cuenta que esta función se ejecuta más rápido para los objetos con __iter__ ya que no prueba para __getitem__ .

La mayoría de los objetos iterables deben depender de __iter__ donde los objetos de casos especiales __iter__ a __getitem__ , aunque cualquiera de los dos es necesario para que un objeto sea iterable.
(y dado que esto es estándar, también afecta a los objetos C)

Answer 17

pandas tiene una función incorporada como esa:

from pandas.util.testing import isiterable

Answer 18

def is_iterable(x):
try:
0 in x
except TypeError:
return False
else:
return True

Esto dirá sí a todo tipo de objetos iterables, pero dirá no a las cadenas en Python 2 . (Eso es lo que quiero, por ejemplo, cuando una función recursiva podría tomar una cadena o un contenedor de cadenas. En esa situación, pedir perdón puede llevar a obfuscode, y es mejor pedir permiso primero).

import numpy
class Yes:
def __iter__(self):
yield 1;
yield 2;
yield 3;
class No:
pass
class Nope:
def __iter__(self):
return ''nonsense''
assert is_iterable(Yes())
assert is_iterable(range(3))
assert is_iterable((1,2,3)) # tuple
assert is_iterable([1,2,3]) # list
assert is_iterable({1,2,3}) # set
assert is_iterable({1:''one'', 2:''two'', 3:''three''}) # dictionary
assert is_iterable(numpy.array([1,2,3]))
assert is_iterable(bytearray("not really a string", ''utf-8''))
assert not is_iterable(No())
assert not is_iterable(Nope())
assert not is_iterable("string")
assert not is_iterable(42)
assert not is_iterable(True)
assert not is_iterable(None)

Muchas otras estrategias aquí dirán sí a las cuerdas. Úsalos si eso es lo que quieres.

import collections
import numpy
assert isinstance("string", collections.Iterable)
assert isinstance("string", collections.Sequence)
assert numpy.iterable("string")
assert iter("string")
assert hasattr("string", ''__getitem__'')

Nota: is_iterable () dirá sí a cadenas de bytes de tipo y bytearray .

• bytes objetos de bytes en Python 3 son iterables. True == is_iterable(b"string") == is_iterable("string".encode(''utf-8'')) No hay tal tipo en Python 2.
• bytearray objetos bytearray en Python 2 y 3 son iterables True == is_iterable(bytearray(b"abc"))

El hasattr(x, ''__iter__'') OP hasattr(x, ''__iter__'') dirá sí a las cadenas en Python 3 y no en Python 2 (no importa si '''' o b'''' o u'''' ). Gracias a @LuisMasuelli por darse cuenta de que también te __iter__ un buggy __iter__ .

Answer 19

try:
#treat object as iterable
except TypeError, e:
#object is not actually iterable

No ejecute los controles para ver si su pato es realmente un pato para ver si es iterable o no, trátelo como si fuera y reclame si no lo fue.