如何检查一个变量是否是一个类？

问题描述：

我想知道如何检查一个变量是否是一个类（而不是一个实例！）。

我曾尝试使用该函数isinstance(object, class_or_type_or_tuple)来执行此操作，但我不知道类会具有什么类型。

例如，在下面的代码中

class Foo:
    pass

isinstance(Foo, **???**) # i want to make this return True.

class我尝试用???替换“ ” ，但我意识到那class是 python 中的一个关键字。

解决方案 1：

甚至更好：使用该inspect.isclass功能。

>>> import inspect
>>> class X(object):
...     pass
... 
>>> inspect.isclass(X)
True

>>> x = X()
>>> isinstance(x, X)
True
>>> inspect.isclass(x)
False

解决方案 2：

>>> class X(object):
...     pass
... 
>>> type(X)
<type 'type'>
>>> isinstance(X,type)
True

解决方案 3：

inspect.isclass 可能是最好的解决方案，而且很容易看出它是如何实际实现的

def isclass(obj):
    """Return true if the obj is a class.

    Class objects provide these attributes:
        __doc__         documentation string
        __module__      name of module in which this class was defined"""
    return isinstance(obj, (type, types.ClassType))

解决方案 4：

此检查与 Python 2.x 和 Python 3.x 兼容。

import six
isinstance(obj, six.class_types)

这基本上是一个包装函数，执行与 andrea_crotti 答案中相同的检查。

例子：

>>> import datetime
>>> isinstance(datetime.date, six.class_types)
>>> True
>>> isinstance(datetime.date.min, six.class_types)
>>> False

解决方案 5：

inspect.isclass()Benjamin Peterson 关于这项工作的用法是正确的。但请注意，您可以使用内置函数issubclassClass来测试某个对象是否为特定的Class，因此隐式地为。根据您的用例，这可能更具 Python 风格。Class

from typing import Type, Any
def isclass(cl: Type[Any]):
    try:
        return issubclass(cl, cl)
    except TypeError:
        return False

然后可以像这样使用：

>>> class X():
...     pass
... 
>>> isclass(X)
True
>>> isclass(X())
False

解决方案 6：

class Foo：被称为旧式类，class X(object)：被称为新式类。

检查一下Python 中旧式和新式类有什么区别？建议使用新式。阅读“统一类型和类”

解决方案 7：

最简单的方法是使用inspect.isclass得票最多的答案中发布的方法。

实现细节可以在python2 inspect和python3 inspect中找到。

对于新式类：isinstance(object, type)

对于旧式类：isinstance(object, types.ClassType)

em，对于旧式类，它使用，这里是来自types.pytypes.ClassType的代码：

class _C:
    def _m(self): pass
ClassType = type(_C)

解决方案 8：

嗯，inspect.isclass对我来说不起作用，试试这个

class foo:
    pass

var = foo()

if str(type(var)).split(".")[0] == "<class '__main__":
    print("this is a class")
else:
    print(str(type(var)).split(".")[0])

type(var)所以基本上，<class 'a type'>

例如：<class 'int'
但是，当var是一个类时，它会出现类似<class '__main__.classname'>

因此，我们将字符串拆分成<class '__main__，然后进行比较if，如果字符串完全匹配，那么它就是一个类

解决方案 9：

如果您使用类装饰器，inspect.isclass()则将不起作用，因为该类由函数包装。相反，inspect.unwrap()请先使用，然后用 进行测试inspect.isclass()。

例子：

import functools
import inspect

def class_decorator(cls):
    @functools.wraps(cls)
    def wrapper(*args, **kwargs):
        return cls(*args, **kwargs)
    return wrapper

@class_decorator
class Spam:
    pass

print(inspect.isclass(Spam)) # False
print(type(Spam)) # class 'function'

print(inspect.isclass(inspect.unwrap(Spam))) # True
print(inspect.unwrap(Spam)) # class 'Spam'

解决方案 10：

我发现并成功使用的最简单的解决方案是：

 def isclass(cls):
    return str(type(cls)).startswith("<class") and hasattr(cls, '__weakref__')

解决方案 11：

检查type(X) is type

>>> type(Exception) is type
True

>>> type(3) is type
False

>>> class Dummy: pass
>>> type(Dummy) is type
True

受到S.Lott 的回答的启发。

解决方案 12：

简短的回答是，在 Python 中，类的类型是 type。如果它是一个对象，那么类型将是其他类型。奇怪的是，在玩了一会儿之后，我发现下面就是你所需要的。为什么没有一行代码的内置方法，我不知道。下面的图片是我尝试的所有操作的终端截图，因为我还不能上传图片。我会给你它的要点：

class MyClass:
   def __init__(self, x):
       self.x = x;

myobj = MyClass(2);
myobj.x;#2
isinstance(myobj, MyClass);#True
isinstance(MyClass, MyClass);#False
MyClass == MyClass;#True
isinstance(MyClass, str);#False
type(myobj) == object;#False
type(myobj);#<class '__main__.MyClass'>
myobj.__class__#<class '__main__.MyClass'>
a = 10;
a.__class__#<class 'int'>
MyClass.__class__#<class 'type'>
type(MyClass);#<class 'type'>
def isClass(val): return (type(val) == type);
isClass(MyClass);#True
isClass(None);#False
isClass(10);#False

使用 PYTHON SHELL 上的终端内容图像完成。答案如下：

def isClass(val): return (type(val) == type);

终端图片，但我尝试的内容在上面

解决方案 13：

在某些情况下（取决于您的系统），一个简单的测试是查看您的变量是否具有 module 属性。

if getattr(my_variable,'__module__', None):
    print(my_variable, ".__module__ is ",my_variable.__module__)
else:
    print(my_variable,' has no __module__.')

int、float、dict、list、str 等没有 module

解决方案 14：

这里已经有一些可行的解决方案，但这里还有另一个：

>>> import types
>>> class Dummy: pass
>>> type(Dummy) is types.ClassType
True