Probar si una variable es una lista o tupla

En python, ¿cuál es la mejor manera de probar si una variable contiene una lista o una tupla? (es decir, una colección)

¿Es isinstance()tan malvado como se sugiere aquí? http://www.canonical.org/~kragen/isinstance/

Actualización: la razón más común por la que quiero distinguir una lista de una cadena es cuando tengo un árbol anidado indefinidamente / estructura de datos de listas de listas de listas de cadenas, etc., que estoy explorando con un algoritmo recursivo y necesito saber cuándo he golpeado los nodos "hoja".

Siga adelante y utilícelo isinstancesi lo necesita. Es algo malvado, ya que excluye secuencias personalizadas, iteradores y otras cosas que realmente pueda necesitar. Sin embargo, a veces debe comportarse de manera diferente si alguien, por ejemplo, pasa una cadena. Mi preferencia sería verificar explícitamente stro de esta unicodemanera:

import types
isinstance(var, types.StringTypes)

NB No te confundas types.StringTypecon types.StringTypes. Este último incorpora stry unicodeobjetos.

El typesmódulo es considerado por muchos como obsoleta en favor de sólo la comprobación directamente contra el tipo del objeto, así que si usted prefiere no utilizar el anterior, alternativamente, puede comprobar de forma explícita en contra stry unicode, de esta manera:

isinstance(var, (str, unicode)):

Editar:

Mejor aún es:

isinstance(var, basestring)

Finalizar edición

Después de cualquiera de estos, puede volver a comportarse como si estuviera obteniendo una secuencia normal, dejando que las no secuencias generen las excepciones apropiadas.

Vea que lo "malo" de la verificación de tipos no es que desee comportarse de manera diferente para un determinado tipo de objeto, es que restringe artificialmente su función de hacer lo correcto con tipos de objetos inesperados que de otro modo harían lo correcto. Si tiene una copia de seguridad final que no está marcada, elimine esta restricción. Cabe señalar que demasiada verificación de tipo es un olor a código que indica que es posible que desee refactorizar, pero eso no significa necesariamente que deba evitarlo desde el principio.

if type(x) is list:
    print 'a list'
elif type(x) is tuple:
    print 'a tuple'
else:
    print 'neither a tuple or a list'

No hay nada de malo en usar isinstancesiempre que no sea redundante. Si una variable solo debe ser una lista / tupla, documente la interfaz y simplemente úsela como tal. De lo contrario, un cheque es perfectamente razonable:

if isinstance(a, collections.Iterable):
    # use as a container
else:
    # not a container!

Este tipo de verificación tiene algunos buenos casos de uso, como con los métodos estándar de cadena comienza con / termina con (aunque para ser precisos, estos se implementan en C en CPython usando una verificación explícita para ver si es una tupla: hay más de una forma para resolver este problema, como se menciona en el artículo al que se vincula).

Una verificación explícita a menudo es mejor que intentar usar el objeto como un contenedor y manejar la excepción, que puede causar todo tipo de problemas con el código que se ejecuta parcial o innecesariamente.

Documente el argumento como si fuera una secuencia y úselo como secuencia. No verifique el tipo.

¿Qué tal hasattr(a, "__iter__"):?

Indica si el objeto devuelto puede iterarse como un generador. Por defecto, las tuplas y las listas pueden, pero no los tipos de cadena.

En Python 2.8 type(list) is listrendimientos false
que sugeriría comparando el tipo en esta horrible manera:

if type(a) == type([]) :
  print "variable a is a list"

(bueno, al menos en mi sistema, usando anaconda en Mac OS X Yosemite)

Python utiliza "Mecanografía pato", es decir, si una variable se mueve como un pato, debe ser un pato. En su caso, es probable que desee que sea iterable o que desee acceder al elemento en un índice determinado. Simplemente debe hacer esto: es decir, usar el objeto dentro for var:o var[idx]dentro de un trybloque, y si obtiene una excepción, no fue un pato ...

>>> l = []
>>> l.__class__.__name__ in ('list', 'tuple')
True

Si solo necesita saber si puede usar la foo[123]notación con la variable, puede verificar la existencia de un __getitem__atributo (que es lo que Python llama cuando accede por índice) conhasattr(foo, '__getitem__')

Tiene que ser una prueba más compleja si realmente desea manejar casi cualquier cosa como argumento de función.

type(a) != type('') and hasattr(a, "__iter__")

Aunque, por lo general, es suficiente explicar que una función espera iterable y luego verificar solo type(a) != type('').

También puede suceder que para una cadena tengas una ruta de procesamiento simple o que seas agradable y hagas una división, etc., por lo que no quieres gritar a las cadenas y si alguien te envía algo extraño, solo déjalo tener una excepción.

Otra forma fácil de averiguar si una variable es lista o tupla o, en general, verificar el tipo de variable sería:

    def islist(obj):

        if ("list" in str(type(obj)) ): return True

        else : return False

En principio, estoy de acuerdo con Ignacio, arriba, pero también puede usar el tipo para verificar si algo es una tupla o una lista.

>>> a = (1,)
>>> type(a)
(type 'tuple')
>>> a = [1]
>>> type(a)
(type 'list')