Wie überprüfe ich, ob ein Objekt eine Liste oder ein Tupel ist (aber keine Zeichenfolge)?

Dies ist, was ich normalerweise mache, um sicherzustellen, dass die Eingabe a list/ tuple- aber nicht a ist str. Weil ich oft auf Fehler gestoßen bin, bei denen eine Funktion versehentlich ein strObjekt passiert , und die Zielfunktion for x in lstdavon ausgeht, dass lstes sich tatsächlich um ein listoder handelt tuple.

assert isinstance(lst, (list, tuple))

Meine Frage ist: Gibt es einen besseren Weg, dies zu erreichen?

Nur in Python 2 (nicht in Python 3):

assert not isinstance(lst, basestring)

Ist eigentlich das, was Sie wollen, sonst verpassen Sie viele Dinge, die sich wie Listen verhalten, aber keine Unterklassen von listoder sind tuple.

Denken Sie daran, dass wir in Python "Duck Typing" verwenden möchten. Alles, was sich wie eine Liste verhält, kann als Liste behandelt werden. Überprüfen Sie also nicht den Typ einer Liste, sondern prüfen Sie, ob sie sich wie eine Liste verhält.

Aber Strings wirken auch wie eine Liste, und oft ist das nicht das, was wir wollen. Es gibt Zeiten, in denen es sogar ein Problem ist! Suchen Sie also explizit nach einer Zeichenfolge, verwenden Sie dann jedoch die Ententypisierung.

Hier ist eine Funktion, die ich zum Spaß geschrieben habe. Es ist eine spezielle Version repr(), die jede Sequenz in spitzen Klammern ('<', '>') druckt.

def srepr(arg):
    if isinstance(arg, basestring): # Python 3: isinstance(arg, str)
        return repr(arg)
    try:
        return '<' + ", ".join(srepr(x) for x in arg) + '>'
    except TypeError: # catch when for loop fails
        return repr(arg) # not a sequence so just return repr

Dies ist insgesamt sauber und elegant. Aber was macht dieser isinstance()Scheck dort? Das ist eine Art Hack. Aber es ist wichtig.

Diese Funktion ruft sich rekursiv für alles auf, was sich wie eine Liste verhält. Wenn wir die Zeichenfolge nicht speziell behandeln würden, würde sie wie eine Liste behandelt und jeweils ein Zeichen aufgeteilt. Aber dann würde der rekursive Aufruf versuchen, jedes Zeichen als Liste zu behandeln - und es würde funktionieren! Sogar eine einstellige Zeichenfolge funktioniert als Liste! Die Funktion ruft sich selbst rekursiv auf, bis der Stapel überläuft.

Funktionen wie diese, die von jedem rekursiven Aufruf abhängen, der die zu erledigende Arbeit aufschlüsselt, müssen Sonderzeichenfolgen enthalten - da Sie eine Zeichenfolge nicht unter der Ebene einer Zeichenfolge mit einem Zeichen und sogar einer Zeichenfolge aufteilen können -character string verhält sich wie eine Liste.

Hinweis: Das try/ exceptist der sauberste Weg, um unsere Absichten auszudrücken. Wenn dieser Code jedoch zeitkritisch wäre, möchten wir ihn möglicherweise durch eine Art Test ersetzen, um festzustellen, ob arges sich um eine Sequenz handelt. Anstatt den Typ zu testen, sollten wir wahrscheinlich das Verhalten testen. Wenn es eine .strip()Methode hat, ist es eine Zeichenfolge. Betrachten Sie sie also nicht als Sequenz. Andernfalls ist es eine Sequenz, wenn es indizierbar oder iterierbar ist:

def is_sequence(arg):
    return (not hasattr(arg, "strip") and
            hasattr(arg, "__getitem__") or
            hasattr(arg, "__iter__"))

def srepr(arg):
    if is_sequence(arg):
        return '<' + ", ".join(srepr(x) for x in arg) + '>'
    return repr(arg)

BEARBEITEN: Ich habe das Obige ursprünglich mit einem Check für geschrieben, __getslice__()aber ich habe festgestellt, dass in der collectionsModuldokumentation die interessante Methode ist __getitem__(); Das macht Sinn, so indizieren Sie ein Objekt. Das scheint grundlegender zu sein, __getslice__()also habe ich das oben Gesagte geändert.

H = "Hello"

if type(H) is list or type(H) is tuple:
    ## Do Something.
else
    ## Do Something.

Für Python 3:

import collections.abc

