Comprobar si una variable es una lista o tupla

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 isinstance siempre y cuando no sea redundante. Si una variable solo debe ser una lista/tupla, documente la interfaz y utilícela como tal. De lo contrario, un control es perfectamente razonable:

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

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

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

Documente el argumento como que necesita ser una secuencia, y utilícelo como una secuencia. No compruebes el tipo.

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

Indica si el objeto devuelto puede ser iterado como un generador. De forma predeterminada, las tuplas y las listas pueden, pero no los tipos de cadenas.

Python usa "Duck typing", es decir, si una variable kwaks como un pato, debe ser un pato. En su caso, probablemente desee que sea iterable, o desea acceder al elemento en un determinado índice. Solo debes hacer esto: es decir, usar el objeto en for var: o var[idx] dentro de un bloque try, y si obtienes una excepción no es un pato...

En Python 2.8 type(list) is list devuelve false
Yo sugeriría comparar el tipo de esta manera horrible:

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

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

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

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

En principio, estoy de acuerdo con Ignacio, pero también puedes usar type para comprobar si algo es una tupla o una lista.

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

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

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

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

También puede suceder que para una cadena tenga una ruta de procesamiento simple o que vaya a ser agradable y haga una división, etc. así que no quieres gritarle a las cuerdas y si alguien te envía algo raro, solo déjalo tener una excepción.