5) More On Functions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "More On Functions.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Coders-Asylum/Python-101/blob/master/More_On_Functions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gyus6kTrDgtD",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "#  **Default agument values**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tcf3TWXVDNLz",
        "colab_type": "text"
      },
      "source": [
        "Argument is one of the way that the information is fed into any functions for your desired operation or the user does'nt enter give a input or an value for the argument is never generated in outside the function.\n",
        "\n",
        "Default arguments is a technique of giving the arguments a default value inside the parenthesis.In this way we accept few argument."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XKUKpxNoDy4q",
        "colab_type": "code",
        "outputId": "d4d00121-72c5-49bf-d32b-03fae22aeec8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "def function_name(a,b=\"world\"):\n",
        "  c=a+b   \n",
        "  return c\n",
        "\n",
        "A=\"hello, \"\n",
        "print(function_name(A))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello, world\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lPx68pDlEPPv",
        "colab_type": "code",
        "outputId": "ef75adf4-a272-48bf-d339-4c73b81b0a15",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "def function_name(a,b=\"world\"):\n",
        "  c=a+b   \n",
        "  return c\n",
        "\n",
        "A=\"hello, \"\n",
        "B='replace_with_your_name'\n",
        "\n",
        "print(function_name(A,B))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello, replace_with_your_name\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hRwmX4ebEEY7",
        "colab_type": "text"
      },
      "source": [
        "Now try the above code with giving a sceond argument as your name:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XidfyBJYE3Mm",
        "colab_type": "text"
      },
      "source": [
        "Default argument values help very much where a function has to have some default values to carry out the function body and the user doesn't give inputs to all the arguments. This is one of the way. But this will help you if you want to restrict a function argument to a specific value. The below example will help you in the same."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fZbFnMpjFWdw",
        "colab_type": "code",
        "outputId": "533349a9-6c54-4ad5-ef43-fa93a7d85403",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "def ask_ok(prompt, retries=4, reminder='Please try again!'):\n",
        "    while True:\n",
        "        ok = input(prompt)\n",
        "        if ok in ('y', 'ye', 'yes'):\n",
        "            return print('Thank You')\n",
        "        if ok in ('n', 'no', 'nop', 'nope'):\n",
        "            return print('Lets go back')\n",
        "        retries = retries - 1\n",
        "        if retries < 0:\n",
        "            raise ValueError('invalid user response')\n",
        "            print(reminder)\n",
        "\n",
        "ask_ok('do you want to quit!')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "do you want to quit!yes\n",
            "Thank You\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4h3Wxuu-Gbt0",
        "colab_type": "text"
      },
      "source": [
        "The above code is a simple code that takes in the user conformation. You may change the code, give a different promt in the function argument, change the number of retries or change the remainder. But if you see carefuly retries is an important argument which calcuates the number of attempts given to the user. So if the function call doesn't pass a  value  for retires, we have an default value given due to which on function call without the reties values would'nt generate an error."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "skWRm9MaIgrW",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "***I would like you to analyze the  function of  'in' and 'raise' for the above code. And keep a note of it.***\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gE_t0PygJQhf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def ask_ok(prompt, retries=4, reminder='Please try again!'):\n",
        "    while True:\n",
        "        ok = input(prompt)\n",
        "        if ok in ('y', 'ye', 'yes'):\n",
        "            return print('Thank You')\n",
        "        if ok in ('n', 'no', 'nop', 'nope'):\n",
        "            return print('Lets go back')\n",
        "        retries = retries - 1\n",
        "        if retries < 0:\n",
        "            raise ValueError('invalid user response')\n",
        "            print(reminder)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "be7SJqj_JG-K",
        "colab_type": "text"
      },
      "source": [
        "This function can be called in several ways:\n",
        "\n",
        "\n",
        "*   giving only the mandatory argument: ask_ok('Do you really want to quit?')\n",
        "*   giving one of the optional arguments: ask_ok('OK to overwrite the file?',2)\n",
        "*or even giving all arguments: ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LZVU-funJw0m",
        "colab_type": "text"
      },
      "source": [
        "**Important:**\n",
        "\n",
        "When you call a default argument value for more than one time you added if you are working with some mutable value such as lists, dictionaries, tuples, etc. Which means it increase the number of elements in this case. I would like you to test the below code in your IDE and understand what happens. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eCslO1LnKeMs",
        "colab_type": "code",
        "outputId": "04002d9c-2e60-4367-f2dd-162b0ffb75d1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "def f(a, L=[]): #function defination\n",
        "  L.append(a)\n",
        "  return L\n",
        "            \n",
        "print(f(1))    #function called first time.\n",
        "print(f(2))    #function called second time.\n",
        "print(f(3))    #function called third time."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1]\n",
            "[1, 2]\n",
            "[1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0YfTGoc3KtUB",
        "colab_type": "text"
      },
      "source": [
        "How you come tackle this problem is by the modifying the code (definition of the function) in the following way: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "twotko6jKyV5",
        "colab_type": "code",
        "outputId": "0244e466-84a1-45a3-9852-92d8dd6d8305",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "def f(a, L=None):\n",
        "  if L is None:\n",
        "    L = []\n",
        "    L.append(a)\n",
        "    return L\n",
        "\n",
        "print(f(1))    #function called first time.\n",
        "print(f(2))    #function called second time.\n",
        "print(f(3))    #function called third time.  "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1]\n",
            "[2]\n",
            "[3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O5nlLlHxtn53",
        "colab_type": "text"
      },
      "source": [
        "# > **Keyword Argument value**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llJt0RMBuAhi",
        "colab_type": "text"
      },
      "source": [
        "Keyword arguments is a second way of addressing the arguments in a function which includes more than one arguments. The first one being positional arguments.\n",
        "\n",
        "Lets take a look at the positional arguments first, in positional arguments during a function call you pass arguments keeping the position of the respective arguments as it is as per the position of the arguments in the function definition."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L2NVoFSFuRLY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n",
        "    print(\"-- This parrot wouldn't\", action, end=' ')\n",
        "    print(\"if you put\", voltage, \"volts through it.\")\n",
        "    print(\"-- Lovely plumage, the\", type)\n",
        "    print(\"-- It's\", state, \"!\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-JpRXWenuWiU",
        "colab_type": "text"
      },
      "source": [
        "Consider the above function definition which has an more than one arguments. If you are calling this function using an positional arguments then the value of 'voltage' would be specified first then 'state' and then 'action' and so on according to the position of the arguments in the function definition. \n",
        "Which would be as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B1iDsIvPugJY",
        "colab_type": "code",
        "outputId": "2e625547-40c2-4ff8-9b5c-88f9911bebcd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n",
        "    print(\"-- This parrot wouldn't\", action, end=' ')\n",
        "    print(\"if you put\", voltage, \"volts through it.\")\n",
        "    print(\"-- Lovely plumage, the\", type)\n",
        "    print(\"-- It's\", state, \"!\")\n",
        "\n",
        "parrot(10000, 'rigid', 'vroom') #leaving type since it has a default argument."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-- This parrot wouldn't vroom if you put 10000 volts through it.\n",
            "-- Lovely plumage, the Norwegian Blue\n",
            "-- It's rigid !\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Undd_RQwux_f",
        "colab_type": "text"
      },
      "source": [
        "**Now in Keyword Arguments:**\n",
        "\n",
        "In the function call the arguments can be placed in any position as long as the argument name (as per the function definition) is writen followed by the '=' and the variable or the value itself.\n",
        "Which would be as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VMv9yrMLu88X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n",
        "    print(\"-- This parrot wouldn't\", action, end=' ')\n",
        "    print(\"if you put\", voltage, \"volts through it.\")\n",
        "    print(\"-- Lovely plumage, the\", type)\n",
        "    print(\"-- It's\", state, \"!\")\n",
        "\n",
        "parrot( state='rigid',voltage=10000, action='vroom')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xJ21ddHmvAdt",
        "colab_type": "text"
      },
      "source": [
        "So with key word agruments you can pass the arguments witout keeping the position of the arguments according to the function defination without generating the error."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ctE6yAS2wwBh",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "# \\*args & \\**kwargs\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ipvrNM8wxazt",
        "colab_type": "text"
      },
      "source": [
        "Its the no of astricks '\\*' that you have to care and the name following the asticks could be aything of your convenience. It can be \\*arguments or  \\**Keywords. Generaly the syntax is \\*name and \\**name.\n",
        "\n",
        "\n",
        "\\*name or \\**name is a way of storing multiple arguments in a list and dictonary in an variable (here name ) respectively. More preciesly the positional arguments will be saved in the form of lists and the keyword arguments will be stored in a form of dictonary.\n",
        "\n",
        "This is useful if you have a huge no of arguments."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tKrx_ebG1KmS",
        "colab_type": "code",
        "outputId": "56b52ff9-a8db-4537-cb38-1f26a0d3cb7e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        }
      },
      "source": [
        "def cheeseshop(kind, *arguments, **keywords):          # arguments and keywords are variables\n",
        "    print(\"-- Do you have any\", kind, \"?\")\n",
        "    print(\"-- I'm sorry, we're all out of\", kind)\n",
        "    for arg in arguments:   #unpacking the list\n",
        "        print(arg)\n",
        "    print(\"-\" * 40)\n",
        "    for kw in keywords:      #unpacking the dictonary\n",
        "        print(kw, \":\", keywords[kw])\n",
        "\n",
        "\n",
        "cheeseshop(\"Limburger\", \"It's very runny, sir.\",\n",
        "           \"It's really very, VERY runny, sir.\",\n",
        "           shopkeeper=\"Michael Palin\",\n",
        "           client=\"John Cleese\",\n",
        "           sketch=\"Cheese Shop Sketch\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-- Do you have any Limburger ?\n",
            "-- I'm sorry, we're all out of Limburger\n",
            "It's very runny, sir.\n",
            "It's really very, VERY runny, sir.\n",
            "----------------------------------------\n",
            "shopkeeper : Michael Palin\n",
            "client : John Cleese\n",
            "sketch : Cheese Shop Sketch\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CgzxGaN111pX",
        "colab_type": "text"
      },
      "source": [
        "Here the postional arguments style is followed and the first argument is 'kind' and given the first argument during the function call. The remaining unkeyworded arguments goes into 'arguments' variable and is stored as a list and the keyworded arguments is stored in the 'keywords' variable as a dictonary."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eOdMhSRA3EJy",
        "colab_type": "text"
      },
      "source": [
        "We have seen how to use \\*args and \\**kwargs in a function definition, they can be aslo used in function calls as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6UYfEKOr3ZmK",
        "colab_type": "code",
        "outputId": "a392dea9-d48d-469c-9f08-1ad2143a5108",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "def parrot(voltage, state='a stiff', action='voom'):\n",
        "     print(\"-- This parrot wouldn't\", action, end=' ')\n",
        "     print(\"if you put\", voltage, \"volts through it.\", end=' ')\n",
        "     print(\"E's\", state, \"!\")\n",
        "\n",
        "d = {\"voltage\": \"four million\", \"state\": \"bleedin' demised\", \"action\": \"VOOM\"}   #defined a dictonary\n",
        "parrot(**d)   #function called using **kwargs type"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ONtmutrx3y_J",
        "colab_type": "text"
      },
      "source": [
        "Similarly instead of a dictonary you can define a list 'd' and call the function parrot as parrot(*d) .![alt text](https://)"
      ]
    }
  ]
}