if isinstance(obj, collections.abc.Sequence) and not isinstance(obj, str):
    print("obj is a sequence (list, tuple, etc) but not a string")

In Version 3.3 geändert: Abstrakte Basisklassen für Sammlungen in das Modul collection.abc verschoben. Aus Gründen der Abwärtskompatibilität sind sie auch in diesem Modul bis zur Version 3.8 sichtbar, in der sie nicht mehr funktionieren.

Für Python 2:

import collections

if isinstance(obj, collections.Sequence) and not isinstance(obj, basestring):
    print "obj is a sequence (list, tuple, etc) but not a string or unicode"

Python mit PHP-Geschmack:

def is_array(var):
    return isinstance(var, (list, tuple))

Im Allgemeinen ist die Tatsache, dass eine Funktion, die über ein Objekt iteriert, sowohl für Zeichenfolgen als auch für Tupel und Listen funktioniert, mehr eine Funktion als ein Fehler. Sie sicherlich können verwenden isinstanceoder Ente eingeben ein Argument zu überprüfen, aber warum sollten Sie?

Das klingt nach einer rhetorischen Frage, ist es aber nicht. Die Antwort auf "Warum sollte ich den Typ des Arguments überprüfen?" wird wahrscheinlich eine Lösung für das eigentliche Problem vorschlagen, nicht für das wahrgenommene Problem. Warum ist es ein Fehler, wenn eine Zeichenfolge an die Funktion übergeben wird? Außerdem: Wenn es ein Fehler ist, wenn eine Zeichenfolge an diese Funktion übergeben wird, ist es auch ein Fehler, wenn eine andere iterierbare Nicht-Liste / Tupel an diese Funktion übergeben wird? Warum oder warum nicht?

Ich denke, dass die häufigste Antwort auf die Frage wahrscheinlich ist, dass Entwickler, die schreiben, f("abc")erwarten , dass sich die Funktion so verhält, als hätten sie geschrieben f(["abc"]). Es gibt wahrscheinlich Umstände, in denen es sinnvoller ist, Entwickler vor sich selbst zu schützen, als den Anwendungsfall des Iterierens über die Zeichen in einer Zeichenfolge zu unterstützen. Aber ich würde zuerst lange und gründlich darüber nachdenken.

Versuchen Sie dies für die Lesbarkeit und Best Practices:

Python2

import types
if isinstance(lst, types.ListType) or isinstance(lst, types.TupleType):
    # Do something

Python3

import typing
if isinstance(lst, typing.List) or isinstance(lst, typing.Tuple):
    # Do something

Ich hoffe es hilft.

Das strObjekt hat kein __iter__Attribut

>>> hasattr('', '__iter__')
False 

So können Sie eine Überprüfung durchführen

assert hasattr(x, '__iter__')

und dies wird auch AssertionErrorfür jedes andere nicht iterierbare Objekt ein Nettes auslösen.

Bearbeiten: Wie Tim in den Kommentaren erwähnt, funktioniert dies nur in Python 2.x, nicht in 3.x.

Dies ist nicht dazu gedacht, das OP direkt zu beantworten, aber ich wollte einige verwandte Ideen teilen.

Ich war sehr interessiert an der obigen Antwort von @steveha, die ein Beispiel zu geben schien, bei dem das Tippen von Enten zu brechen scheint. Beim zweiten Gedanken deutet sein Beispiel jedoch darauf hin, dass es schwierig ist, sich an die Ententypisierung zu halten, aber es deutet nicht darauf hin, dass dies streine besondere Behandlung verdient.

Schließlich kann ein Nicht- strTyp (z. B. ein benutzerdefinierter Typ, der einige komplizierte rekursive Strukturen beibehält) dazu führen, dass die @ steveha- sreprFunktion eine unendliche Rekursion verursacht. Dies ist zwar zugegebenermaßen eher unwahrscheinlich, wir können diese Möglichkeit jedoch nicht ignorieren. Daher eher als Sonder-Gehäuse strin srepr, sollten wir klären , was wir wollen , sreprwenn ein unendliches Rekursion Ergebnisse tun.

Es scheint, dass ein vernünftiger Ansatz darin besteht, die Rekursion im sreprMoment einfach zu brechen list(arg) == [arg]. Dies würde in der Tat vollständig löst das Problem mit str, ohne isinstance.

Eine wirklich komplizierte rekursive Struktur kann jedoch eine Endlosschleife verursachen, in der dies list(arg) == [arg]niemals geschieht. Daher ist die obige Prüfung zwar nützlich, aber nicht ausreichend. Wir brauchen so etwas wie eine harte Grenze für die Rekursionstiefe.

