Metaclasses in Five Minutes

我就是我 2022-09-30 00:32 139阅读 0赞

[http://www.voidspace.org.uk/python/articles/five-minutes.shtml][http_www.voidspace.org.uk_python_articles_five-minutes.shtml]

*  [Everything is an Object][]
 *  [Honestly, it's True][Honestly_ it_s True]
 *  [The Class of a Class is...][]
 *  [So when you create a class...][]
 *  [Easy to Demonstrate][]
 *  [The Magic of \_\_metaclass\_\_][The Magic of _metaclass]
 *  [In Action...][]
 *  [What can we do with this?][What can we do with this]
 *  [But...][]

Originally a lightning talk first given at [PyCon UK 2008][].

Metaclasses have a reputation for being 'deep-black-magic' in Python. The cases where you need them are genuinely rare (unless you program with Zope...), but the basic principles are surprisingly easy to understand.

# [Everything is an Object][Everything is an Object 1] #

*  Everything is an object
 *  Everything has a type
 *  No real difference between 'class' and 'type'
 *  Classes are objects
 *  Their type is type

Typically the term type is used for the built-in types and the term class for user-defined classes. Since Python 2.2 there has been no real difference and 'class' and 'type' are synonyms.

For classic (old-style) classes, their type is types.ClassType.

# [Honestly, it's True][Honestly_ it_s True 1] #

Python  2.5 .1  ( r251 : 54869 ,  Apr  18  2007 ,  22 : 0 8 : 04 )  
>> >  class  Something ( object ) :  
. . .      pass  
. . .  
>> >  Something  
< class  '\_\_main\_\_.Something' >  
>> >  type ( Something )  
< type  'type' >

Here we can see that a class created at the interactive interpreter is a first class object.

# [The Class of a Class is...][The Class of a Class is... 1] #

Its metaclass...

Just as an object is an instance of its class; a class is an instance of its metaclass.

The metaclass is called to create the class.

*In exactly the same way as any other object in Python.*

# [So when you create a class...][So when you create a class... 1] #

The interpreter calls the metaclass to create it...

For a normal class that inherits from object this means that type is called to create the class:

>>> help(type)
    Help on class type in module __builtin__:
    
    class type(object)
     |  type(object) -> the object's type
     |  type(name, bases, dict) -> a new type

It is this second usage of type that is important. When the Python interpreter executes a class statement (like in the example with the interactive interpreter from a couple of sections back), it calls type with the following arguments:

*  The name of the class as a string
 *  A tuple of base classes - for our example this is the 'one-pl' [\[1\]][1] (object,)
 *  A dictionary containing members of the class (class attributes, methods, etc) mapped by their names

# [Easy to Demonstrate][Easy to Demonstrate 1] #

>> >  def  \_\_init\_\_ ( self ) :  
. . .      self . message  =  'Hello World'  
. . .  
>> >  def  say\_hello ( self ) :  
. . .      print  self . message  
. . .  
>> >  attrs  =  \{  '\_\_init\_\_' :  \_\_init\_\_ ,  'say\_hello' :  say\_hello \}  
>> >  bases  =  ( object , )  
>> >  Hello  =  type ( 'Hello' ,  bases ,  attrs )  
>> >  Hello  
< class  '\_\_main\_\_.Hello' >  
>> >  h  =  Hello ( )  
>> >  h . say\_hello ( )  
Hello  World

This code creates a dictionary of class attributes, and then calls type to create a class called Hello.

# [The Magic of \_\_metaclass\_\_][The Magic of _metaclass 1] #

We can provide a custom metaclass by setting \_\_metaclass\_\_ in a class definition to *any callable that takes the same arguments as type*.

The normal way to do this is to inherit from type:

class  PointlessMetaclass ( type ) :  
     def  \_\_new\_\_ ( meta ,  name ,  bases ,  attrs ) :  
         \# do stuff...  
         return  type . \_\_new\_\_ ( meta ,  name ,  bases ,  attrs )

The important thing is that inside the body of the \_\_new\_\_ method we have access to the arguments passed to create the new class. We can introspect the dictionary of attributes and modify, add or remove members.

It is important to override \_\_new\_\_ rather than \_\_init\_\_. When you instantiate a class both \_\_init\_\_ and \_\_new\_\_ are called. \_\_init\_\_ initialises an instance - but \_\_new\_\_ is responsible for creating it. So if our metaclass is going to customise class creation we need to override \_\_new\_\_ on type.

The reason to use a new type rather than just a factory function is that if you use a factory function (that just calls type) then the metaclass won't be inherited.

# [In Action...][In Action... 1] #

>> >  class  WhizzBang ( object ) :  
. . .      \_\_metaclass\_\_  =  PointlessMetaclass  
. . .  
>> >  WhizzBang  
< class  '\_\_main\_\_.WhizzBang' >  
>> >  type ( WhizzBang )  
< class  '\_\_main\_\_.PointlessMetaClass' >

WhizzBang is a class, but instead of being an instance of type the class object is now an instance of our custom metaclass...

# [What can we do with this?][What can we do with this 1] #

Well (I'm glad you asked)... our metaclass will be called whenever a new class is created that uses it. Here are some ideas:

*  Decorate all methods in a class for logging, or profiling.
 *  Automatically mix-in new methods.
 *  Register classes as they are created. (Auto-register plugins or create a db schema from class members for example.)
 *  Provide interface registration, auto-discovery of features and interface adaptation.
 *  Class verification: prevent subclassing, verify all methods have docstrings.

The important things is that the class is only actually created by the final call to type in the metaclass - so you are free to modify the dictionary of attributes as you see fit (and the name plus the tuple of base classes of course).

Several of the popular Python ORM (Object Relational Mappers for working with databases) use metaclasses in these ways.

Oh, and because metaclasses are inherited so you can provide a base-class that uses your metaclass and sub-classes inherit it without explicitly having to declare it.

# [But...][But... 1] #

I've ever needed to use one in production code... (I have used them for profiling and we make extensive use of them in [Ironclad][] - but I didn't write these.)

Of course all this only applies to Python 2.X. The mechanism changes in Python 3.

> type(type) is type

With Python 2.6 you can now use [class decorators][] to achieve a lot of the things that previously you might have used metaclasses for.

For a truly awful example (with a slightly more in depth but still easy-to-digest look at metaclasses) see [The Selfless Metaclass][]. It does bytecode and method signature rewriting to avoid the need to explicitly declare self. ![Smile][]

<table>       
 <tbody> 
  <tr> 
   <td><a href="http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id2" rel="nofollow">[1]</a></td> 
   <td>A 'one-pl' is tuple with only one element...</td> 
  </tr> 
 </tbody> 
</table>

[http_www.voidspace.org.uk_python_articles_five-minutes.shtml]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml
[Everything is an Object]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#everything-is-an-object
[Honestly_ it_s True]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#honestly-it-s-true
[The Class of a Class is...]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#the-class-of-a-class-is
[So when you create a class...]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#so-when-you-create-a-class
[Easy to Demonstrate]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#easy-to-demonstrate
[The Magic of _metaclass]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#the-magic-of-metaclass
[In Action...]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#in-action
[What can we do with this]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#what-can-we-do-with-this
[But...]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#but
[PyCon UK 2008]: http://pyconuk.org/
[Everything is an Object 1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id4
[Honestly_ it_s True 1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id5
[The Class of a Class is... 1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id6
[So when you create a class... 1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id7
[1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id3
[Easy to Demonstrate 1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id8
[The Magic of _metaclass 1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id9
[In Action... 1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id10
[What can we do with this 1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id11
[But... 1]: http://www.voidspace.org.uk/python/articles/five-minutes.shtml#id12
[Ironclad]: http://code.google.com/p/ironclad
[class decorators]: http://jackdied.blogspot.com/2008/09/pycon-uk-class-decorators-radically.html
[The Selfless Metaclass]: http://www.voidspace.org.uk/python/articles/metaclasses.shtml
[Smile]: http://www.voidspace.org.uk/smilies/smile.gif