Tester si une variable est une liste ou un tuple

En python, quelle est la meilleure façon de tester si une variable contient une liste ou un tuple? (c.-à-d. une collection)

Est-ce isinstance()aussi mal que suggéré ici? http://www.canonical.org/~kragen/isinstance/

Mise à jour: la raison la plus courante pour laquelle je veux distinguer une liste d'une chaîne est lorsque j'ai une arborescence imbriquée indéfiniment profonde / une structure de données de listes de listes de listes de chaînes, etc. que j'explore avec un algorithme récursif et dont j'ai besoin pour savoir quand j'ai touché les nœuds "feuilles".

Allez-y et utilisez isinstancesi vous en avez besoin. C'est un peu mal, car il exclut les séquences personnalisées, les itérateurs et autres choses dont vous pourriez avoir besoin. Cependant, vous devez parfois vous comporter différemment si quelqu'un, par exemple, passe une chaîne. Ma préférence serait de vérifier explicitement strou unicodecomme ceci:

import types
isinstance(var, types.StringTypes)

NB Ne confondez pas types.StringTypepour types.StringTypes. Ce dernier intègre stret unicodeobjets.

Le typesmodule est considéré par beaucoup comme obsolète en faveur de la vérification directe par rapport au type de l'objet, donc si vous préférez ne pas utiliser ce qui précède, vous pouvez également vérifier explicitement stret unicode, comme ceci:

isinstance(var, (str, unicode)):

Éditer:

Mieux vaut encore:

isinstance(var, basestring)

Fin de la modification

Après l'un ou l'autre de ces éléments, vous pouvez vous remettre à vous comporter comme si vous obteniez une séquence normale, laissant les non-séquences lever des exceptions appropriées.

Voyez ce qui est "mal" à propos de la vérification de type, ce n'est pas que vous souhaitiez peut-être vous comporter différemment pour un certain type d'objet, c'est que vous limitez artificiellement votre fonction de faire la bonne chose avec des types d'objet inattendus qui autrement feraient la bonne chose. Si vous avez une solution de secours finale qui n'est pas vérifiée par type, vous supprimez cette restriction. Il convient de noter que trop de vérification de type est une odeur de code qui indique que vous voudrez peut-être effectuer une refactorisation, mais cela ne signifie pas nécessairement que vous devriez l'éviter du 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'

Il n'y a rien de mal à l'utiliser isinstancetant qu'il n'est pas redondant. Si une variable ne doit être qu'une liste / tuple, documentez l'interface et utilisez-la comme telle. Sinon, un chèque est parfaitement raisonnable:

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

Ce type de vérification a de bons cas d'utilisation, comme avec la méthode standard commence par / fin avec les méthodes (bien que pour être précis, elles soient implémentées en C dans CPython en utilisant une vérification explicite pour voir s'il s'agit d'un tuple - il y a plus d'une façon pour résoudre ce problème, comme mentionné dans l'article auquel vous liez).

Une vérification explicite est souvent meilleure que d'essayer d'utiliser l'objet comme conteneur et de gérer l'exception - ce qui peut provoquer toutes sortes de problèmes avec l'exécution partielle ou inutile du code.

Documentez l'argument comme devant être une séquence et utilisez-le comme une séquence. Ne cochez pas le type.

Que diriez-vous hasattr(a, "__iter__"):?

Il indique si l'objet retourné peut être itéré en tant que générateur. Par défaut, les tuples et les listes le peuvent, mais pas les types de chaînes.

Sur les type(list) is listretours Python 2.8, false
je suggère de comparer le type de cette manière horrible:

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

(enfin au moins sur mon système, en utilisant anaconda sur Mac OS X Yosemite)

Python utilise le "Duck typing", c'est-à-dire que si une variable kwaks comme un canard, ce doit être un canard. Dans votre cas, vous voulez probablement qu'il soit itérable, ou vous voulez accéder à l'élément à un certain index. Vous devriez juste faire ceci: c'est-à-dire utiliser l'objet dans for var:ou à l' var[idx]intérieur d'un trybloc, et si vous obtenez une exception, ce n'était pas un canard ...

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

Si vous avez juste besoin de savoir si vous pouvez utiliser la foo[123]notation avec la variable, vous pouvez vérifier l'existence d'un __getitem__attribut (qui est ce que python appelle lorsque vous accédez par index) avechasattr(foo, '__getitem__')

Doit être un test plus complexe si vous voulez vraiment gérer à peu près n'importe quoi comme argument de fonction.

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

Bien que, généralement, il suffit de préciser qu'une fonction s'attend à être itérable et de ne vérifier que type(a) != type('') .

Il peut également arriver que pour une chaîne, vous ayez un chemin de traitement simple ou que vous soyez gentil et fassiez un fractionnement, etc., donc vous ne voulez pas crier sur les chaînes et si quelqu'un vous envoie quelque chose de bizarre, laissez-le simplement une exception.

Un autre moyen simple de savoir si une variable est une liste ou un tuple ou de vérifier généralement le type de variable serait:

    def islist(obj):

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

        else : return False

En principe, je suis d'accord avec Ignacio, ci-dessus, mais vous pouvez également utiliser type pour vérifier si quelque chose est un tuple ou une liste.

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