Gibt es eine einfache Möglichkeit, festzustellen, ob eine Variable eine Liste, ein Wörterbuch oder etwas anderes ist? Ich bekomme ein Objekt zurück, das von beiden Typen sein kann, und ich muss in der Lage sein, den Unterschied zu erkennen.

Es gibt zwei integrierte Funktionen, mit denen Sie den Typ eines Objekts identifizieren können. Sie verwenden können , type() wenn Sie den genauen Typ eines Objekts benötigen, und isinstance()zu überprüfen , ein Objekt der Art gegen etwas. Normalerweise möchten Sie die isistance()meiste Zeit verwenden, da es sehr robust ist und auch die Typvererbung unterstützt.

Um den tatsächlichen Typ eines Objekts abzurufen, verwenden Sie die integrierte type()Funktion. Wenn Sie ein Objekt als einzigen Parameter übergeben, wird das Typobjekt dieses Objekts zurückgegeben:

>>> type([]) is list
True
>>> type({}) is dict
True
>>> type('') is str
True
>>> type(0) is int
True

Dies funktioniert natürlich auch für benutzerdefinierte Typen:

>>> class Test1 (object):
        pass
>>> class Test2 (Test1):
        pass
>>> a = Test1()
>>> b = Test2()
>>> type(a) is Test1
True
>>> type(b) is Test2
True

Beachten Sie, dass type()nur der unmittelbare Typ des Objekts zurückgegeben wird, Sie jedoch nicht über die Typvererbung informiert werden können.

>>> type(b) is Test1
False

Um dies abzudecken, sollten Sie die isinstanceFunktion verwenden. Dies funktioniert natürlich auch für eingebaute Typen:

>>> isinstance(b, Test1)
True
>>> isinstance(b, Test2)
True
>>> isinstance(a, Test1)
True
>>> isinstance(a, Test2)
False
>>> isinstance([], list)
True
>>> isinstance({}, dict)
True

isinstance()Dies ist normalerweise die bevorzugte Methode, um den Typ eines Objekts sicherzustellen, da auch abgeleitete Typen akzeptiert werden. Wenn Sie das Typobjekt nicht tatsächlich benötigen (aus welchem ​​Grund auch immer), wird die Verwendung der Verwendung isinstance()vorgezogen type().

Der zweite Parameter von isinstance()akzeptiert auch ein Tupel von Typen, sodass nach mehreren Typen gleichzeitig gesucht werden kann. isinstancegibt dann true zurück, wenn das Objekt einen dieser Typen hat:

>>> isinstance([], (tuple, list, set))
True

Sie können dies tun mit type():

>>> a = []
>>> type(a)
<type 'list'>
>>> f = ()
>>> type(f)
<type 'tuple'>

Es könnte pythonischer sein, einen try... exceptBlock zu verwenden. Auf diese Weise verhält sich eine Klasse, die wie eine Liste quakt oder wie ein Diktat quakt, unabhängig von ihrem tatsächlichen Typ ordnungsgemäß .

Zur Verdeutlichung besteht die bevorzugte Methode zum "Erkennen des Unterschieds" zwischen Variablentypen in der sogenannten Ententypisierung : Solange die Methoden (und Rückgabetypen), auf die eine Variable reagiert, den Erwartungen Ihres Unterprogramms entsprechen, behandeln Sie sie so, wie Sie es erwarten sein. Wenn Sie beispielsweise eine Klasse haben, die die Klammeroperatoren mit getattrund überlastet setattr, aber ein lustiges internes Schema verwendet, ist es angemessen, dass sie sich wie ein Wörterbuch verhält, wenn sie dies zu emulieren versucht.

Das andere Problem bei der type(A) is type(B)Überprüfung besteht darin, dass, wenn Aes sich um eine Unterklasse von handelt B, ausgewertet wird, falsewann dies programmgesteuert der Fall sein würde true. Wenn ein Objekt eine Unterklasse einer Liste ist, sollte es wie eine Liste funktionieren: Wenn Sie den in der anderen Antwort angegebenen Typ überprüfen, wird dies verhindert. ( isinstancewird jedoch funktionieren).

Auf Instanzen von Objekten haben Sie auch die:

__class__

Attribut. Hier ist ein Beispiel aus der Python 3.3-Konsole

>>> str = "str"
>>> str.__class__
<class 'str'>
>>> i = 2
>>> i.__class__
<class 'int'>
>>> class Test():
...     pass
...
>>> a = Test()
>>> a.__class__
<class '__main__.Test'>

Beachten Sie, dass in Python 3.x und in New-Style-Klassen (optional in Python 2.6 verfügbar) Klasse und Typ zusammengeführt wurden und dies manchmal zu unerwarteten Ergebnissen führen kann. Hauptsächlich aus diesem Grund ist meine Lieblingsmethode zum Testen von Typen / Klassen die in isinstance integrierte Funktion.

