10_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center>Functions in Python </center>\n",
    "### <center>Author: e-Yantra Team </center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Code reusability\n",
    "- Abstraction\n",
    "- Testing becomes easy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def funcName(parameters):\n",
    "    # perform operations\n",
    "    returnStatement;\n",
    "```\n",
    "A semicolon (;) in python is used to denote seperation and not termination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python functions\n"
     ]
    }
   ],
   "source": [
    "def funcName():\n",
    "    print(\"Welcome to Python functions\");\n",
    "funcName(); # Function call"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function returns sum of the two variables which are passed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "def summation(a, b):\n",
    "    return a+b;\n",
    "\n",
    "print(summation(2, 4));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Below function takes two string arguments and returns concatenation of those two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Python\n"
     ]
    }
   ],
   "source": [
    "def concat(x, y):\n",
    "    return x+y;\n",
    "\n",
    "print(concat(\"Hello\", \" Python\"));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Below function takes two arguments and returns two values after performing some operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(20, 30)\n"
     ]
    }
   ],
   "source": [
    "def returnTwo(a, b):\n",
    "    a = a + 10;\n",
    "    b = b + 20;\n",
    "    return a, b;\n",
    "print(returnTwo(10, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### swap() function takes two arguments and swaps the content of the variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before swap -  4 5\n",
      "After swap -  5 4\n"
     ]
    }
   ],
   "source": [
    "def swap(a, b):\n",
    "    return(b, a);\n",
    "x = 4;\n",
    "y = 5;\n",
    "print(\"Before swap - \",x, y);\n",
    "x, y = swap(x, y);\n",
    "print(\"After swap - \",x, y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Below is the function which returns a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 6, 3, 8]\n"
     ]
    }
   ],
   "source": [
    "def returnArray():\n",
    "    a = [1, 2, 6, 3, 8];\n",
    "    return a;\n",
    "print(returnArray())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Below function returns a boolean value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "def returnBoolean(a, b):\n",
    "    if(a>b):\n",
    "        return True;\n",
    "    else:\n",
    "        return False;\n",
    "print(returnBoolean(5, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keyword Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Below function is called with parameter names mentioned explicitely"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID - 1 \n",
      "Name - Naveen\n"
     ]
    }
   ],
   "source": [
    "def printDetails(ID, name):\n",
    "    print(\"ID - \"+str(ID),\"\\nName - \"+name);\n",
    "    #or\n",
    "    #print(\"ID - \",ID,\"\\nName - \"+name);\n",
    "\n",
    "printDetails(name=\"Naveen\", ID=1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable Length Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID -  1\n",
      "Name -  Naveen\n",
      "IIT Bombay\n",
      "M. Tech CSE\n"
     ]
    }
   ],
   "source": [
    "def printDetails(ID, name, *varArg):\n",
    "    print(\"ID - \", ID);\n",
    "    print(\"Name - \", name);\n",
    "    for arg in varArg:\n",
    "        print(arg);\n",
    "printDetails(1, \"Naveen\", \"IIT Bombay\", \"M. Tech CSE\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Local and Global Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "a = 10;\n",
    "def func():\n",
    "    a = 15; # local to func()\n",
    "func()\n",
    "print(a) # prints the global a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "a = 10;\n",
    "def func():\n",
    "    global a;\n",
    "    a = 15; # refers to global a\n",
    "func()\n",
    "print(a) # prints the global a value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Anonymous Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Lambda Functions are anonymous as they don't have any name and they are not defined in the standard manner\n",
    "- They take any number of arguments but return only one value\n",
    "- Operation is performed on the arguments using the expression which is passed\n",
    "- Lambda function takes only expression along with arguments. We are not allowed write any other statements like print\n",
    "- They do not have access to other varaibles declared outside. They have only access to arguments which are passed\n",
    "- Lambda functions helps us to perform basic operations without the need of writing functions explicitly\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70\n"
     ]
    }
   ],
   "source": [
    "x = 30;\n",
    "y= 40;\n",
    "sum = lambda x, y:x+y\n",
    "print(sum(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Generally Lambda functions are used along with Map, Reduce and Filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Map function takes lambda function along with a list on which the operation needs to be performed\n",
    "- Map always returns a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3, 4, 5];\n",
    "for i in range(len(l)):\n",
    "    l[i] = l[i]**2;\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "sqr = list(map(lambda x: x**2, [1, 2, 3, 4, 5])) # Returns \n",
    "print(sqr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 7]\n"
     ]
    }
   ],
   "source": [
    "incr = list(map(lambda x: x+1, [1,3,5,7,6]))\n",
    "print(incr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 2.0, 3.0, 5.0]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "sqrt_list = list(map(math.sqrt, [1, 4, 9, 25]))\n",
    "print(sqrt_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Reduce takes a list and a seed value and outputs a value\n",
    "- Below Reduce Fucntion returns factorial of 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "720\n"
     ]
    }
   ],
   "source": [
    "fact = 1;\n",
    "for i in range(1, 7):\n",
    "    fact = fact*i;\n",
    "print(fact);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "720\n"
     ]
    }
   ],
   "source": [
    "import functools as f\n",
    "fact = f.reduce(lambda x, y: x*y, [i for i in range(1, 7)], 1)\n",
    "print(fact)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- seed value i.e., x = 1\n",
    "- Step-1: y = 1 and x = 1. Therefore x*y = 1 which is returned\n",
    "- Step-2: For this step seed becomes the output of the previous step which is 1. x = 1 and y = 2. Therefore x*y = 2 which is returned.\n",
    "- Step-3: Seed value will be 2 and y = 3 and the steps continue.. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Filter takes a list and returns a filtered list\n",
    "- Below Filter function returns list of integers which are divisible by 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]\n"
     ]
    }
   ],
   "source": [
    "l = [i for i in range(1, 100)];\n",
    "filtered_list=[];\n",
    "for elem in l:\n",
    "    if(elem%3 == 0):\n",
    "        filtered_list.append(elem);\n",
    "print(filtered_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]\n"
     ]
    }
   ],
   "source": [
    "l = [i for i in range(1, 100)];\n",
    "filtered_list = list(filter(lambda x: (x%3 == 0), l))\n",
    "print(filtered_list)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "NB_9999",
   "language": "python",
   "name": "nb_9999"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}