#5Revisiting Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c07a2266",
   "metadata": {},
   "source": [
    "# Python Functions\n",
    "### A function is a block of code which only runs when it is called.\n",
    "\n",
    "### You can pass data, known as parameters, into a function.\n",
    "\n",
    "### A function can return data as a result.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a0d62e07",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function():\n",
    "  print(\"Hello from a function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "45a24557",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from a function\n"
     ]
    }
   ],
   "source": [
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bed303b0",
   "metadata": {},
   "source": [
    "### Arguments\n",
    "#### Information can be passed into functions as arguments. We can add as many arguments as we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "85515b85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from Ashok\n",
      "Hello from maddy\n"
     ]
    }
   ],
   "source": [
    "def my_function(name):\n",
    "  print(\"Hello from\",name)\n",
    "my_function(\"Ashok\")\n",
    "my_function(\"maddy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04389363",
   "metadata": {},
   "source": [
    "### From a function's perspective: \n",
    "#### A parameter is the variable listed inside the parentheses in the function definition. An argument is the value that is sent to the function when it is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ec0d6395",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from Charles Ashok\n",
      "Hello from Kishore maddy\n"
     ]
    }
   ],
   "source": [
    "def my_function(name,lname):\n",
    "  print(\"Hello from\",lname,name)\n",
    "my_function(\"Ashok\",\"Charles\")\n",
    "my_function(\"maddy\",\"Kishore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "204990b4",
   "metadata": {},
   "source": [
    "### Arbitrary Arguments  (*args)\n",
    "#### If not sure about the number of arguments, use * before parameter name "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7b309191",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from Ashok Charles Rahman\n",
      "Hello from ('Ashok', 'Charles', 'Rahman')\n",
      "Hello from Rahman\n"
     ]
    }
   ],
   "source": [
    "def my_function(*name):\n",
    "    print(\"Hello from\",*name)\n",
    "    print(\"Hello from\",name)\n",
    "    print(\"Hello from \"+name[-1])\n",
    "\n",
    "\n",
    "my_function(\"Ashok\",\"Charles\",\"Rahman\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8d07c8a",
   "metadata": {},
   "source": [
    "### Keyword Arguments\n",
    "#### We can also send arguments with the key = value syntax. The order of the arguments does not matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eaa3f9a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from Ashok Charles\n"
     ]
    }
   ],
   "source": [
    "def my_function(name,lname):\n",
    "  print(\"Hello from\",lname,name)\n",
    "my_function(lname=\"Ashok\",name=\"Charles\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21d38f87",
   "metadata": {},
   "source": [
    "### Arbitrary Keyword Arguments\n",
    "#### If we do not know how many keyword arguments that will be passed into our function, add  ** before the parameter name in the function definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c4f5d9c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from Ashok\n"
     ]
    }
   ],
   "source": [
    "def my_function(**n):\n",
    "  print(\"Hello from\",n[\"lname\"])\n",
    "my_function(lname=\"Ashok\",name=\"Charles\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c888b6c0",
   "metadata": {},
   "source": [
    "### Default Parameter Value\n",
    "#### If we call the function without argument, it uses the default value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "81f08c9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from Ashok\n",
      "Hello from maddy\n",
      "Hello from Sneha\n"
     ]
    }
   ],
   "source": [
    "def my_function(name=\"Sneha\"):\n",
    "  print(\"Hello from\",name)\n",
    "my_function(\"Ashok\")\n",
    "my_function(\"maddy\")\n",
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f366429",
   "metadata": {},
   "source": [
    "### Passing a List as an Argument\n",
    "#### Any data types of argument can be send to a function (string, number, list, dictionary etc.), and it will be treated as the same data type inside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a5cbc708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kiwi\n",
      "lady's finger\n",
      "tomato\n"
     ]
    }
   ],
   "source": [
    "def fruits(k):\n",
    "    for j in k:\n",
    "        print(j)\n",
    "    \n",
    "fruits([\"kiwi\",\"lady's finger\",\"tomato\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01a4e972",
   "metadata": {},
   "source": [
    "### Return Values\n",
    "#### To let a function return a value, use the return statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c7cd701a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "63"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mul(no):\n",
    "    return 7*no\n",
    "mul(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abb76dff",
   "metadata": {},
   "source": [
    "### Pass statement\n",
    "#### Function definitions cannot be empty, but if you for some reason have a function definition with no content, put in the pass statement to avoid getting an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "740dada8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunction():\n",
    "  pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ad2d305",
   "metadata": {},
   "source": [
    "### Recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4414dee5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Recursion Example Results\n",
      "1\n",
      "3\n",
      "6\n",
      "10\n",
      "15\n",
      "21\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def tri_recursion(k):\n",
    "  if(k > 0):\n",
    "    result = k + tri_recursion(k - 1)\n",
    "    print(result)\n",
    "  else:\n",
    "    result = 0\n",
    "  return result\n",
    "\n",
    "print(\"\\n\\nRecursion Example Results\")\n",
    "tri_recursion(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f7899e2",
   "metadata": {},
   "source": [
    "### Lambda\n",
    "#### A small anonymous function  (can take any number of arguments, but can only have one expression.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b93a54f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n"
     ]
    }
   ],
   "source": [
    "x = lambda a: a+10*a\n",
    "print(x(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "797b7f16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "g = lambda a,b: a*b\n",
    "print(g(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f5c9ee6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    }
   ],
   "source": [
    "def myfunc(n):\n",
    "  return lambda a : a * n \n",
    "\n",
    "mydoubler = myfunc(2)\n",
    "\n",
    "print(mydoubler(11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "401b6484",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n"
     ]
    }
   ],
   "source": [
    "def myfunc(n):\n",
    "  return lambda a : a * n\n",
    "\n",
    "mytripler = myfunc(3)\n",
    "\n",
    "print(mytripler(11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f2f3b4a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n",
      "33\n"
     ]
    }
   ],
   "source": [
    "def myfunc(n):\n",
    "  return lambda a : a * n\n",
    "\n",
    "mydoubler = myfunc(2)\n",
    "mytripler = myfunc(3)\n",
    "\n",
    "print(mydoubler(11))\n",
    "print(mytripler(11))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a27af17",
   "metadata": {},
   "source": [
    "#### Use lambda functions when an anonymous function is required for a short period of time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "672a1645",
   "metadata": {},
   "source": [
    "### Python Arrays\n",
    "#### Python does not have built-in support for Arrays, but Python Lists can be used instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ac8884f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n"
     ]
    }
   ],
   "source": [
    "print(dir(list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1114bd0",
   "metadata": {},
   "source": [
    "### Python Classes\n",
    "#### Python is an object oriented programming language.\n",
    "\n",
    "#### Almost everything in Python is an object, with its properties and methods.\n",
    "\n",
    "#### A Class is like an object constructor, or a \"blueprint\" for creating objects.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1331bc90",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating class\n",
    "\n",
    "class fruits: # class name\n",
    "    a = 7 # a is class property"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3d0a9396",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# Creating object\n",
    "\n",
    "p1 = fruits() # object name\n",
    "print(p1.a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "303afffa",
   "metadata": {},
   "source": [
    "### __init__() function\n",
    "#### All classes have a function called __init__(), which is always executed when the class is being initiated.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "46134c63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "4\n",
      "<__main__.Person object at 0x000002C6602C7460>\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,name,age):\n",
    "        self.name=name\n",
    "        self.age=age\n",
    "        \n",
    "\n",
    "p1 = Person(\"John\",4)\n",
    "print(p1.name)\n",
    "print(p1.age)\n",
    "print(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a953a67",
   "metadata": {},
   "source": [
    "#### The __init__() function is called automatically every time the class is being used to create a new object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa111b88",
   "metadata": {},
   "source": [
    "### __str__() Function\n",
    "#### The __str__() function controls what should be returned when the class object is represented as a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "77bf0fb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Annie -- her age is 2\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,name,age):\n",
    "        self.name=name\n",
    "        self.age=age\n",
    "    def __str__(self):\n",
    "        return f\"{self.name} -- her age is {self.age}\"\n",
    "\n",
    "p1 = Person(\"Annie\",2)\n",
    "print(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31d0f14c",
   "metadata": {},
   "source": [
    "### Object methods\n",
    "#### Objects can also contain methods. Methods in objects are functions that belong to the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "1e1584b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, I am  Annie\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,name,age):\n",
    "        self.name=name\n",
    "        self.age=age\n",
    "    def myfun(self):\n",
    "        print(\"Hello, I am \",self.name)\n",
    "p1 = Person(\"Annie\",2)\n",
    "p1.myfun()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce9e3cfb",
   "metadata": {},
   "source": [
    "#### The self parameter is a reference to the current instance of the class, and is used to access variables that belong to the class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecdf10af",
   "metadata": {},
   "source": [
    "### Python Inheritance\n",
    "#### Inheritance allows us to define a class that inherits all the methods and properties from another class.\n",
    "#### PARENT class is the class being inherited from, also called BASE class.\n",
    "\n",
    "#### CHILD class is the class that inherits from another class, also called DERIVED class.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b859a929",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Doe\n"
     ]
    }
   ],
   "source": [
    "# Creating Parent class\n",
    "class Person:\n",
    "  def __init__(self, fname, lname):\n",
    "    self.firstname = fname\n",
    "    self.lastname = lname\n",
    "\n",
    "  def printname(self):\n",
    "    print(self.firstname, self.lastname)\n",
    "\n",
    "#Use the Person class to create an object, and then execute the printname method:\n",
    "\n",
    "x = Person(\"John\", \"Doe\")\n",
    "x.printname()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b54ef642",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creating child class\n",
    "class Student(Person):\n",
    "  pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "04d13b7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mike Olsen\n"
     ]
    }
   ],
   "source": [
    "x = Student(\"Mike\", \"Olsen\")\n",
    "x.printname()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9df3843e",
   "metadata": {},
   "source": [
    "#### When you add the __init__() function, the child class will no longer inherit the parent's __init__() function.\n",
    "#### The child's __init__() function overrides the inheritance of the parent's __init__() function.\n",
    "#### To keep the inheritance of the parent's __init__() function, add a call to the parent's __init__() function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f0bf000f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student(Person):\n",
    "  def __init__(self, fname, lname):\n",
    "    Person.__init__(self, fname, lname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b4e413e",
   "metadata": {},
   "source": [
    "### super() Function\n",
    "#### Python also has a super() function that will make the child class inherit all the methods and properties from its parent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "79988ff9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student(Person):\n",
    "  def __init__(self, fname, lname):\n",
    "    super().__init__(fname, lname)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee99a427",
   "metadata": {},
   "source": [
    "#### By using the super() function, you do not have to use the name of the parent element, it will automatically inherit the methods and properties from its parent.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a34e1bfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student(Person):\n",
    "  def __init__(self, fname, lname):\n",
    "    super().__init__(fname, lname)\n",
    "    self.graduationyear = 2019"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a8810af4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student(Person):\n",
    "  def __init__(self, fname, lname, year):\n",
    "    super().__init__(fname, lname)\n",
    "    self.graduationyear = year\n",
    "\n",
    "x = Student(\"Mike\", \"Olsen\", 2019)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "8cb3fde3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Joe Monu to the class of 2021\n"
     ]
    }
   ],
   "source": [
    "class Student(Person):\n",
    "  def __init__(self, fname, lname, year):\n",
    "    super().__init__(fname, lname)\n",
    "    self.graduationyear = year\n",
    "\n",
    "  def welcome(self):\n",
    "    print(\"Welcome\", self.firstname, self.lastname, \"to the class of\", self.graduationyear)\n",
    "    \n",
    "p2 = Student(\"Joe\",\"Monu\",2021)\n",
    "p2.welcome()"
   ]
  }
 ],
 "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}