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


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

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

type(A) is type(B)检查的另一个问题是,如果AB的一个子类,则在程序上希望它是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支持这一点。

使用摘要

更好的是,您可以从collectionsnumbers中查找特定的抽象基类:

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表示可以用作地图的对象,IterableCallable等。所有这些的完整列表可以在collections.abc的文档中看到。