Verifica se una variabile è un elenco o una tupla

In Python, qual è il modo migliore per verificare se una variabile contiene un elenco o una tupla? (cioè una collezione)

Il isinstance()male è come suggerito qui? http://www.canonical.org/~kragen/isinstance/

Aggiornamento: il motivo più comune che voglio distinguere un elenco da una stringa è quando ho un albero nidificato indefinitamente profondo / struttura dati di elenchi di elenchi di elenchi di stringhe ecc. Che sto esplorando con un algoritmo ricorsivo e ho bisogno di per sapere quando ho colpito i nodi "foglia".

Vai avanti e usa isinstancese ne hai bisogno. È in qualche modo malvagio, in quanto esclude sequenze personalizzate, iteratori e altre cose di cui potresti effettivamente aver bisogno. Tuttavia, a volte è necessario comportarsi diversamente se qualcuno, ad esempio, passa una stringa. La mia preferenza sarebbe quella di verificare esplicitamente stro unicodesimili:

import types
isinstance(var, types.StringTypes)

NB non sbaglio types.StringTypeper types.StringTypes. Quest'ultimo incorpora stre unicodeoggetti.

Il typesmodulo è considerato da molti obsoleto a favore del solo controllo diretto rispetto al tipo di oggetto, quindi se preferisci non utilizzare quanto sopra, puoi alternativamente verificare esplicitamente contro stre unicode, in questo modo:

isinstance(var, (str, unicode)):

Modificare:

Meglio ancora è:

isinstance(var, basestring)

Termina modifica

Dopo uno di questi, puoi ricominciare a comportarti come se avessi una sequenza normale, lasciando che le non-sequenze sollevino le opportune eccezioni.

Vedere la cosa "cattiva" nel controllo dei tipi non è che potresti voler comportarti diversamente per un certo tipo di oggetto, è che limiti artificialmente la tua funzione dal fare la cosa giusta con tipi di oggetti inaspettati che altrimenti farebbero la cosa giusta. Se si dispone di un fallback finale che non è stato verificato, si rimuove questa restrizione. Va notato che un eccessivo controllo del tipo è un odore di codice che indica che potresti voler eseguire un refactoring, ma ciò non significa necessariamente che dovresti evitarlo dal 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'

Non c'è niente di sbagliato nell'uso isinstancepurché non ridondante. Se una variabile deve essere solo un elenco / tupla, documenta l'interfaccia e utilizzala come tale. Altrimenti un controllo è perfettamente ragionevole:

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

Questo tipo di controllo presenta alcuni casi d'uso validi, ad esempio con la stringa standard di inizio / fine metodi (anche se per essere precisi questi sono implementati in C in CPython usando un controllo esplicito per vedere se è una tupla - c'è più di un modo per risolvere questo problema, come menzionato nell'articolo a cui ti colleghi).

Un controllo esplicito è spesso meglio che tentare di utilizzare l'oggetto come contenitore e gestire l'eccezione, il che può causare tutti i tipi di problemi con l'esecuzione del codice in parte o inutilmente.

Documenta l'argomento come necessità di essere una sequenza e usalo come sequenza. Non controllare il tipo.

Che ne dici di hasattr(a, "__iter__"):?

Indica se l'oggetto restituito può essere ripetuto come generatore. Per impostazione predefinita, le tuple e gli elenchi possono, ma non i tipi di stringa.

Sui type(list) is listrendimenti di Python 2.8 false
suggerirei di confrontare il tipo in questo modo orribile:

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

(bene almeno sul mio sistema, usando anaconda su Mac OS X Yosemite)

Python usa "Duck typing", cioè se una variabile kwaks come un'anatra, deve essere un'anatra. Nel tuo caso, probabilmente desideri che sia iterabile o vuoi accedere all'elemento in un determinato indice. Dovresti semplicemente fare questo: cioè usare l'oggetto dentro for var:o var[idx]dentro un tryblocco, e se ottieni un'eccezione non era un'anatra ...

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

Se hai solo bisogno di sapere se puoi usare la foo[123]notazione con la variabile, puoi verificare l'esistenza di un __getitem__attributo (che è ciò che Python chiama quando accedi per indice) conhasattr(foo, '__getitem__')

Deve essere un test più complesso se vuoi davvero gestire qualsiasi cosa come argomento di funzione.

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

Anche se, di solito è sufficiente precisare che una funzione si aspetta iterabile e quindi controllare solo type(a) != type('') .

Inoltre può capitare che per una stringa tu abbia un semplice percorso di elaborazione o che tu sia simpatico e fai una divisione ecc., Quindi non vuoi urlare alle stringhe e se qualcuno ti manda qualcosa di strano, lascia che abbia un'eccezione.

Un altro modo semplice per scoprire se una variabile è list o tuple o in generale controllare il tipo di variabile sarebbe:

    def islist(obj):

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

        else : return False

In linea di principio, sono d'accordo con Ignacio, sopra, ma puoi anche usare type per verificare se qualcosa è una tupla o un elenco.

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