Overloading.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Overloading.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMEyFhKVMdxE7d1Cyy9y6yQ",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Sabyasachi123276/Python-Tutorial/blob/master/Overloading.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LUmk7U6IZivY",
        "colab_type": "text"
      },
      "source": [
        "# **Object Oriented Programming in Python | Set 3 (Overloading)**\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "IlrtjurapFYr"
      },
      "source": [
        "# **Overloading Built-in Functions**\n",
        "Many of the special methods defined in the Data Model can be used to change the behavior of functions such as len, abs, hash, divmod, and so on. To do this, you only need to define the corresponding special method in your class. Let’s look at a few examples:\n",
        "# **Giving a Length to Your Objects Using len()**\n",
        "To change the behavior of len(), you need to define the __len__() special method in your class. Whenever you pass an object of your class to len(), your custom definition of __len__() will be used to obtain the result. Let’s implement len() for the order class we talked about in the beginning:\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-QRpWNt7r8ot",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a43c1402-9f3f-49ed-cdc0-e7d7c890e11f"
      },
      "source": [
        "class Order:\n",
        "...     def __init__(self, cart, customer):\n",
        "...         self.cart = list(cart)\n",
        "...         self.customer = customer\n",
        "...\n",
        "...     def __len__(self):\n",
        "...         return len(self.cart)\n",
        "...\n",
        ">>> order = Order(['banana', 'apple', 'mango'], 'Sabyasachi')\n",
        ">>> len(order)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E-yVJoKH2DFF",
        "colab_type": "text"
      },
      "source": [
        "As you can see, you can now use len() to directly obtain the length of the cart. Moreover, it makes more intuitive sense to say “length of order” rather than calling something like order.get_cart_len(). Your call is both Pythonic and more intuitive. When you don’t have the __len__() method defined but still call len() on your object, you get a TypeError:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3aGFcDu-4QIf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 197
        },
        "outputId": "7717a2ef-eaf2-40c5-d718-11b52a236167"
      },
      "source": [
        "class Order:\n",
        "...     def __init__(self, cart, customer):\n",
        "...         self.cart = list(cart)\n",
        "...         self.customer = customer\n",
        "...\n",
        ">>> order = Order(['banana', 'apple', 'mango'], 'Sabyasachi')\n",
        ">>> len(order)  # Calling len when no __len__"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-21-2d527e4caabb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0morder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mOrder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'banana'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'apple'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'mango'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Sabyasachi'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0morder\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# Calling len when no __len__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: object of type 'Order' has no len()"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a-5XPh676r_q",
        "colab_type": "text"
      },
      "source": [
        "But, when overloading len(), you should keep in mind that Python requires the function to return an integer. If your method were to return anything other than an integer, you would get a TypeError. This, most probably, is to keep it consistent with the fact that len() is generally used to obtain the length of a sequence, which can only be an integer:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_55Z9o787JOO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 197
        },
        "outputId": "d4aaa691-2c85-4111-fde9-b307895e2dc1"
      },
      "source": [
        "class Order:\n",
        "...     def __init__(self, cart, customer):\n",
        "...         self.cart = list(cart)\n",
        "...         self.customer = customer\n",
        "...\n",
        "...     def __len__(self):\n",
        "...         return float(len(self.cart))  # Return type changed to float\n",
        "...\n",
        ">>> order = Order(['banana', 'apple', 'mango'], 'Sabyasachi')\n",
        ">>> len(order)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-22-6d8f5885809e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0morder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mOrder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'banana'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'apple'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'mango'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Sabyasachi'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0morder\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'float' object cannot be interpreted as an integer"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rjn4SyiC7fhK",
        "colab_type": "text"
      },
      "source": [
        "# **Making Your Objects Work With abs()**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hbI7bFuq71oO",
        "colab_type": "text"
      },
      "source": [
        "You can dictate the behavior of the abs() built-in for instances of your class by defining the __abs__() special method in the class. There are no restrictions on the return value of abs(), and you get a TypeError when the special method is absent in your class definition.\n",
        "\n",
        "In a class representing a vector in a two-dimensional space, abs() can be used to get the length of the vector. Let’s see it in action:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qTGAbQw28pjD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3c70326c-abed-4ebc-d8b4-028af84e238e"
      },
      "source": [
        "class Vector:\n",
        "...     def __init__(self, x_comp, y_comp):\n",
        "...         self.x_comp = x_comp\n",
        "...         self.y_comp = y_comp\n",
        "...\n",
        "...     def __abs__(self):\n",
        "...         return (self.x_comp ** 2 + self.y_comp ** 2) ** 0.5\n",
        "...\n",
        ">>> vector = Vector(3, 4)\n",
        ">>> abs(vector) "
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qSGOX7Xj-jV4",
        "colab_type": "text"
      },
      "source": [
        "It makes more intuitive sense to say “absolute value of vector” rather than calling something like vector.get_mag()."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W5KGHiqZ_A1J",
        "colab_type": "text"
      },
      "source": [
        "# **Printing Your Objects Prettily Using str()**\n",
        "The str() built-in is used to cast an instance of a class to a str object, or more appropriately, to obtain a user-friendly string representation of the object which can be read by a normal user rather than the programmer. You can define the string format your object should be displayed in when passed to str() by defining the __str__() method in your class. Moreover, __str__() is the method that is used by Python when you call print() on your object.\n",
        "\n",
        "Let’s implement this in the Vector class to format Vector objects as xi+yj. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zdjn5Ou0BGeZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "132bd77c-7392-4236-8e1b-916028618243"
      },
      "source": [
        "class Vector:\n",
        "     def __init__(self, x_comp, y_comp):\n",
        "         self.x_comp = x_comp\n",
        "         self.y_comp = y_comp\n",
        "\n",
        "     def __str__(self):\n",
        "         # By default, sign of +ve number is not displayed\n",
        "         # Using `+`, sign is always displayed\n",
        "         return f'{self.x_comp}i{self.y_comp:+}j'\n",
        "\n",
        "vector = Vector(3, 4)\n",
        "str(vector)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'3i+4j'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J581sWpHBdEF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e3f3acb1-3c5c-440d-bd6b-9952f8531b21"
      },
      "source": [
        "print(vector)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3i+4j\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nS5LhIOsB0c5",
        "colab_type": "text"
      },
      "source": [
        "It is necessary that __str__() returns a str object, and we get a TypeError if the return type is non-string.\n",
        "# **Representing Your Objects Using repr()**\n",
        "The repr() built-in is used to obtain the parsable string representation of an object. If an object is parsable, that means that Python should be able to recreate the object from the representation when repr is used in conjunction with functions like eval(). To define the behavior of repr(), you can use the __repr__() special method.\n",
        "\n",
        "This is also the method Python uses to display the object in a REPL session. If the __repr__() method is not defined, you will get something like <__main__.Vector object at 0x...> trying to look at the object in the REPL session. Let’s see it in action in the Vector class:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6qIOFynbFiBP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4b7e3572-dc58-46a0-c15d-f8febf2b1003"
      },
      "source": [
        "class Vector:\n",
        "...     def __init__(self, x_comp, y_comp):\n",
        "...         self.x_comp = x_comp\n",
        "...         self.y_comp = y_comp\n",
        "...\n",
        "...     def __repr__(self):\n",
        "...         return f'Vector({self.x_comp}, {self.y_comp})'\n",
        "...\n",
        "\n",
        ">>> vector = Vector(3, 4)\n",
        ">>> repr(vector)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Vector(3, 4)'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MZ_s8kJ-GPLm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "632d0a09-1153-4931-dddd-e25045964d88"
      },
      "source": [
        "b = eval(repr(vector))\n",
        ">>> type(b), b.x_comp, b.y_comp"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.Vector, 3, 4)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yUfAYOPEGY8b",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "13e95de5-ecf7-4979-8918-e1e34b64a03f"
      },
      "source": [
        "vector  # Looking at object; __repr__ used"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Vector(3, 4)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-_WTJm3hG83z",
        "colab_type": "text"
      },
      "source": [
        "# **Making Your Objects Truthy or Falsey Using bool()**\n",
        "The bool() built-in can be used to obtain the truth value of an object. To define its behavior, you can use the __bool__() special method.\n",
        "\n",
        "The behavior defined here will determine the truth value of an instance in all contexts that require obtaining a truth value such as in if statements.\n",
        "\n",
        "As an example, for the Order class that was defined above, an instance can be considered to be truthy if the length of the cart list is non-zero. This can be used to check whether an order should be processed or not:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rGfVc9kVJwWH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e3b50077-4176-4e8b-9b2e-043d62103def"
      },
      "source": [
        "class Order:\n",
        "...     def __init__(self, cart, customer):\n",
        "...         self.cart = list(cart)\n",
        "...         self.customer = customer\n",
        "...\n",
        "...     def __bool__(self):\n",
        "...         return len(self.cart) > 0\n",
        "...\n",
        ">>> order1 = Order(['banana', 'apple', 'mango'], 'Sabyasachi')\n",
        ">>> order2 = Order([], 'Python')\n",
        "\n",
        ">>> bool(order1)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5bKu-2TELCTd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b8f8fa66-3475-4486-e3ae-313cc9be43ff"
      },
      "source": [
        "bool(order2)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8er8udZhLSEB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "b992b42d-0cef-46e8-a207-05d593b5d449"
      },
      "source": [
        "for order in [order1, order2]:\n",
        "...     if order:\n",
        "...         print(f\"{order.customer}'s order is processing...\")\n",
        "...     else:\n",
        "...         print(f\"Empty order for customer {order.customer}\")"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Sabyasachi's order is processing...\n",
            "Empty order for customer Python\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AIbTIQgDMn8x",
        "colab_type": "text"
      },
      "source": [
        "There are many more special methods that overload built-in functions. Having discussed some of them, let’s move to operators.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3c-FvqtiM6vE",
        "colab_type": "text"
      },
      "source": [
        "# **Overloading Built-in Operators**\n",
        "Changing the behavior of operators is just as simple as changing the behavior of functions. You define their corresponding special methods in your class, and the operators work according to the behavior defined in these methods.\n",
        "\n",
        "These are different from the above special methods in the sense that they need to accept another argument in the definition other than self, generally referred to by the name other. Let’s look at a few examples.\n",
        "\n",
        "# **Making Your Objects Capable of Being Added Using +**\n",
        "The special method corresponding to the + operator is the __add__() method. Adding a custom definition of __add__() changes the behavior of the operator. It is recommended that __add__() returns a new instance of the class instead of modifying the calling instance itself. You’ll see this behavior quite commonly in Python:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8_9DzwliO177",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4ddae0e3-fc3b-4e38-c977-7358370de090"
      },
      "source": [
        "a = 'Sabyasachi'\n",
        "a + 'Mukhopadhyay'  # Gives new str instance"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'SabyasachiMukhopadhyay'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BT6qWFg-PVpt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b3eaa0fc-53c0-4794-9e88-76c14dd3e219"
      },
      "source": [
        "a  # Values unchanged"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Sabyasachi'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3J6UUB9EP5DD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d9353d95-fdd4-46d0-b09a-3672a5158b10"
      },
      "source": [
        "a = a + 'Mukhopadhyay' # Creates new instance and assigns a to it\n",
        "a"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'SabyasachiMukhopadhyay'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TAk8leSgQYE2",
        "colab_type": "text"
      },
      "source": [
        "You can see above that using the + operator on a str object actually returns a new str instance, keeping the value of the calling instance (a) unmodified. To change it, we need to explicitly assign the new instance to a.\n",
        "\n",
        "Let’s implement the ability to append new items to our cart in the Order class using the operator. We’ll follow the recommended practice and make the operator return a new Order instance that has our required changes instead of making the changes directly to our instance:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-rlLjdqqSvai",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c4d0e402-89dd-4239-9861-167657d89bec"
      },
      "source": [
        "class Order:\n",
        "...     def __init__(self, cart, customer):\n",
        "...         self.cart = list(cart)\n",
        "...         self.customer = customer\n",
        "...\n",
        "...     def __add__(self, other):\n",
        "...         new_cart = self.cart.copy()\n",
        "...         new_cart.append(other)\n",
        "...         return Order(new_cart, self.customer)\n",
        "...\n",
        ">>> order = Order(['banana', 'apple'], 'Sabyasachi Mukhopadhyay')\n",
        "(order + 'orange').cart  # New Order instance"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['banana', 'apple', 'orange']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3qg_hE2fTfjj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9a83b31c-3c05-42e9-a97d-f0c6f17a75af"
      },
      "source": [
        "order.cart  # Original instance unchanged"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['banana', 'apple']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gp5Pl0S8TprN",
        "colab_type": "text"
      },
      "source": [
        "Similarly, you have the __sub__(), __mul__(), and other special methods which define the behavior of -, *, and so on. These methods should return a new instance of the class as well."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eZvufvjMUMXN",
        "colab_type": "text"
      },
      "source": [
        "# **Shortcuts: the += Operator**\n",
        "The += operator stands as a shortcut to the expression obj1 = obj1 + obj2. The special method corresponding to it is __iadd__(). The __iadd__() method should make changes directly to the self argument and return the result, which may or may not be self. This behavior is quite different from __add__() since the latter creates a new object and returns that, as you saw above.\n",
        "\n",
        "Roughly, any += use on two objects is equivalent to this:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u1_wn1B8USdy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "result = obj1 + obj2\n",
        "obj1 = result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cx6qUPBeUuMt",
        "colab_type": "text"
      },
      "source": [
        "Here, result is the value returned by __iadd__(). The second assignment is taken care of automatically by Python, meaning that you do not need to explicitly assign obj1 to the result as in the case of obj1 = obj1 + obj2.\n",
        "\n",
        "Let’s make this possible for the Order class so that new items can be appended to the cart using +=:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cvhBtzaaXzL6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c26e1289-7ce8-4186-f06a-ae3946ad5b71"
      },
      "source": [
        "class Order:\n",
        "...     def __init__(self, cart, customer):\n",
        "...         self.cart = list(cart)\n",
        "...         self.customer = customer\n",
        "...\n",
        "...     def __iadd__(self, other):\n",
        "...         self.cart.append(other)\n",
        "...         return self\n",
        "...\n",
        ">>> order = Order(['banana', 'apple'], 'Sabyasachi Mukhopadhyay')\n",
        ">>> order += 'mango'\n",
        ">>> order.cart"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['banana', 'apple', 'mango']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WA5AJ-29eb8T",
        "colab_type": "text"
      },
      "source": [
        "As can be seen, any change is made directly to self and it is then returned. What happens when you return some random value, like a string or an integer?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_8LSBDoOefvb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e7a756de-f26d-4b23-fc89-c89614f3fcee"
      },
      "source": [
        "class Order:\n",
        "...     def __init__(self, cart, customer):\n",
        "...         self.cart = list(cart)\n",
        "...         self.customer = customer\n",
        "...\n",
        "...     def __iadd__(self, other):\n",
        "...         self.cart.append(other)\n",
        "...         return 'Hey, I am string!'\n",
        "...\n",
        ">>> order = Order(['banana', 'apple'], 'Sabyasachi Mukhopadhyay')\n",
        ">>> order += 'mango'\n",
        "order"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hey, I am string!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ljMpffUBffhc",
        "colab_type": "text"
      },
      "source": [
        "Even though the relevant item was appended to the cart, the value of order changed to what was returned by __iadd__(). Python implicitly handled the assignment for you. This can lead to surprising behavior if you forget to return something in your implementation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lPjQ9PAwfiRL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "991a2209-148f-4273-caf6-050179efe5f0"
      },
      "source": [
        "class Order:\n",
        "...     def __init__(self, cart, customer):\n",
        "...         self.cart = list(cart)\n",
        "...         self.customer = customer\n",
        "...\n",
        "...     def __iadd__(self, other):\n",
        "...         self.cart.append(other)\n",
        "...\n",
        ">>> order = Order(['banana', 'apple'], 'Sabyasachi Mukhopadhyay')\n",
        ">>> order += 'mango'\n",
        ">>> order  # No output\n",
        "type(order)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "NoneType"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "59oeTGuDoGct",
        "colab_type": "text"
      },
      "source": [
        "Since all Python functions (or methods) return None implicitly, order is reassigned to None and the REPL session doesn’t show any output when order is inspected. Looking at the type of order, you see that it is now NoneType. Therefore, always make sure that you’re returning something in your implementation of __iadd__() and that it is the result of the operation and not anything else.\n",
        "\n",
        "Similar to __iadd__(), you have __isub__(), __imul__(), __idiv__() and other special methods which define the behavior of -=, *=, /=, and others alike.\n",
        "\n",
        "# **Difference between __add__() and __iadd__() Operators**\n",
        "Normal operator's “add()” method, implements “a+b” and stores the result in the mentioned variable. Inplace operator's “iadd()” method, implements “a+=b or a = a + b ” if it exists and changes the value of passed argument. The same explanation holds for other cases also. When __iadd__() or its friends are missing from your class definition but you still use their operators on your objects, Python uses __add__() and its friends to get the result of the operation and assigns that to the calling instance. Generally speaking, it is safe to not implement __iadd__() and its friends in your classes as long as __add__() and its friends work properly (return something which is the result of the operation)."
      ]
    }
  ]
}