Ho una funzione che accetta un argomento che può essere un elemento singolo o un elemento doppio:

def iterable(arg)
    if #arg is an iterable:
        print "yes"
    else:
        print "no"

così che:

>>> iterabile (("f", "f"))
sì

>>> iterabile (["f", "f"])
sì

>>> iterabile ("ff")
no

Il problema è che la stringa è tecnicamente iterabile, quindi non posso semplicemente rilevare ValueError quando provo arg[1]. Non voglio usare isinstance (), perché non è una buona pratica (o almeno così mi è stato detto).

Usa un'istanza (non vedo perché sia ​​una cattiva pratica)

import types
if not isinstance(arg, types.StringTypes):

Nota l'uso di StringTypes. Assicura che non ci dimentichiamo di qualche tipo oscuro di stringa.

Al rialzo, questo funziona anche per le classi di stringhe derivate.

class MyString(str):
    pass

isinstance(MyString("  "), types.StringTypes) # true

Inoltre, potresti voler dare un'occhiata a questa domanda precedente .

Saluti.

NB: comportamento cambiato in Python 3 in quanto StringTypese basestringnon sono più definiti. A seconda delle proprie esigenze, è possibile sostituirli in isinstanceby stro in una tupla di sottoinsiemi (str, bytes, unicode), ad esempio per gli utenti Cython. Come menzionato da @Theron Luhn , puoi anche usare six.

A partire dal 2017, ecco una soluzione portatile che funziona con tutte le versioni di Python:

#!/usr/bin/env python
import collections
import six


def iterable(arg):
    return (
        isinstance(arg, collections.Iterable) 
        and not isinstance(arg, six.string_types)
    )


# non-string iterables    
assert iterable(("f", "f"))    # tuple
assert iterable(["f", "f"])    # list
assert iterable(iter("ff"))    # iterator
assert iterable(range(44))     # generator
assert iterable(b"ff")         # bytes (Python 2 calls this a string)

# strings or non-iterables
assert not iterable(u"ff")     # string
assert not iterable(44)        # integer
assert not iterable(iterable)  # function

Dal momento che Python 2.6, con l'introduzione delle classi base astratte, isinstance(usate su ABC, non classi concrete) è ora considerato perfettamente accettabile. Nello specifico:

from abc import ABCMeta, abstractmethod

class NonStringIterable:
    __metaclass__ = ABCMeta

    @abstractmethod
    def __iter__(self):
        while False:
            yield None

    @classmethod
    def __subclasshook__(cls, C):
        if cls is NonStringIterable:
            if any("__iter__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

Questa è una copia esatta (cambiando solo il nome della classe) di Iterablecome definito in _abcoll.py(un dettaglio di implementazione di collections.py) ... il motivo per cui funziona come desideri, mentre collections.Iterablenon lo fa, è che quest'ultimo fa il possibile per garantire che le stringhe siano considerato iterabile, chiamando Iterable.register(str)esplicitamente subito dopo questa classistruzione.

Ovviamente è facile aumentare __subclasshook__tornando Falseprima della anychiamata per altre classi che desideri escludere specificamente dalla tua definizione.

In ogni caso, dopo aver importato questo nuovo modulo come myiter, isinstance('ciao', myiter.NonStringIterable)sarà Falsee isinstance([1,2,3], myiter.NonStringIterable)sarà True, proprio come richiesto - e in Python 2.6 e versioni successive questo è considerato il modo corretto per incorporare tali controlli ... definire una classe base astratta e controllalo isinstance.

Mi rendo conto che questo è un vecchio post, ma ho pensato che valesse la pena aggiungere il mio approccio per i posteri di Internet. La funzione di seguito sembra funzionare per me nella maggior parte dei casi con Python 2 e 3:

def is_collection(obj):
    """ Returns true for any iterable which is not a string or byte sequence.
    """
    try:
        if isinstance(obj, unicode):
            return False
    except NameError:
        pass
    if isinstance(obj, bytes):
        return False
    try:
        iter(obj)
    except TypeError:
        return False
    try:
        hasattr(None, obj)
    except TypeError:
        return True
    return False

Questo verifica la presenza di una stringa non iterabile da (mis) utilizzando l'integrato hasattrche solleverà a TypeErrorquando il suo secondo argomento non è una stringa o una stringa Unicode.

Combinando le risposte precedenti, sto usando:

import types
import collections

#[...]

if isinstance(var, types.StringTypes ) \
    or not isinstance(var, collections.Iterable):

#[Do stuff...]

Non a prova di stupido al 100%, ma se un oggetto non è un iterabile puoi comunque lasciarlo passare e ricadere nella digitazione anatra.

Modifica: Python3

types.StringTypes == (str, unicode). L'equivalente Phython3 è:

if isinstance(var, str ) \
    or not isinstance(var, collections.Iterable):

2.x

Avrei suggerito:

hasattr(x, '__iter__')

o in vista del commento di David Charles che modifica questo per Python3, che dire di:

hasattr(x, '__iter__') and not isinstance(x, (str, bytes))

3.x

il basestringtipo astratto incorporato è stato rimosso . Usa strinvece. I tipi stre bytesnon hanno abbastanza funzionalità in comune per garantire una classe base condivisa.

Come hai sottolineato correttamente, una singola stringa è una sequenza di caratteri.

Quindi la cosa che vuoi veramente fare è scoprire che tipo di sequenza argè usando isinstance o digita (a) == str.

Se vuoi realizzare una funzione che accetta una quantità variabile di parametri, dovresti farlo in questo modo:

def function(*args):
    # args is a tuple
    for arg in args:
        do_something(arg)

function ("ff") e function ("ff", "ff") funzioneranno.

Non riesco a vedere uno scenario in cui è necessaria una funzione isiterable () come la tua. Non è isinstance () che è cattivo stile, ma situazioni in cui è necessario utilizzare isinstance ().

Per espandere esplicitamente l'eccellente hack di Alex Martelli collections.pye rispondere ad alcune delle domande che lo circondano: L'attuale soluzione di lavoro in Python 3.6+ è

import collections
import _collections_abc as cabc
import abc


class NonStringIterable(metaclass=abc.ABCMeta):

    __slots__ = ()

    @abc.abstractmethod
    def __iter__(self):
        while False:
            yield None

    @classmethod
    def __subclasshook__(cls, c):
        if cls is NonStringIterable:
            if issubclass(c, str):
                return False
            return cabc._check_methods(c, "__iter__")
        return NotImplemented

e dimostrato

>>> typs = ['string', iter(''), list(), dict(), tuple(), set()]
>>> [isinstance(o, NonStringIterable) for o in typs]
[False, True, True, True, True, True]

Se vuoi aggiungere iter('')delle esclusioni, ad esempio, modifica la riga

            if issubclass(c, str):
                return False

essere

            # `str_iterator` is just a shortcut for `type(iter(''))`*
            if issubclass(c, (str, cabc.str_iterator)):
                return False

ottenere

[False, False, True, True, True, True]