关于Python的类型：如何确定对象的类型？


Determine the type of an object?

有没有一种简单的方法来确定变量是列表、字典还是其他什么？我正在取回一个可能是任何一种类型的物体，我需要能够分辨出其中的区别。

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
>>> type([]) is list
True
>>> type({}) is dict
True
>>> type('') is str
True
>>> type(0) is int
True
>>> type({})
<type 'dict'>
>>> type([])
<type 'list'>

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

1
2
3
4
5
6
7
8
9
10
>>> class Test1 (object):
        pass
>>> class Test2 (Test1):
        pass
>>> a = Test1()
>>> b = Test2()
>>> type(a) is Test1
True
>>> type(b) is Test2
True

注意，type()只返回对象的直接类型，但不能告诉您类型继承。

1
2
>>> type(b) is Test1
False

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

1
2
3
4
5
6
7
8
9
10
11
12
>>> 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：

1
2
>>> isinstance([], (tuple, list, set))
True
相关讨论

您可以使用type()来实现：

1
2
3
4
5
6
>>> a = []
>>> type(a)
<type 'list'>
>>> f = ()
>>> type(f)
<type 'tuple'>

使用try和except块可能更像是一种Python。这样，如果你有一个类像列表一样嘎嘎叫，或者像口述一样嘎嘎叫，那么不管它的类型是什么，它都会表现得很好。

为了澄清，变量类型之间"说明差异"的首选方法是使用一种称为duck类型的方法：只要变量响应的方法(和返回类型)是您的子例程所期望的，就按您期望的方式处理它。例如，如果有一个类用getattr和setattr重载了括号运算符，但使用了一些有趣的内部方案，那么它应该像字典一样工作，如果这是它试图模拟的。

type(A) is type(B)检查的另一个问题是，如果A是B的一个子类，则在程序上希望它是true时，它将评估为false。如果一个对象是一个列表的子类，它应该像一个列表一样工作：检查另一个答案中显示的类型将防止这种情况发生。(不过，isinstance将起作用)。

相关讨论

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

1
__class__

属性。这是从python 3.3控制台获取的示例

1
2
3
4
5
6
7
8
9
10
11
12
>>> 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和新样式类(可以从python 2.6中选择)中，类和类型已经合并，这有时会导致意外的结果。主要是因为这个原因，我最喜欢的测试类型/类的方法是使用isInstance内置函数。

相关讨论

确定python对象的类型

用type确定对象的类型

1
2
3
>>> obj = object()
>>> type(obj)
<class 'object'>

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

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

类型检查

Is there a simple way to determine if a variable is a list, dictionary, or something else? I am getting an object back that may be either type and I need to be able to tell the difference.

好吧，这是一个不同的问题，不要使用类型使用的isinstance：

1
2
3
4
5
6
7
8
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替换原则，您希望能够在不破坏代码的情况下使用子类实例——而isinstance支持这一点。

使用摘要

更好的是，您可以从collections或numbers中查找特定的抽象基类：

1
2
3
4
5
6
7
8
9
10
11
12
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)

或者只是不显式地进行类型检查

或者，也许最重要的是，使用duck类型，不要显式地键入检查代码。duck类型支持以更优雅和更少冗长的方式替换liskov。

1
2
3
4
5
6
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实际获取实例的类。
  • 使用isinstance明确检查实际的子类或注册的摘要。
  • 并且避免在有意义的地方进行类型检查。
相关讨论

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

1
2
>>> type([]) is list
True

请注意，您可以通过在当前相同名称的范围内分配一个变量来删除list或任何其他类型。

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

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

1
type({}) is dict

……失败了。

要绕过这个问题，更谨慎地使用type()：

1
2
3
4
5
6
7
8
9
>>> import __builtin__
>>> the_d = {}
>>> type({}) is dict
True
>>> dict =""
>>> type({}) is dict
False
>>> type({}) is __builtin__.dict
True
相关讨论

虽然问题已经很老了，但我在找到合适的方法的时候偶然发现了这一点，我认为它仍然需要澄清，至少对于python 2.x而言(没有检查python 3，但是由于这个问题是由经典类引起的，而这些类都是在这个版本中出现的，所以这可能无关紧要)。

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

type()方法的主要问题是它不能在旧样式的实例中正常工作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

执行此代码段将产生：

1
Are o and t instances of the same class? True

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

__class__方法是最接近正确性的方法，但在一个关键的情况下它不会起作用：当传入对象是一个旧式类(而不是实例！)，因为这些对象缺少此类属性。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/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

小心使用IsInstance

1
2
3
4
isinstance(True, bool)
True
>>> isinstance(True, int)
True

但类型

1
2
3
4
type(True) == bool
True
>>> type(True) == int
False

除了前面的答案外，值得一提的是，collections.abc的存在，它包含了几个抽象基类(abc)，这些抽象基类是duck类型的补充。

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

1
isinstance(my_obj, list)

如果您只想查看您拥有的对象是否允许获取项目，可以使用collections.abc.Sequence：

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

如果您对允许获取、设置和删除项目(即可变序列)的对象非常感兴趣，那么您可以选择collections.abc.MutableSequence。

这里还定义了许多其他的abc，Mapping表示可以用作地图的对象，Iterable、Callable等。所有这些的完整列表可以在collections.abc的文档中看到。