Como verificar se um objeto é uma lista ou tupla (mas não string)?

Isto é o que eu normalmente faço para verificar se a entrada é um list/ tuple- mas não um str. Porque muitas vezes me deparei com bugs em que uma função passa um strobjeto por engano, e a função alvo for x in lstassume que lsté realmente um listou tuple.

assert isinstance(lst, (list, tuple))

Minha pergunta é: existe uma maneira melhor de conseguir isso?

Somente no python 2 (não no python 3):

assert not isinstance(lst, basestring)

Na verdade, é o que você deseja, caso contrário, você perderá muitas coisas que funcionam como listas, mas não são subclasses de listou tuple.

Lembre-se de que, em Python, queremos usar "digitação de pato". Portanto, qualquer coisa que atue como uma lista pode ser tratada como uma lista. Portanto, não verifique o tipo de uma lista, apenas veja se ela funciona como uma lista.

Mas as strings também funcionam como uma lista, e muitas vezes não é isso que queremos. Há momentos em que é até um problema! Portanto, verifique explicitamente se há uma string, mas use a digitação de pato.

Aqui está uma função que escrevi por diversão. É uma versão especial repr()que imprime qualquer sequência entre colchetes angulares ('<', '>').

def srepr(arg):
    if isinstance(arg, basestring): # Python 3: isinstance(arg, str)
        return repr(arg)
    try:
        return '<' + ", ".join(srepr(x) for x in arg) + '>'
    except TypeError: # catch when for loop fails
        return repr(arg) # not a sequence so just return repr

Isso é limpo e elegante, em geral. Mas o que esse isinstance()cheque está fazendo lá? Isso é meio que um hack. Mas é essencial.

Essa função se chama recursivamente em qualquer coisa que atue como uma lista. Se não tratássemos a string especialmente, ela seria tratada como uma lista e dividiria um caractere de cada vez. Mas então a chamada recursiva tentaria tratar cada caractere como uma lista - e funcionaria! Mesmo uma cadeia de um caractere funciona como uma lista! A função continuaria se chamando recursivamente até o estouro da pilha.

Funções como esta, que dependem de cada chamada recursiva, dividindo o trabalho a ser realizado, têm cadeias de casos especiais - porque você não pode dividir uma cadeia abaixo do nível de uma cadeia de um caractere e até uma -caracter string atua como uma lista.

Nota: a try/ excepté a maneira mais limpa de expressar nossas intenções. Mas se esse código for de alguma forma crítico em termos de tempo, podemos substituí-lo por algum tipo de teste para ver se argé uma sequência. Em vez de testar o tipo, provavelmente devemos testar comportamentos. Se ele tem um .strip()método, é uma string, então não considere uma sequência; caso contrário, se for indexável ou iterável, é uma sequência:

def is_sequence(arg):
    return (not hasattr(arg, "strip") and
            hasattr(arg, "__getitem__") or
            hasattr(arg, "__iter__"))

def srepr(arg):
    if is_sequence(arg):
        return '<' + ", ".join(srepr(x) for x in arg) + '>'
    return repr(arg)

EDIT: Eu escrevi originalmente o acima com uma verificação, __getslice__()mas notei que na collectionsdocumentação do módulo, o método interessante é __getitem__(); isso faz sentido, é assim que você indexa um objeto. Isso parece mais fundamental do que __getslice__()eu mudei o acima.

H = "Hello"

if type(H) is list or type(H) is tuple:
    ## Do Something.
else
    ## Do Something.

Para Python 3:

import collections.abc

if isinstance(obj, collections.abc.Sequence) and not isinstance(obj, str):
    print("obj is a sequence (list, tuple, etc) but not a string")

Alterado na versão 3.3: Movido as classes base abstratas de coleções para o módulo collections.abc. Para compatibilidade com versões anteriores, eles continuarão visíveis neste módulo até a versão 3.8, onde parará de funcionar.

Para Python 2:

import collections

if isinstance(obj, collections.Sequence) and not isinstance(obj, basestring):
    print "obj is a sequence (list, tuple, etc) but not a string or unicode"

Python com sabor PHP:

def is_array(var):
    return isinstance(var, (list, tuple))

De um modo geral, o fato de uma função que itera sobre um objeto funcionar tanto em strings quanto em tuplas e listas é mais um recurso que um bug. Você certamente pode usar isinstanceou digitar para verificar um argumento, mas por que deveria?

Isso soa como uma pergunta retórica, mas não é. A resposta para "por que devo verificar o tipo de argumento?" provavelmente vai sugerir uma solução para o problema real, não para o problema percebido. Por que é um erro quando uma string é passada para a função? Além disso: se é um bug quando uma string é passada para essa função, também é um bug se alguma outra iterável não listada / tupla for passada para ela? Por que ou por que não?

Acho que a resposta mais comum para a pergunta provavelmente é que os desenvolvedores que escrevem f("abc")esperam que a função se comporte como se tivessem escrito f(["abc"]). Provavelmente, há circunstâncias em que faz mais sentido proteger os desenvolvedores de si mesmos do que apoiar o caso de uso de iteração entre os caracteres em uma sequência. Mas eu pensaria muito nisso primeiro.

Tente isso para facilitar a leitura e as práticas recomendadas:

Python2

import types
if isinstance(lst, types.ListType) or isinstance(lst, types.TupleType):
    # Do something

Python3

import typing
if isinstance(lst, typing.List) or isinstance(lst, typing.Tuple):
    # Do something

Espero que ajude.

