У мене є функція, яка приймає аргумент, який може бути як одиничним, так і подвійним елементом:

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

так що:

>>> ітерабельний (("f", "f"))
так

>>> ітерабельний (["f", "f"])
так

>>> ітерабельний ("ff")
немає

Проблема в тому, що рядок технічно повторюваний, тому я не можу просто вловити ValueError при спробі arg[1]. Я не хочу використовувати isinstance (), тому що це погана практика (або, так мені сказали).

Використовуйте isinstance (я не розумію, чому це погана практика)

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

Зверніть увагу на використання StringTypes. Це гарантує, що ми не забуваємо про якийсь неясний тип рядка.

З іншого боку, це також працює для похідних класів рядків.

class MyString(str):
    pass

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

Крім того, ви можете поглянути на це попереднє запитання .

Ура.

NB: поведінка змінена в 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.py(деталі реалізації collections.py) ... причина, по якій це працює, як ви хочете, хоча collections.Iterableі ні, полягає в тому, що остання проходить додаткову милю, щоб забезпечити вважається ітеративним, зателефонувавшиIterable.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

Це перевіряє нестроковий ітерабельний (mis) за допомогою вбудованого, hasattrякий піднімає a, TypeErrorколи другий аргумент не є рядком або рядком Unicode.

Поєднуючи попередні відповіді, я використовую:

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__')

або з огляду на коментар Девіда Чарльза, який налаштовує це для 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 ().

Щоб явно розширити чудовий злом Алекса Мартеллі 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]