Mein Punkt ist, dass, wenn Sie vorhaben, mit beliebigen Argumenttypen umzugehen, die Handhabung strüber die Ententypisierung weitaus einfacher ist als die Behandlung der allgemeineren Typen, denen Sie (theoretisch) begegnen können. Wenn Sie also das Bedürfnis haben, strInstanzen auszuschließen , sollten Sie stattdessen verlangen, dass das Argument eine Instanz eines der wenigen Typen ist, die Sie explizit angeben.

Ich finde eine solche Funktion namens is_sequence im Tensorflow .

def is_sequence(seq):
  """Returns a true if its input is a collections.Sequence (except strings).
  Args:
    seq: an input sequence.
  Returns:
    True if the sequence is a not a string and is a collections.Sequence.
  """
  return (isinstance(seq, collections.Sequence)
and not isinstance(seq, six.string_types))

Und ich habe überprüft, ob es Ihren Anforderungen entspricht.

Ich mache das in meinen Testfällen.

def assertIsIterable(self, item):
    #add types here you don't want to mistake as iterables
    if isinstance(item, basestring): 
        raise AssertionError("type %s is not iterable" % type(item))

    #Fake an iteration.
    try:
        for x in item:
            break;
    except TypeError:
        raise AssertionError("type %s is not iterable" % type(item))

Ungetestet an Generatoren, denke ich, bleiben Sie bei der nächsten "Ausbeute", wenn Sie in einen Generator geleitet werden, was die Dinge stromabwärts vermasseln kann. Aber andererseits ist dies ein "unittest"

Wie wäre es mit "Ententyping"?

try:
    lst = lst + []
except TypeError:
    #it's not a list

oder

try:
    lst = lst + ()
except TypeError:
    #it's not a tuple

beziehungsweise. Dies vermeidet das isinstance/hasattr Introspection-Zeug.

Sie können auch umgekehrt überprüfen:

try:
    lst = lst + ''
except TypeError:
    #it's not (base)string

Alle Varianten ändern den Inhalt der Variablen nicht, sondern implizieren eine Neuzuweisung. Ich bin mir nicht sicher, ob dies unter bestimmten Umständen unerwünscht sein könnte.

Interessanterweise mit der „in place“ Zuordnung +=nicht TypeErrorwürde auf jedem Fall erhöht werden , wenn lsta Liste (kein Tupel ). Deshalb erfolgt die Zuordnung auf diese Weise. Vielleicht kann jemand Licht ins Dunkel bringen, warum das so ist.

einfachster Weg ... mit anyundisinstance

>>> console_routers = 'x'
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
False
>>>
>>> console_routers = ('x',)
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
True
>>> console_routers = list('x',)
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
True

Eine andere Version der Ententypisierung, um stringähnliche Objekte von anderen sequenzähnlichen Objekten zu unterscheiden.

Die Zeichenfolgendarstellung von Zeichenfolgen-ähnlichen Objekten ist die Zeichenfolge selbst. Sie können also überprüfen, ob Sie vom strKonstruktor ein gleiches Objekt zurückerhalten :

# If a string was passed, convert it to a single-element sequence
if var == str(var):
    my_list = [var]

# All other iterables
else: 
    my_list = list(var)

Dies sollte für alle Objekte funktionieren, die mit strund für alle Arten von iterierbaren Objekten kompatibel sind.

Python 3 hat Folgendes:

from typing import List

def isit(value):
    return isinstance(value, List)

isit([1, 2, 3])  # True
isit("test")  # False
isit({"Hello": "Mars"})  # False
isit((1, 2))  # False

Um nach Listen und Tupeln zu suchen, wäre es:

from typing import List, Tuple

def isit(value):
    return isinstance(value, List) or isinstance(value, Tuple)

assert (type(lst) == list) | (type(lst) == tuple), "Not a valid lst type, cannot be string"

Mach das einfach

if type(lst) in (list, tuple):
    # Do stuff

in Python> 3.6

import collections
isinstance(set(),collections.abc.Container)
True
isinstance([],collections.abc.Container)
True
isinstance({},collections.abc.Container)
True
isinstance((),collections.abc.Container)
True
isinstance(str,collections.abc.Container)
False

Ich neige dazu (wenn ich wirklich, wirklich musste):

for i in some_var:
   if type(i) == type(list()):
       #do something with a list
   elif type(i) == type(tuple()):
       #do something with a tuple
   elif type(i) == type(str()):
       #here's your string