Chapter13.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Chapter13.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "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/farshidbalan/FluentPython/blob/master/Chapter13.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gRuNH9T4tQAS",
        "colab_type": "text"
      },
      "source": [
        "# Operator Overloading: Doing It Right"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6C-ddbQatTdN",
        "colab_type": "text"
      },
      "source": [
        "From Chapter10, we have the Vector class. We want an output like:\n",
        "\n",
        "```\n",
        "v1 = Vector([3, 4, 5, 6])\n",
        " \n",
        "v3 = Vector([1, 2])\n",
        "\n",
        "v1 + v3\n",
        "\n",
        "Vector([4.0, 6.0, 5.0, 6.0])\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9KY9I_litSt_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from array import array\n",
        "import reprlib\n",
        "import itertools\n",
        "class Vector:\n",
        "  typecode = 'd'\n",
        "  \n",
        "  def __init__(self, components):\n",
        "    # The self._components instance “protected” attribute will hold an array \n",
        "    # with the Vector components.\n",
        "    self._components = array(self.typecode, components)\n",
        "    \n",
        "  def __iter__(self):\n",
        "    # To allow iteration, we return an iterator over self._components\n",
        "    return iter(self._components)\n",
        "\n",
        "  def __repr__(self):\n",
        "    # Use reprlib.repr() to get a limited-length representation of \n",
        "    # self._components (e.g., array('d', [0.0, 1.0, 2.0, 3.0, 4.0, ...])).\n",
        "    components = reprlib.repr(self._components)\n",
        "    \n",
        "    # Remove the array('d', prefix and the trailing ) before plugging the string \n",
        "    # into a Vector constructor call.\n",
        "    components = components[components.find('['): -1]\n",
        "    return f'Vector({components})'\n",
        "  \n",
        "  def __bytes__(self):\n",
        "    # Build a bytes object directly from self._components\n",
        "    return bytes([ord(self.typecode)]) + bytes(self._components)\n",
        "  \n",
        "  def __eq__(self, other):\n",
        "    return tuple(self) == tuple(other)\n",
        "  \n",
        "  def __abs__(self):\n",
        "    return math.sqrt(sum(x*x for x in self))\n",
        "  \n",
        "  def __boll__(self):\n",
        "    return bool(abs(self))\n",
        "  \n",
        "  def __add__(self, other):\n",
        "    pairs = itertools.zip_longest(self, other, fillvalue=0.0)  # pairs is a generator that will produce tuples (a, b) where a is from self, and\n",
        "                                                               #b is from other. If self and other have different lengths, fillvalue is used to\n",
        "                                                               # supply the missing values for the shortest iterable.\n",
        "        \n",
        "    return Vector(a + b for a, b in pairs)    # A new Vector is built from a generator expression producing one sum for each item in pairs.                \n",
        "  \n",
        "  @classmethod\n",
        "  def frombytes(cls, octets):\n",
        "    typecode = chr(octets[0])\n",
        "    memv = memoryview(octets[1:]).cast(typecode)\n",
        "    #  we pass the memoryview directly to the constructor\n",
        "    return cls(memv)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "77oD3NHG8C54",
        "colab_type": "code",
        "outputId": "81f299f0-5e8c-4184-a8eb-35ad3de9c5e5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "v1 = Vector([1, 2, 3])\n",
        "v2 = Vector([3, 4, 5, 3])\n",
        "v1 + v2"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Vector([4.0, 6.0, 8.0, 3.0])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4CxiOItm-yxc",
        "colab_type": "text"
      },
      "source": [
        "### Remark\n",
        "\n",
        "Very interesting to see that we return the object type in the  \\_\\_add\\_\\_ method\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "def __add__(self, other):\n",
        "    pairs = itertools.zip_longest(self, other, fillvalue=0.0) \n",
        "    return Vector(a + b for a, b in pairs) \n",
        "        \n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "srPmrPimA45i",
        "colab_type": "text"
      },
      "source": [
        "### Remark\n",
        "\n",
        "To support operations involving objects of different types, Python implements a special\n",
        "dispatching mechanism for the infix operator special methods. Given an expression a+ b, the interpreter will perform these steps:\n",
        "1. If a has \\_\\_add\\_\\_, call a. \\_\\_add \\_\\_(b) and return result unless it’s NotImplemented.\n",
        "2. If a doesn’t have  \\_\\_add \\_\\_, or calling it returns NotImplemented, check if b has\n",
        " \\_\\_radd \\_\\_, then call b. \\_\\_radd \\_\\_(a) and return result unless it’s NotImplemented.\n",
        "3. If b doesn’t have  \\_\\_radd \\_\\_, or calling it returns NotImplemented, raise TypeError\n",
        "with an unsupported operand types message"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aZz8T1vx8O3r",
        "colab_type": "code",
        "outputId": "29d51a0f-41d5-49f6-9560-54b276394939",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 180
        }
      },
      "source": [
        "# Example 13-6. Vector.__add__ take #1 fails with non-Vector left operands\n",
        "v1 = Vector([3, 4, 5])\n",
        "(10, 20, 30) + v1\n"
      ],
      "execution_count": 0,
      "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-12-092a25a14861>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mv1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mVector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m30\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mv1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can only concatenate tuple (not \"Vector\") to tuple"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6BHXYNmEB-FG",
        "colab_type": "text"
      },
      "source": [
        "Often, \\_\\_radd\\_\\_ can be as simple as that: just invoke the proper operator, therefore\n",
        "delegating to \\_\\_add\\_\\_ in this case. This applies to any commutative operator; + is commutative when dealing with numbers or our vectors, but it’s not commutative when\n",
        "concatenating sequences in Python."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qXbYnMRaBnLb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def __add__(self, other): #\n",
        "  pairs = itertools.zip_longest(self, other, fillvalue=0.0)\n",
        "  return Vector(a + b for a, b in pairs)\n",
        "\n",
        "def __radd__(self, other):\n",
        "  return self + other"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "174Qy5R2bHAk",
        "colab_type": "text"
      },
      "source": [
        "## Overloading * for Scalar Multiplication"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z_zb1Fa0eAzL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Example 13-11. vector_v7.py: operator * methods added\n",
        "\n",
        "from array import array\n",
        "import reprlib\n",
        "import math\n",
        "import numbers\n",
        "import functools\n",
        "import operator\n",
        "import itertools\n",
        "\n",
        "\n",
        "class Vector:\n",
        "    typecode = 'd'\n",
        "\n",
        "    def __init__(self, components):\n",
        "        self._components = array(self.typecode, components)\n",
        "\n",
        "    def __iter__(self):\n",
        "        return iter(self._components)\n",
        "\n",
        "    def __repr__(self):\n",
        "        components = reprlib.repr(self._components)\n",
        "        components = components[components.find('['):-1]\n",
        "        return 'Vector({})'.format(components)\n",
        "\n",
        "    def __str__(self):\n",
        "        return str(tuple(self))\n",
        "\n",
        "    def __bytes__(self):\n",
        "        return (bytes([ord(self.typecode)]) +\n",
        "                bytes(self._components))\n",
        "\n",
        "    def __eq__(self, other):\n",
        "        return (len(self) == len(other) and\n",
        "                all(a == b for a, b in zip(self, other)))\n",
        "\n",
        "    def __hash__(self):\n",
        "        hashes = (hash(x) for x in self)\n",
        "        return functools.reduce(operator.xor, hashes, 0)\n",
        "\n",
        "    def __abs__(self):\n",
        "        return math.sqrt(sum(x * x for x in self))\n",
        "\n",
        "    def __neg__(self):\n",
        "        return Vector(-x for x in self)\n",
        "\n",
        "    def __pos__(self):\n",
        "        return Vector(self)\n",
        "\n",
        "    def __bool__(self):\n",
        "        return bool(abs(self))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self._components)\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        cls = type(self)\n",
        "        if isinstance(index, slice):\n",
        "            return cls(self._components[index])\n",
        "        elif isinstance(index, numbers.Integral):\n",
        "            return self._components[index]\n",
        "        else:\n",
        "            msg = '{.__name__} indices must be integers'\n",
        "            raise TypeError(msg.format(cls))\n",
        "\n",
        "    shortcut_names = 'xyzt'\n",
        "\n",
        "    def __getattr__(self, name):\n",
        "        cls = type(self)\n",
        "        if len(name) == 1:\n",
        "            pos = cls.shortcut_names.find(name)\n",
        "            if 0 <= pos < len(self._components):\n",
        "                return self._components[pos]\n",
        "        msg = '{.__name__!r} object has no attribute {!r}'\n",
        "        raise AttributeError(msg.format(cls, name))\n",
        "\n",
        "    def angle(self, n):\n",
        "        r = math.sqrt(sum(x * x for x in self[n:]))\n",
        "        a = math.atan2(r, self[n-1])\n",
        "        if (n == len(self) - 1) and (self[-1] < 0):\n",
        "            return math.pi * 2 - a\n",
        "        else:\n",
        "            return a\n",
        "\n",
        "    def angles(self):\n",
        "        return (self.angle(n) for n in range(1, len(self)))\n",
        "\n",
        "    def __format__(self, fmt_spec=''):\n",
        "        if fmt_spec.endswith('h'):  # hyperspherical coordinates\n",
        "            fmt_spec = fmt_spec[:-1]\n",
        "            coords = itertools.chain([abs(self)],\n",
        "                                     self.angles())\n",
        "            outer_fmt = '<{}>'\n",
        "        else:\n",
        "            coords = self\n",
        "            outer_fmt = '({})'\n",
        "        components = (format(c, fmt_spec) for c in coords)\n",
        "        return outer_fmt.format(', '.join(components))\n",
        "\n",
        "    @classmethod\n",
        "    def frombytes(cls, octets):\n",
        "        typecode = chr(octets[0])\n",
        "        memv = memoryview(octets[1:]).cast(typecode)\n",
        "        return cls(memv)\n",
        "\n",
        "    def __add__(self, other):\n",
        "        try:\n",
        "            pairs = itertools.zip_longest(self, other, fillvalue=0.0)\n",
        "            return Vector(a + b for a, b in pairs)\n",
        "        except TypeError:\n",
        "            return NotImplemented\n",
        "\n",
        "    def __radd__(self, other):\n",
        "        return self + other\n",
        "      \n",
        "    def __mul__(self, scalar):\n",
        "      if isinstance(scalar, numbers.Real): # If scalar is an instance of a numbers.Real subclass, \n",
        "                                           # create new Vector with multiplied component values\n",
        "        return Vector(n * scalar for n in self)\n",
        "      else:\n",
        "        return NotImplemented\n",
        "      \n",
        "    def __rmul__(self, scalar):\n",
        "      return self * scalar  # In this example, __rmul__ works fine by just performing self * scalar, delegating to the __mul__ method\n",
        "      "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0YIM0yDde_bQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fde92cda-5982-4268-b818-7801f49ffa5e"
      },
      "source": [
        "v1 = Vector([1.0, 3.0, 5.0])\n",
        "14 * v1"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Vector([14.0, 42.0, 70.0])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p1eZcSdVhZAE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c3520f89-1441-4a78-a83e-fc77ab53c7a4"
      },
      "source": [
        "v1 * True"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Vector([1.0, 3.0, 5.0])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kms50ecFhcPc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "77afc069-7699-4f01-83c5-18e06cbee9ab"
      },
      "source": [
        "from fractions import Fraction\n",
        "v1 * Fraction(1, 3)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Vector([0.3333333333333333, 1.0, 1.6666666666666665])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OCgudNhtjyl5",
        "colab_type": "text"
      },
      "source": [
        "## Further Reading\n",
        "Operator overloading is one area of Python programming where isinstance tests are\n",
        "common. In general, libraries should leverage dynamic typing—to be more flexible—\n",
        "by avoiding explicit type tests and just trying operations and then handling the except\n",
        "opening the door for working with objects regardless of their types, as long as\n",
        "they support the necessary operations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "US0n7ENHh6Zq",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    }
  ]
}