Function_In_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Function In Python",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i62Cx-sgEjRH"
      },
      "source": [
        "<b><h1>**FUNCTIONS IN PYTHON**</h1><b>\n",
        "<h4> Welcome to the lesson on Function! You will learn why and how we use functions in Python :)</h4>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-qW2PqmxGTCM"
      },
      "source": [
        "<h3><b>What is a Function and why we use it</h3></b>\n",
        "A function is a block of which when called perform a specific task.\n",
        "In python programming or any programming language you use, a function is used:\n",
        "\n",
        "<i><li> When a specific block of code is required to be performed again and again.\n",
        "<i><li> To make the code easier to understand and more user friendly."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PhCK935wIbSP"
      },
      "source": [
        "<H3><B>IMPLEMENTING A FUNCTION</b></h3>\n",
        "<u><h5>For implementing a function we need to follow three steps:</u></h5>\n",
        "<ul><li><I>   Define the function\n",
        "<li>   Write function body\n",
        "<li>   Return Statement</i></ul>\n",
        "Don't Worry!! We will  look at these three steps one by one\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VsYtma0koCgV"
      },
      "source": [
        "<h3><b>1. Defining a Funnction in Python</b></h3>\n",
        "\n",
        "In python you define a Function using the keyword <u>**def**</u>.\n",
        "```\n",
        "# To define a  function we first write the keyword \"def\" followed by \"name of the function\" and round paranthesis \"()\". \n",
        "\n",
        "def Fun_Name():\n",
        "    ## Here we just defined a function\n",
        "    ## The name of the function is Fun_Name\n",
        "    ## COOL XD\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-OLSFOg5p1OY"
      },
      "source": [
        "<h3><b>2. Writing the Function body</b></h3>\n",
        "\n",
        "After defining the function now you need to write the body of the function which is the working of youe function  <i>i.e. what you want your function to do for you</i>\n",
        "\n",
        "```\n",
        "def Hello():\n",
        "    print('Hello')\n",
        "```\n",
        "<h5> The code above will print Hello whenever you call the function.</h5>\n",
        "<b> Don't worry we will see calling function in details later... </B> <br><br>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2QhjUtOP6WnQ"
      },
      "source": [
        "#LET'S TRY THE ABOVE CODE\n",
        "def Hello():\n",
        "  print('Hello')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MXh60SMz6mBK"
      },
      "source": [
        "><b>Note: You can use as many print lines in the function as you want!!</b>\n",
        "\n",
        "<br>\n",
        "<h2><b>TASK</b></h2>\n",
        "Try making a function to print the message you want the way we just did...  For now keep the name of the function <b>ShapeAI</b>  and run the two cells below..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DP3EpUlas0v_"
      },
      "source": [
        "def ShapeAI():\n",
        "  ## PRINT WHATEVER YOU WANT TO PRINT BUT MAKE SURE TO INDENT THE CODE PROPERLY\n",
        "  \n",
        "\n",
        "# DON'T WORRY AFTER YOU RUN THIS CELL,THERE WOULD BE NO OUTPUT AS YOU ARE JUST DEFINING THE FUNCTION"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cDj9lwFFs1Fx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fd52a758-fbae-4810-da5d-e08c140cb0b8"
      },
      "source": [
        "ShapeAI()    ## HERE WE ARE CALLING THE FUNCTION, IT SHOULD PRIINT THE STATEMENT YOU ASKED THE FUNCTION TO PRINT IN THE ABOVE CELL"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7q_vkccewgc4"
      },
      "source": [
        "<b>In the function we just defined we just called the function and didnot pass any other value..But what if you want to write a function that print the addition of the two number that you want?</b>\n",
        "<li>You have to pass the two values in the function as an argument...\n",
        "<BR>\n",
        "<br>\n",
        "<b>How does you do that?</b>\n",
        "<li>You define the arguments you want your function to take as input when the function is called inside the round paaranthesis\n",
        "\n",
        "```\n",
        "def ADD(a, b):\n",
        "    print(a+b)\n",
        "```\n",
        "<i>The function we just wrote take the two arguments by the user and store them in local variables <b>a</b> and <b>b</b>. The function then use the value stored in the variables to perform addition and print the addition</i>\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TPEdfLOj6uO_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1957aac6-91d5-4c44-a251-3722aef66d74"
      },
      "source": [
        "def ADD(a,b):\n",
        "  print(a+b)\n",
        "\n",
        "ADD(5,6)  #expexted output = 11"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NhKPhAej7RRc"
      },
      "source": [
        "<H4><B>Calling of a Function</b></h4>\n",
        "\n",
        "<li>Calling a function means to make a refference in your code to a function that you wrote.\n",
        "<li>To call a function you need to write the function name followed by round parannthesis <b>()</b>\n",
        "<li>If the function you're calling requires arguments, you pass the argument values inside the paranthesis.  \n",
        "\n",
        "\n",
        "```\n",
        "fun_name(arguments_to_pass_if_any)   # This how a function is called\n",
        "```\n",
        "If you notice, while calling the ADD function or any of the function we define above, we just follow the same pattern. In the function hello, we didnot pass any argument because that didn't need any argument.<br><br>\n",
        "\n",
        "> **NOTE:** We can pass the arguments while calling the function using two ways:\n",
        "* *By position, and*\n",
        "* *By name*\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jyCOQ8kj-cOZ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "ae722ca1-009b-49c9-de43-8db4f6688cdd"
      },
      "source": [
        "def divide(numinator, denominator):\n",
        "  print(numinator/denominator)\n",
        "\n",
        "divide(4,2)   # Calling by position\n",
        "divide(denominator=2, numinator=4)   # Calling ny name"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.0\n",
            "2.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HiEo76HX62uy"
      },
      "source": [
        "<h2><b>Task:</b></h2>Write a function which takes two number as arguments and print the multiplication of the two numbers\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-vBMmkR75ZDl"
      },
      "source": [
        "def Multiply(## WRITE THE VARIABLE NAMES):\n",
        "  ## WRITE THE CODE TO PRINT THE MULTIPLICATION OF TWO NUMBERS\n",
        "\n",
        "\n",
        "# Call the multiply function you just defined "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CZn_Rz6a646Z"
      },
      "source": [
        "<h4> <B> Default Values to the Arguments</b></h4>\n",
        "While defining a function you can set some default values for the arguments in case if user dosn't pass the argument value\n",
        "Let's look how:<br>\n",
        "\n",
        "```\n",
        "def Area(length=2, breadth=2):\n",
        "    print(length*breadth)\n",
        "```\n",
        "Here if you don't pass the values of length and breadth while calling the function, the default values the function will take will be 2 and 2 for length and breadth repectively.</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s9WoT5I08lJR"
      },
      "source": [
        "# Lets give it a try\n",
        "def Area(length=5, breadth=1):\n",
        "  print(length*breadth)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "05708Hxs9Ak3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "a717bbbb-971b-43f6-84f0-67d663a0f89f"
      },
      "source": [
        "Area(5,2)          # Expected Output: 10\n",
        "Area(3)            # Expected Output: 3\n",
        "Area(breadth=2)    # Expected Output: 10\n",
        "Area()             # Expected Output: 5"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "3\n",
            "10\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z2_NfhKP9e_k"
      },
      "source": [
        "<h3> <b>3. Return Statement</h3></b>\n",
        "<b>In the function we saw above, we just print the things which we wanted. But what if we instead of printing the value, we want to store those values and use them later for our work ?</b>\n",
        "<li> We use the return statement to return the calculations we did in our function\n",
        "\n",
        "```\n",
        "def ADD(a=4, b=3):\n",
        "    returb a+b\n",
        "```\n",
        "The code returns the addition of two numbers, we can store the value return by the function and use it later whenever required"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mSzq9Na69sUr"
      },
      "source": [
        "# Let's see the code in action\n",
        "def ADD(a=10, b=20):\n",
        "  return a+b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xFi0OPFkAX7U",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d141711a-a388-4a00-f33a-2606d83fbd0a"
      },
      "source": [
        "sum = ADD(5,2)\n",
        "# HERE WE JUST STORED THE VALUE RETURNED BY THE FUNCTION IN THE VARIABLE SUM \n",
        "# LET'S SEE WHAT DOES THE VARIABLE SUM CONTAIN BY PRINTIG IT\n",
        "print(sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ZYcLWB0BGUT"
      },
      "source": [
        "> <B>Note: You can also return more than one value in a function</B>\n",
        "\n",
        "```\n",
        "def Fun(a=5, b=10):\n",
        "    sum=a+b\n",
        "    diff=a-b\n",
        "    return sum, diff \n",
        "```\n",
        "The code returns the addition and subtraction of the two numbers..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KLq3T8KPC-Ar"
      },
      "source": [
        "def Fun(a=5, b=10):\n",
        "  sum=a+b\n",
        "  diff=a-b\n",
        "  return sum, diff"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jv41bQubDHzJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "4b0d7453-2953-4309-e11c-6b193538a2fe"
      },
      "source": [
        "sum, diff = Fun(10,6)\n",
        "print(f'Addition of the two numbers is {sum}')\n",
        "print(f'Difference of the two numbers is {diff}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Addition of the two numbers is 16\n",
            "Difference of the two numbers is 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SqjcXLtSEWWy"
      },
      "source": [
        "> <b>Note: All function have a return statement. If you doesn't return anything then by default it returns None</b>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a-YipBdOEhjD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "cc5d7ade-8f36-4a66-ea15-af6080e154d8"
      },
      "source": [
        "a = Area()\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "It9OU80SXKP2"
      },
      "source": [
        "## **Summary:**\n",
        "A function definition includes several important parts.\n",
        "\n",
        "#### **Function Header:**\n",
        "Let's start with the function header, which is the first line of a function definition.\n",
        "\n",
        "1. The function header always starts with the def keyword, which indicates that this is a function definition.\n",
        "2. Then comes the function name (here, cylinder_volume), which follows the same naming conventions as variables. You can revisit the naming conventions below.\n",
        "3. Immediately after the name are parentheses that may include arguments separated by commas (here, height and radius). Arguments, or parameters, are values that are passed in as inputs when the function is called, and are used in the function body. If a function doesn't take arguments, these parentheses are left empty.\n",
        "4. The header always end with a colon :.\n",
        "<br><br>\n",
        "\n",
        "#### **Function Body:**\n",
        "The rest of the function is contained in the body, which is where the function does its work.\n",
        "\n",
        "1. The body of a function is the code indented after the header line. Here, it's the two lines that define pi and return the volume.\n",
        "2. Within this body, we can refer to the argument variables and define new variables, which can only be used within these indented lines.\n",
        "3. The body will often include a return statement, which is used to send back an output value from the function to the statement that called the function. A return statement consists of the return keyword followed by an expression that is evaluated to get the output value for the function. If there is no return statement, the function simply returns None.\n",
        "\n",
        "\n",
        "Below, you'll find a code editor where you can experiment with this.\n",
        "<br><br>\n",
        "\n",
        "\n",
        "#### **Naming Conventions for Functions:**\n",
        "Function names follow the same naming conventions as variables.\n",
        "\n",
        "1. Only use ordinary letters, numbers and underscores in your function names. They can’t have spaces, and need to start with a letter or underscore.\n",
        "2. You can’t use reserved words or built-in identifiers that have important purposes in Python, which you’ll learn about throughout this bootcamp.\n",
        "3. Try to use descriptive names that can help readers understand what the function does."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1zWym1bCYaIO"
      },
      "source": [
        "### **Question:**\n",
        "Write a function named population_density that takes two arguments, population and land_area, and returns a population density calculated from those values. I've included two test cases that you can use to verify that your function works correctly. Once you've written your function, use the Test Run button to test your code."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xl0sQn71YhmM"
      },
      "source": [
        "# write your function here\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# test cases for your function\n",
        "test1 = population_density(10, 1)\n",
        "expected_result1 = 10\n",
        "print(\"expected result: {}, actual result: {}\".format(expected_result1, test1))\n",
        "\n",
        "test2 = population_density(864816, 121.4)\n",
        "expected_result2 = 7123.6902801\n",
        "print(\"expected result: {}, actual result: {}\".format(expected_result2, test2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mUQ7EhYmYmAQ"
      },
      "source": [
        "### **Question:**\n",
        "Write a function named readable_timedelta. The function should take one argument, an integer days, and return a string that says how many weeks and days that is. For example, calling the function and printing the result like this:\n",
        "\n",
        "```\n",
        "print(readable_timedelta(10))\n",
        "```\n",
        "should output the following:\n",
        "```\n",
        "1 week(s) and 3 day(s).\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DoExPTYTY0CQ"
      },
      "source": [
        "# write your function here\n",
        "\n",
        "\n",
        "# test your function\n",
        "print(readable_timedelta(10))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ZHUsdxdeixH"
      },
      "source": [
        "<H2> <b>Lambda Function </b> </H2>\n",
        "We just saw a simple function to return addition of two numbers, instead of writting the function the way we defined earlier there is an another way of writtng it.\n",
        "\n",
        "```\n",
        "def Add(a, b):\n",
        "    return a+b\n",
        "```\n",
        "The code above can be written as:\n",
        "\n",
        "```\n",
        "Add = lambda a,b: a+b\n",
        "```\n",
        "\n",
        "> <b> Note: The lambda function can take any number of arguments but can have only one expression\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PVz2uvOhgd_5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a268e168-32b9-4603-819e-6db30c1db50b"
      },
      "source": [
        "Sub = lambda a,b: a-b\n",
        "\n",
        "print(Sub(5,2))    #EXPEXTED OUTPUT: 3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lj2o-TCQbbcH"
      },
      "source": [
        "### **Components of a Lambda Function:**\n",
        "1. The lambda keyword is used to indicate that this is a lambda expression.\n",
        "2. Following lambda are one or more arguments for the anonymous function separated by commas, followed by a colon :. Similar to functions, the way the arguments are named in a lambda expression is arbitrary.\n",
        "3. Last is an expression that is evaluated and returned in this function. This is a lot like an expression you might see as a return statement in a function.\n",
        "\n",
        "With this structure, lambda expressions aren’t ideal for complex functions, but can be very useful for short, simple functions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WKLQ5wLybvql"
      },
      "source": [
        "### **Question:**\n",
        "map() is a higher-order built-in function that takes a function and iterable as inputs, and returns an iterator that applies the function to each element of the iterable. The code below uses map() to find the mean of each list in numbers to create the list averages. Give it a test run to see what happens.\n",
        "\n",
        "Rewrite this code to be more concise by replacing the mean function with a lambda expression defined within the call to map()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T4v-Zdlmb1l6"
      },
      "source": [
        "numbers = [\n",
        "              [34, 63, 88, 71, 29],\n",
        "              [90, 78, 51, 27, 45],\n",
        "              [63, 37, 85, 46, 22],\n",
        "              [51, 22, 34, 11, 18]\n",
        "           ]\n",
        "\n",
        "def mean(num_list):\n",
        "    return sum(num_list) / len(num_list)\n",
        "\n",
        "averages = list(map(mean, numbers))\n",
        "print(averages)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6jeo8OmIAvYx"
      },
      "source": [
        "**<h2>VARIABLE SCOPE</h2>**\n",
        " The scope of the variable reffers to which part of the code, the variable can be referenced, or used, from\n",
        "\n",
        "* If a variable is created inside a function, then it can only be used inside that function and not anywhere else."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6l0VMXsZBUD6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 195
        },
        "outputId": "799b4c9f-d248-483a-b371-8d48e377f514"
      },
      "source": [
        "def sum(a, b):\n",
        "  answer = a+b\n",
        "  return answer\n",
        "\n",
        "S = sum(5,6)\n",
        "print(answer)  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-51cf615d0ff2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mS\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0manswer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'answer' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WGuzyNZmB8MW"
      },
      "source": [
        "Here we will get an error, because the variable answer is defined within the the function and can't be used outside unless defined"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S7rV4GiDCARY"
      },
      "source": [
        "<br>On the other hand, we might have a variable defined outside the function, and we can access it anywhere outside or within these functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BDo_TT6XCSDM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "8dffbb4d-27c3-48eb-c05f-1d13758abfe9"
      },
      "source": [
        "ans = 0\n",
        "def print_ans():\n",
        "  print(ans)\n",
        "\n",
        "print_ans()\n",
        "print(ans)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kYPgvVWbDFhs"
      },
      "source": [
        "The purpose of the functions is to make the code cleaner and easy to understand. Writting the formula for calculating simple interest again and again is mush more difficult to understand than writting a function to calculate the interest ans call it again and again.<br>\n",
        "<br>\n",
        "One of the most important thing that makes code conataining the function easier to understand is that the functions have the human defined name, which are easier to understand i.e. the function to return area of the circle can be named as cir_area, which makes it easier to recognize as the area of circle.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pIY7nP_dZoKx"
      },
      "source": [
        "> **Good practice:** It is best to define variables in the smallest scope they will be needed in. While functions can refer to variables defined in a larger scope, this is very rarely a good idea since you may not know what variables you have defined if your program has a lot of variables.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XZitbxlaZkZt"
      },
      "source": [
        "## **DOCSTRINGS**\n",
        "There is one more technique that makes the function in python more readable, the **documentation strings** or the **docstrings**. Docstrings are the type of comments that explains the purpose of a function and how it should be used.\n",
        "\n",
        "* Docstrings are surrounded by tripple quotes.\n",
        "* The first line of the docstring is the brief explaination of the function perpose.\n",
        "* The next line of the docstring is generally contains information about the arguments that the function takes\n",
        "* Finally it provides the description about the output.\n",
        "\n",
        ">**NOTE:** Every part of the docstring is optional, but it is good habit to write docstring while defining a function, so that everyone can understand the code easily"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k6aGsQJdGPIm",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ad0d7971-629f-4e2a-80fe-adcf0c8f5757"
      },
      "source": [
        "def simple_interest(amount, rate, time):\n",
        "  \"\"\"\n",
        "  Calculate the total amount to be paid after adding Simple Interest.\n",
        "  INPUT:\n",
        "  amount = principal amount (ruppes)\n",
        "  rate = rate (in %) at which the interest is gonna increase (rupees/year)\n",
        "  time = time for which the principal amount was kept (in years)\n",
        "\n",
        "  OUTPUT:\n",
        "  returns the total amount to be paid after adding simple interest \n",
        "  \"\"\"\n",
        "  return (amount + amount*rate*time/100)\n",
        "\n",
        "simple_interest(1000, 10, 1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1100.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8wDTqUigbD4u"
      },
      "source": [
        "If you think that a longer description would be appropriate for the function, you can add more information after the one-line summary. In the example above, you can see that we wrote an explanation of the function's arguments, stating the purpose and types of each one. It's also common to provide some description of the function's output.\n",
        "\n",
        "Every piece of the docstring is optional, however, docstrings are a part of good coding practice. You can read more about docstring conventions [here.](https://www.python.org/dev/peps/pep-0257/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fm0KB_kaCl9p"
      },
      "source": [
        "Scope is essential to understand how information is passed in python or any other programming language"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K6ZDNvQ3FHEe"
      },
      "source": [
        "**<h3>TASK**</h3>\n",
        "Write a python function find max(a/b) for all (a,b) belongs to {x1, x2, x3}, where x1, x2 and x3 are the numbers passed as an argument to the function.\n",
        "<br><br>\n",
        "for e.g: if we pass 1, 2 and 3 to the function , then it should return:\n",
        "\n",
        "**max( 1/1, 1/2, 1/3, 2/1, 2/2, 2/3, 3/1, 3/2, 3/3 )**\n",
        "so the answer for the example will be 3 *i.e* 3/1.   \n",
        "\n",
        "also write an appropriate docstring for that"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RcO6Um_NbS-n"
      },
      "source": [
        "# your function here"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}