These are the methods that start and end with double underscores (e.g., __init__(), __str__()). They have special meaning to Python and help us customize our classes without having to write a ton of boilerplate code.
But what about metaclasses? What’s all the fuss about them? Well, in short, they allow us to create new types (classes) at runtime. This can be useful for creating dynamic class hierarchies or adding custom behavior to existing classes without having to modify their source code.
Now lets talk about some common special methods and how we might use them:
– __init__(): This is the constructor method that gets called when a new object of our class is created. It allows us to initialize any necessary data or perform other setup tasks for our objects. For example, in our SillyClass from earlier, we could add some more initialization logic like this:
# Define a class called SillyClass
class SillyClass:
# Define the constructor method that gets called when a new object of our class is created
def __init__(self):
# Initialize an empty list as an attribute of the object
self.data = []
# Define the rest of the class definition here
# Define a method that determines the behavior of `self[key]`
def __getitem__(self, key):
# Return a value from a list based on the given key
return [True, False, True, False][key % len(self.data)]
# Define a method that determines the behavior of `self ** other`
def __pow__(self, other):
# Return a string
return "Python Like You Mean It"
In this example, we’re initializing an empty list called data in our constructor method. This will be used later by the __getitem__() special method to provide a nonsensical response when accessing elements of our object using indexes.
– __str__(): This is the string representation of our class. It gets called whenever we print or convert an instance of our class to a string. For example, in our SillyClass from earlier, we could add some custom behavior for this special method like this:
# This is a class definition for a class called SillyClass
class SillyClass:
# This is the constructor method for the class, it initializes the class with an empty list
def __init__(self):
self.data = []
# This is a special method that determines the behavior of indexing the class using square brackets
def __getitem__(self, key):
# This method returns a value from a list based on the given key
return [True, False, True, False][key % len(self.data)]
# This is a special method that determines the behavior of using the power operator on the class
def __pow__(self, other):
# This method returns a string when the power operator is used on the class
return "Python Like You Mean It"
# This is a special method that determines the string representation of the class
def __str__(self):
# This method returns a string with the number of items in the class
return f'SillyClass({len(self.data)} items)'
In this example, we’re returning a string representation that includes the number of items in our data list. This can be useful for debugging or logging purposes.
– __call__(): This is the method that gets called when an object of our class is invoked as if it were a function. For example, lets say we have a custom calculator class:
# Define a class called Calculator
class Calculator:
# Define a constructor method that initializes the class with two variables, num1 and num2, both set to 0
def __init__(self):
self.num1 = 0
self.num2 = 0
# Define a method called add that takes in a number as a parameter and adds it to the internal storage variable, num1
def add(self, num):
self.num1 += num
# Define a method called subtract that takes in a number as a parameter and subtracts it from the internal storage variable, num2
def subtract(self, num):
self.num2 -= num
# Define a method called __call__ that gets called when an object of our class is invoked as if it were a function
def __call__(self, op):
# Check if the operation is addition
if op == '+':
# Call the add method and pass in the operation as a parameter, then call the subtract method and pass in the operation as a parameter
return self.add(op) + self.subtract(op)
# Check if the operation is subtraction
elif op == '-':
# Call the add method and pass in the operation as a parameter, then call the subtract method and pass in the operation as a parameter
return self.add(op) self.subtract(op)
# If the operation is neither addition nor subtraction, raise a ValueError
else:
raise ValueError('Invalid operation')
In this example, we’re defining a custom calculator class that allows us to add and subtract numbers using the __call__() special method. This can be useful for creating dynamic function-like behavior without having to write boilerplate code for each operation.
Now lets talk about metaclasses. In short, they allow us to create new types (classes) at runtime. For example:
# This script defines a metaclass called MyMetaclass, which will be used to create a new type (class) at runtime.
class MyMetaclass(type):
# The __new__() method is used to create and return a new instance of the class.
# It takes in the metaclass, name of the class, base classes, and attributes as parameters.
def __new__(cls, name, bases, attrs):
# Custom behavior can be added here before creating the new class.
# The super() function is used to access and call methods from the parent class.
# In this case, it calls the __new__() method of the metaclass to create the new class.
return super().__new__(cls, name, bases, attrs)
# A new class called MyClass is created, using the MyMetaclass as its metaclass.
# This allows for dynamic creation of classes at runtime.
class MyClass(metaclass=MyMetaclass):
pass
In this example, we’re defining a new metaclass called MyMetaclass that will be used to create our custom classes. The __new__() method gets called when a new object of our metaclass is created (i.e., when we define a new class using the metaclass keyword). This can be useful for adding custom behavior or constraints to our class definitions without having to modify their source code.