Advanced Python — What are Metaclasses?
In this article, we’ll be discussing Python Metaclasses. What are Metaclasses? How do classes work under the hood in Python? This article will investigate how we can hook into the creation of a class and modify it to fit any desired functionality. Allowing us to enforce constraints on subclasses, remove and monitor attributes and so much more.
Firstly, What is a Metaclass? A Meta class in Python is a class that creates other classes. It can define exactly how they behave and how they function. Because of that, they can get complicated very quickly.
This article will cover only the basic implementation for understanding the concepts behind metaclasses. Because of their complex nature, there are few instances in which metaclasses are required and many of the features implemented in this guide can be accomplished in other ways.
So why learn it at all? Whilst I don’t recommend using these on a regular basis, understanding how metaclasses work gives you a much greater understanding of what Python is doing under the hood when you create a regular class. This can help with your general knowledge of Python, debugging and can even help you show off that extra bit of knowledge in an interview.
I’ve attached python3 code snippets where applicable so you can try it out if you prefer a hands-on approach.
Basics of Python Classes
Before tunneling down the rabbit hole of metaclasses in Python, we must first understand classes. In many languages, classes are essentially just building blocks of code that tell you how to produce an object. We can then instantiate each object to create unique instances of that class.
Below is a basic example of a Python Class:
In the above example we’ve defined some attributes: Name , Breed , and Age . Now that we’ve created this template of what our class is supposed to look like, we can create instances of it.
bailey = Dog("Bailey", "Labrador", 1, False)
print(bailey)#Name: Bailey, Breed: Labrador, Age: 1Defining a __repr__method allows us to access the attributes of the object easily. We can also define methods that will act as actions of what our objects can do as demonstrated by our eat method in our example Dog Class above.
Dynamically creating classes
Where python strays away from many other popular programming languages is the implementation of these classes. In Python, not only are the instances of the classes considered objects, but also the class itself; and since classes are technically objects, we can create them dynamically.
We can use the function type to determine what type an object is. Let’s run through our example code from earlier and find out what type of objects we have.
bailey = Dog("Bailey", "Labrador", 1, False)print(type(bailey))
# <type 'instance'>print(type(Dog))
# <type 'classobj'>We can see now that we have two object types, we have bailey as an instance of the Dog class, but we also have Dog which is a type classobj.
Using this knowledge, we can actually create classes inside our type function.
Whilst this seems odd, it’s actually working as intended. The Syntax works as follows:
- Name — Name of the class
- Bases — Any Classes we inherit from
- Attrs — Any Attributes associated with the same class.
type(name, bases, attrs)Okay, Let’s combine all this together we’ll create a new class using typethat inherits from the Dog class we created in our earlier example.
In the above code, we’ve created a brand new class using our type function (line 24). We’ve inherited from the previous Dog class and also added some extra functionality in an additional variable and method.
Metaclasses
All that sounds amazing, but what does it have to do with Metaclasses?
Well, Metaclasses are just classes that create other classes. That type function we were using earlier wasn’t a function after all. It was actually our first example of a Metaclass. We utilised type to dynamically create our other classes.
Luckily, every time we want to do this, we don’t have to use type. We can create our own metaclass. And that’s exactly what we’re going to do next.
Firstly let’s create a really simple example that exactly mimics the functionality of type and create a new class with it just so we can wrap our head around how this works.
As shown above we’ve created our Metaclass and called it Meta. It’s inherited from the class Type and mimicked its functionality exactly. Now anytime we wanted to use typewe could simply use our newly created Meta class instead.
Unfortunately, this doesn’t really do much of anything at all. There is currently no reason to use our new class instead of type as has exactly the same functionality.
Let’s fix that.
Let’s add a piece of functionality to our newly created Metaclass. For this example, we’re going to ensure that every class created by our Metaclass will automatically inherit from Dog . We’ll also add the pet attribute to the class and set it to be True by default.
There we have it. We’ve created our own metaclass that we can use to dynamically create classes that conform to certain rules.
Now that we have the power to modify the creation of any and all classes. We can utilise this to enforce various constraints, we can add/remove attributes from classes by default, force inheritance to parent classes and so much more. Once you have the ability to hook into the class creation for every single class the possibilities are endless.
Thanks for reading all, hope you’ve enjoyed. Check out my other articles below:
