Come verificare se un oggetto è un elenco o una tupla (ma non una stringa)?

Questo è ciò che faccio normalmente per accertare che l'input sia un list/ tuple- ma non un str. Perché molte volte mi sono imbattuto in bug in cui una funzione passa strper errore un oggetto e la funzione target for x in lstpresuppone che lstsia effettivamente un listo tuple.

assert isinstance(lst, (list, tuple))

La mia domanda è: esiste un modo migliore per raggiungere questo obiettivo?

Solo in python 2 (non in python 3):

assert not isinstance(lst, basestring)

In realtà è quello che vuoi, altrimenti ti perderai molte cose che si comportano come elenchi, ma non sono sottoclassi di listo tuple.

Ricorda che in Python vogliamo usare la "tipizzazione anatra". Quindi, tutto ciò che si comporta come un elenco può essere trattato come un elenco. Quindi, non controllare il tipo di un elenco, vedi solo se si comporta come un elenco.

Ma anche le stringhe si comportano come un elenco e spesso non è quello che vogliamo. Ci sono momenti in cui è persino un problema! Quindi, controlla esplicitamente una stringa, ma poi usa la tipizzazione duck.

Ecco una funzione che ho scritto per divertimento. È una versione speciale repr()che stampa qualsiasi sequenza tra parentesi angolari ('<', '>').

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

Questo è pulito ed elegante, nel complesso. Ma che isinstance()ci fa quel controllo? È una specie di hack. Ma è essenziale.

Questa funzione si chiama ricorsivamente su tutto ciò che si comporta come un elenco. Se non gestissimo la stringa in modo speciale, verrebbe trattata come una lista e divisa un carattere alla volta. Ma poi la chiamata ricorsiva proverebbe a trattare ogni personaggio come un elenco - e funzionerebbe! Anche una stringa di un carattere funziona come un elenco! La funzione continuerebbe a richiamare se stessa in modo ricorsivo fino allo overflow dello stack.

Funzioni come questa, che dipendono da ogni chiamata ricorsiva che interrompe il lavoro da svolgere, devono stringhe di casi speciali, poiché non è possibile suddividere una stringa al di sotto del livello di una stringa di un carattere e persino una -character stringa si comporta come un elenco.

Nota: il try/ exceptè il modo più pulito per esprimere le nostre intenzioni. Ma se questo codice fosse in qualche modo critico nel tempo, potremmo volerlo sostituire con una sorta di test per vedere se argè una sequenza. Invece di testare il tipo, dovremmo probabilmente testare i comportamenti. Se ha un .strip()metodo, è una stringa, quindi non considerarla una sequenza; altrimenti, se è indicizzabile o iterabile, è una sequenza:

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: originariamente ho scritto quanto sopra con un controllo per __getslice__()ma ho notato che nella collectionsdocumentazione del modulo, il metodo interessante è __getitem__(); questo ha senso, è così che indicizzi un oggetto. Sembra più fondamentale di __getslice__()così, ho cambiato quanto sopra.

H = "Hello"

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

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

Modificato nella versione 3.3: Classi di base astratte delle raccolte spostate nel modulo collections.abc. Per compatibilità con le versioni precedenti, continueranno a essere visibili anche in questo modulo fino alla versione 3.8, dove smetterà di funzionare.

Per 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 sapore PHP:

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

In generale, il fatto che una funzione che scorre su un oggetto funzioni sia su stringhe che su tuple ed elenchi è più una caratteristica che un bug. Certamente puoi usare isinstanceo anatra digitando per controllare un argomento, ma perché dovresti?

Sembra una domanda retorica, ma non lo è. La risposta a "perché dovrei controllare il tipo di argomento?" probabilmente suggerirà una soluzione al problema reale, non al problema percepito. Perché è un bug quando una stringa viene passata alla funzione? Inoltre: se è un bug quando una stringa viene passata a questa funzione, è anche un bug se qualche altro iterable non-list / tuple gli viene passato? Perché o perché no?

