How to check a variable is class object or not

Question

Assume a simple class:

class MyClass(object):
    pass

.
.
.
m = MyClass
print type(m) # gets: <type 'classobj'>
# if m is classobj, how can i check a variable is class object?

My question is: how can i check a variable is a class object?

a simple solution:

if str(type(m)) == "<type 'classobj'>":
    # do something

But i think there is at least one classic way to check that.

The code you showed above will not print `` for `type(m)`, because `m` is a new-style class. It will print ``. You'll only get `` for classic classes. — abarnert, Apr 05 '13 at 19:02

score 42 · Answer 1 · answered Apr 05 '13 at 19:07

42

Use inspect:

import inspect
print inspect.isclass(obj)

answered Apr 05 '13 at 19:07

Jochen Ritzel

104,512
31
200
194

+1 for inspect module – pylover Apr 05 '13 at 19:08
Now why didn't I think of that ... (+1) – mgilson Apr 05 '13 at 19:08
I don't know how I forgot this, but this is a better answer than mine (and the equivalents to mine). – abarnert Apr 05 '13 at 19:08
1

@abarnert -- Yes, but yours explains *how* it all works, which is definitely worth keeping around. – mgilson Apr 05 '13 at 19:09
@abarnert -- It's not about what gets accepted ... As long as the community chooses this one, it's all good I think :). – mgilson Apr 05 '13 at 19:10
all your answers are realy best answer. but just for good explanation, abarnert answer has been accepted. – pylover Apr 05 '13 at 19:14
This doesn't work for me in Python 3.9.16. – marvin Jul 17 '23 at 19:13

abarnert · Accepted Answer · 2013-04-05T19:07:09.123

26

In 2.x, a class object can be be a type (new-style classes) or a classobj (classic classes). The type type is a builtin, but the classobj type is not. So, how do you get it? That's what the types module is for.

isinstance(MyClass, (types.TypeType, types.ClassType))

In 3.x, you don't need to worry about classic classes, so:

isinstance(MyClass, type)

Even if you want to compare the types directly, you should never compare any objects by their str. Compare:

>>> class MyClassicClass:
...     pass
>>> str(type(MyClassicClass)) == "<type 'classobj'>"
True
>>> str("<type 'classobj'>") == "<type 'classobj'>"
True

You can almost always just compare objects directly:

>>> type(MyClassicClass) == types.ClassType
True
>>> "<type 'classobj'>" == types.ClassType
False

(And in the incredibly rare cases where you really do need to compare the string representation for some reason, you want the repr, not the str.)

edited Apr 05 '13 at 19:07

answered Apr 05 '13 at 19:00

abarnert

354,177
51
601
671

1

This is an excellent answer. +1 (more if I could) – mgilson Apr 05 '13 at 19:08
+1. I like Jochen's answer for its simplicity, but this is a good explanation. – Nitzle Apr 05 '13 at 19:10
The [`six`](https://six.readthedocs.io) library has a pre-defined value that covers Python 2 or 3. See `class_types`. – Russell B May 24 '19 at 04:03
Seems like `types.ClassType` doesn't exist any more (at least in Python 3.10) – Sasha O Oct 24 '22 at 16:25

kindall · Answer 3 · 2013-04-05T19:32:04.993

A new-style class (derived explicitly from object as in your example, or implicitly in Python 3) is not of type classobj. Only old-style classes are classobjs. So for your example class as written, you could simply check to see if MyClass is an instance of type, as all new-style classes are:

isinstance(MyClass, type)

Because all new-style classes are derived from object you can also do:

issubclass(MyClass, object)

I would advise against:

type(MyClass) == type

This will fail if the type of a class is not type, but a metaclass. Although there may be use cases for that, of course.

If you really need to see if you've got an old-style class, you can import the types module and use types.ClassType, or just declare an old-style class and see if the class you're testing is of the same type:

class OldStyleClass:
   pass
OldStyleClass = type(OldStyleClass)

isinstance(MyClass, OldStyleClass)

Piotr Hajduga · Answer 4 · 2013-04-05T19:04:24.157

3

Is this what you're looking for?

>>> class A(object):
...    pass
>>> isinstance(A, type)
True

>>> isinstance("asd", type)
False

But works only for classes inherited from object.

edited Apr 05 '13 at 19:04

answered Apr 05 '13 at 18:58

Piotr Hajduga

608
4
13

I'm pretty sure this isn't what OP is looking for. – mgilson Apr 05 '13 at 19:07

sergzach · Answer 5 · 2016-02-19T17:45:56.307

0

Sometimes the next is working (if you want to determine how to print the object):

def is_class(o):
    return hasattr(o, '__dict__')

edited Feb 19 '16 at 17:45

answered Feb 19 '16 at 17:39

sergzach

6,578
7
46
84

most of objects including classes, has this attribute – pylover Sep 15 '16 at 07:10
@pylover Excuse me, I answered to another question: "How to determine if a variable is a class instance". I'm agree with you. But could you give an example of objects which are not classes and have this attribute? – sergzach Sep 17 '16 at 20:56
No, the question is `How to check a variable is class **OBJECT** or not`, not INSTANCE – pylover Sep 18 '16 at 08:25
Your method always return true for either class or instance – pylover Sep 18 '16 at 08:27
@pylover `i = int(5)` is an `object`, because `issubclass(int, object)` is `True`, but the method returns `False` for ints because `int` is not a real user-defined class. so. its not an instance of a real class. – sergzach Sep 18 '16 at 19:46
you don't get the question well as well. – pylover Sep 19 '16 at 08:33

How to check a variable is class object or not

5 Answers5