我有一个带有参数的函数，该参数可以是单项或双项：

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

以便：

>>> iterable（（“ f”，“ f”））
是

>>> iterable（[“ f”，“ f”]）
是

>>> iterable（“ ff”）
没有

问题是字符串在技术上是可迭代的，因此在尝试时我不能只捕捉ValueError arg[1]。我不想使用isinstance（），因为这不是一个好习惯（或者有人告诉我）。

使用isinstance（我不明白为什么这是不好的做法）

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

请注意StringTypes的使用。它确保我们不会忘记一些晦涩的字符串类型。

从好的方面来说，这也适用于派生的字符串类。

class MyString(str):
    pass

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

另外，您可能想看看上一个问题。

干杯。

注意：行为在Python 3中更改为StringTypes，basestring并且不再定义。根据您的需要，您可以将它们替换isinstance为str，或替换为的子集元组(str, bytes, unicode)，例如，对于Cython用户。正如@Theron Luhn提到的那样，您也可以使用six。

截至2017年，以下是可移植解决方案，可与所有版本的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

从Python 2.6开始，引入了抽象基类isinstance（用于ABC，而不是具体类），现在被认为是完全可以接受的。特别：

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

这是（的实现细节）中Iterable定义的的精确副本（仅更改类名）...之所以能按您希望的那样工作而并非如此，是因为后者会加倍努力以确保字符串通过在此语句之后显式调用，将其视为可迭代的。_abcoll.pycollections.pycollections.IterableIterable.register(str)class

当然，很容易__subclasshook__通过False在any调用您要专门从定义中排除的其他类之前返回来进行扩充。

无论如何，按照您的要求将新模块导入为myiter，isinstance('ciao', myiter.NonStringIterable)将是False和isinstance([1,2,3], myiter.NonStringIterable)将是之后True-在Python 2.6及更高版本中，这被视为体现此类检查的正确方法...定义抽象基类并检查isinstance一下。

我意识到这是一篇过时的文章，但认为值得添加我的后代方法。以下功能似乎在大多数情况下都适用于Python 2和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

这通过使用内置函数（错误）来检查非字符串可迭代的，当其第二个参数不是字符串或Unicode字符串时hasattr，它将引发a TypeError。

通过合并以前的答复，我正在使用：

import types
import collections

#[...]

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

#[Do stuff...]

不是100％的傻瓜证明，但是如果对象不是可迭代的，您仍然可以让它通过并退回给鸭子输入。

编辑：Python3

types.StringTypes == (str, unicode)。Phython3等效项是：

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

2.x

我会建议：

hasattr(x, '__iter__')

或鉴于David Charles的评论针对Python3进行了调整，那么：

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

3.x

内置的basestring抽象类型被移除。使用str代替。该str和bytes类型没有足够的功能共同保证一个共享的基类。

如您正确指出的那样，单个字符串是一个字符序列。

因此，您真正想做的arg就是通过使用isinstance或type（a）== str找出什么样的序列。

如果要实现一个需要可变数量参数的函数，则应这样进行：

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

function（“ ff”）和function（“ ff”，“ ff”）将起作用。

我看不到需要像您一样的isiterable（）函数的情况。不是isinstance（）是不好的样式，而是需要使用isinstance（）的情况。

为了明确扩展Alex Martelli的出色技巧collections.py并解决围绕它的一些问题：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

并展示

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

iter('')例如，如果要添加到排除项中，请修改该行

            if issubclass(c, str):
                return False

成为

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

要得到

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