确定对象的类型？

Question

是否有一种简单的方法可以确定变量是列表，字典还是其他内容？我得到的对象可能是任何一种类型，我需要能够分辨出来。

Answer 1

要获取对象的类型，可以使用内置的type()函数。将对象作为唯一参数传递将返回该对象的类型对象：

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

这当然也适用于自定义类型：

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

请注意，type()只会返回对象的直接类型，但无法告诉您类型继承。

>>> type(b) is Test1
False

为了解决这个问题，您应该使用isinstance功能。这当然也适用于内置类型：

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

isinstance()通常是确保对象类型的首选方法，因为它也会接受派生类型。因此，除非您确实需要类型对象（无论出于何种原因），否则优先使用isinstance()而不是type()。

isinstance()的第二个参数也接受一个类型元组，因此可以一次检查多个类型。如果对象属于以下任何类型，则isinstance将返回true：

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

Answer 2

您可以使用type()：

执行此操作

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

Answer 3

使用try ... except块可能更具Pythonic。这样，如果你有一个像列表那样嘎嘎叫的类，或像dict一样嘎嘎叫，那么无论它的类型是什么，它都会表现得正常。

为了澄清，变量类型之间“区别对待”的首选方法是使用名为duck typing的东西：只要变量响应的方法（和返回类型）是您的子程序所期望的，就对待它就像你期望的那样。例如，如果你有一个使用getattr和setattr重载括号运算符的类，但是使用了一些有趣的内部方案，那么如果它正在尝试的话，那么它应该像字典一样运行。仿真。

type(A) is type(B)检查的另一个问题是，如果A是B的子类，则在编程方面，当您希望它为false时，它将评估为true isinstance。如果一个对象是列表的子类，它应该像列表一样工作：检查另一个答案中显示的类型将阻止这种情况。 （{{1}}会起作用。）

Answer 4

在对象的实例上，您还有：

__class__

属性。以下是从Python 3.3控制台

中获取的示例

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

请注意，在python 3.x和New-Style类中（可选择从Python 2.6中提供），类和类型已合并，这有时会导致意外结果。主要是出于这个原因，我最喜欢的测试类型/类的方法是isinstance内置函数。

Answer 5

确定Python对象的类型

使用type

确定对象的类型

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

虽然它有效但是避免使用双重下划线属性，例如__class__ - 它们在语义上不公开，并且，虽然在这种情况下可能不是这样，但内置函数通常具有更好的行为。

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

类型检查

  

是否有一种简单的方法可以确定变量是列表，字典还是其他内容？我得到的对象可能是任何一种类型，我需要能够分辨出来。

那是一个不同的问题，不要使用类型 - 使用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)

这涵盖了用户可能通过子类str做一些聪明或明智的事情 - 根据Liskov Substitution的原则，您希望能够在不破坏代码的情况下使用子类实例 - 而且{{ 1}}支持这个。

使用抽象

更好的是，您可以从isinstance或collections寻找特定的抽象基类：

numbers

或者只是不明确地进行类型检查

或者，或许最重要的是，使用duck-typing，并且不要显式地键入 - 检查你的代码。鸭子打字支持Liskov替换更优雅和更少的冗长。

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)

结论

• 使用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) 实际获取实例的类。
• 使用type显式检查实际的子类或注册的抽象。
• 只是避免在有意义的地方进行类型检查。

Answer 6

您可以使用type()或isinstance()。

>>> type([]) is list
True

警告您可以通过在同名的当前范围内分配变量来破解list或任何其他类型。

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

上面我们看到dict被重新分配给一个字符串，因此测试：

type({}) is dict

...失败。

要解决此问题并谨慎使用type()：

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

Answer 7

虽然这些问题已经很老了，但我偶然发现了一个正确的方法，我认为它仍然需要澄清，至少对于Python 2.x （没有检查Python 3，但由于问题出现在经典课程中，这个版本已经不存在了，这可能并不重要。“

我在这里试图回答标题的问题：如何确定任意对象的类型？关于使用或不使用isinstance的其他建议在许多评论和答案中都很好，但我没有解决这些问题。

type()方法的主要问题是它无法正常使用旧式实例：

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

执行此代码段会产生：

Are o and t instances of the same class? True

我认为，这不是大多数人所期望的。

__class__方法最接近正确性，但它在一个关键案例中无法工作：当传入的对象是旧式类时（不是实例！），因为那些对象缺乏这样的属性。

这是我能想到的最小代码片段，它以一致的方式满足这样的合法问题：

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

Answer 8

除了之前的答案之外，值得一提的是collections.abc的存在，其中包含几个补充鸭子类型的抽象基类（ABCs）。

例如，而不是显式检查某些内容是否为包含以下内容的列表：

isinstance(my_obj, list)

你可以，如果你只是想知道你所拥有的物品是否允许获取物品，请使用collections.abc.Sequence：

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

如果您对允许获取，设置和删除项目（即可变序列）的对象严格感兴趣，则您需要选择{{ 1}}。

在那里定义了许多其他ABC，collections.abc.MutableSequence用于可用作地图的对象，Mapping，Iterable等等。在the documentation for collections.abc.

中可以看到所有这些的完整列表

Answer 9

小心使用isinstance

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

但输入

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

Answer 10

value = 12
print(type(value)) # will return <class 'int'> (means integer)

或者你可以这样做

value = 12
print(type(value) == int) # will return true

Answer 11

type()是比isinstance()更好的解决方案，尤其是对于booleans：

True和False只是在python中表示1和0的关键字。因此，

isinstance(True, int)

和

isinstance(False, int)

都返回True。两个布尔值都是整数的实例。 type()更聪明：

type(True) == int

返回False。

Answer 12

通常，您可以从具有类名称的对象中提取字符串，

str_class = object.__class__.__name__

并将其用于比较

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

Answer 13

在许多实际情况下，也可以使用@functools.singledispatch来代替type或isinstance，generic functions用来定义abstract classes（由多个函数组成的函数为不同的类型实现相同的操作）。

换句话说，当您具有如下代码时，您将希望使用它：

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

这是一个小例子：

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

---

此外，我们可以使用Creating All Day Event failing一次覆盖几种类型：

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!

Answer 14

出于完整性考虑，isinstance 将不适用于不是实例的子类型的类型检查。虽然这很合理，但没有一个答案（包括已接受的答案）涵盖了所有答案。为此使用issubclass。

>>> class a(list):
...   pass
... 
>>> isinstance(a, list)
False
>>> issubclass(a, list)
True