O strobjeto não tem um __iter__atributo

>>> hasattr('', '__iter__')
False 

para que você possa fazer uma verificação

assert hasattr(x, '__iter__')

e isso também aumentará a importância AssertionErrorde qualquer outro objeto não iterável.

Edit: Como Tim menciona nos comentários, isso funcionará apenas no python 2.x, não no 3.x

Isso não pretende responder diretamente ao OP, mas eu queria compartilhar algumas idéias relacionadas.

Eu estava muito interessado na resposta @steveha acima, que parecia dar um exemplo em que a digitação do pato parece quebrar. Pensando bem, no entanto, seu exemplo sugere que a digitação com patos é difícil de se adaptar, mas não sugere que strmereça um tratamento especial.

Afinal, um não- strtipo (por exemplo, um tipo definido pelo usuário que mantém algumas estruturas recursivas complicadas) pode fazer com que a sreprfunção @steveha cause uma recursão infinita. Embora isso seja bastante improvável, não podemos ignorar essa possibilidade. Portanto, ao invés de especial-invólucro strem srepr, devemos esclarecer o que queremos sreprfazer quando um infinitas resultados recursão.

Pode parecer que uma abordagem razoável seja simplesmente interromper a recursão no sreprmomento list(arg) == [arg]. De fato, isso resolveria completamente o problema com str, sem nenhum isinstance.

No entanto, uma estrutura recursiva realmente complicada pode causar um loop infinito onde list(arg) == [arg]nunca acontece. Portanto, embora a verificação acima seja útil, não é suficiente. Precisamos de algo como um limite rígido na profundidade da recursão.

Meu argumento é que, se você planeja lidar com tipos de argumentos arbitrários, o manuseio strpor meio da digitação com patos é muito, muito mais fácil do que com os tipos mais gerais que você pode (teoricamente) encontrar. Portanto, se você sentir a necessidade de excluir strinstâncias, deve exigir que o argumento seja uma instância de um dos poucos tipos especificados explicitamente.

Eu encontro uma função chamada is_sequence no tensorflow .

def is_sequence(seq):
  """Returns a true if its input is a collections.Sequence (except strings).
  Args:
    seq: an input sequence.
  Returns:
    True if the sequence is a not a string and is a collections.Sequence.
  """
  return (isinstance(seq, collections.Sequence)
and not isinstance(seq, six.string_types))

E verifiquei que atende às suas necessidades.

Eu faço isso em minhas caixas de teste.

def assertIsIterable(self, item):
    #add types here you don't want to mistake as iterables
    if isinstance(item, basestring): 
        raise AssertionError("type %s is not iterable" % type(item))

    #Fake an iteration.
    try:
        for x in item:
            break;
    except TypeError:
        raise AssertionError("type %s is not iterable" % type(item))

Não testado em geradores, acho que você fica no próximo 'rendimento' se for passado em um gerador, o que pode estragar tudo a jusante. Mas, novamente, este é um 'unittest'

No modo "digitação de pato", que tal

try:
    lst = lst + []
except TypeError:
    #it's not a list

ou

try:
    lst = lst + ()
except TypeError:
    #it's not a tuple

respectivamente. Isso evita o material isinstance/ hasattrintrospecção.

Você também pode verificar o contrário:

try:
    lst = lst + ''
except TypeError:
    #it's not (base)string

Todas as variantes, na verdade, não alteram o conteúdo da variável, mas implicam em uma reatribuição. Não tenho certeza se isso pode ser indesejável em algumas circunstâncias.

Curiosamente, com a atribuição "no local", +=nenhum TypeErrorseria aumentado em qualquer caso se lstfor uma lista (não uma tupla ). É por isso que a tarefa é feita dessa maneira. Talvez alguém possa esclarecer o porquê disso.

maneira mais simples ... usando anyeisinstance

>>> console_routers = 'x'
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
False
>>>
>>> console_routers = ('x',)
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
True
>>> console_routers = list('x',)
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
True

Outra versão da digitação de pato para ajudar a distinguir objetos do tipo seqüência de caracteres de outros objetos do tipo seqüência.

A representação de string de objetos do tipo string é a própria string, portanto você pode verificar se obtém um objeto igual do strconstrutor:

# If a string was passed, convert it to a single-element sequence
if var == str(var):
    my_list = [var]

# All other iterables
else: 
    my_list = list(var)

Isso deve funcionar para todos os objetos compatíveis com stre para todos os tipos de objetos iteráveis.

O Python 3 tem isso:

from typing import List

def isit(value):
    return isinstance(value, List)

isit([1, 2, 3])  # True
isit("test")  # False
isit({"Hello": "Mars"})  # False
isit((1, 2))  # False

Portanto, para verificar listas e tuplas, seria:

from typing import List, Tuple

def isit(value):
    return isinstance(value, List) or isinstance(value, Tuple)

assert (type(lst) == list) | (type(lst) == tuple), "Not a valid lst type, cannot be string"

Apenas faça isso

if type(lst) in (list, tuple):
    # Do stuff

em python> 3.6

import collections
isinstance(set(),collections.abc.Container)
True
isinstance([],collections.abc.Container)
True
isinstance({},collections.abc.Container)
True
isinstance((),collections.abc.Container)
True
isinstance(str,collections.abc.Container)
False

Costumo fazer isso (se realmente, realmente):

for i in some_var:
   if type(i) == type(list()):
       #do something with a list
   elif type(i) == type(tuple()):
       #do something with a tuple
   elif type(i) == type(str()):
       #here's your string