Teste se uma variável é uma lista ou tupla

Em python, qual é a melhor maneira de testar se uma variável contém uma lista ou uma tupla? (ou seja, uma coleção)

É isinstance()tão mau como sugerido aqui? http://www.canonical.org/~kragen/isinstance/

Atualização: a razão mais comum pela qual desejo distinguir uma lista de uma string é quando tenho uma estrutura de árvore / dados aninhada indefinidamente profunda de listas de listas de listas de strings etc. que estou explorando com um algoritmo recursivo e preciso para saber quando atingi os nós da "folha".

Vá em frente e use isinstancese precisar. É um tanto ruim, pois exclui sequências personalizadas, iteradores e outras coisas que você realmente pode precisar. No entanto, às vezes você precisa se comportar de maneira diferente se alguém, por exemplo, passa uma string. Minha preferência seria verificar explicitamente strou algo unicodeassim:

import types
isinstance(var, types.StringTypes)

NB Não confunda types.StringTypecom types.StringTypes. Este último incorpora stre unicodeobjeta.

O typesmódulo é considerado por muitos obsoleto em favor de apenas verificar diretamente o tipo de objeto; portanto, se você preferir não usar o acima, pode alternativamente verificar explicitamente contra stre unicode, assim:

isinstance(var, (str, unicode)):

Editar:

Melhor ainda é:

isinstance(var, basestring)

Finalizar edição

Depois de qualquer uma dessas opções, você pode voltar a se comportar como se estivesse obtendo uma sequência normal, permitindo que as não-sequências gerem exceções apropriadas.

Ver o que é "mau" na verificação de tipos não é que você queira se comportar de maneira diferente para um determinado tipo de objeto, é que você restringe artificialmente sua função de fazer a coisa certa com tipos de objetos inesperados que, de outra forma, fariam a coisa certa. Se você tiver um fallback final que não é verificado por tipo, remova essa restrição. Deve-se observar que muita verificação de tipo é um cheiro de código que indica que você pode querer refatorar, mas isso não significa necessariamente que você deve evitá-la do getgo.

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

Não há nada errado em usar isinstance, desde que não seja redundante. Se uma variável deve ser apenas uma lista / tupla, documente a interface e use-a como tal. Caso contrário, um cheque é perfeitamente razoável:

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

Esse tipo de verificação possui alguns bons casos de uso, como com a sequência padrão beginwith / endswith methods (embora, para ser preciso, eles sejam implementados em C no CPython, usando uma verificação explícita para verificar se é uma tupla - há mais de uma maneira para resolver esse problema, conforme mencionado no artigo ao qual você vincula).

Uma verificação explícita geralmente é melhor do que tentar usar o objeto como um contêiner e manipular a exceção - isso pode causar todos os tipos de problemas com o código sendo executado parcial ou desnecessariamente.

Documente o argumento como precisando ser uma sequência e use-o como uma sequência. Não verifique o tipo.

Que tal hasattr(a, "__iter__"):?

Informa se o objeto retornado pode ser iterado como um gerador. Por padrão, tuplas e listas podem, mas não os tipos de sequência.

Nos type(list) is listretornos do Python 2.8 false
, sugiro comparar o tipo dessa maneira horrível:

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

(pelo menos no meu sistema, usando anaconda no Mac OS X Yosemite)

Python usa "digitação de pato", ou seja, se uma variável kwaks como um pato, deve ser um pato. No seu caso, você provavelmente deseja que seja iterável ou deseja acessar o item em um determinado índice. Você deve fazer o seguinte: ou seja, usar o objeto dentro for var:ou var[idx]dentro de um trybloco e, se você receber uma exceção, não era um pato ...

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

Se você só precisa saber se pode usar a foo[123]notação com a variável, pode verificar a existência de um __getitem__atributo (que é o que python chama quando você acessa por índice) comhasattr(foo, '__getitem__')

Tem que ser um teste mais complexo se você realmente quiser lidar com praticamente qualquer coisa como argumento de função.

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

Embora, geralmente seja suficiente apenas especificar que uma função espera iterável e depois verificar apenas type(a) != type('') .

Também pode acontecer que, para uma string, você tenha um caminho de processamento simples ou que seja legal e faça uma divisão etc., para que não queira gritar com strings e se alguém lhe enviar algo estranho, deixe uma exceção.

Outra maneira fácil de descobrir se uma variável é lista ou tupla ou geralmente verifica o tipo de variável seria:

    def islist(obj):

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

        else : return False

Em princípio, concordo com Ignacio, acima, mas você também pode usar o tipo para verificar se algo é uma tupla ou uma lista.

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