Part_007_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If I were asked to jot down a list of most helpful yet easy to access functionalities w.r.t generic programming or coding, FUNCTIONS would be at the top of the list. One of the most basic idea of utisling programming in our daily life is getting the boring and redundant stuff we do on a daily basis happen automatically. Guess what, functions help us to achieve the same within the program. Functions are a common functionality available in most programming languages. A good program shold follow the concept of DRY, DO NOT REPEAT YOURSELF !!! Functions capture all the repeative set of statements using an indentifier (fucntion name) , this can be called anywhere, any number of times and the action can be repeated with absolutely zero additional efforts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though the term 'functions' maybe reltively new to us, but all the way in the previous basic data type dicussions we ahve been using functions exhaustively. The expressions/methods like print(), .len(), .append() etc are the existing built in functions available redily in Python. \n",
    "\n",
    "In this section, we discuss about how do we define and execute a user defined funtion to demostrate or achive a target of our own choice. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function f(x) is a piece of code that performs a specified task when called or executed. It may or \n",
    "may not return any value. \n",
    "\n",
    "Functions are advantageous in two main possible manners:\n",
    "\n",
    "1) Avoiding repeatability of the code: \n",
    "\n",
    "There may be certain set of statements that need to\n",
    "be executed multiple times with varying inputs at different segments of the program. The \n",
    "set of sentences that need to repeated can be stored as a function, f(inputs) and called at \n",
    "the whenever required by executing just line of the code instead of retyping the whole set \n",
    "of statements.\n",
    "\n",
    "2) Compartmentalising the code: \n",
    "\n",
    "Certain parts of the code may involve some significant\n",
    "complexity. These can be defined at isolated locations and just be called whenever\n",
    "required so that the basic structure of the code remains simple and easy to understand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Demonstration of reusability of the function sum_func\n",
      "Enter two integers10 20\n",
      "Sum is 30\n",
      "Enter two integers21 34\n",
      "Sum is 55\n",
      "Enter two integers10 20\n",
      "Sum is 30\n",
      "Enter two integers15 23\n",
      "Sum is 38\n",
      "Enter two integers10 90\n",
      "Sum is 100\n"
     ]
    }
   ],
   "source": [
    "#Function defnition is always denoted by the keyword : def\n",
    "#'def' refers to DEFINITION, this is followed by a function name, the identifier which is used to refer the function\n",
    "\n",
    "#BEST FOR THE LAST !!! \n",
    "#FUNCTIONS DO NOT GET EXECUTED AT THE TIME OF DEFINITION\n",
    "#THEY GET EXECUTED ONLY WHEN THEY ARE CALLED USING THE FUNCTION NAME SUFFIXED WITH () IN THE MAIN PROGRAM\n",
    "#PYTHON FUNCTIONS CAN BE DEFINED AT THE STARTING OF THE CODE, THEY CAN BE CALLED ANYWHERE IN THE MAIN PROGRAM\n",
    "\n",
    "#Example function definition to get two integers as inputs and print out the sum of the input numbers\n",
    "def sum_fun():\n",
    "    x,y=input('Enter two integers').split()\n",
    "    x=int(x)\n",
    "    y=int(y)\n",
    "    z=x+y\n",
    "    print(f'Sum is {z}')\n",
    "\n",
    "#Main Program\n",
    "print('Demonstration of reusability of the function sum_func')\n",
    "\n",
    "#Let us simply try to print the sum of two numbers 5 times without rewriting above code 5 times\n",
    "for i in range(5):\n",
    "    sum_fun() #This kind of a statement is referred as a function call. This is exactly when Python executes the function\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The programming syntax w.r.t functions are really simpe, very easy to grasp. \\nBut the devil in the details. With very basic syntax we can achieve wonders, this acts as the devil, \\nsubtle changes in the statements is interpreted by Python differently. \\nThis jupyter notebook feel more like a sotry book than a Python coding reference.'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''The programming syntax w.r.t functions are really simpe, very easy to grasp. \n",
    "But the devil in the details. With very basic syntax we can achieve wonders, this acts as the devil, \n",
    "subtle changes in the statements is interpreted by Python differently. \n",
    "This jupyter notebook feel more like a sotry book than a Python coding reference.'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Return Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us gradually complicate the function sum_fun() to a full fledged function with multiple features\n",
    "\n",
    "Let us start with the return statement. 'Return' statement is an optional statement appended to the tail of the function definition which specified, what the does the function return on being called. We can even return the None Object, for example, the required task is perfomed within the function itself, there is no need to tranfer informtion from within the function to an external object for further operations, we can return NONE. \n",
    "\n",
    "Let us rewrite the above function with a return statement with NONE\n",
    "\n",
    "Note, if not 'return' statement is defined, the function returns NONE (NoneType Object) by default\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Demonstration of reusability of the function sum_func\n",
      "Enter two integers separated by \" \" : 10 10\n",
      "Sum is 20\n",
      "Retruned value is None\n",
      "Type of the returned value is <class 'NoneType'>\n",
      "\n",
      "\n",
      "Enter two integers separated by \" \" : 90 89\n",
      "Sum is 179\n",
      "Retruned value is None\n",
      "Type of the returned value is <class 'NoneType'>\n",
      "\n",
      "\n",
      "Enter two integers separated by \" \" : 88 77\n",
      "Sum is 165\n",
      "Retruned value is None\n",
      "Type of the returned value is <class 'NoneType'>\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def sum_fun_return():\n",
    "    x,y=input('Enter two integers separated by \" \" : ').split()\n",
    "    x=int(x)\n",
    "    y=int(y)\n",
    "    z=x+y\n",
    "    print(f'Sum is {z}')\n",
    "    return None #Return statement, we can return anything (any variable within the scope of this function)\n",
    "\n",
    "#Main Program\n",
    "print('Demonstration of reusability of the function sum_func')\n",
    "\n",
    "#Understanding return statements... If the function is assigned to a vairable when it is called, \\\n",
    "#the returned value gets stored in the variable   \n",
    "\n",
    "for i in range(3):\n",
    "    ret=sum_fun_return()\n",
    "    print(f'Retruned value is {ret}')\n",
    "    print(f'Type of the returned value is {type(ret)}')\n",
    "    print(\"\\n\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Returning Multiple Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the same function, using the same return statement, multiple values can be returned. Let us just understand this through code lines rather than boring stories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Demonstration of reusability of the function sum_func with all returned values stored in a tuple\n",
      "Enter two integers separated by \" \" : 10 15\n",
      "Sum is 25\n",
      "Retruned value is (25, 625, '25')\n",
      "Type of the returned value is <class 'tuple'>\n",
      "\n",
      "\n",
      "Enter two integers separated by \" \" : 23 45\n",
      "Sum is 68\n",
      "Retruned value is (68, 4624, '68')\n",
      "Type of the returned value is <class 'tuple'>\n",
      "\n",
      "\n",
      "Enter two integers separated by \" \" : 13 14\n",
      "Sum is 27\n",
      "Retruned value is (27, 729, '27')\n",
      "Type of the returned value is <class 'tuple'>\n",
      "\n",
      "\n",
      "Demonstration of multiple returns stored in separate variables\n",
      "\n",
      "Enter two integers separated by \" \" : 10 10\n",
      "Sum is 20\n",
      "First Returned value is 20\n",
      "Type of the first returned value is <class 'int'>\n",
      "Second Returned value is 400\n",
      "Type of the first returned value is <class 'int'>\n",
      "Third Returned value is 20\n",
      "Type of the first returned value is <class 'str'>\n",
      "\n",
      "\n",
      "Enter two integers separated by \" \" : 88 54\n",
      "Sum is 142\n",
      "First Returned value is 142\n",
      "Type of the first returned value is <class 'int'>\n",
      "Second Returned value is 20164\n",
      "Type of the first returned value is <class 'int'>\n",
      "Third Returned value is 142\n",
      "Type of the first returned value is <class 'str'>\n",
      "\n",
      "\n",
      "Enter two integers separated by \" \" : 14 56\n",
      "Sum is 70\n",
      "First Returned value is 70\n",
      "Type of the first returned value is <class 'int'>\n",
      "Second Returned value is 4900\n",
      "Type of the first returned value is <class 'int'>\n",
      "Third Returned value is 70\n",
      "Type of the first returned value is <class 'str'>\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def sum_fun_return_multiple():\n",
    "    x,y=input('Enter two integers separated by \" \" : ').split()\n",
    "    x=int(x)\n",
    "    y=int(y)\n",
    "    z=x+y\n",
    "    print(f'Sum is {z}')\n",
    "    return z, z**2, str(z) #Return statement, we can return anything (any expression within the scope of this function)\n",
    "\n",
    "#Main Program\n",
    "print('Demonstration of reusability of the function sum_func with all returned values stored in a tuple')\n",
    "\n",
    "#Understanding return statements... If the function is assigned to a vairable when it is called, \\\n",
    "#the returned value gets stored in the variable   \n",
    "\n",
    "#If the fucntion returns multiple values, but the fucntion call is assigned to just one variable, \n",
    "#A TUPLE of all values returned gets stored in the variable\n",
    "\n",
    "for i in range(3):\n",
    "    ret=sum_fun_return_multiple()\n",
    "    print(f'Retruned value is {ret}')\n",
    "    print(f'Type of the returned value is {type(ret)}')\n",
    "    print(\"\\n\")\n",
    "    \n",
    "#If mutiple variables (equal to the number of values are returned) are used at the time of function call \n",
    "#Each variable will be assinged a return value in the order od retun statement definition\n",
    "\n",
    "print('Demonstration of multiple returns stored in separate variables\\n')\n",
    "\n",
    "for i in range(3):\n",
    "    ret_sum, ret_sum_square, ret_sum_string=sum_fun_return_multiple()\n",
    "    print(f'First Returned value is {ret_sum}')\n",
    "    print(f'Type of the first returned value is {type(ret_sum)}')\n",
    "    print(f'Second Returned value is {ret_sum_square}')\n",
    "    print(f'Type of the first returned value is {type(ret_sum_square)}')\n",
    "    print(f'Third Returned value is {ret_sum_string}')\n",
    "    print(f'Type of the first returned value is {type(ret_sum_string)}')\n",
    "    print(\"\\n\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parameters and Positional Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Guess, we are in the final stage of discussion to utilise functions effectively. After understanding Parameters and Arguments we will be a situation to explot functions. It is all about the right application as per our requirements.\n",
    "\n",
    "I am very sure, the empty brackets () at the time of function definition and fucntion call might have intrigued everyone. Why is it always empty, can't we use this empty space to do some additional wonders ?? Yes we can. \n",
    "\n",
    "Let us dicuss PARAMETERS first. At the time of definition of a function, we can define a certain set of variables, which can be used within the scope of the function to perform any action. These variables can be fed at the time of function call. When the function is called, same number of variables need to be defined which will be fed to the function for its execution. The variables defined at the time of funnction call is called as ARGUMENTS.\n",
    "\n",
    "These are known as POSITIONAL ARGUMENTS. The sequence of the arguments fed at the time of the function call will be passed on the PARAMTERS at the time in the same sequence at the time of function definition.\n",
    "\n",
    "Food for thought, we can use '_' (without ' ') as a variable name, also referred as a placeholder, if we are interested in a particualr value, but in case of positional outputs like multiple returns, out interest in just the 3rd return, first and second are just by products, we do not need to assign them to two different variables, rather use '_','_', var3 = fun()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Demonstration of Positional Arguments\n",
      "\n",
      "Enter two integers separated by \" \" : 14 15\n",
      "Sum is 29\n",
      "Retruned value is (29, 841, '29')\n",
      "Type of the returned value is <class 'tuple'>\n",
      "\n",
      "\n",
      "Enter two integers separated by \" \" : 13 19\n",
      "Sum is 32\n",
      "Retruned value is (32, 1024, '32')\n",
      "Type of the returned value is <class 'tuple'>\n",
      "\n",
      "\n",
      "Enter two integers separated by \" \" : 15 15\n",
      "Sum is 30\n",
      "Retruned value is (30, 900, '30')\n",
      "Type of the returned value is <class 'tuple'>\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#let us just replicate the same sum function, but instead of taking inputs inside the function, let us pass them as args\n",
    "\n",
    "def sum_fun_pos_args(x,y): #x and y are the parameters, these can be used within the scope of this function\n",
    "    z=x+y\n",
    "    print(f'Sum is {z}')\n",
    "    return z, z**2, str(z) #Return statement, we can return anything (any expression within the scope of this function)\n",
    "\n",
    "#Main Program\n",
    "print('Demonstration of Positional Arguments\\n')\n",
    "\n",
    "#Understanding return statements... If the function is assigned to a vairable when it is called, \\\n",
    "#the returned value gets stored in the variable   \n",
    "\n",
    "#If the fucntion returns multiple values, but the fucntion call is assigned to just one variable, \n",
    "#A TUPLE of all values returned gets stored in the variable\n",
    "\n",
    "for i in range(3):\n",
    "    a,b=input('Enter two integers separated by \" \" : ').split()\n",
    "    a=int(a)\n",
    "    b=int(b)\n",
    "    ret=sum_fun_pos_args(a,b) \n",
    "    #The variables a, b are the arguments ..it will supply the values to params x, y in the function sequentially\n",
    "    print(f'Retruned value is {ret}')\n",
    "    print(f'Type of the returned value is {type(ret)}')\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Keyword Arguments (**kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Until now, we have been working on arguments which are positional in nature. This means, the number of arhuments passed at the time of function call should be same as the number of parameters defined at the time of the time of function definition. Secondly, the sequennce of arguments and paramters should be the same so that Python assings the right value to the right variable. Now what if, we want to provide some default values as input to the parameters or we are not really interested in changing certain parameters for most cases, we need not keep passing all the arguments again and again at the time of a function call, we can define certain default values in the parameters definition itself. Such arguments are called as KEYWORD Arguments. Let us look at a basic example and then discuss further in detail. \n",
    "\n",
    "In our discussions, the term argument refers to postional arguments unless explicity specified as Keyword arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "#Defining some dummy function to return some integer\n",
    "\n",
    "def ret_in(a=10): #Notice the value of 10 assigned to the parameter a, this is KEYWORD Argument, a default value is assinged\n",
    "    return a\n",
    "\n",
    "#Executing function ret_in\n",
    "print(ret_in()) #Notice, no arguments are passed, even though it has an argument. Since it is a kwarg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "#Overriding defaukt values in a Keyword argument\n",
    "#If a fucntion call is accompanied by some argument, this will override the default value of the kwarg assigned\n",
    "\n",
    "def ret_in_override(a=10): #Notice the value of 10 assigned to the parameter a, this is KEYWORD Argument, a default value is assinged\n",
    "    return a\n",
    "\n",
    "#Executing function ret_in\n",
    "print(ret_in_override(20)) #Notice, this argument overrides the default value defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use Keyword Arguments and Positional Arguments together in the same function. The only thing to be kept in mind is that, when defining the function and its paramters, the kwargs should be defined at the end. The whole idea behind this restriction is that, Python understands positional arguments based on the sequence of variable definition.. if we suddenly define a kwarg in bewteen and assign some default value, Python won't be able to interpret such anarchies. Hence, define all the postional arguments/parameters first, then define the kwargs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 15\n",
      "b is 10\n",
      "The sum is 25\n"
     ]
    }
   ],
   "source": [
    "#Let us try to find the sum of two numbers where one number is fed to the function as a kwarg\n",
    "\n",
    "def sum_func_kwarg(a, b=10):\n",
    "    print(f'a is {a}')\n",
    "    print(f'b is {b}')\n",
    "    return a+b\n",
    "print(f'The sum is {sum_func_kwarg(15)}') \n",
    "#Notice, the function has two params, a, b. 15 is the positional argument (a), b is a kwarg with default value 10\n",
    "#The positional arguments are defined prior or kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "def temp_(*args):\n",
    "    conc=[]\n",
    "    for item in args:\n",
    "        conc.extend(item)\n",
    "    return conc    \n",
    "print(temp_([1,2,3],[4,5,6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# args and kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' \"args\" refer to postional arguments and \"kwargs\" refer to keywrod arguments. But what is the whole point of discussing it\\n again in ?? \\n Well, here is the catch, now we are going to discuss dynamic argumnents, means, as a developer, we can use the *args to \\n allow the user to input as many postional arguments as possible at the time of function call. All these need not be\\n defined as parameters in the function definition .... Sounds powerful, right ?'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Finally, time to fully utilise some additional benefits using the *args and **kwargs feature\n",
    "\n",
    "''' \"args\" refer to postional arguments and \"kwargs\" refer to keywrod arguments. But what is the whole point of discussing it\n",
    " again in ?? \n",
    " Well, here is the catch, now we are going to discuss dynamic argumnents, means, as a developer, we can use the *args to \n",
    " allow the user to input as many postional arguments as possible at the time of function call. All these need not be\n",
    " defined as parameters in the function definition .... Sounds powerful, right ?'''\n",
    "\n",
    "#let us understand *args first, then we just analogially understand **kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Type of the series that stores *args is <class 'tuple'>\n",
      "\n",
      "The required sum of numerical values passed to the function sum_numeric() is : 18.4\n"
     ]
    }
   ],
   "source": [
    "#Utilization of *args\n",
    "\n",
    "#let us write a function which can take in as many arguments as it can, \n",
    "#And returns the sum of all the integers ane float data type arguments passed\n",
    "\n",
    "def sum_numeric(*args): #The use of *args means, it can take any number of postional arguments at the time of function call\n",
    "    sum_num=0\n",
    "    \n",
    "    for item in args: #*args is a series of postional arguments, this can be iterated upon\n",
    "        if (type(item)==int) or (type(item)==float):\n",
    "            sum_num+=item\n",
    "        else:\n",
    "            pass\n",
    "    print(f\"\\nType of the series that stores *args is {type(args)}\\n\" )\n",
    "    return sum_num\n",
    "\n",
    "#Let us call the fucntion by passing some arbitrary arguments\n",
    "\n",
    "target_sum=sum_numeric(1,3.5,'Hi 5',5, 8.9, [3,4,5],True, False, True or False)\n",
    "\n",
    "print(f'The required sum of numerical values passed to the function sum_numeric() is : {target_sum}' )\n",
    "        \n",
    "#Noticed, no whatever number of arguments gets passed, sum of all numerical values gets calculated\n",
    "#All Hail *args \n",
    "\n",
    "#Remember, * is just to notify Python at the time of fucntion definition that it can dynamically take any number of args\n",
    "#Thorughout the fucntion definition, it is referred as args without the *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Type of the series that stores *args is <class 'dict'>\n",
      "\n",
      "The required sum of numerical values passed to the function sum_numeric() is : 18.4\n"
     ]
    }
   ],
   "source": [
    "#And yes, time for **kwargs .. Guess we can already guess, what it is ... just something similar to *args\n",
    "#But the arguments should be supplied as key-word args rather than just args\n",
    "\n",
    "#The following example will clarify it\n",
    "\n",
    "#The use of **kwargs means, it can take any number of key word arguments at the time of function call\n",
    "\n",
    "def sum_numeric_kwargs(**kwargs): \n",
    "    sum_num=0\n",
    "    \n",
    "    for item in kwargs: #kwargs is a series of key word arguments, this can be iterated upon\n",
    "        \n",
    "        if (type(kwargs[item])==int) or (type(kwargs[item])==float):\n",
    "            sum_num+=kwargs[item]\n",
    "        else:\n",
    "            pass\n",
    "    print(f\"\\nType of the series that stores *args is {type(kwargs)}\\n\" )\n",
    "    return sum_num\n",
    "\n",
    "#Let us call the fucntion by passing some arbitrary arguments along with keywords (i.e variable names)\n",
    "\n",
    "target_sum=sum_numeric_kwargs(a=1,b=3.5,c='Hi 5',d=5, e=8.9, f=[3,4,5], g=True, h = False, i =True or False)\n",
    "\n",
    "print(f'The required sum of numerical values passed to the function sum_numeric() is : {target_sum}' )\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hello, yes, the syntax for kwargs does not exactly look like that fr args, right ?? The secret is hidden in the details... Check the data type of args in the first example with args and comapre against the same for kwargs ... WHAT DO WE SEE ??\n",
    "\n",
    "Args are stored or interpreted as tuples, we knew this already, in Python, the series or postional arguments are interpreted as tuples. So on iterating over tuples, we could directly access the items within the tuple, i.e the induvidual arguments.\n",
    "\n",
    "But in case of kwargs using the double asterik .... Python maps the keywords supplied to their corresponding values. And KEY-VALUE pairs are interpreted as DICTIONARIES by Python. Hence, when iterated ove the iterator KWARGS as it is iterated over the keys of the dictioanry and not over the values. To access the values, just index the dcitionary with its key ... as KWARG[KEY]\n",
    "\n",
    "I would suggest, please give a read about dictionaries once more to understand KWARGS better :\n",
    "https://github.com/arvindhhp/PyPro_ahhp/blob/main/Part_006_Dictionaries.ipynb\n",
    "\n",
    "Lastly, one statement, ARGS and KWARGS can be used together in a function call, it is just that, the number of arguments are not fixed anyore. Happy deploying DRY !!!!\n",
    "\n",
    "This ends the discussion on FUNCTIONS .. CONGRATULATIONS !!!!!! "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}