Ich habe eine Funktion, die ein Argument akzeptiert, das entweder ein einzelnes oder ein doppeltes Element sein kann:

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

damit:

>>> iterable (("f", "f"))
Ja

>>> iterierbar (["f", "f"])
Ja

>>> iterable ("ff")
Nein

Das Problem ist, dass die Zeichenfolge technisch iterierbar ist, sodass ich den ValueError beim Versuch nicht einfach abfangen kann arg[1]. Ich möchte isinstance () nicht verwenden, da dies keine gute Praxis ist (oder wie mir gesagt wurde).

Verwenden Sie isinstance (ich verstehe nicht, warum es schlechte Praxis ist)

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

Beachten Sie die Verwendung von StringTypes. Es stellt sicher, dass wir keine obskure Art von Zeichenfolge vergessen.

Auf der anderen Seite funktioniert dies auch für abgeleitete Zeichenfolgenklassen.

class MyString(str):
    pass

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

Vielleicht möchten Sie auch einen Blick auf diese vorherige Frage werfen .

Prost.

NB: Das Verhalten wurde in Python 3 geändert StringTypesund basestringist nicht mehr definiert. Abhängig von Ihren Anforderungen können Sie sie isinstancedurch stroder ein Teilmengen-Tupel ersetzen (str, bytes, unicode), z. B. für Cython-Benutzer. Wie @Theron Luhn erwähnt hat, können Sie auch verwenden six.

Ab 2017 ist hier eine tragbare Lösung, die mit allen Versionen von Python funktioniert:

#!/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

Seit Python 2.6 mit der Einführung abstrakter Basisklassen isinstance(verwendet auf ABCs, keine konkreten Klassen) wird dies nun als vollkommen akzeptabel angesehen. Speziell:

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

Dies ist eine exakte Kopie (die nur den Klassennamen ändert) von Iterablewie in _abcoll.py(ein Implementierungsdetail von collections.py) definiert. Der Grund, warum dies so funktioniert, wie Sie es wünschen collections.Iterable, ist, dass letzteres die Extrameile geht, um sicherzustellen, dass Zeichenfolgen vorhanden sind wird als iterabel angesehen, indem Iterable.register(str)explizit direkt nach dieser classAnweisung aufgerufen wird .

Natürlich ist es einfach zu erweitern, __subclasshook__indem Sie Falsevor dem anyAufruf für andere Klassen zurückkehren, die Sie ausdrücklich von Ihrer Definition ausschließen möchten.

In jedem Fall , nachdem Sie dieses neue Modul als importiert haben myiter, isinstance('ciao', myiter.NonStringIterable)werden False, und isinstance([1,2,3], myiter.NonStringIterable)wird True, wie Sie es fordern - und in Python 2.6 und höher ist dies der richtige Weg , so auszugestalten, Kontrollen betrachtet ... definieren eine abstrakte Basisklasse und überprüfe isinstancees.

Mir ist klar, dass dies ein alter Beitrag ist, aber ich dachte, es lohnt sich, meinen Ansatz für die Internet-Nachwelt hinzuzufügen. Die folgende Funktion scheint unter den meisten Umständen sowohl mit Python 2 als auch mit Python 3 für mich zu funktionieren:

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

Dies prüft, ob eine Nicht-Zeichenfolge durch (mis) Verwendung der integrierten Zeichenfolge iterierbar ist, hasattrwodurch a ausgelöst wird, TypeErrorwenn das zweite Argument keine Zeichenfolge oder Unicode-Zeichenfolge ist.

Durch das Kombinieren früherer Antworten verwende ich:

import types
import collections

#[...]

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

#[Do stuff...]

Kein 100% iger Narrenbeweis, aber wenn ein Objekt nicht iterierbar ist, können Sie es trotzdem passieren lassen und auf das Tippen von Enten zurückgreifen.

Bearbeiten: Python3

types.StringTypes == (str, unicode). Das Phython3-Äquivalent lautet:

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

2.x.

Ich hätte vorgeschlagen:

hasattr( x, '__iter__' )

oder angesichts des Kommentars von David Charles, der dies für Python3 optimiert, was ist mit:

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

3.x.

Der eingebaute abstrakte Typ 'basestring' wurde entfernt ( https://docs.python.org/3.0/whatsnew/3.0.html ). Verwenden Sie stattdessen 'str'. Die Typen 'str' und 'bytes' haben nicht genügend gemeinsame Funktionen, um eine gemeinsam genutzte Basisklasse zu gewährleisten.

Wie Sie richtig hervorheben, ist eine einzelne Zeichenfolge eine Zeichenfolge.

Das, was Sie wirklich tun möchten, ist herauszufinden, welche Art von Sequenz arg ist, indem Sie isinstance oder type (a) == str verwenden.

Wenn Sie eine Funktion realisieren möchten, die eine variable Anzahl von Parametern akzeptiert, sollten Sie dies folgendermaßen tun:

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

Funktion ("ff") und Funktion ("ff", "ff") funktionieren.

Ich kann kein Szenario sehen, in dem eine isiterable () - Funktion wie Ihre benötigt wird. Es ist nicht isinstance (), das einen schlechten Stil hat, sondern Situationen, in denen Sie isinstance () verwenden müssen.

Um Alex Martellis hervorragenden Hack explizit zu erweitern collections.pyund einige der damit verbundenen Fragen zu beantworten: Die derzeit funktionierende Lösung in Python 3.6+ ist

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

und demonstriert

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

Wenn Sie iter('')beispielsweise Ausschlüsse hinzufügen möchten , ändern Sie die Zeile

            if issubclass(c, str):
                return False

sein

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

bekommen

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