确定对象的类型?

有没有一种简单的方法来确定变量是列表,字典还是其他?我回来的对象可能是任何一种类型,我需要能够分辨出两者之间的区别。

答案

要获取对象的类型,可以使用内置的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

您可以使用type()来做到这一点:

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

使用try ... except块可能更 Pythonic。这样一来,如果你有这叫声也像列表,或叫声也像字典类,它会循规蹈矩,无论什么的类型真的是。

为了明确起见,“告诉变量” 之间的差异的首选方法是使用 “ 鸭子类型” :只要变量响应的方法(和返回类型)是子例程所期望的,就可以像对待期望一样对待它。成为。例如,如果您有一个用getattrsetattr重载方括号运算符的类,但是使用了一些有趣的内部方案,那么如果它试图模仿的话,它就适合充当字典。

另一个问题与type(A) is type(B)检查是,如果A是一个子B ,它的计算结果为false时,编程,你会希望它是true 。如果对象是列表的子类,则它应像列表一样工作:检查其他答案中提供的类型将防止此情况。 (不过, isinstance将起作用)。

在对象的实例上,您还具有:

__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

确定 Python 对象的类型

确定具有类型的对象的type

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

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

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

类型检查

有没有一种简单的方法来确定变量是列表,字典还是其他?我回来的对象可能是任何一种类型,我需要能够分辨出两者之间的区别。

嗯,这是一个不同的问题,不要使用isinstance使用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 的原理,您希望能够使用子类实例而不会破坏您的代码isinstance支持这一点。

使用抽象

更好的是,您可能会从collectionsnumbers寻找特定的抽象基类:

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)

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

或者,也许最重要的是,使用鸭式输入,而不要显式地检查代码。鸭式打字支持 Liskov Substitution 的功能更优雅,更省力。

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()

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

小心使用 isinstance

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

但是输入

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

尽管问题已经很老了,但我偶然发现了这个问题,同时自己找到了正确的方法,我认为仍然需要澄清一下,至少对于 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

除了前面的答案外,值得一提的是collections.abc的存在,其中包含几个补充鸭类输入法的抽象基类(ABC)。

例如,与其显式检查某物是否为列表,不如:

isinstance(my_obj, list)

如果您只想查看自己拥有的对象是否允许获取物品,可以使用collections.abc.Sequence

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

如果您对允许获取,设置删除项目(即可序列)的对象严格感兴趣,则可以选择collections.abc.MutableSequence

在那里定义了许多其他 ABC,用于可用作Mapping的对象的映射IterableCallable等。所有这些的完整列表可以在collections.abc的文档中看到

在许多实际情况下,也可以使用@functools.singledispatch ,而不是使用typeisinstance ,它用于定义通用函数由多个函数组成的函数,这些函数为不同类型实现相同的操作 )。

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

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

另外,我们可以使用抽象类一次覆盖几种类型:

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!