Question

I’m using Python 2.x and I’m wondering if there’s a way to tell if a variable is a new-style class? I know that if it’s an old-style class that I can do the following to find out.

import types

class oldclass:
  pass

def test():
  o = oldclass()
  if type(o) is types.InstanceType:
    print 'Is old-style'
  else:
    print 'Is NOT old-style'

But I haven’t been able to find anything that works for new-style classes. I found this question, but the proposed solutions don’t seem to work as expected, because simple values as are identified as classes.

import inspect

def newclass(object):
  pass

def test():
  n = newclass()
  if inspect.isclass(n):
    print 'Is class'
  else:
    print 'Is NOT class'
  if inspect.isclass(type(n)):
    print 'Is class'
  else:
    print 'Is NOT class'
  if inspect.isclass(type(1)):
    print 'Is class'
  else:
    print 'Is NOT class'
  if isinstance(n, object):
    print 'Is class'
  else:
    print 'Is NOT class'
  if isinstance(1, object):
    print 'Is class'
  else:
    print 'Is NOT class'

So is there anyway to do something like this? Or is everything in Python just a class and there’s no way to get around that?

Answer 1

I think what you are asking is: “Can I test if a class was defined in Python code as a new-style class?”. Technically simple types such as int are new-style classes, but it is still possible to distinguish classes written in Python from the built-in types.

Here’s something that works, although it’s a bit of a hack:

def is_new_style(cls):
    return hasattr(cls, '__class__') \
           and \
           ('__dict__' in dir(cls) or hasattr(cls, '__slots__'))


class new_style(object):
    pass

class old_style():
    pass

print is_new_style(int)
print is_new_style(new_style)
print is_new_style(old_style)

Output from Python 2.6:

False
True
False

Here’s a different way to do it:

def is_new_style(cls):
    return str(cls).startswith('<class ')