¿Cómo verificar si un objeto es una lista o una tupla (pero no una cadena)?

Esto es lo que normalmente hago para determinar que la entrada es a list/ tuple- pero no a str. Porque muchas veces me topé con errores en los que una función pasa un strobjeto por error, y la función de destino for x in lstsupone que en lstrealidad es un listo tuple.

assert isinstance(lst, (list, tuple))

Mi pregunta es: ¿hay una mejor manera de lograr esto?

Solo en Python 2 (no Python 3):

assert not isinstance(lst, basestring)

En realidad es lo que quieres, de lo contrario te perderás muchas cosas que actúan como listas, pero no son subclases de listo tuple.

Recuerde que en Python queremos usar "escribir pato". Entonces, cualquier cosa que actúe como una lista puede tratarse como una lista. Por lo tanto, no verifique el tipo de lista, solo vea si actúa como una lista.

Pero las cadenas también actúan como una lista, y a menudo eso no es lo que queremos. ¡Hay momentos en que incluso es un problema! Por lo tanto, verifique explícitamente una cadena, pero luego use la escritura de pato.

Aquí hay una función que escribí por diversión. Es una versión especial de repr()que imprime cualquier secuencia entre paréntesis 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

Esto es limpio y elegante, en general. ¿Pero qué hace ese isinstance()cheque allí? Eso es una especie de truco. Pero es esencial.

Esta función se llama recursivamente sobre cualquier cosa que actúe como una lista. Si no manejáramos la cadena especialmente, entonces sería tratada como una lista y dividiría un carácter a la vez. Pero entonces la llamada recursiva trataría de tratar a cada personaje como una lista, ¡y funcionaría! ¡Incluso una cadena de un carácter funciona como una lista! La función seguiría llamándose recursivamente hasta que se desborde la pila.

Las funciones como esta, que dependen de cada llamada recursiva que desglosa el trabajo a realizar, tienen que ser cadenas de casos especiales, porque no puede dividir una cadena por debajo del nivel de una cadena de un carácter, e incluso una La cadena de caracteres actúa como una lista.

Nota: la try/ exceptes la forma más limpia de expresar nuestras intenciones. Pero si este código fuera de alguna manera crítico en el tiempo, podríamos reemplazarlo con algún tipo de prueba para ver si arges una secuencia. En lugar de probar el tipo, probablemente deberíamos probar los comportamientos. Si tiene un .strip()método, es una cadena, así que no lo considere una secuencia; de lo contrario, si es indexable o iterable, es una secuencia:

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)

EDITAR: Originalmente escribí lo anterior con un cheque __getslice__()pero noté que en la collectionsdocumentación del módulo, el método interesante es __getitem__(); esto tiene sentido, así es como indizas un objeto. Eso parece más fundamental que __getslice__()eso, cambié lo anterior.

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")

Cambiado en la versión 3.3: Moved Collections Abstract Classes al módulo collections.abc. Por compatibilidad con versiones anteriores, continuarán siendo visibles en este módulo también hasta la versión 3.8, donde dejará 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 con sabor PHP:

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

En términos generales, el hecho de que una función que itera sobre un objeto funciona tanto en cadenas como en tuplas y listas es más característica que error. Ciertamente puede usar isinstanceo esquivar la escritura para verificar un argumento, pero ¿por qué debería hacerlo?

Eso suena como una pregunta retórica, pero no lo es. La respuesta a "¿por qué debería verificar el tipo de argumento?" probablemente va a sugerir una solución al problema real, no el problema percibido. ¿Por qué es un error cuando se pasa una cadena a la función? Además: si se trata de un error cuando se pasa una cadena a esta función, ¿también es un error si se le pasa algún otro iterable que no sea de lista / tupla? ¿Por qué o por qué no?

