Here, we have replaced the metaclass (type) with print, just to investigate how it works. This is quite useless, of course, but does show that the metaclass gets called with three arguments when a class is created. The first is the name of the class to be created, the second is a tuple of base classes, and the third is a dictionary that has the namespace of the body of a class, with a few extra special values added.

Given this, we know see show to make this into a class using type: (I will not bother to add __module__ and __qualname__ for now, they are not needed)

class WillBeAClass(object):
    x = 1


WillBeAClass

WillAlsoBeAClass = type("WillAlsoBeAClass", (object,), {"x": 1})
WillAlsoBeAClass

These two objects, WillBeAClass and WillAlsoBeAClass, are basically the same thing. The second method is exactly what the class statement does (with __module__ and __qualname__ added).

The type

So, we are done with metaclasses, that’s all there is to know. However, to actually make useful classes, you probably want to make normal classes, just with some sort of modification. For that, you need to understand type, and how it works, and how to subclass it.

First, let’s pretend we can just patch type and ignore subclassing. You probably already see how to do that:

def newtype(*args):
    print("I'm sort of a new type, but I have a problem!")
    return type(*args)

class NewClass(object, metaclass=newtype):
    x = 1

class NewNewClass(NewClass):
    y = 2

All was fine and well, until we subclassed NewClass. The metaclass did not come along for the ride! That’s because type adds a reference to itself when it creates a class:

NewClass.__class__

Note: the standard way to check the class of an object is to call type(NewClass), however, since that is an unrelated use of type that is there for historical reasons, I’ve avoided using it here)

How type works

We must subclass type to get a metaclass that actually works on subclasses, too: (Here I’m overriding all the used parameters, so that you can see where each gets called)

class NewType(type):
    def __new__(cls, *args, **kargs):
        print("I'm a new type! __new__")
        return super().__new__(cls, *args, **kargs)

    def __init__(self, *args, **kargs):
        print("I'm a new type! __init__")
        super().__init__(*args, **kargs)

    @classmethod
    def __prepare__(cls, *args, **kargs):
        print("I'm new in Python 3! __prepare__")
        return super().__prepare__(cls, *args, **kargs)

    def __call__(self, *args, **kargs):
        print("I'm a new type! __call__")
        return super().__call__(*args, **kargs)

class NewClass(object, metaclass=NewType):
    def __init__(self):
        print("I'm init in the class")

    def __new__(cls):
        print("I'm new")
        return super().__new__(cls)

class NewNewClass(NewClass):
    y = 2

instance = NewClass()

Notice how __init__ was used, too? This gives us a peek at one more feature of metaclasses: the __class__ parameter of a class is used to create instances. The super part of __call__ actually puts together the class, it’s where __new__ and __init__ are called, etc.

Python 3 only

As you already have seen, the __prepare__ method is only in Python 3, and allows you to customize the __dict__ before __new__, however, as a reminder, in CPython the dict for a class is written in C and is not customizable (ie, can’t be ordered, etc). So you’ll have to manage that yourself, but __prepare__ helps. It returns a dictionary-like object that then collects the namespace, then gets passed to __new__.

from collections import OrderedDict


class PrepareMeta(type):
    def __new__(cls, name, bases, ns):
        print(ns)
        return super().__new__(cls, name, bases, ns)

    @classmethod
    def __prepare__(cls, *args, **kargs):
        return OrderedDict()

class PrepareClass(metaclass=PrepareMeta):
    y = 2

We only get that one look at the dict, since it becomes the special C mappingproxy once the class is created.

PrepareClass.__dict__

Another Python 3 only feature is class level arguments. You can do things like this:

class ArgMeta(type):
    def __new__(cls, *args, **kargs):
        print(kargs)
        return super().__new__(cls, *args)

    def __init__(self, *args, **kargs):
        return super().__init__(*args)


class ArgClass(metaclass=ArgMeta, kwarg=2):
    y = 2

Example

A dictionary can be make using the following ugly hack:

class a_dictionary(
    metaclass=lambda name, bases, ns: {n: ns[n] for n in ns if "__" not in n}
):
    one = 1
    two = 2
    three = 3

print(a_dictionary)

An ordered class can be make using the __prepare__ method (Python 3 only):

class OrderedMeta(type):
    def __new__(cls, name, bases, ns):
        ns["orderednames"] = list(ns)
        return super().__new__(cls, name, bases, ns)

    @classmethod
    def __prepare__(cls, *args, **kargs):
        return OrderedDict()

class Ordered(metaclass=OrderedMeta):
    one = 1
    two = 2
    three = 3
    four = 4
    five = 5

print(Ordered.__dict__)

Here we can see that the list orderednames is ordered correctly.