Bestimmen Sie den Typ eines Python-Objekts

Bestimmen Sie den Typ eines Objekts mit type

>>> obj = object()
>>> type(obj)
<class 'object'>

Vermeiden Sie doppelte Unterstrichattribute wie __class__- sie sind nicht semantisch öffentlich, und obwohl dies in diesem Fall möglicherweise nicht der Fall ist, verhalten sich die integrierten Funktionen normalerweise besser.

>>> obj.__class__ # avoid this!
<class 'object'>

Typprüfung

Gibt es eine einfache Möglichkeit, festzustellen, ob eine Variable eine Liste, ein Wörterbuch oder etwas anderes ist? Ich bekomme ein Objekt zurück, das von beiden Typen sein kann, und ich muss in der Lage sein, den Unterschied zu erkennen.

Nun, das ist eine andere Frage, benutze keinen Typ - benutze isinstance:

def foo(obj):
    """given a string with items separated by spaces, 
    or a list or tuple, 
    do something sensible
    """
    if isinstance(obj, str):
        obj = str.split()
    return _foo_handles_only_lists_or_tuples(obj)

Dies deckt den Fall ab, in dem Ihr Benutzer durch Unterklassen möglicherweise etwas Kluges oder Sinnvolles tut str- gemäß dem Prinzip der Liskov-Substitution möchten Sie Unterklasseninstanzen verwenden können, ohne Ihren Code zu beschädigen - und isinstanceunterstützt dies.

Verwenden Sie Abstraktionen

Noch besser ist es, wenn Sie nach einer bestimmten abstrakten Basisklasse suchen von collectionsoder numbers:

from collections import Iterable
from numbers import Number

def bar(obj):
    """does something sensible with an iterable of numbers, 
    or just one number
    """
    if isinstance(obj, Number): # make it a 1-tuple
        obj = (obj,)
    if not isinstance(obj, Iterable):
        raise TypeError('obj must be either a number or iterable of numbers')
    return _bar_sensible_with_iterable(obj)

Oder einfach nicht explizit Typprüfung

Oder, vielleicht am besten, verwenden Sie die Enten-Typisierung und überprüfen Sie Ihren Code nicht explizit. Die Ententypisierung unterstützt die Liskov-Substitution mit mehr Eleganz und weniger Ausführlichkeit.

def baz(obj):
    """given an obj, a dict (or anything with an .items method) 
    do something sensible with each key-value pair
    """
    for key, value in obj.items():
        _baz_something_sensible(key, value)

Fazit

• Verwenden Sie typediese Option, um die Klasse einer Instanz abzurufen.
• Verwenden Sie isinstancediese Option, um explizit nach tatsächlichen Unterklassen oder registrierten Abstraktionen zu suchen.
• Und vermeiden Sie einfach die Typprüfung, wo es Sinn macht.

Sie können type()oder verwenden isinstance().

>>> type([]) is list
True

Seien Sie gewarnt, dass Sie Clobber listoder einen anderen Typ verwenden können, indem Sie eine Variable im aktuellen Bereich mit demselben Namen zuweisen.

>>> the_d = {}
>>> t = lambda x: "aight" if type(x) is dict else "NOPE"
>>> t(the_d) 'aight'
>>> dict = "dude."
>>> t(the_d) 'NOPE'

Oben sehen wir, dass dicteine Zeichenfolge neu zugewiesen wird, daher der Test:

type({}) is dict

... schlägt fehl.

Um dies zu umgehen und type()vorsichtiger zu verwenden:

>>> import __builtin__
>>> the_d = {}
>>> type({}) is dict
True
>>> dict =""
>>> type({}) is dict
False
>>> type({}) is __builtin__.dict
True

Obwohl die Fragen ziemlich alt sind, bin ich darauf gestoßen, als ich selbst einen richtigen Weg gefunden habe, und ich denke, es muss noch geklärt werden, zumindest für Python 2.x (habe Python 3 nicht überprüft, aber da das Problem bei klassischen Klassen auftritt welche auf solche version gegangen sind, spielt es wahrscheinlich keine rolle).

Hier versuche ich die Frage des Titels zu beantworten: Wie kann ich den Typ eines beliebigen Objekts bestimmen ? Andere Vorschläge zur Verwendung oder Nichtverwendung von isinstance sind in vielen Kommentaren und Antworten in Ordnung, aber ich gehe nicht auf diese Bedenken ein.

Das Hauptproblem bei diesem type()Ansatz ist, dass er mit Instanzen alten Stils nicht richtig funktioniert :

class One:
    pass

class Two:
    pass


o = One()
t = Two()

o_type = type(o)
t_type = type(t)

