{"id":32395,"date":"2022-07-30T23:13:37","date_gmt":"2022-07-30T23:13:37","guid":{"rendered":"https:\/\/www.askpython.com\/?p=32395"},"modified":"2026-09-29T17:26:12","modified_gmt":"2026-09-29T17:26:12","slug":"magic-methods","status":"publish","type":"post","link":"https:\/\/www.askpython.com\/python\/oops\/magic-methods","title":{"rendered":"The Magic Methods in Python"},"content":{"rendered":"\n

The magic methods in Python programming language are specifically for Object Oriented Design. Every class that we create has its own magic methods. Python’s standard interpreter assigns these to every class we create inside it. So, in this article, we shall see in detail how to call and use magic methods for a better programming approach. Let the coding fun begin!<\/p>\n\n\n\n

Brushing up OOP knowledge<\/h2>\n\n\n\n

Before we get to the main topic, let us understand and polish the knowledge of OOP concepts. We shall see only the basics. So, Object Oriented Programming is a way of enclosing the data members and member functions into a user-defined entity called a Class<\/strong>. <\/p>\n\n\n\n

Class is something that holds particular data items that relate to each other and communicate in a specific way. We access the properties and the member functions using Object<\/strong>. The object is an instance of a class. In any programming language, memory is never allocated when we create a class, but it is actually created when we create its instance I.e object.<\/p>\n\n\n\n

Example:<\/strong><\/p>\n\n\n\n

The animal<\/b> is a type of class. In that, we include all the living beings that reside on Earth. So, everyone has their own way of living, food, and shelter. The animal just defines the blueprint of all these. For example, the cat is the object of the Animal class. It has four legs, eats mice, and lives in houses or bushes.<\/strong> In the same way, the tiger has four legs but it kills and eats many animals so we say that the tiger eats meat, it lives in the forest.<\/p>\n\n\n\n

Code Example with Python:<\/strong><\/p>\n\n\n

\nclass Animal:\n    def __init__(self, legs, food, shelter):\n        self.legs = legs\n        self.food = food\n        self.shelter = shelter\n        \n    def showAnimal(self):\n        print("The animal has {} legs: ".format(self.legs))\n        print("The animal eats: {}".format(self.food))\n        print("The animal lives in: {}".format(self.shelter))\n        \ncat = Animal(4, "Mouse", "House")\ntiger = Animal(4, "Meat", "Forest")\ncat.showAnimal()\ntiger.showAnimal()\n<\/pre><\/div>\n\n\n
Output:<\/strong><\/p>\n\n\n
\nThe animal has 4 legs: \nThe animal eats: Mouse\nThe animal lives in: House\nThe animal has 4 legs: \nThe animal eats: Meat\nThe animal lives in: Forest\n<\/pre><\/div>\n\n\n
Explanation:<\/strong><\/p>\n\n\n\n
  1. The animal class contains the number of legs, food, and shelter as properties.<\/strong><\/li>
  2. When we create an instance and insert the values inside the constructor, the difference in their behaviour<\/strong> is clear.<\/li>
  3. So, objects of the same class can be different according to the behaviour of values.<\/strong><\/li><\/ol>\n\n\n\n
    The magic methods in OOP<\/h2>\n\n\n\n
    So, in the above example, we have a class as Animal. Python has a set of methods namely Dunder methods<\/strong> that are responsible for holding the properties, data members, and member functions of a class.<\/p>\n\n\n\n
    Definition: When we create an object, the Python interpreter calls special functions in the backend of code execution. They are known as Magic Methods or Dunder Methods.<\/em><\/strong><\/p>\n\n\n\n
    Why do we say Dunder? Because their names lie between double underscores<\/strong>. They perform some set of calculations that are just like magic while we create an object of a class. So, how do we check what are they and how many of them are there in the standard class? Use the steps below to find them:<\/p>\n\n\n\n
    1. Create a sample class.<\/strong><\/li>
    2. Create its object.<\/strong><\/li>
    3. Use the dir()<\/strong> function and insert the object inside it.<\/li>
    4. This function prints a list of all the Magic Methods along with data members and member functions that are assigned to the class.<\/strong><\/li><\/ol>\n\n\n\n
      Code:<\/strong><\/p>\n\n\n
      \nprint(dir(cat))\n<\/pre><\/div>\n\n\n
      Output:<\/strong><\/p>\n\n\n
      \n__class__\n__delattr__\n__dict__\n__dir__\n__doc__\n__eq__\n__format__\n__ge__\n__getattribute__\n__gt__\n__hash__\n__init__\n__init_subclass__\n__le__\n__lt__\n__module__\n__ne__\n__new__\n__reduce__\n__reduce_ex__\n__repr__\n__setattr__\n__sizeof__\n__str__\n__subclasshook__\n__weakref__\nfood\nlegs\nshelter\nshowAnimal\n<\/pre><\/div>\n\n\n
      The names that you see in double underscores are all magic methods. <\/strong>The rest of the properties are defined by the user. As we can see __init__()<\/code> which is the constructor of any class in Python, is also a magic method. Let us see their use one by one. To understand their functionality always try to override the functions.<\/strong><\/p>\n\n\n\n
       One thing to note is that, for any class the user defines, there is some set of default magic methods with respect to each of them. <\/strong><\/p>\n\n\n\n
      Use and implementation of some magic methods<\/h3>\n\n\n\n
      In this section, we shall see the use and implementation and use of some magic methods for writing a better OOP design<\/a>.<\/p>\n\n\n\n
      1. __new__():<\/h4>\n\n\n\n
      This method helps the constructor __init__() method to create objects for a class. So, when we create an instance of a class, the Python interpreter first calls the __new__() method and after that__init__() method. They work hand in hand with each other. <\/p>\n\n\n\n
      1. When a programmer opts to create an object, __new__() gets invoked that accepts the name of the object.<\/li>
      2. Then __init__() is invoked where the parameters including self<\/strong> are inserted into the object which in turn helps us to modify the class properties.<\/li><\/ol>\n\n\n\n
        Code:<\/strong><\/p>\n\n\n
        \nclass Sample:\n    def __new__(self, parameter):\n        print("new invoked", parameter)\n        return super().__new__(self)\n        \n    def __init__(self, parameter):\n        print("init invoked", parameter)\n        \nobj = Sample("a")\n<\/pre><\/div>\n\n\n
        Output:<\/strong><\/p>\n\n\n
        \nnew invoked a\ninit invoked a\n<\/pre><\/div>\n\n\n
        Explanation:<\/strong><\/p>\n\n\n\n
        1. First, we create a class as Sample.<\/li>
        2. Then override the __new__() method by creating it. Then, as usual, the self parameter comes, and after that gives a simple parameter.<\/li>
        3. Return a super() function with the __new__()<\/code> function with the self parameter to get access to the customizations we make to the method.<\/li>
        4. Then, with the same practice call the __init__()<\/code> function with some parameter.<\/li>
        5. After that create an object of a sample class.<\/li>
        6. Now, when we run the code, the interpreter first calls the __new__(), and then it calls __init__() method. <\/strong><\/li><\/ol>\n\n\n\n
          2. __init__():<\/h4>\n\n\n\n
          Python is an Object Oriented Programming<\/a> language. So, the class must have a constructor. This requirement is fulfilled using the __init__() method. When we create a class and want to give some initial parameters to it. The initializer method performs this task for us. <\/p>\n\n\n\n
          Code:<\/strong><\/p>\n\n\n
          \nclass Sample:        \n    def __init__(self, parameter):\n        print("init invoked", parameter)\n\nobj = Sample("a")\n<\/pre><\/div>\n\n\n
          Output:<\/strong><\/p>\n\n\n
          \ninit invoked a\n<\/pre><\/div>\n\n\n
          Explanation:<\/strong><\/p>\n\n\n\n
          1. Create\/override the __init__() method. Insert self parameter to signal the interpreter that this is a class method.<\/li>
          2. Insert required parameter.<\/li>
          3. Then print that parameter using the print() function.<\/li>
          4. After that create an object.<\/li>
          5. When we run the code we get the output as “init invoked a”, this states that the interpreter calls init() and prints that parameter.<\/strong><\/li><\/ol>\n\n\n\n
            3. __str__():<\/h4>\n\n\n\n
            This method helps us to display the object according to our requirements. So, let us say that when we create an object and try to print it. The print() function displays the memory location of the object. If we want to modify we can do this. The __str__() function gives a nice representation of the object.<\/strong><\/p>\n\n\n\n
            Code (before using __str__()):<\/strong><\/p>\n\n\n
            \nclass Student:\n    def __init__(self, name, roll_no):\n        self.name = name\n        self.roll_no = roll_no\n        \nstud_1 = Student("Suresh", 1)\nprint(stud_1) \n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \n<__main__.Student object at 0x0000023E2CF37CA0>\n<\/pre><\/div>\n\n\n
            Code (after using __str__()):<\/strong><\/p>\n\n\n
            \nclass Student:\n    def __init__(self, name, roll_no):\n        self.name = name\n        self.roll_no = roll_no\n        \n    def __str__(self):\n        return ("{} {}".format(self.name, self.roll_no))\n        \nstud_1 = Student("Suresh", 1)\nprint(stud_1) \n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \nSuresh 1\n<\/pre><\/div>\n\n\n
            Cool right! now we can also use similar methods. We can format the object as according to our needs.<\/p>\n\n\n\n
            4. __repr__():<\/h4>\n\n\n\n
            Similar to the __str__(), we can use __repr__ function for the decoration of objects. The code is similar to __str__() implementation.<\/p>\n\n\n
            \nclass Student:\n    def __init__(self, name, roll_no):\n        self.name = name\n        self.roll_no = roll_no\n        \n    def __repr__(self):\n        print("repr invoked")\n        return ("{} {}".format(self.name, self.roll_no))\n        \nstud_1 = Student("Suresh", 1)\nprint(stud_1) \n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \nrepr invoked\nSuresh 1\n<\/pre><\/div>\n\n\n
            5. __sizeof__():<\/h4>\n\n\n\n
            When we create a class the interpreter never assigns memory to it. It assigns memory to the object. If we want to know the memory allocated to that object, then we can call or override the __sizeof__() function and pass our object. This also returns size of a list =, tuple, dictionary object.<\/p>\n\n\n\n
            Code:<\/strong><\/p>\n\n\n
            \nclass Student:\n    def __init__(self, name, roll_no):\n        self.name = name\n        self.roll_no = roll_no\n        \nstud_1 = Student("Suresh", 1)\nprint("Size of student class object: ", stud_1.__sizeof__()) \n\nlist_1 = [1, 2, 3, 4]\ntup_1 = (1, 2, 3, 4, 5)\ndict_1 = {"a":1, "b":2, "c":3, "d":4}\nprint("Size of list: ", list_1.__sizeof__())\nprint("Size of tuple: ", tup_1.__sizeof__())\nprint("Size of dictionary: ", dict_1.__sizeof__())\n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \nSize of student class object:  32\nSize of list object:  104\nSize of tuple object:  64\nSize of dictionary object:  216\n<\/pre><\/div>\n\n\n
            6. __add__():<\/h4>\n\n\n\n
            This magic method is specifically similar to its name. It adds two variables<\/a>. For an integer it returns the sum, for a string, it returns their concatenation result.<\/p>\n\n\n\n
            Code:<\/strong><\/p>\n\n\n
            \nclass Numbers:\n    def __init__(self, a, b):\n        self.a = a\n        self.b = b\n        \n    def __add__(self):\n        print("__add__ invoked")\n        return self.a + self.b\n\nnum = Numbers(3, 4)\nnum_2 = Numbers("a", "b")\nprint(num.__add__())\nprint(num_2.__add__())\n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \n__add__ invoked\n7\n__add__ invoked\nab\n<\/pre><\/div>\n\n\n
            7. __reduce__():<\/h4>\n\n\n\n
            This magic method returns a set or a dictionary of all the parameters of a class and their values in key: value<\/strong> format. This can be directly called using the object name with the dot operator. So, when we create a class<\/a> and instantiate it with some values. The function shall return it with the name of the parameters which were given during the declaration of a class.<\/p>\n\n\n\n
            Code:<\/strong><\/p>\n\n\n
            \nclass Employee:\n    def __init__(self, name, salary):\n        self.name = name\n        self.sal = salary\n        \nemp = Employee("Shrinivas", 150000)\nprint(emp.__reduce__())\n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \n(&lt;function _reconstructor at 0x0000023E22892EE0>, (&lt;class '__main__.Employee'>, &lt;class 'object'>, None), {'name': 'Shrinivas', 'sal': 150000})\n<\/pre><\/div>\n\n\n
            Code (after overriding __reduce__()):<\/strong><\/p>\n\n\n
            \nclass Employee:\n    def __init__(self, name, salary):\n        self.name = name\n        self.sal = salary\n        \n    def __reduce__(self):\n        return self.name, self.sal\n        \nemp = Employee("Shrinivas", 150000)\nprint(emp.__reduce__())\n\n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \n{"Shrinivas", 150000}\n<\/pre><\/div>\n\n\n
            Explanation:<\/strong><\/p>\n\n\n\n
            When we override and try to return the parameters, we only get their values in a set.<\/p>\n\n\n\n
            8. __hash__():<\/h4>\n\n\n\n
            The __hash__() function returns a specific hash value of the object stored in the heap memory<\/a>. We can either override it or call it using the object name. Hashing<\/a> is very useful to fetch the memory address of any random element in a computer. All programming languages use hash for the sake of simplicity and for memory allocation.<\/p>\n\n\n\n
            Code:<\/strong><\/p>\n\n\n
            \nclass Employee:\n    def __init__(self, name, salary):\n        self.name = name\n        self.sal = salary\n    \n    def __hash__(self):\n        return super().__hash__()\n        \nemp = Employee("Shrinivas", 150000)\nprint(emp.__hash__())\n\n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \n154129100057\n<\/pre><\/div>\n\n\n
            Code:<\/strong><\/p>\n\n\n
            \nclass Employee:\n    def __init__(self, name, salary):\n        self.name = name\n        self.sal = salary\n    \nemp = Employee("Shrinivas", 150000)\nprint(emp.__hash__())\n\n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \n154129054082\n<\/pre><\/div>\n\n\n
            9. __getattribute__(name):<\/h4>\n\n\n\n
            This function returns the value of the attribute of a class if it exists. We need to call the function and pass the attribute which we assigned to the class parameter using the self <\/strong>keyword. Like if we assign the value of salary <\/strong>to self.sal <\/strong>we need to call sal<\/strong> inside the __getattribute__() function.<\/p>\n\n\n\n
            Code:<\/strong><\/p>\n\n\n
            \nclass Employee:\n    def __init__(self, name, salary):\n        self.name = name\n        self.sal = salary\n        \n    def __getattribute__(self, name):\n        return super().__getattribute__(name)\n        \nemp = Employee("Ravi", 500000)\nprint(emp.__getattribute__("sal"))\n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \n50000\n<\/pre><\/div>\n\n\n
            Explanation:<\/strong><\/p>\n\n\n\n
            In this function, the “self.sal” <\/strong>is assigned to the salary <\/strong>parameter of the Employee class. The function returns its value as the attribute that exists inside the class. If it does not exist the function returns an error message.<\/p>\n\n\n\n
            10. __setattr__(name, value):<\/h4>\n\n\n\n
            As the name suggests, this magic method helps us change the value of an attribute when we define the object. No need to override the __getattribute__() and __setattr__()<\/strong> functions. Just call them using the objects created.<\/p>\n\n\n\n
            Code:<\/strong><\/p>\n\n\n
            \nclass Employee:\n    def __init__(self, name, salary):\n        self.name = name\n        self.sal = salary\n\n        \nemp = Employee("Ravi", 500000)\nemp.__setattr__("name", "Suresh")\nemp.__setattr__("sal":600000)\nprint("The changed name of the employee is: ", emp.__getattribute__("name"))\nprint("The changed salary of the employee is: ", emp.__getattribute__("sal"))\n\n        \n<\/pre><\/div>\n\n\n
            Output:<\/strong><\/p>\n\n\n
            \nThe changed name of the employee is: Suresh\nThe changed salary of the employee is: 600000\n<\/pre><\/div>\n\n\n
            Explanation:<\/strong><\/p>\n\n\n\n
            1. the __setattr__() take two parameters. <\/strong>
              1. name of attribute<\/strong><\/li>
              2. its new value<\/strong><\/li><\/ol><\/li>
              3. Then it assigns that particular value to that attribute.<\/strong><\/li>
              4. After that, to check the value assigned to it call the __getattrbute__() function using the employee object and dot operator. emp.__getattribute(“name”).<\/strong><\/li><\/ol>\n\n\n\n
                Point to note: These two functions replace getter and setter methods for a class in Python.<\/strong><\/p>\n\n\n\n
                Conclusion<\/h2>\n\n\n\n
                So, we saw the in-depth implementation of some of the magic methods in Python. I hope this helps and will make programming easier. They prove to be helpful pieces of code for quick implementation and use. Happy python programming 🐍🐍😎.<\/p>\n","protected":false},"excerpt":{"rendered":"
                The magic methods in Python programming language are specifically for Object Oriented Design. Every class that we create has its own magic methods. Python’s standard interpreter assigns these to every class we create inside it. So, in this article, we shall see in detail how to call and use magic methods for a better programming […]<\/p>\n","protected":false},"author":36,"featured_media":69541,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11],"tags":[],"class_list":["post-32395","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oops"],"_links":{"self":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/32395","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/users\/36"}],"replies":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/comments?post=32395"}],"version-history":[{"count":0,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/32395\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media\/69541"}],"wp:attachment":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media?parent=32395"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/categories?post=32395"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/tags?post=32395"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}