How to create an instance of a Metaclass that run on both Python2 and Python3?

Metaclasses are classes that generate other classes. It is an efficient tool for class verification, to prevent sub class from inheriting certain class function, and dynamic generation of classes. Here we will discuss how to create an instance of a Metaclass that runs on both Python 2 and Python 3. Before delving into it, let’s go through the code design for each Python version.  

Python 3

In Python 3, an instance of a metaclass is created while declaring a class, by providing the Metaclass to the metaclass keyword argument. Let’s look into the preferred way of doing this in Python 3.
 

Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

class MetaCls(type):
  def __new__(cls, name, bases, attrs):
    return super(MetaCls, cls).__new__(cls, name, bases, attrs)
    
class C(object, metaclass=MetaCls):
  pass
  
print('Type of class C:',type(C))

chevron_right


Output

Type of class C: <class '__main__.MetaCls'>

Here, we have created a class called C by providing the MetaCls class to the metaclass keyword argument.  You can see the type of class C as MetaCls.

Note: MetaCls is a metaclass that directly inherited from type.

Python 2

Now, let look into, how to create an instance of a metaclass in Python 2. In Python 3, we have seen that the metaclass is mentioned in the keyword argument during class declaration; whereas in Python 2, a metaclass is assigned in the class body by using a __metaclass__ attribute. Let’s see the code below:



Python

filter_none

edit
close

play_arrow

link
brightness_4
code

class MetaCls(type):
  def __new__(cls, name, bases, attrs):
    return super(MetaCls, cls).__new__(cls, name, bases, attrs)
    
class C(object):
  __metaclass__ = MetaCls
    
print(type(C))

chevron_right


Output

<class '__main__.MetaCls'>

Metaclass code that runs on both Python 2 and Python 3

Now it’s clear how the syntax differs in Python 2 and Python 3. This difference in syntax may create trouble if you are trying to migrate your Python 2 code to Python 3. Since Python 3 is backward incompatible, the Python 3 syntax doesn’t execute on Python 2 and vice versa.

Here comes the importance of a tool called six. It provides two ways to declare a metaclass that ensures cross-compatibility. 

  1. By creating a stand-in class
  2. As a decorator

In the first method, we will create a stand-in class and use it as a direct subclass. Let’s look into the below code.

Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

import six
  
class MetaCls(type):
  def __new__(cls, name, bases, attrs):
    return super(MetaCls, cls).__new__(cls, name, bases, attrs)
    
class C(six.with_metaclass(MetaCls)):
  pass
  
print(type(C))

chevron_right


Output

<class '__main__.Meta'>

Now, let’s see how to create an instance of metaclass by using a decorator. 

Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

import six
  
class MetaCls(type):
  def __new__(cls, name, bases, attrs):
    return super(MetaCls, cls).__new__(cls, name, bases, attrs)
    
@six.add_metaclass(MetaCls)
class C(object):
  pass
  
print(type(C))

chevron_right


Output

<class '__main__.MetaCls'>



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.