Python_for_Machine_Learning.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python for Machine Learning",
      "provenance": [],
      "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/ialimustufa/python-crash-course/blob/master/Python_for_Machine_Learning.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ei-GOj0Gu-9S"
      },
      "source": [
        "#Introduction to Colab for the classroom\n",
        "\n",
        "This is an \"Google Colab\" notebook. It's a shared document where everybody can see and make changes to the same document.\n",
        "\n",
        "The first few problems will get us acquainted with working together;\n",
        "\n",
        "1.Go to file in the upper left corner\n",
        "\n",
        "2.Click Save copy in drive\n",
        "\n",
        "3.Follow along and use your own notebook!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1D9tQyRbuQwg"
      },
      "source": [
        "# This is a comment\n",
        "# in a code cell\n",
        "# Press shift + enter to execute a cell\n",
        "# Nothing will print from this cell since these are all comments"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-TjZmYl523lH"
      },
      "source": [
        "# **What is Python?**\n",
        "\n",
        "Python is an open-source object-oriented programming language. It first \n",
        "appeared in 1991 and has become extremely popular among data scientists. StackOverflow calls it as the fastest growing programming language.\n",
        "\n",
        "It is used for:\n",
        "\n",
        "*   Web development\n",
        "*   Software Development\n",
        "*   Mathematics\n",
        "*   System Scripting and Much more\n",
        "\n",
        "\n",
        "# **What Python can do?**\n",
        "\n",
        "*   Python can be used on a server to create web applications.\n",
        "*   Python can be used alongside software to create workflows.\n",
        "*   Python can connect to database systems. It can also read and modify files.\n",
        "*   Python can be used to handle big data and perform complex mathematics.\n",
        "*   Python can be used for rapid prototyping, or for production-ready software development."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jj2dwPJGxZDy"
      },
      "source": [
        "# Why Learn Python?\n",
        "Python’s syntax is very simple hence it's easy for the beginners to understand. The lines of code required for a task is less compared to other languages.\n",
        "\n",
        "\n",
        "*  Python works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc).\n",
        "* Python has a simple syntax similar to the English language.\n",
        "* Python has syntax that allows developers to write programs with fewer lines than some other programming languages.\n",
        "*  Python runs on an interpreter system, meaning that code can be executed as soon as it is written. This means that prototyping can be very quick.\n",
        "*  Python can be treated in a procedural way, an object-orientated way or a functional way."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XnoczNYXz1TI"
      },
      "source": [
        "# **Let’s look at some cool features of Python:**\n",
        "\n",
        "1.   Simple and easy to learn\n",
        "2.   Free and Open Source\n",
        "3.   Portable\n",
        "4.   Supports different programming paradigm\n",
        "5.   Extensible"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tjwVKXvB0VKw"
      },
      "source": [
        "# **Python Applications:**\n",
        "​\n",
        "1.    Artificial Intelligence\n",
        "2.    Desktop Application\n",
        "3.    Automation\n",
        "4.    Web Development\n",
        "5.    Data Wrangling, Exploration\n",
        "6.    Visualization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "huR1RLMp1FgR"
      },
      "source": [
        "# **Python Setup:**\n",
        "\n",
        "For Windows PC, search in the start bar for Python or run the following on the Command Line (cmd.exe):\n",
        "\n",
        "```\n",
        "C:\\Users\\Your Name>python --version\n",
        "```\n",
        "\n",
        "To check if you have python installed on a Linux or Mac, then on linux open the command line or on Mac open the Terminal and type:\n",
        "\n",
        "```\n",
        "python --version\n",
        "```\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "*   If you are on Windows OS download Python by [clicking here](https://www.python.org/downloads/windows/) and now install from the setup and in the start menu type IDLE.IDLE, you can think it as an Python’s IDE to run the Python Scripts.\n",
        "*  If you are on Linux/Unix-like just open the terminal and on 99% linux OS Python comes preinstalled with the OS.Just type ‘python3’ in terminal and you are ready to go.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1bl4wCqBnDv8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eb728101-99ce-4994-a1fd-e12c8f60386e"
      },
      "source": [
        "# uncomment and run this code (Rember in colab you need to ass a \"!\" before running linux commands)\r\n",
        "!python --version "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Python 3.7.10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cc1FDi8M26vh"
      },
      "source": [
        "# **Starting with Python**\n",
        "\n",
        "Python is an interpreted programming language, this means that as a developer you write Python (.py) files in a text editor and then put those files into the python interpreter to be executed.\n",
        "\n",
        "The way to run a python file is like this on the command line:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "C:\\Users\\Your Name>python helloworld.py\n",
        "```\n",
        "Where \"helloworld.py\" is the name of your python file.\n",
        "\n",
        "Let's write our first Python file, called helloworld.py, which can be done in any text editor.\n",
        "\n",
        "\n",
        "helloworld.py\n",
        "```\n",
        "print(\"Hello, World! :) \")\n",
        "```\n",
        "Simple as that. Save your file. Open your command line, navigate to the directory where you saved your file, and run:\n",
        "\n",
        "```\n",
        "C:\\Users\\Your Name>python helloworld.py\n",
        "```\n",
        "\n",
        "The output should read:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "Hello, World! :)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YIQ3UsYAm-kI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5b231871-b27e-41d2-c8ab-331dc4e4e14e"
      },
      "source": [
        "#TO-DO Print Hello World using print command!\r\n",
        "\r\n",
        "print(\"\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qViu26SV6-TK"
      },
      "source": [
        "# **Python Syntax & Indentation**\n",
        "\n",
        "Python syntax can be executed by writing directly in the Command Line:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        ">>> print(\"Hello, World! :)\")\n",
        "Hello, World! :)\n",
        "```\n",
        "\n",
        "Or by creating a python file on the server, using the .py file extension, and running it in the Command Line:\n",
        "\n",
        "```\n",
        "C:\\Users\\Your Name>python myfile.py\n",
        "```\n",
        "\n",
        "\n",
        "**Python Indentation**\n",
        "\n",
        "\n",
        "Indentation refers to the spaces at the beginning of a code line.\n",
        "\n",
        "Where in other programming languages the indentation in code is for readability only, the indentation in Python is very important.\n",
        "\n",
        "Python uses indentation to indicate a block of code.\n",
        "\n",
        "Example :\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eR0pjRyn7Tta",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 128
        },
        "outputId": "a63f7475-4f20-4e1d-b9ba-b5845cfd3bbd"
      },
      "source": [
        "#indentation is imp in python below code will give you error\n",
        "\n",
        "if 5 > 2:\n",
        "print(\"Five is greater than two!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-a314491c53bb>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    print(\"Five is greater than two!\")\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k0xS4nZX9Y04"
      },
      "source": [
        "The number of spaces is up to you as a programmer, but it has to be at least one."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zq9-XLgz9cZ_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d8fa3cbe-9b71-4d49-b207-7bff76b84d38"
      },
      "source": [
        "#Example (Generally we prefer a tab's space)\n",
        "\n",
        "if 10 > 5:\n",
        " print(\"Ten is greater than Five!\") \n",
        "if 10 > 5:\n",
        "        print(\"Ten is greater than Five!\") \n",
        "        print(\"Ten is greater than Five!\") "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ten is greater than Five!\n",
            "Ten is greater than Five!\n",
            "Ten is greater than Five!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "btd_GvHt9upn"
      },
      "source": [
        "# **Comments:**\n",
        "\n",
        "Python has commenting capability for the purpose of in-code documentation.\n",
        "\n",
        "Comments start with a #, and Python will render the rest of the line as a comment:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a_YeED9D9x6s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9b2aae17-5869-41c1-e679-88a7159ed5c5"
      },
      "source": [
        "#This is a comment, this line will not execute.\n",
        "\n",
        "print(\"Yoooo!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Yoooo!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pft3WfTe-LUe"
      },
      "source": [
        "*   Comments can be used to explain Python code.\n",
        "\n",
        "*   Comments can be used to make the code more readable.\n",
        "*   Comments can be used to prevent execution when testing code.\n",
        "*   In `Colab` we have a option to comment a block using `ctrl+/`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B77HLpYIoIXN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "63e7c6e2-6ba2-41e8-b967-3455fbbc26db"
      },
      "source": [
        "print(\"Comment in colab line 1\")\r\n",
        "print(\"Comment in colab line 2\")\r\n",
        "print(\"Comment in colab line 3\")\r\n",
        "print(\"select all the lines and then do crtl+/ to comment and again to reverse back\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Comment in colab line 1\n",
            "Comment in colab line 2\n",
            "Comment in colab line 3\n",
            "select all the lines and then do crtl+/ to comment and again to reverse back\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MiCtOU0F-uLN"
      },
      "source": [
        "# **Variables in Python:**\n",
        "\n",
        "Variables are nothing but reserved memory locations to store values. This means that when you create a variable you reserve some space in memory.\n",
        "\n",
        "In Python you don’t need to declare variables before using it, unlike other languages like Java, C etc.\n",
        "\n",
        "# **Assigning values to a variable:**\n",
        "\n",
        "Python variables do not need explicit declaration to reserve memory space. The declaration happens automatically when you assign a value to a variable. \n",
        "The equal sign (=) is used to assign values to variables."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WOgTcEk2_J21",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "482bb554-6c33-48e5-b674-ce220231c2eb"
      },
      "source": [
        "x = 11 \n",
        "y = \"Google\" \n",
        "print(x)\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11\n",
            "Google\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1RlM5twW_VQB"
      },
      "source": [
        "Variables do not need to be declared with any particular type and can even change type after they have been set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fo-8MR7q_b-o",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4c16f97d-236d-4875-95b1-2c5455acdc1d"
      },
      "source": [
        "x = 4 # x is of type int\n",
        "x = \"Frost forbite\" # x is now of type str\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Frost forbite\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N09PcvZvFPt9"
      },
      "source": [
        "String variables can be declared either by using single or double quotes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CGG7Pza5FQzg"
      },
      "source": [
        "x = \"Marcus Burns\"\n",
        "# is the same as\n",
        "x = 'Marcus Burns'\n",
        "y = 10"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H_tMoZ7toprY"
      },
      "source": [
        "At any point if you want to see the `type of the variable` like `int` or `str` use `type()` function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KyXGQZQkoo5q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d5d3386c-7aae-436d-c9dc-d27ee82696b5"
      },
      "source": [
        "type(x) # replace \"x\" with \"y\" and see its type"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_SR0saT9KvwE"
      },
      "source": [
        "# **Assign Value to Multiple Variables:**\n",
        "\n",
        "Python allows you to assign values to multiple variables in one line:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tTsMoY7MK1wx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ae118ee7-238d-492d-c35f-756f02aea2be"
      },
      "source": [
        "x, y, z = \"Apples\", \"Grapes\", \"Mangoes\" #very useful in spliting the data\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Apples\n",
            "Grapes\n",
            "Mangoes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TyJ-roCOK9zT"
      },
      "source": [
        "And you can assign the same value to multiple variables in one line:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AC-SxzcVK_6J",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b2be17d9-adf2-4b0c-d742-b717c66cae5c"
      },
      "source": [
        "x = y = z = \"Kiwi\"\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Kiwi\n",
            "Kiwi\n",
            "Kiwi\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pULZk2i3OpH8"
      },
      "source": [
        "# **Data Types in Python:**\n",
        "Python supports various data types, these data types defines the operations possible on the variables and the storage method. \n",
        "\n",
        "\n",
        "* Text Type:\t`str`\n",
        "* Numeric Types:\t`int, float, complex`\n",
        "* Sequence Types:\t`list, tuple, range`\n",
        "* Mapping Type:\t`dict`\n",
        "* Set Types:\t`set, frozenset`\n",
        "* Boolean Type:\t`bool`\n",
        "* Binary Types:\t`bytes, bytearray, memoryview`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QVlmz3KzOvEv"
      },
      "source": [
        "# **Getting the Data Type:**\n",
        "\n",
        "You can get the data type of any object by using the type() function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZN5P37qLOwYW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "86231f02-4361-41a8-b65e-8c7877011efc"
      },
      "source": [
        "x = 5\n",
        "print(type(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JmJ0drEEO7Sp"
      },
      "source": [
        "**Numeric:**\n",
        "\n",
        "Just as expected Numeric data types store numeric values. They are immutable data types, this means that you cannot change it’s value. Python supports three different Numeric data types:\n",
        "\n",
        "1. Integer type: It holds all the integer values i.e. all the positive and negative whole numbers, example – 10.\n",
        "\n",
        "2. Float type: It holds the real numbers and are represented by decimal and sometimes even scientific notations with E or e indicating the power of 10 (2.5e2 = 2.5 x 102 = 250), example – 10.24.\n",
        "\n",
        "3. Complex type: These are of the form a + bj, where a and b are floats and J represents the square root of -1 (which is an imaginary number), example – 10+6j.\n",
        "\n",
        "Now you can even perform type conversion. For example, you can convert the integer value to a float value and vice-versa."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "860P3--YPFvM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89046cd3-79e8-436a-afb3-67632c7db494"
      },
      "source": [
        "x = 11    # int\n",
        "y = 2.8  # float\n",
        "\n",
        "print(type(x))\n",
        "print(type(y))\n",
        "print(type(z))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n",
            "<class 'float'>\n",
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tMCB-d5SPPcz"
      },
      "source": [
        "**Type Conversion**\n",
        "\n",
        "You can convert from one type to another with the int(), float(), and complex() methods:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLEAczK2Pf3_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e492ee83-017b-455e-ec93-4d2aeb3add1c"
      },
      "source": [
        "# we usually use int conversion for some values in ML\n",
        "a = 8.16\n",
        "# Convert it into int type\n",
        "b = int(a)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uevK81TSPqiU"
      },
      "source": [
        "**Strings:**\n",
        "\n",
        "Strings are amongst the most popular data types in Python. We can create them simply by enclosing characters in quotes. Python treats single and double quotes in exactly the same fashion. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PFRQnE8vPswE"
      },
      "source": [
        "**String Methods**\n",
        "\n",
        "Python has a set of built-in methods that you can use on strings.\n",
        "\n",
        "* capitalize() : Converts the first character to upper case\n",
        "* casefold() :\tConverts string into lower case\n",
        "* count() :\tReturns the number of times a specified value occurs in a string\n",
        "* encode()\t: Returns an encoded version of the string\n",
        "* find() :\tSearches the string for a specified value and returns the position of where it was found\n",
        "* format() :\tFormats specified values in a string\n",
        "* index()\t: Searches the string for a specified value and returns the position of where it was found\n",
        "* isdecimal() :\tReturns True if all characters in the string are decimals\n",
        "* isdigit() :\tReturns True if all characters in the string are digits\n",
        "* isidentifier() :\tReturns True if the string is an identifier\n",
        "* islower()\t: Returns True if all characters in the string are lower case\n",
        "* isnumeric()\t: Returns True if all characters in the string are numeric\n",
        "* isupper()\t: Returns True if all characters in the string are upper case\n",
        "* lower() :\tConverts a string into lower case\n",
        "* upper()\t: Converts a string into upper case"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "URny1DMeQEUF"
      },
      "source": [
        "**Strings are Arrays**\n",
        "\n",
        "Like many other popular programming languages, strings in Python are arrays of bytes representing unicode characters.\n",
        "\n",
        "However, Python does not have a character data type, a single character is simply a string with a length of 1.\n",
        "\n",
        "Square brackets can be used to access elements of the string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d32_CS-LQLO9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "2df018a4-f5f1-4a86-f1ca-86cc53d5e612"
      },
      "source": [
        "#Get the character at position 1 (remember that the first character has the position 0):\n",
        "\n",
        "a = \"Hello, World!\"\n",
        "print(a[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "e\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J3T1vjztQhRo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 134
        },
        "outputId": "61335e11-0477-4244-a6d7-7ddbcd131ecc"
      },
      "source": [
        "a = \"Hello World!\"\n",
        "b = 'Welcome'\n",
        "\n",
        "#operations on Strings-*\n",
        "\n",
        "print (len(b))\t        #String Length\n",
        "print (a.index('e'))    #Locate a character in String\n",
        "print (a[1:5])\t        #Slicing\n",
        "print (a[::-1])\t        #Reverse a String\n",
        "print (b.upper())\t      #Convert the letters in a String to upper-case\n",
        "\n",
        "#TO-DO Convert \"a\" to lower case \n",
        "\n",
        "\n",
        "#TO-DO print reverse of b\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "1\n",
            "3\n",
            "ello\n",
            "!dlroW olleH\n",
            "WELCOME\n",
            "welcome\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KWC2_vcGRCig"
      },
      "source": [
        "**List:**\n",
        "\n",
        "You can consider the Lists as Arrays in C, but in List you can store elements of different types, but in Array all the elements should of the same type.\n",
        "List is the most versatile datatype available in Python which can be written as a list of comma-separated values (items) between square brackets."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CZjaRi7jRHxs"
      },
      "source": [
        "**List Methods**\n",
        "\n",
        "Python has a set of built-in methods that you can use on lists.\n",
        "\n",
        "\n",
        "* append() : Adds an element at the end of the list\n",
        "* clear()\t: Removes all the elements from the list\n",
        "* copy() :\tReturns a copy of the list\n",
        "* count() :\tReturns the number of elements with the specified value\n",
        "* extend(): Add the elements of a list (or any iterable), to the end of the current list\n",
        "* index()\t: Returns the index of the first element with the specified value\n",
        "* insert() :\tAdds an element at the specified position\n",
        "* pop() :\tRemoves the element at the specified position\n",
        "* remove() :\tRemoves the item with the specified value\n",
        "* reverse() :\tReverses the order of the list\n",
        "* sort() :\tSorts the list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0XmYBMyGRS62",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0f933e6d-1f1f-457b-982e-d6490e803430"
      },
      "source": [
        "Sports = ['Basketball', 'Cricket', 'Football', 1,5,6.0] #unlike array in c list in pyhthoin can store any data type\n",
        "print(Sports)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Basketball', 'Cricket', 'Football', 1, 5, 6.0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8TGv1lb4sOko"
      },
      "source": [
        "## Operations on lists\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AJMM4LoEsMYT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a13a113-c553-4a2d-b9af-3699c4c3237c"
      },
      "source": [
        "print (Sports[0])       #printing the value at index"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Basketball\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BTvaBT1msTTt"
      },
      "source": [
        "#TO-DO Print first three elements using the slicing we learnt earlier\r\n",
        "\r\n",
        "print (Sports{[:]})    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JKyk4NHksU1f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e1be3db1-1178-46ba-8483-c44adb9051c3"
      },
      "source": [
        "Sports[2]='baseball'       #replacing the value at particular index\r\n",
        "\r\n",
        "print (Sports)\r\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Basketball', 'Rugby', 'baseball', 5, 6.0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mq3inSA0sYeW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ec64802f-85b5-4156-ecb8-28c62c423bf9"
      },
      "source": [
        "del Sports[1]           #deleting a value at an index\r\n",
        " \r\n",
        "print (Sports)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Basketball', 'baseball', 5, 6.0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g3ldEjkKsaZo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1d5a5c58-370c-48ec-faee-058dedb5514e"
      },
      "source": [
        "print (len(Sports))     #get the length of the string"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a8lTMliwTZYa"
      },
      "source": [
        "**Negative Indexing**\n",
        "\n",
        "Negative indexing means beginning from the end, -1 refers to the last item, -2 refers to the second last item etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IM25puDcTaxu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f1b1119e-df06-4291-cb50-9be867a106c9"
      },
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(fruits[-1])\n",
        "\n",
        "#TO-DO Print apple using negative indexing\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cherry\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BG33LT1jWVxD"
      },
      "source": [
        "**Dictionary Methods**\n",
        "\n",
        "Python has a set of built-in methods that you can use on dictionaries.\n",
        "\n",
        "* clear() :\tRemoves all the elements from the dictionary\n",
        "* copy()\t: Returns a copy of the dictionary\n",
        "* get()\t: Returns the value of the specified key\n",
        "* items()\t: Returns a list containing a tuple for each key value pair\n",
        "* keys()\t: Returns a list containing the dictionary's keys\n",
        "* pop()\t: Removes the element with the specified key\n",
        "* popitem() :\tRemoves the last inserted key-value pair\n",
        "* update() :\tUpdates the dictionary with the specified key-value pairs\n",
        "* values() :\tReturns a list of all the values in the dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XBVUOI6mWbW5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7a40c4cd-c876-4079-8e50-89067251ec9a"
      },
      "source": [
        "family = {\n",
        "  \"child1\" : {\n",
        "    \"name\" : \"Walter White\",\n",
        "    \"year\" : 2004\n",
        "  },\n",
        "  \"child2\" : {\n",
        "    \"name\" : \"Jesse Pinkman\",\n",
        "    \"year\" : 2007\n",
        "  },\n",
        "  \"child3\" : {\n",
        "    \"name\" : \"Harvey Specter\",\n",
        "    \"year\" : 2011\n",
        "  }\n",
        "}\n",
        "\n",
        "print(family)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'child1': {'name': 'Walter White', 'year': 2004}, 'child2': {'name': 'Jesse Pinkman', 'year': 2007}, 'child3': {'name': 'Harvey Specter', 'year': 2011}}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ir6lXKCmu1Uo"
      },
      "source": [
        "# TO-DO make a dictionay of people sitting beside you and print it\r\n",
        "\r\n",
        "neighbor = {}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tvslFLCWZ1bH"
      },
      "source": [
        "Operators in Python:\n",
        "\n",
        "Operators are the constructs which can manipulate the values of the operands. Consider the expression 2 + 3 = 5, here 2 and 3 are operands and + is called operator.\n",
        "\n",
        "*Types of Operators in Python: *\n",
        "\n",
        "Arithmetic\n",
        "\n",
        "Comparision\n",
        "\n",
        "Logical\n",
        "\n",
        "Assignment\n",
        "\n",
        "Bitwise"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RIeUyG_4Z__-"
      },
      "source": [
        "Arithmetic Operation:\n",
        "\n",
        "These Operators are used to perform mathematical operations like addition, subtraction etc.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cSkXbDXiaCJ2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 117
        },
        "outputId": "998ea758-61e7-4381-a8e9-4664cf4123ff"
      },
      "source": [
        "a = 11\n",
        "b = 20\n",
        "c = 0\n",
        " \n",
        "c = a + b\n",
        "print ( c )\n",
        " \n",
        "c = a - b\n",
        "print ( c )\n",
        " \n",
        "c = a * b\n",
        "print ( c )\n",
        " \n",
        "c = a / b\n",
        "print ( c )\n",
        " \n",
        "c = b % a\n",
        "print ( c )\n",
        "\n",
        "a = 2\n",
        "b = 3\n",
        "c = a ** b\n",
        "print ( c )"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "31\n",
            "-9\n",
            "220\n",
            "0.55\n",
            "9\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UiO2-g1laJrO"
      },
      "source": [
        "Comparision Operation:\n",
        "\n",
        "These Operators compare the values on either sides of them and decide the relation among them."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_RKwhzvWaNRu",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 117
        },
        "outputId": "fa210382-cc30-4838-f666-c336759b41b8"
      },
      "source": [
        "a = 11\n",
        "b = 20\n",
        "result = (a == b)\n",
        "\n",
        "print(result)\n",
        "\n",
        "result = (a != b)\n",
        "\n",
        "print(result)\n",
        "\n",
        "result = ( a < b )\n",
        "\n",
        "print(result)\n",
        " \n",
        "result = ( a > b )\n",
        "\n",
        "print(result)\n",
        "\n",
        "result = ( a <= b )\n",
        "\n",
        "print(result)\n",
        "\n",
        "type(result)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "True\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oXcDjDAAsHsh",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "d668fdc3-70c9-442c-de2e-2fcb30f83fde"
      },
      "source": [
        "result = ( a >= b)\n",
        "result"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tTilkmuJYRLR"
      },
      "source": [
        "# Logical Operators\n",
        "* ( and ) to check if the LHS and RHS conditions both conditions are satisfied. Basically checking for truthy values\n",
        "* ( or  ) to check if atleast one of the side satisfy the condition. Basically checking for truthy values\n",
        "* ( not ) to check if the condition is not satified. Basically checking for falsy values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yktGQJDnaVtv",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "5d185f5f-4faa-4fc8-9902-b131e01b946b"
      },
      "source": [
        "x = True\n",
        "y = False\n",
        " \n",
        "print('x and y is',x and y)\n",
        " \n",
        "print('x or y is',x or y)\n",
        " \n",
        "print('not x is',not x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x and y is False\n",
            "x or y is True\n",
            "not x is False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1E1lQlM6YZEn"
      },
      "source": [
        "# **Input Output:**\n",
        "Take input from the user and work with it"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XNUhYjMwegiX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "5df88946-3872-41b1-9392-9d58b79be435"
      },
      "source": [
        "my_age = input(\"Enter your age: \")\n",
        "\n",
        "# add code here \n",
        "\n",
        "# end code here\n",
        "\n",
        "add_age = my_age + 2 #It will throw an error\n",
        "\n",
        "#lets check why?\n",
        "type(my_age)\n",
        "\n",
        "#Lets fix this;\n",
        "\n",
        "# TO-DO Convert my_age to int using int() \n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter your age: 10\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9QWIlKu6vnLl"
      },
      "source": [
        "## Decision making and loops"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jjuPYlcqzPiz"
      },
      "source": [
        "# don't run will throw error\r\n",
        "\r\n",
        "if condition 1\r\n",
        "    perform task1\r\n",
        "else \r\n",
        "    perform task2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G8H6QPmlwnrK"
      },
      "source": [
        "Example\r\n",
        "\r\n",
        "Take input and see if its even or odd"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qZuL2AEAwlaT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5952ceb-dc90-4592-cb30-f5b58a588765"
      },
      "source": [
        "# TO-DO take input from the user and store in \"number\" variable\r\n",
        "\r\n",
        "\r\n",
        "# TO-DO Convert it to int\r\n",
        "\r\n",
        "# if else logic here\r\n",
        "if (number%2 ==0):\r\n",
        "  print(\"Event Number\")\r\n",
        "else:\r\n",
        "  print(\"Odd Number\")\r\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Event Number\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sT0Io0tJxXTL"
      },
      "source": [
        "Example of 3 or more conditions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ZkdGfwMxL_a"
      },
      "source": [
        "# TO-DO Take input from user and store it in \"number\" variable\r\n",
        "\r\n",
        "\r\n",
        "if number == 1:\r\n",
        "    print('Task 1')\r\n",
        "elif number == 2:   # we don't write else if we write elif here\r\n",
        "    print('Task 2')\r\n",
        "else:\r\n",
        "    print('Task 3')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3vXrg8CGyDpN"
      },
      "source": [
        "# **Loops:**\r\n",
        "In general, statements are executed sequentially. The first statement in a function is executed first, followed by the second, and so on.\r\n",
        "\r\n",
        "There may be a situation when you need to execute a block of code several number of times\r\n",
        "A loop statement allows us to execute a statement or group of statements multiple times. \r\n",
        "\r\n",
        "In Python, there are three loops:\r\n",
        "\r\n",
        "1.  While\r\n",
        "2.  For\r\n",
        "3.  Nested"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "emvamYGCyuWY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1837b77e-dbb0-4712-df1e-0fa400adfb35"
      },
      "source": [
        "# before we go into loops understand range() function\r\n",
        "\r\n",
        "list(range(10)) # will generate list of 10 numbers from 0-9\r\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "la0iS_TbzPjN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "216ab8b9-48f8-4527-c96a-ab05191c8ae3"
      },
      "source": [
        "list(range(2,10)) # will start from 2 and print till 9"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 3, 4, 5, 6, 7, 8, 9]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5oxJZtbxzWFI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ebe97d87-3573-49db-9ad0-586d88903a97"
      },
      "source": [
        "#very simple loop\r\n",
        "\r\n",
        "for temp in range(6):\r\n",
        "    print(temp)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R-di82WKzgN5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c38e0b7-09e1-4cb2-c620-b86d1b5c00ec"
      },
      "source": [
        "mytask = [3,5,'Hi',8]\r\n",
        "\r\n",
        "for temp in mytask: #you can iterate anything in For Loop\r\n",
        "    print(temp)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "5\n",
            "Hi\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ailAK2-nz02d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "42d2b4eb-a00f-4632-9b1f-892cd784a39a"
      },
      "source": [
        "# While Loop\r\n",
        "\r\n",
        "i = 0\r\n",
        "while i<10:\r\n",
        "    print('HI')\r\n",
        "    i = i+1\r\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "HI\n",
            "HI\n",
            "HI\n",
            "HI\n",
            "HI\n",
            "HI\n",
            "HI\n",
            "HI\n",
            "HI\n",
            "HI\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u64LQwaoY3sn"
      },
      "source": [
        "# **Functions:**\n",
        "\n",
        "Functions are a convenient way to divide your code into useful blocks, allowing us to order our code, make it more readable, reuse it and save some time."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "41Sl4Q_RZOqY"
      },
      "source": [
        "**Define a function with no arguments and no return values:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7lPlGuNiY_xP"
      },
      "source": [
        "def print_text():\n",
        "    print('this is text')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_9uSsLHPZKi5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8ca6270e-15b1-4a2b-9bbb-0687812a797e"
      },
      "source": [
        "# call the function\n",
        "print_text()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "this is text\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2iYTL18xZS6Q"
      },
      "source": [
        "**Define a function with one argument and no return values:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vo-cD2OxZUuB"
      },
      "source": [
        "def print_this(x):\n",
        "    print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7D16LaH5ZWHY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f2450e21-9702-4fac-d0f9-515a05d2fb18"
      },
      "source": [
        "# call the function\n",
        "print_this(3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "35bK9N-FZbsg"
      },
      "source": [
        "**Define a function with one argument and one return value:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z1jqUXCiZfk5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f2e5d200-8768-4172-844e-6b441a884e71"
      },
      "source": [
        "def square(x):\n",
        "    return x**2\n",
        "    \n",
        "square(5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "25"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ne0NdmCn5ul9"
      },
      "source": [
        "#Example\n",
        "\n",
        "def calc(a, b, op='add'):\n",
        "\n",
        "    if op == 'add':\n",
        "        return a + b\n",
        "\n",
        "    elif op == 'sub':\n",
        "        return a - b\n",
        "        \n",
        "    else:\n",
        "        print('valid operations are add and sub')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hH_4MlBcaOjZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f1187e78-88a2-4e09-c654-5cff89893044"
      },
      "source": [
        "# call the function\n",
        "calc(10, 4, op='add')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6yJj0Zr4af0w",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cc12e37a-ab83-4ed3-f6e9-e92c0bf2219e"
      },
      "source": [
        "# unnamed arguments are inferred by position\n",
        "calc(10, 4, 'add')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yy-kreh6agU4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8c7c59a7-8ee7-4f0c-efc1-c81a10a3af5e"
      },
      "source": [
        "# default for 'op' is 'add'\n",
        "calc(10, 4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TnLSMIGeahaZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f05b5a05-1502-4d08-df0d-52130044e3fd"
      },
      "source": [
        "calc(10, 4, 'sub')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lftlrceMeClR"
      },
      "source": [
        "# **Anonymous Functions (Lambda Functions)**\n",
        "Primarily used to temporarily define a function for use by another function.\n",
        "* Anonymous\n",
        "* Single use, simple 1=line function\n",
        "* Throw-away functions\n",
        "\n",
        "**Syntax :**\n",
        "\n",
        "`lambda arguments : expression`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DuIye2TkeK_R"
      },
      "source": [
        "**Here are some single-argument Lambdas:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oTZQdaT9enQi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1469c5b7-bc25-4a92-8969-f0427f2a5266"
      },
      "source": [
        "add10 = lambda x : x + 10\n",
        "print (add10(5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "15\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HS2ZWAjsezaS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f6863170-8a07-47ba-9572-34ec5a2ba015"
      },
      "source": [
        "square = lambda x : x * x\n",
        "print (square(10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Bj4AQ8m0ftF"
      },
      "source": [
        "# TO-DO print even odd using Lambda function\r\n",
        "\r\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}