Old-Style vs. New-Style Classes

In the Python realm, a classcan be one of two varieties. No official terminology has been decided on, so they are informally referred to as old-style and new-style classes.

>>>classFoo:...pass...>>>x=Foo()>>>x.__class__<class __main__.Foo at 0x000000000535CC48>>>>type(x)<type 'instance'>

>>>classFoo:...pass>>>obj=Foo()>>>obj.__class__<class '__main__.Foo'>>>>type(obj)<class '__main__.Foo'>>>>obj.__class__istype(obj)True

>>>n=5>>>d={'x':1,'y':2}>>>classFoo:...pass...>>>x=Foo()>>>forobjin(n,d,x):...print(type(obj)isobj.__class__)...TrueTrueTrue

Type and Class

In Python 3, all classes are new-style classes. Thus, in Python 3 it is reasonable to refer to an object’s type and its class interchangeably.

Remember that,in Python, everything is an object. Classes are objects as well. As a result, a class must have a type. What is the type of a class?

Consider the following:

>>>classFoo:...pass...>>>x=Foo()>>>type(x)<class '__main__.Foo'>>>>type(Foo)<class 'type'>

The type ofx is classFoo, as you would expect. But the type ofFoo, the class itself, istype. In general, the type of any new-style class istype.

The type of the built-in classes you are familiar with is alsotype:

>>>fortinint,float,dict,list,tuple:...print(type(t))...<class 'type'><class 'type'><class 'type'><class 'type'><class 'type'>

For that matter, the type oftype istype as well (yes, really):

>>>type(type)<class 'type'>

type is a metaclass, of which classes are instances. Just as an ordinary object is an instance of a class, any new-style class in Python, and thus any class in Python 3, is an instance of thetype metaclass.

In the above case:

• x is an instance of classFoo.
• Foo is an instance of thetype metaclass.
• type is also an instance of thetype metaclass, so it is an instance of itself.

Defining a Class Dynamically

The built-intype() function, when passed one argument, returns the type of an object. For new-style classes, that is generally the same as theobject’s__class__ attribute:

>>>type(3)<class 'int'>>>>type(['foo','bar','baz'])<class 'list'>>>>t=(1,2,3,4,5)>>>type(t)<class 'tuple'>>>>classFoo:...pass...>>>type(Foo())<class '__main__.Foo'>

You can also calltype() with three arguments—type(<name>, <bases>, <dct>):

• <name> specifies the class name. This becomes the__name__ attribute of the class.
• <bases> specifies a tuple of the base classes from which the class inherits. This becomes the__bases__ attribute of the class.
• <dct> specifies anamespace dictionary containing definitions for the class body. This becomes the__dict__ attribute of the class.

Callingtype() in this manner creates a new instance of thetype metaclass. In other words, it dynamically creates a new class.

In each of the following examples, the top snippet defines a class dynamically withtype(), while the snippet below it defines the class the usual way, with theclass statement. In each case, the two snippets are functionally equivalent.

>>>Foo=type('Foo',(),{})>>>x=Foo()>>>x<__main__.Foo object at 0x04CFAD50>

>>>classFoo:...pass...>>>x=Foo()>>>x<__main__.Foo object at 0x0370AD50>

>>>Bar=type('Bar',(Foo,),dict(attr=100))>>>x=Bar()>>>x.attr100>>>x.__class__<class '__main__.Bar'>>>>x.__class__.__bases__(<class '__main__.Foo'>,)

>>>classBar(Foo):...attr=100...>>>x=Bar()>>>x.attr100>>>x.__class__<class '__main__.Bar'>>>>x.__class__.__bases__(<class '__main__.Foo'>,)

>>>Foo=type(...'Foo',...(),...{...'attr':100,...'attr_val':lambdax:x.attr...}...)>>>x=Foo()>>>x.attr100>>>x.attr_val()100

>>>classFoo:...attr=100...defattr_val(self):...returnself.attr...>>>x=Foo()>>>x.attr100>>>x.attr_val()100

>>>deff(obj):...print('attr =',obj.attr)...>>>Foo=type(...'Foo',...(),...{...'attr':100,...'attr_val':f...}...)>>>x=Foo()>>>x.attr100>>>x.attr_val()attr = 100

>>>deff(obj):...print('attr =',obj.attr)...>>>classFoo:...attr=100...attr_val=f...>>>x=Foo()>>>x.attr100>>>x.attr_val()attr = 100

Custom Metaclasses

Consider again this well-worn example:

>>>classFoo:...pass...>>>f=Foo()

The expressionFoo() creates a new instance of classFoo. When the interpreter encountersFoo(), the following occurs:

• The__call__() method ofFoo’s parent class is called. SinceFoo is a standard new-style class, its parent class is thetype metaclass, sotype’s__call__() method is invoked.

• That__call__() method in turn invokes the following:

  • __new__()
  • __init__()

