Python 检查类的实例

你试过内置的 isinstance()功能吗？

您还可以查看 hasattr(obj, '__class__')，看看对象是否是从某种类类型实例化的。

这有点难以判断你想要什么，但是也许 inspect.isclass(val)是你正在寻找的？

isinstance()在这里是你的朋友。它返回一个布尔值，可以用以下方式检查类型。

if isinstance(obj, (int, long, float, complex)):
print obj, "is a built-in number type"


if isinstance(obj, MyClass):
print obj, "is of type MyClass"

希望这个能帮上忙。

class test(object): pass
type(test)

报税表

<type 'type'>


instance = test()
type(instance)

报税表

<class '__main__.test'>

这是区分他们的一种方法。

def is_instance(obj):
import inspect, types
if not hasattr(obj, '__dict__'):
return False
if inspect.isroutine(obj):
return False
if type(obj) == types.TypeType: # alternatively inspect.isclass(obj)
# class type
return False
else:
return True

我要迟到了，不管怎样，我觉得这样应该行得通。

is_class = hasattr(obj, '__name__')

或者

import inspect
inspect.isclass(myclass)

这里有一个肮脏的把戏。

if str(type(this_object)) == "<type 'instance'>":
print "yes it is"
else:
print "no it isn't"

最近不得不处理类似的事情。

import inspect


class A:
pass


def func():
pass


instance_a = A()


def is_object(obj):
return inspect.isclass(type(obj)) and not type(obj) == type


is_object(A)          # False
is_object(func)       # False
is_object(instance_a) # True

我在这方面也遇到过类似的问题，结果对我很有效:

def isclass(obj):
return isinstance(obj, type)

如果要检查用户定义类的对象而不是具体内置类型的实例，可以检查它是否具有 __dict__属性。

>>> class A:
...     pass
...
>>> obj = A()
>>> hasattr(obj, '__dict__')
True
>>> hasattr((1,2), '__dict__')
False
>>> hasattr(['a', 'b', 1], '__dict__')
False
>>> hasattr({'a':1, 'b':2}, '__dict__')
False
>>> hasattr({'a', 'b'}, '__dict__')
False
>>> hasattr(2, '__dict__')
False
>>> hasattr('hello', '__dict__')
False
>>> hasattr(2.5, '__dict__')
False
>>>

如果您有兴趣检查一个实例是否是任何类的对象，无论是用户定义的还是具体的，那么您可以简单地检查它是否是 Python 中最终的基类 object的实例。

class A:
pass
a = A()
isinstance(a, object)
True
isinstance(4, object)
True
isinstance("hello", object)
True
isinstance((1,), object)
True

是的。因此，您可以使用 hasattr(obj, '__dict__')或 obj is not callable(obj)。

有没有办法检查对象是否是类的实例 具体类的实例，但任何类的实例。

我可以检查一个对象是否不是一个类，不是一个模块，不是一个 但是我对一个简单的解决方案感兴趣。

一个方法，就像你在问题中描述的，是一个排除的过程，检查它是否不是你想要的。我们检查它是类、模块、回溯、异常还是函数。如果是，那么它就不是一个类实例。否则，我们返回 True，这在某些情况下可能非常有用，另外，我们还在此过程中构建了一个小帮助程序库。

下面是一些代码，它们定义了一组类型检查器，然后将它们组合在一起，以排除我们不关心的各种问题。

from types import (
BuiltinFunctionType,
BuiltinMethodType,
FunctionType,
MethodType,
LambdaType,
ModuleType,
TracebackType,
)
from functools import partial
from toolz import curry
import inspect
    

def isfunction(variable: any) -> bool:
return isinstance(
variable,
(
BuiltinFunctionType,
BuiltinMethodType,
FunctionType,
MethodType,
LambdaType,
partial,
curry
),
)
    

isclass = inspect.isclass
    

def ismodule(variable: any) -> bool:
return isinstance(variable, ModuleType)
    

    

def isexception(variable: any) -> bool:
return isinstance(variable, Exception)
    

    

def istraceback(variable: any) -> bool:
return isinstance(variable, TracebackType)
    

    

def isclassinstance(x: any) -> bool:
if isfunction(x) or isclass(x) or ismodule(x) or istraceback(x) or isexception(x):
return False
return True

请记住，从抽象的角度来看，一切都是事物，甚至是事物或函数的类别... ... 但是从实际的角度来看，这可以帮助避免把 MyClass 错当成 my _ class _ instance (python 社区也非正式地使用 PascalCase 对 Snake _ case)

我们可以改进一下