Creo que la respuesta más común a la pregunta es que los desarrolladores que escriben f("abc")esperan que la función se comporte como si hubiera escrito f(["abc"]). Probablemente hay circunstancias en las que tiene más sentido proteger a los desarrolladores de sí mismos que respaldar el caso de uso de iterar a través de los caracteres en una cadena. Pero pensaría mucho en ello primero.

Pruebe esto para facilitar la lectura y las mejores prácticas:

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 eso ayude.

El strobjeto no tiene un __iter__atributo.

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

para que puedas hacer un chequeo

assert hasattr(x, '__iter__')

y esto también generará un AssertionErrorbeneficio para cualquier otro objeto no iterable.

Editar: como Tim menciona en los comentarios, esto solo funcionará en python 2.x, no 3.x

Esto no tiene la intención de responder directamente al OP, pero quería compartir algunas ideas relacionadas.

Estaba muy interesado en la respuesta de @steveha anterior, que parecía dar un ejemplo donde la escritura de patos parece romperse. Pensándolo bien, sin embargo, su ejemplo sugiere que es difícil cumplir con la escritura del pato, pero lo hace no sugiere questr merezca un manejo especial.

Después de todo, un no strtipo (por ejemplo, un tipo definido por el usuario que mantiene algunas estructuras recursivas complicadas) puede causar que la sreprfunción @steveha provoque una recursión infinita. Si bien esto es ciertamente poco probable, no podemos ignorar esta posibilidad. Por lo tanto, en lugar de especial-carcasa stren srepr, hay que aclarar lo que queremossrepr hacer cuando un infinito resultados de recursividad.

Puede parecer que un enfoque razonable es simplemente romper la recursión en sreprel momento list(arg) == [arg]. Esto, de hecho, resolvería completamente el problema con str, sin ningunaisinstance .

Sin embargo, una estructura recursiva realmente complicada puede causar un bucle infinito donde list(arg) == [arg]nunca sucede. Por lo tanto, si bien la comprobación anterior es útil, no es suficiente. Necesitamos algo así como un límite estricto en la profundidad de recursión.

Mi punto es que si planea manejar tipos de argumentos arbitrarios, el manejo strmediante la escritura de pato es mucho, mucho más fácil que el manejo de los tipos más generales que puede encontrar (en teoría). Entonces, si siente la necesidad de excluir strinstancias, debería exigir que el argumento sea una instancia de uno de los pocos tipos que especifique explícitamente.

Encuentro una función llamada is_sequence en 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))

Y he verificado que satisface tus necesidades.

Hago esto en mis casos de prueba.

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))

No probado en los generadores, creo que te quedan en el próximo 'rendimiento' si se pasa en un generador, que puede arruinar las cosas aguas abajo. Pero, de nuevo, esta es una 'prueba de unidad'

En la manera de "escribir pato", ¿qué tal

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

o

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

respectivamente. Esto evita las cosas isinstance/ hasattrintrospección.

También puede verificar viceversa:

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

Todas las variantes en realidad no cambian el contenido de la variable, sino que implican una reasignación. No estoy seguro de si esto podría ser indeseable en algunas circunstancias.

Curiosamente, con la asignación "en el lugar" +=no TypeErrorse plantearía en ningún caso si se lsttrata de una lista (no una tupla ). Es por eso que la tarea se realiza de esta manera. Tal vez alguien pueda arrojar luz sobre por qué es eso.

forma más simple ... usando anyyisinstance

>>> 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

Otra versión de tipeo de pato para ayudar a distinguir los objetos con forma de cadena de otros objetos con secuencia.

La representación de cadena de los objetos en forma de cadena es la cadena misma, por lo que puede verificar si obtiene un objeto igual del strconstructor:

# 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)

Esto debería funcionar para todos los objetos compatibles con stry para todo tipo de objetos iterables.

Python 3 tiene esto:

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

Entonces, para verificar tanto las Listas como las Tuplas, sería:

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"

Solo haz esto

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

en 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

Tiendo a hacer esto (si realmente, realmente tuviera que hacerlo):

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