IfFoo does not define__new__() and__init__(), default methods are inherited fromFoo’s ancestry. But ifFoo does define these methods, they override those from the ancestry, which allows for customized behavior when instantiatingFoo.

In the following, a custom method callednew() is defined and assigned as the__new__() method forFoo:

>>>defnew(cls):...x=object.__new__(cls)...x.attr=100...returnx...>>>Foo.__new__=new>>>f=Foo()>>>f.attr100>>>g=Foo()>>>g.attr100

This modifies the instantiation behavior of classFoo: each time an instance ofFoo is created, by default it is initialized with an attribute calledattr, which has a value of100. (Code like this would more usually appear in the__init__() method and not typically in__new__(). This example is contrived for demonstration purposes.)

Now, as has already been reiterated, classes are objects too. Suppose you wanted to similarly customize instantiation behavior when creating a class likeFoo. If you were to follow the pattern above, you’d again define a custom method and assign it as the__new__() method for the class of whichFoo is an instance.Foo is an instance of thetype metaclass, so the code looks something like this:

# Spoiler alert:  This doesn't work!>>>defnew(cls):...x=type.__new__(cls)...x.attr=100...returnx...>>>type.__new__=newTraceback (most recent call last):  File"<pyshell#77>", line1, in<module>type.__new__=newTypeError:can't set attributes of built-in/extension type 'type'

Except, as you can see, you can’t reassign the__new__() method of thetype metaclass. Python doesn’t allow it.

This is probably just as well.type is the metaclass from which all new-style classes are derived. You really shouldn’t be mucking around with it anyway. But then what recourse is there, if you want to customize instantiation of a class?

One possible solution is a custom metaclass. Essentially, instead of mucking around with thetype metaclass, you can define your own metaclass, which derives fromtype, and then you can muck around with that instead.

The first step is to define a metaclass that derives fromtype, as follows:

>>>classMeta(type):...def__new__(cls,name,bases,dct):...x=super().__new__(cls,name,bases,dct)...x.attr=100...returnx...

The definition headerclass Meta(type): specifies thatMeta derives fromtype. Sincetype is a metaclass, that makesMeta a metaclass as well.

Note that a custom__new__() method has been defined forMeta. It wasn’t possible to do that to thetype metaclass directly. The__new__() method does the following:

• Delegates viasuper() to the__new__() method of the parent metaclass (type) to actually create a new class
• Assigns the custom attributeattr to the class, with a value of100
• Returns the newly created class

Now the other half of the voodoo: Define a new classFoo and specify that its metaclass is the custom metaclassMeta, rather than the standard metaclasstype. This is done using themetaclass keyword in the class definition as follows:

>>>classFoo(metaclass=Meta):...pass...>>>Foo.attr100

Voila!Foo has picked up theattr attribute automatically from theMeta metaclass. Of course, any other classes you define similarly will do likewise:

>>>classBar(metaclass=Meta):...pass...>>>classQux(metaclass=Meta):...pass...>>>Bar.attr,Qux.attr(100, 100)

In the same way that a class functions as a template for the creation of objects, a metaclass functions as a template for the creation of classes. Metaclasses are sometimes referred to asclass factories.

Compare the following two examples:

Object Factory:

>>>classFoo:...def__init__(self):...self.attr=100...>>>x=Foo()>>>x.attr100>>>y=Foo()>>>y.attr100>>>z=Foo()>>>z.attr100

Class Factory:

>>>classMeta(type):...def__init__(...cls,name,bases,dct...):...cls.attr=100...>>>classX(metaclass=Meta):...pass...>>>X.attr100>>>classY(metaclass=Meta):...pass...>>>Y.attr100>>>classZ(metaclass=Meta):...pass...>>>Z.attr100

Is This Really Necessary?

As simple as the above class factory example is, it is the essence of how metaclasses work. They allow customization of class instantiation.

Still, this is a lot of fuss just to bestow the custom attributeattr on each newly created class. Do you really need a metaclass just for that?

In Python, there are at least a couple other ways in which effectively the same thing can be accomplished:

Simple Inheritance:

>>>classBase:...attr=100...>>>classX(Base):...pass...>>>classY(Base):...pass...>>>classZ(Base):...pass...>>>X.attr100>>>Y.attr100>>>Z.attr100

Class Decorator:

>>>defdecorator(cls):...classNewClass(cls):...attr=100...returnNewClass...>>>@decorator...classX:...pass...>>>@decorator...classY:...pass...>>>@decorator...classZ:...pass...>>>X.attr100>>>Y.attr100>>>Z.attr100

Conclusion

As Tim Peters suggests,metaclasses can easily veer into the realm of being a “solution in search of a problem.” It isn’t typically necessary to create custom metaclasses. If the problem at hand can be solved in a simpler way, it probably should be. Still, it is beneficial to understand metaclasses so that you understandPython classes in general and can recognize when a metaclass really is the appropriate tool to use.