A metaclass is the class of a class. A class defines how an instance of the class (ie an object) behaves, while a metaclass defines how a class behaves. A class is an instance of a metaclass.

While in Python you can use arbitrary calls for metaclasses (as Jerub shows), the best approach is to make it an actual class. type is the usual metaclass in Python. type is itself a class, and is its own type. You won't be able to recreate something like type purely in Python, but Python cheats a bit. To create your own metaclass in Python, you really just want to create a type subclass.

A metaclass is most commonly used as a class factory. When you create an object by calling the class, Python creates a new class (when it executes the 'class' statement) by calling the metaclass. In combination with the normal __init__ and __new__ methods, metaclasses allow you to do 'extra things' when creating a class, like register the new class with some registry, or replace the class with something else entirely.

When the class statement is executed, Python first executes the body of the class statement as a normal code block. The resulting namespace (a dict) contains the attributes of the future class. The metaclass is determined by looking at the base classes of the future class (metaclasses are inherited), the __metaclass__ attribute of the future class (if it exists), or the __metaclass__ global variable. The metaclass is then called with the name, bases, and attributes of the class to instantiate it.

However, metaclasses actually define the type of a class, not just a factory for it, so you can do a lot more with them. You can, for example, define normal methods in the metaclass. These metaclass methods are like class methods in that they can be called on the class without an instance, but they are also not like class methods in that they cannot be called on an instance of the class. type.__subclasses__() is an example of a method on the type metaclass. You can also define the normal 'magic' methods, such as __add__ , __iter__ and __getattr__ , to implement or change the behavior of the class.

Here's an aggregated example of the bits and pieces:

 def make_hook(f): """Decorator to turn 'foo' method into '__foo__'""" f.is_hook = 1 return f class MyType(type): def __new__(mcls, name, bases, attrs): if name.startswith('None'): return None # Go over attributes and see if they should be renamed. newattrs = {} for attrname, attrvalue in attrs.iteritems(): if getattr(attrvalue, 'is_hook', 0): newattrs['__%s__' % attrname] = attrvalue else: newattrs[attrname] = attrvalue return super(MyType, mcls).__new__(mcls, name, bases, newattrs) def __init__(self, name, bases, attrs): super(MyType, self).__init__(name, bases, attrs) # classregistry.register(self, self.interfaces) print "Would register class %s now." % self def __add__(self, other): class AutoClass(self, other): pass return AutoClass # Alternatively, to autogenerate the classname as well as the class: # return type(self.__name__ + other.__name__, (self, other), {}) def unregister(self): # classregistry.unregister(self) print "Would unregister class %s now." % self class MyObject: __metaclass__ = MyType class NoneSample(MyObject): pass # Will print "NoneType None" print type(NoneSample), repr(NoneSample) class Example(MyObject): def __init__(self, value): self.value = value @make_hook def add(self, other): return self.__class__(self.value + other.value) # Will unregister the class Example.unregister() inst = Example(10) # Will fail with an AttributeError #inst.unregister() print inst + inst class Sibling(MyObject): pass ExampleSibling = Example + Sibling # ExampleSibling is now a subclass of both Example and Sibling (with no # content of its own) although it will believe it's called 'AutoClass' print ExampleSibling print ExampleSibling.__mro__