Penso che la risposta più comune alla domanda sia probabilmente che gli sviluppatori che scrivono f("abc")si aspettano che la funzione si comporti come se avessero scritto f(["abc"]). Ci sono probabilmente circostanze in cui ha più senso proteggere gli sviluppatori da se stessi che supportare il caso d'uso di iterare attraverso i caratteri in una stringa. Ma prima ci penserei a lungo.

Prova questo per la leggibilità e le migliori pratiche:

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

Spero che sia d'aiuto.

L' stroggetto non ha un __iter__attributo

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

così puoi fare un controllo

assert hasattr(x, '__iter__')

e questo aumenterà anche un valore AssertionErrorper qualsiasi altro oggetto non iterabile.

Modifica: Come accenna Tim nei commenti, questo funzionerà solo in Python 2.x, non 3.x

Questo non ha lo scopo di rispondere direttamente al PO, ma volevo condividere alcune idee correlate.

Ero molto interessato alla risposta di @steveha sopra, che sembrava dare un esempio in cui la digitazione delle anatre sembra rompersi. A pensarci bene, tuttavia, il suo esempio suggerisce che la tipizzazione di anatre è difficile da conformare, ma non lo suggeriscestr meriti una gestione speciale.

Dopotutto, un non- strtipo (ad esempio, un tipo definito dall'utente che mantiene alcune strutture ricorsive complicate) può causare la sreprfunzione @steveha per provocare una ricorsione infinita. Anche se questo è certamente piuttosto improbabile, non possiamo ignorare questa possibilità. Pertanto, piuttosto che speciale involucro strin srepr, dobbiamo chiarire che cosa vogliamosrepr fare quando un infinito risultati ricorsione.

Può sembrare che un approccio ragionevole sia semplicemente quello di interrompere la ricorsione nel sreprmomento list(arg) == [arg]. Questo, in effetti, risolverebbe completamente il problema con str, senza nessunoisinstance .

Tuttavia, una struttura ricorsiva davvero complicata può causare un ciclo infinito dove list(arg) == [arg]non accade mai. Pertanto, sebbene il controllo sopra riportato sia utile, non è sufficiente. Abbiamo bisogno di qualcosa come un limite rigido alla profondità della ricorsione.

Il mio punto è che se si prevede di gestire tipi di argomenti arbitrari, la gestione strtramite la tipizzazione anatra è molto, molto più semplice rispetto alla gestione dei tipi più generali che si possono incontrare (teoricamente). Quindi, se senti la necessità di escludere le stristanze, dovresti invece richiedere che l'argomento sia un'istanza di uno dei pochi tipi specificati in modo esplicito.

Trovo una tale funzione chiamata is_sequence in 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 ho verificato che soddisfa le tue esigenze.

Lo faccio nei miei test.

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

Non testato sui generatori, penso che rimarrai al prossimo 'rendimento' se passato in un generatore, che potrebbe rovinare le cose a valle. Ma poi di nuovo, questo è un 'unittest'

In modo "tipizzazione anatra", che ne dici

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

o

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

rispettivamente. Questo evita il isinstance/hasattr cose introspezione.

Puoi anche controllare viceversa:

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

Tutte le varianti non cambiano effettivamente il contenuto della variabile, ma implicano una riassegnazione. Non sono sicuro che ciò possa essere indesiderabile in alcune circostanze.

È interessante notare che con l'assegnazione "sul posto" +=non TypeErrorverrebbe sollevato in ogni caso se si lsttratta di un elenco (non di una tupla ). Ecco perché il compito viene svolto in questo modo. Forse qualcuno può far luce sul perché.

modo più semplice ... 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

Un'altra versione della tipizzazione anatra per aiutare a distinguere oggetti simili a stringhe da altri oggetti simili a sequenze.

La rappresentazione in stringa di oggetti simili a stringhe è la stringa stessa, quindi puoi verificare se ottieni un oggetto uguale dal strcostruttore:

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

Questo dovrebbe funzionare per tutti gli oggetti compatibili con stre per tutti i tipi di oggetti iterabili.

Python 3 ha questo:

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

Quindi, per controllare sia Elenchi che Tuple, sarebbe:

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"

Fallo e basta

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

in 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

Tendo a fare questo (se davvero, davvero dovevo):

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