P-E-callable instances with __call__ method.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b3c0145c",
   "metadata": {},
   "source": [
    "# Python: Everything\n",
    "- 26) **Create callable instances with magic method $\\_ call \\_$:** \n",
    "<br>----------------------------------------------\n",
    "<br> https://www.pinterest.com/HamedShahHosseini/programming-languages/\n",
    "<br>https://github.com/ostad-ai/Python-Everything"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35474859",
   "metadata": {},
   "source": [
    "**Callable:** is an object that can be called like a function in Python. To create a callable object, we define a custom class in which we implement the $\\_ call \\_$ magic method.\n",
    "<Br>Hint: To check if an object is callable or not, we employ the built-in function **callable()**.\n",
    "<br> With callable classes, we can keep the **state** between calls, hold in memory the values obtained so far by calling the object, or writing user-friendly APIs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1ade53a",
   "metadata": {},
   "source": [
    "A simple callable object is created below. We define a callable class to compute a base raised to the given power (exponent):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "0ca133a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 to the power 2 is: 25\n",
      "5 to the power 3 is: 125\n"
     ]
    }
   ],
   "source": [
    "# a base to the power given at the instantiation \n",
    "class Power:\n",
    "    def __init__(self,pow=2):\n",
    "        self.pow=pow\n",
    "    def __call__(self,base):\n",
    "        return base**self.pow\n",
    "power_2=Power()\n",
    "power_3=Power(3)\n",
    "x=5\n",
    "# calling class instance like a function\n",
    "print(f'{x} to the power 2 is: {power_2(x)}')\n",
    "print(f'{x} to the power 3 is: {power_3(x)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f040af3e",
   "metadata": {},
   "source": [
    "Let's define a callable class for polynomials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "b25be9e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of polynomial at x=2.2 is: 19.92\n",
      "The value of polynomial at x=0 is: 1\n"
     ]
    }
   ],
   "source": [
    "# polynomial is a0+a1*x+a2*x^2+a3*x^3+...\n",
    "# coefficients=[a0,a1,a2,a3,...]\n",
    "class Poly:\n",
    "    def __init__(self,*coefficients):\n",
    "        self.coeffs=coefficients\n",
    "    def __call__(self,x):\n",
    "        result=0\n",
    "        for power,coeff in enumerate(self.coeffs):\n",
    "            result+=coeff*x**power\n",
    "        return result\n",
    "p1=Poly(1,2,3) # 1+2x+3x^2\n",
    "x=2.2\n",
    "print(f'The value of polynomial at x={x} is: {p1(x)}')\n",
    "x=0\n",
    "print(f'The value of polynomial at x={x} is: {p1(x)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5412d346",
   "metadata": {},
   "source": [
    "Having a callable class to define a **line** by ite slope and intercept:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "374e3084",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "# define line as: y=mx+b\n",
    "class Line:\n",
    "    def __init__(self,slope,intercept):\n",
    "        self.m=slope\n",
    "        self.b=intercept\n",
    "    def __call__(self,x):\n",
    "        return self.m*x+self.b\n",
    "line1=Line(5,3); line2=Line(-3,5)\n",
    "xs=np.linspace(-5,5,100)\n",
    "line1_np,line2_np=np.vectorize(line1),np.vectorize(line2)\n",
    "plt.plot(xs,line1_np(xs))\n",
    "plt.plot(xs,line2_np(xs))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d2a1b9c",
   "metadata": {},
   "source": [
    "In the following, we define a callable class which computs the average of a stream of numeric values.\n",
    "<br>One way is to divide the summation of the all values by the number of values. But, there is a better way to compute a running average by:\n",
    "<br>$average_{new}=\\frac{1}{n+1}(average_{old}\\cdot n+value_{new})$, where $n$ is the number of values before the new value comes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "95a219d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 is average of [5]\n",
      "4.0 is average of [5, 3]\n",
      "6.0 is average of [5, 3, 10]\n"
     ]
    }
   ],
   "source": [
    "class Average:\n",
    "    def __init__(self):\n",
    "        self.n=0\n",
    "        self.average=None\n",
    "    def __call__(self,value):        \n",
    "        if self.n==0:\n",
    "            self.average=value\n",
    "        else:\n",
    "            self.average=(self.average*self.n+value)/(self.n+1)\n",
    "        self.n+=1\n",
    "        return self.average\n",
    "    \n",
    "# creating an instance of a class\n",
    "ave_stream=Average()\n",
    "# calling the class instance, like a function\n",
    "numbers=[5,3,10]\n",
    "for i in range(len(numbers)):\n",
    "    print(f'{ave_stream(numbers[i])} is average of {numbers[:i+1]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22275727",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}