print "Are o and t instances of the same class?", o_type is t_type

Das Ausführen dieses Snippets würde ergeben:

Are o and t instances of the same class? True

Was, so argumentiere ich, nicht das ist, was die meisten Leute erwarten würden.

Der __class__Ansatz kommt der Korrektheit am nächsten, funktioniert jedoch in einem entscheidenden Fall nicht: Wenn das übergebene Objekt eine Klasse alten Stils ist (keine Instanz!), Da diesen Objekten ein solches Attribut fehlt.

Dies ist der kleinste Codeausschnitt, den ich mir vorstellen kann, der eine solche legitime Frage auf konsistente Weise erfüllt:

#!/usr/bin/env python
from types import ClassType
#we adopt the null object pattern in the (unlikely) case
#that __class__ is None for some strange reason
_NO_CLASS=object()
def get_object_type(obj):
    obj_type = getattr(obj, "__class__", _NO_CLASS)
    if obj_type is not _NO_CLASS:
        return obj_type
    # AFAIK the only situation where this happens is an old-style class
    obj_type = type(obj)
    if obj_type is not ClassType:
        raise ValueError("Could not determine object '{}' type.".format(obj_type))
    return obj_type

Seien Sie vorsichtig mit isinstance

isinstance(True, bool)
True
>>> isinstance(True, int)
True

aber tippe

type(True) == bool
True
>>> type(True) == int
False

Neben den vorherigen Antworten ist zu erwähnen, dass es collections.abcmehrere abstrakte Basisklassen (ABCs) gibt, die die Ententypisierung ergänzen.

Anstatt beispielsweise explizit zu überprüfen, ob es sich bei einer Liste um eine Liste handelt mit:

isinstance(my_obj, list)

Wenn Sie nur sehen möchten, ob das Objekt, das Sie haben, das Abrufen von Elementen ermöglicht, können Sie Folgendes verwenden collections.abc.Sequence:

from collections.abc import Sequence
isinstance(my_obj, Sequence) 

Wenn Sie ausschließlich an Objekten interessiert sind, mit denen Elemente abgerufen , festgelegt und gelöscht werden können (dh veränderbare Sequenzen), entscheiden Sie sich für collections.abc.MutableSequence.

Viele andere ABCs sind dort definiert, Mappingfür Objekte , die als Karten verwendet werden können, Iterable, Callable, et cetera. Eine vollständige Liste aller dieser Elemente finden Sie in der Dokumentation zu collections.abc.

Im Allgemeinen können Sie eine Zeichenfolge aus einem Objekt mit dem Klassennamen extrahieren.

str_class = object.__class__.__name__

und zum Vergleich verwenden,

if str_class == 'dict':
    # blablabla..
elif str_class == 'customclass':
    # blebleble..

In vielen praktischen Fällen anstelle von typeoder können isinstanceSie auch verwenden @functools.singledispatch, um allgemeine Funktionen zu definieren ( Funktion, die aus mehreren Funktionen besteht, die dieselbe Operation für verschiedene Typen implementieren ).

Mit anderen Worten, Sie möchten es verwenden, wenn Sie einen Code wie den folgenden haben:

def do_something(arg):
    if isinstance(arg, int):
        ... # some code specific to processing integers
    if isinstance(arg, str):
        ... # some code specific to processing strings
    if isinstance(arg, list):
        ... # some code specific to processing lists
    ...  # etc

Hier ist ein kleines Beispiel, wie es funktioniert:

from functools import singledispatch


@singledispatch
def say_type(arg):
    raise NotImplementedError(f"I don't work with {type(arg)}")


@say_type.register
def _(arg: int):
    print(f"{arg} is an integer")


@say_type.register
def _(arg: bool):
    print(f"{arg} is a boolean")

>>> say_type(0)
0 is an integer
>>> say_type(False)
False is a boolean
>>> say_type(dict())
# long error traceback ending with:
NotImplementedError: I don't work with <class 'dict'>

Zusätzlich können wir abstrakte Klassen verwenden , um mehrere Typen gleichzeitig abzudecken:

from collections.abc import Sequence


@say_type.register
def _(arg: Sequence):
    print(f"{arg} is a sequence!")

>>> say_type([0, 1, 2])
[0, 1, 2] is a sequence!
>>> say_type((1, 2, 3))
(1, 2, 3) is a sequence!

type()ist eine bessere Lösung als isinstance()insbesondere für booleans:

Trueund Falsesind nur Schlüsselwörter, die bedeuten 1und 0in Python. Somit,

isinstance(True, int)

und

isinstance(False, int)

beide kehren zurück True. Beide Booleschen Werte sind eine Instanz einer Ganzzahl. type()ist jedoch klüger:

type(True) == int

kehrt zurück False.