Python Dunder and Magic Methods

Python Dunder Methods In Python, there is a set of special methods, called ‘Dunder’ methods, which is derived from ‘double-under’, since they use double underscores as prefix and suffix, like in __init__ or __len__ . Often, these methods are also referred to as ‘magic methods’, making them look more complicated, although there is really nothing magical about them. At the end of the day – they are just another Python feature.

These so-called Dunders give us the possibility to emulate built-in behavior, in other words, to change the built-in functions to behave the way we want them to. To understand these magic methods, let’s go through some important keywords:

1. Class – Category of things that have common attributes or properties
2. Object – Single instance of the class, able to perform the functionalities from the class
3. Self – The key to the attributes and methods in the class
4. __init__ - Initialization of the attributes in a class, also called a constructor in object-oriented concepts, invoked when an object is created
5. Overriding – Giving a new value to an attribute that already has value

Now let’s try to code something simple: class Vehicle:

class Vehicle:
    # simple class called vehicle
    def __init__(self, wheels=2):
        # constructing the vehicle, supposing that it has at least two wheels
        self.wheels = wheels
    # setting the class attribute wheels to a value from the object

bicycle = Vehicle()  # new object, 2 wheels by default
car = Vehicle(4)  # another object, 4 wheels passed as a parameter

Explanation:

__init__ can be also referred as a constructor of the class as it is the method which runs automatically whenever a new object is created.

So far, we created a class vehicle we instantiated a parameter wheels, with a default value of 2. Then we created two objects, from which one has a parameter. If we pass an integer in the object, it will override the number of wheels, like in the object ‘car’. The __init__ method takes care of the object creation. If we try to print the ‘car’ object:

This returns the class name, pointing that this is an object from it and its current address in memory. What if we want to print the number of wheels? We can add the function __str__, this allows us to make a printable version of an object. Let’s see this in code:

class Vehicle:
    # simple class called vehicle

    def __init__(self, wheels=2):
        # constructing the vehicle, supposing that it has at least two wheels
        self.wheels = wheels
        # setting the class attribute wheels to a value from the object

    def __str__(self):
        # printable object method
        return "Number of wheels: {}".format(self.wheels)
        # print the number of wheels


car = Vehicle(4)  # new object, with a passed value
print(str(car))  # calling the overridden function str, so we can print the object

Every built-in method has a dunder method. In fact, all logical operators have a built-in method, for example: ‘+’ has a correspondent method called __add__, ‘-’ has __sub__ and they can also be overloaded. You can take a look at method overloading for more details. Let’s list through some of the most important special methods.

Of course, there are many more dunder methods and these are just a part of the whole Python built-in method list. To get the hang of it, it requires practice. Also, you can list all the dunder methods with code. To explore we can use the __dict__ method, simply type this:

print(list.__dict__)

According to Python documentation, every object has an attribute, which is denoted in __dict__. This dictionary method is also called mappingproxy. We will go through the __dict__ method in the following example.

Now let’s imagine that we want to create a school class that contains details about student grades. What we also want, is an easy way to count out the students. Let’s code this.

class Student:
    def __init__(self, ids, name):
        self.ids, self.name = ids, name

    def __str__(self):
        return f"Student: {self.name}, ID: {self.ids}"


# class Student, requires ID and Name of student, uses str() to return the student


class School:
    def __init__(self, students, grades):
        self.students, self.grades = students, grades

    def __len__(self):
        return len(self.students)


# class School, requires student – uses object from class Student, and grades, len() returns the number of students

students = [
    Student(1, "Billy"),
    Student(2, "Ann"),
    Student(3, "Chris"),
]  # creating object students
grades = ["C-", "B", "A+"]  # creating the grades for each student

school = School(students, grades)  # creating object School with the created values
print(len(school))  # returning the number of students in the school

This works, but what if we want to manage the student grades? So far, students are not accessible, let’s try __setitem__ and __getitem__.

class Student:
    def __init__(self, ids, name):
        self.ids, self.name = ids, name

    def __str__(self):
        return f"Student: {self.name}, ID: {self.ids}"


class School:
    def __init__(self, student, grades):
        self.student, self.grades = student, grades

    def __len__(self):
        return len(self.student)

    # ADDED: Change the grade of a certain student
    def __setitem__(self, key, value):
        self.grades[key] = value

    # ADDED: Return the grade from a certain student
    def __getitem__(self, key):
        return self.student[key].name, self.grades[key]


students = [Student(1, "Billy"), Student(2, "Ann"), Student(3, "Chris")]
grades = ["C-", "B", "A+"]

school = School(students, grades)
print(len(school))

print(school[0])  # Prints the 0th student, name and grade

school[0] = "B"  # Billy got a ‘B’ now!
print(school[0])  # Prints the 0th student, name and grade again, only updated.

Output​

Now, let’s call the __dict__ method from the class names. 

print(School.__dict__)
print(Student.__dict__)

This method allows us to observe the functionalities built in the classes. It is also possible to call the dict method to access specific functions, simply by typing:

print(School.__dict__['__init__'])

and the output is:

This is another useful feature in Python that allows users to analyze huge classes easily. Having all these ‘tricks up the sleeve’ is exceptionally important when a problem occurs. To master the dunder methods, you need to implement code on your own. Certain things can only be learned through typing code. These magic methods are extremely useful to make a class interactive. They make the class compatible with the built-in methods. Another bonus is that you don’t need to remember the name of the function, you just remember the built-in methods. This way, Python is consistent with its syntax.