Python：类实例是类

Question

Is it possible to create a class whose instances are classes?

At first it seemed possible, but I wondered if this would actually be possible without any external interference. Eg:

NewClass = ClassClass(someArgs)
instance = NewClass(someOtherArgs)

Is this possible? If so, how would it structurally work? Is this even useful?

Answer 1

If you check the type of 1 you get type(1) == int . If you check the type of int you get type(int) == type .

A class whose instances are classes is called a metaclass and in Python you create metaclasses by subclassing type .

class ClassClass(type):
    pass

Technically collections.namedtuple is a metaclass, but it's actually cheating .

There's a great PyCon talk by David Beazly about metaprogramming in Python . It's long, but very interesting. He starts talking about metaclasses around the 27 minute mark.

Answer 2

You're looking for metaclasses:

class Foo(type):
    # Foo is a subclass of type and just like instances of type are
    # classes, instances of Foo are classes.
    pass

class Bar(object):
    # The Bar class is an instance of Foo
    __metaclass__ = Foo

# You can also create instances of Foo dynamically.
Bar = Foo("Bar", (object,), {})

More on metaclasses.

Answer 3

From the Python help:

type(name, bases, dict) -> a new type

So lets create a simple class:

Dog = type('Dog', (object,), {})

And now you can create a dog:

fido = Dog()

If you literally want a class that creates classes, you can do it, by extending type... Honestly I have no idea what you want it for, but here it is:

class ClassMaker(type):
    def __new__(self, name):
        return type(name, (object,), {})

NewClass = ClassMaker('NewClass')
print NewClass

Answer 4

In (modern) python, classes are first order objects. This is easy to verify by accessing a class' __class__ property:

class A:
    pass

print(A.__class__)
-> <class 'type'>

Note that type 's class is also type :

print(type.__class__)
-> <class 'type'>

It is possible to actually derive from type :

class A:
    def do(self):
       print("DOING")


class mytype(type):
    def __new__(cls, *args, **kwargs):
        return type.__new__(cls, 'mytype', cls.__bases__, {})

    def __init__(self):
        return type.__init__(self, 'mytype', self.__class__.__bases__, {})

    def __call__(self, *args, **kwargs):
        return A(*args, **kwargs)

aClass = mytype()
-> <class '__main__.mytype'>
aObj = aClass()
print(aObj)
-> <__main__.A object at 0xdeadbeaf>
aObj.do()
-> DOING

However, with proper metaclasses I do not see a good reason jumping through such hoops. Even metaclasses are only needed in special cases. Most often, a factory method that returns a class object is sufficient:

def ClassClass():
    return A

aClass = ClassClass()
aObj = aClass()

Syntax is the same and if the only operation on the factory is instantiation, there is no difference.