Itérer sur une liste ou un élément unique en python

Je voudrais effectuer une itération sur les sorties d'une fonction inconnue. Malheureusement, je ne sais pas si la fonction renvoie un seul élément ou d'un tuple. Ce doit être un problème et il doit y avoir un moyen standard de traiter avec cela-ce que j'ai maintenant c'est assez moche.

x = UnknownFunction()
if islist(x):
    iterator = x
else:
    iterator = [x]

def islist(s):
    try:
        len(s)
        return True
    except TypeError:
        return False

for ii in iterator:
    #do stuff

source d'informationauteur Edward

  1. 21

    Le plus de solution générale à ce problème est l'utilisation isinstance avec la classe de base abstraite collections.Iterable. 

    import collections

def get_iterable(x):
    if isinstance(x, collections.Iterable):
        return x
    else:
        return (x,)

    Vous pouvez également tester basestring ainsi, comme Kindall suggère.

        if isinstance(x, collections.Iterable) and not isinstance(x, basestring):

    Maintenant, certaines personnes pourraient penser, comme je l'ai déjà fait", n'est-ce pas isinstance considéré comme nocif? N'est-ce pas vous enfermer dans l'aide d'un genre de type? N'utilisez pas hasattr(x, '__iter__') être mieux?"

    La réponse est: pas quand il s'agit de classes de base abstraites. En fait, vous pouvez définir votre propre classe avec un __iter__ méthode et il sera reconnu comme une instance de collections.Iterablemême si vous n'avez pas de sous-classe collections.Iterable. Cela fonctionne parce que collections.Iterable définit un __subclasshook__ qui détermine si un type est passé est un objet iterable par quelle que soit la définition qu'il implémente.

    >>> class MyIter(object):
...     def __iter__(self):
...         return iter(range(10))
... 
>>> i = MyIter()
>>> isinstance(i, collections.Iterable)
True
>>> collections.Iterable.__subclasshook__(type(i))
True
  2. 5

    Il n'est pas particulièrement élégant d'inclure le code partout où vous en avez besoin. Donc écrire une fonction qui fait le massage. Voici une suggestion je suis venu avec une semblable question précédente. Il spéciaux-cas des chaînes de caractères (ce qui est généralement itérable) en pièces uniques, qui est ce que je trouve d'habitude je veux.

    def iterfy(iterable):
    if isinstance(iterable, basestring):
        iterable = [iterable]
    try:
        iter(iterable)
    except TypeError:
        iterable = [iterable]
    return iterable

    Utilisation:

    for item in iterfy(unknownfunction()):
     # do something
  3. 2

    Vous aurez envie de faire ce qui suit:

    iterator = (x,) if not isinstance(x, (tuple, list)) else x

    puis

    for i in iterator:
    #do stuff
  4. 1

    Peut-être mieux d'utiliser collections.Iterable pour savoir si la sortie est un objet iterable ou pas.

    import collections

x = UnknownFunction()
if not isinstance(x, collections.Iterable): x = [x]

for ii in x:
    #do stuff

    Ceci fonctionnera si le type de x est l'un de ces - listtupledictstrtoute classe dérivée de ces.

  5. 0

    Vous pouvez également essayer d'utiliser l'opérateur.isSequenceType fonction

    import operator
x = unknown_function()
if not operator.isSequenceType(x) and not isinstance(x, basestring):
    x = (x,)
for item in x:
    do_something(item)
  6. 0

    Vous pouvez définir une fonction qui assure la valeur retournée supporte l'itération (strdicttupleetc --y compris défini par l'utilisateur types de séquences qui ne sont pas directement hériter de ces classes) plutôt que de vérifier si c'est un tuple ou list directement.

    def ensure_iterable(x):
    return (x,) if not hasattr(x, '__iter__') else x

x = ensure_iterable(UnknownFunction())
for i in x:
    do_something(i)