Python_basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "RoboISM Workshop.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlIY33i08blo",
        "colab_type": "text"
      },
      "source": [
        "###Welcome to our Basic Python Programming Workshop !!!!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nNwr4a-VbfPb",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "#General overview of the python\n",
        "\n",
        "The following are a few things that are to be kept in mind, once you start coding in python -\n",
        "\n",
        "\n",
        "\n",
        "*   *Interpreted* , not compiled\n",
        "*   Case sensitive \n",
        "*   Identations \n",
        "*   Can be used with an iteractive environment \n",
        "*   Object Oriented \n",
        "*   Broad standard library \n",
        "*   Scripting language\n",
        "*   GUI programming\n",
        "*   One of the easiest and most versatile of languages\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l5NZ7_cq9sDC",
        "colab_type": "text"
      },
      "source": [
        "###File Format\n",
        " \n",
        " Generally python files are stored in the format-\n",
        " > **file_name.py**\n",
        " \n",
        " and can be executed through the terminal using the command-\n",
        "  > **$    python file_name.py**\n",
        " "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DUy9SAb7U0aO",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "#Basic Data Types\n",
        "\n",
        "The following are the built in types supported by the python -\n",
        "\n",
        "\n",
        "\n",
        "1.   int ( integers )  \n",
        "2.   float ( floating point numbers )\n",
        "3.   complex  (complex numbers)\n",
        "4.   str ( strings )\n",
        "5.   lists ( series of elements stored under a common name )\n",
        "6.   tuples \n",
        "7.   dict ( dictionaries )\n",
        "8.   sets   \n",
        "\n",
        "**Note-** A variable must be initialised before it is used .\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7T7y_1tvRb2t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#############  Basic Data Types  ###############\n",
        "\n",
        "a=10;b=5.01                                 # float\n",
        "c=\"This is a string\"                                 # string\n",
        "d=[1,2.0, \"String\",[1,2,3]]                                 # list\n",
        "e=(1,2,34)                             # tuple\n",
        "f={\"pi\":3.14,\"chi\":2.0}                             # dict\n",
        "g=complex(10,20)                                 # complex"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zocG_nzdZ7LE",
        "colab_type": "text"
      },
      "source": [
        "## Rules for naming Python Identifiers\n",
        "\n",
        "\n",
        "\n",
        "*   Class names start with an uppercase letter. All other identifiers start with a lowercase letter.\n",
        "*   Starting an identifier with a single leading underscore indicates that the identifier is private\n",
        "*   Starting an identifier with two leading underscores indicates a strong private identifier\n",
        "*   If the identifier also ends with two trailing underscores, the identifier is a language-defined special name.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qVwALoDWSTO8",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "##Print Statement\n",
        "\n",
        "\n",
        "To print something on the standard output, all you have to do is write -\n",
        "\n",
        ">**print(\"string to be shown on the screen \")**\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0gzATKOKQ11V",
        "colab_type": "code",
        "outputId": "76f4cba7-efe9-4d5e-fe19-1d2d3dffae40",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#############  Printing stuff  ###############\n",
        "\n",
        "## Write your code here ## \n",
        "print(\"Hello World\")\n",
        "##"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nzhd8yvbT_jm",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "The basic syntax of the print statement is -\n",
        "\n",
        ">**print(s1,s2,s3,...,end=\"\\n\",sep=\" \", file, flush )**\n",
        "\n",
        "As you can see, there is comma seperated list of variables s1,s2,.... which refers to different variables. Tis means that multiple variables can be printed at the same time. The seperator and the character to be placed at the end of the line can also be changed. \n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "exMBbuF3Rkml",
        "colab_type": "code",
        "outputId": "352726ce-7f89-414d-87e0-65dce0752b0b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#############  Printing some more stuff  ###############\n",
        "\n",
        "## Write your code here ## \n",
        "print(a,b,c,sep=\" filler \",end=\" end \")\n",
        "print(\"string\")\n",
        "##"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10 filler 5.01 filler This is a string end string\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dZPvLgvnjubm",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "##type() , dir() and help()\n",
        "\n",
        "python provides some extra functions to help you with get a better understanding of the variables and the code during run time.The following are three of the most basic and most important of these functions. Run the foloowing cells and check these out. \n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qtb0CQSgki8t",
        "colab_type": "code",
        "outputId": "25ed2da8-fd3f-4ffe-ebc1-b5510a101abb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        }
      },
      "source": [
        "#print(help(list))\n",
        "print(type(a))\n",
        "print(dir(int))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n",
            "['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mjFg-MRLGr4K",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "##Taking Input from the user\n",
        "\n",
        "\n",
        "use the input() function to accept input from the user in the form of a string\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TUZ3Q8ATRPqZ",
        "colab_type": "code",
        "outputId": "8786aea2-4706-40bb-eaf6-32daf37c38eb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "#############  Input  ###############\n",
        "\n",
        "s=input(\"Enter the value of variable s: \")                                       # take input from the user\n",
        "print(s,type(s))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the value of variable s: 10\n",
            "10 <class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-rAoHR6GE0a",
        "colab_type": "text"
      },
      "source": [
        "##Type conversion Functions \n",
        "\n",
        "python provides some basic functions to convert one data type to the other. These functions are same as their type names."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WkmMLblTGESH",
        "colab_type": "code",
        "outputId": "6d11eb67-7bea-487c-83de-86451e6a7c3b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        }
      },
      "source": [
        "a=10\n",
        "b=int(input())\n",
        "print(b,type(b))\n",
        "b=str(a)\n",
        "print(b,type(b))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12\n",
            "12 <class 'int'>\n",
            "10 <class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oPhMHYtY-tj4",
        "colab_type": "text"
      },
      "source": [
        "###Indentations\n",
        "\n",
        "Indentations are extremely important in python. It also makes the code more readable. Writing code without proper indentations raises critical errors during execution time. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k6vHGi25_3A_",
        "colab_type": "code",
        "outputId": "2c4ce089-38c5-44ec-bfaa-f881f95fbf04",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "####### indentations ########\n",
        "\n",
        "if False:                           #try changing this to True\n",
        "  \n",
        "  print(\"True\")\n",
        "  print(\"statement2 \")\n",
        "  print(\"statement3\")\n",
        "print(\"statement 4 \")\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "statement 4 \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kgMosiUiXMt3",
        "colab_type": "text"
      },
      "source": [
        "###Multi-line statements"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gp_QU63EXLkg",
        "colab_type": "code",
        "outputId": "2b1e8cf4-f7c4-41e3-efa7-ee254eb47f40",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "result=10 + \\\n",
        "       5 + \\\n",
        "       6\n",
        "\n",
        "print(result)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "21\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1mqh54HAYMbG",
        "colab_type": "text"
      },
      "source": [
        "###Comments\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1YIyiLZnYSvh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# A comment starts with a hash symbol"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qdJEagAaYcIZ",
        "colab_type": "text"
      },
      "source": [
        "###Multi-line String \n",
        "\n",
        "A triple quotation marks in python refers to a muti-line string. It continues until it is terminated by a closing triple quote."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BbN6SYaY6Dve",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#trying to write quotes within quotes\n",
        "\n",
        "s=\"My name is \"Hardik\", and i'm  not a sexist \"                          #try replacing teh outer quotes with triple quotes"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kClf-gfNYbd5",
        "colab_type": "code",
        "outputId": "e3bbe838-3e0c-4e9a-def9-141baf1ce20d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "s=\"\"\"Chacha.....\n",
        "Arey Oo  @$%#&!wale Chacha \"\"\"\n",
        "\n",
        "print(s)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Chacha.....\n",
            "Arey Oo  @$%#&!wale Chacha \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GLb6Aae-iDjE",
        "colab_type": "text"
      },
      "source": [
        "###Deleting objects\n",
        "\n",
        "To delete previously declared objects all you have to do is write the command:\n",
        ">**del var1[, var2, var3, ... ]**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "itjxFUDniee1",
        "colab_type": "code",
        "outputId": "80869e2c-08ff-419e-f366-ac70d3f401e5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 183
        }
      },
      "source": [
        "del s## delete some of the previously defined variable\n",
        "print(s)"
      ],
      "execution_count": 0,
      "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-23-899de01502a9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0ms\u001b[0m\u001b[0;31m## delete some of the previously defined variable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\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 's' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Df-wnNyeZqR6",
        "colab_type": "text"
      },
      "source": [
        "###If you ever see  {     if  \\__name__==\"\\__main__\" :  }\n",
        "\n",
        "This is a way of defining what other programming languages call the main function, method or class. It can be omitted and the code will still run just fine.(although it is sometimes important to write this in some scripting applications)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hAnUPX61Zp1g",
        "colab_type": "code",
        "outputId": "7cd048d8-ca6d-4f96-b815-1ffa48c8fd76",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        }
      },
      "source": [
        "print(\"statement 1\")\n",
        "\n",
        "if __name__==\"__main__\":\n",
        "  \n",
        "  print(\"statement 2\")\n",
        "\n",
        "print(\"statement 3\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "statement 1\n",
            "statement 2\n",
            "statement 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WwgNhjW0d8Mi",
        "colab_type": "text"
      },
      "source": [
        "#Basic Operators And Operations \n",
        "\n",
        "Python language supports the following types of operators −\n",
        "\n",
        "*   Arithmetic Operators\n",
        "*   Comparison (Relational) Operators\n",
        "*   Assignment Operator\n",
        "*   Logical Operators\n",
        "*   Bitwise Operators\n",
        "*   Membership Operators\n",
        "*   Identity Operators\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "The following are some basic operations that can be performed on integral and floating point type objects.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YkE-lbzKhKmk",
        "colab_type": "code",
        "outputId": "05cbba28-0f7a-4a87-f465-de559b832c0e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 139
        }
      },
      "source": [
        "a=5\n",
        "b=2\n",
        "\n",
        "print(a+b)              # addition      \n",
        "print(a-b)              # subtraction      \n",
        "print(a*b)              # multiplication        \n",
        "print(a/b)              # division\n",
        "print(a%b)              # modulus\n",
        "print(8//3)             # floor or integral division       \n",
        "print(a**b)             # exponent; equivalent to a^b         "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "3\n",
            "10\n",
            "2.5\n",
            "1\n",
            "2\n",
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AGg4KNChjndH",
        "colab_type": "text"
      },
      "source": [
        "###Multiple Assignments \n",
        "\n",
        "Python allows multiple assignments at the same time  in the following ways: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "uikIL8zFkhB5",
        "outputId": "155bca70-dd61-4d79-89ca-4ae910d962b9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        }
      },
      "source": [
        "a=b=c=15.0                \n",
        "print(a,b,c)#try printing out the values\n",
        "\n",
        "\n",
        "a,b,c= 10,3,45              ## this os a tuple-based assignment\n",
        "print(a,b)\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "15.0 15.0 15.0\n",
            "10 3\n",
            "45\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t7Z-MVZNmZbJ",
        "colab_type": "text"
      },
      "source": [
        "###Comparison Operator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cnJ5Vmpnmk_J",
        "colab_type": "code",
        "outputId": "1d7f1f78-d111-4369-c49f-699f80d44ae6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        }
      },
      "source": [
        "a=20\n",
        "b=10\n",
        "\n",
        "print(a==b)                            # is equal to     \n",
        "print(a>=b)                           # greater than or equal to\n",
        "print(a<=b)                           # less than or is equal to\n",
        "print(a<b)                            # less than\n",
        "print(a>b)                            # greater than\n",
        "print(a!=b)                           # not equal to \n",
        "             "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "False\n",
            "False\n",
            "True\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v6oI7iwrnXrQ",
        "colab_type": "text"
      },
      "source": [
        "###Assignment operators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "suPZkZx4nfSf",
        "colab_type": "code",
        "outputId": "54d98f9b-0418-42fd-925b-54d7225a2110",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 139
        }
      },
      "source": [
        "a=20\n",
        "b=10\n",
        "                \n",
        "a+=b                   # a=a+b         addition assignment               \n",
        "print(a)\n",
        "\n",
        "a-=b#subtraction              \n",
        "print(a)\n",
        "a/=b                \n",
        "#division              \n",
        "print(a)\n",
        "                \n",
        "a*=b#multiplication              \n",
        "print(a)  \n",
        "\n",
        "a//=b#floor division              \n",
        "print(a)                \n",
        "\n",
        "a**=b#exponent              \n",
        "print(a)                \n",
        "\n",
        "a%=b#modulus         \n",
        "print(a)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "30\n",
            "20\n",
            "2.0\n",
            "20.0\n",
            "2.0\n",
            "1024.0\n",
            "4.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QU7DqfRnp2FD",
        "colab_type": "text"
      },
      "source": [
        "###Logical Operators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YHAll4CXpz81",
        "colab_type": "code",
        "outputId": "f555daab-cac8-48ce-9e6b-2023f9054832",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        }
      },
      "source": [
        "a=10 \n",
        "b=20\n",
        "\n",
        "print(a and b)\n",
        "print(a or b)\n",
        "print(not a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "20\n",
            "10\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D0CBCAbEscX5",
        "colab_type": "text"
      },
      "source": [
        "###\"is\" and \"in\"\n",
        "\n",
        "**is**: used to check for similarity\n",
        "\n",
        "**in**: used to check for containership"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3YvfMPJxs96j",
        "colab_type": "code",
        "outputId": "b31d5d20-dc2a-497c-e050-ec0b3b61bf5a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "# use of is\n",
        "\n",
        "a=10\n",
        "b=10\n",
        "c=20\n",
        "\n",
        "print(a is b)\n",
        "print(a is c)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4My1HWBHtWgf",
        "colab_type": "code",
        "outputId": "06dcea38-f6ef-46b7-b14d-889a53b1ac0b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "# use of in\n",
        "\n",
        "l=[\"a\",\"b\",'c',\"d\"]\n",
        "\n",
        "print(\"a\" in l)\n",
        "print(\"c\" in l)\n",
        "print(\"k\" in l)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sfZPWuUuzm3Z",
        "colab_type": "text"
      },
      "source": [
        "#Conditional Statements\n",
        "\n",
        "The conditional statements in  python are generally defined using the keywords if, elif and else. The general syntax is -\n",
        "\n",
        "\n",
        "```\n",
        "if condition_1:\n",
        "    statement_1\n",
        "elif condition_2:\n",
        "    statement_2\n",
        "else:\n",
        "    statement_3\n",
        "\n",
        "```\n",
        "\n",
        "The if-else structure can also be nested, i.e. if can contain other if statements. For example:\n",
        "\n",
        "\n",
        "```\n",
        "if condition_1:\n",
        "    if condition_11:\n",
        "        statement_11\n",
        "    else:\n",
        "        statement_12\n",
        "else:\n",
        "     statement_2\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6hDcFgRx3TrZ",
        "colab_type": "code",
        "outputId": "670db0b0-23ef-42c5-d498-0d31d3d6ae37",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a=20\n",
        "\n",
        "if a==10:\n",
        "  print(\"this is not going to be printed\")\n",
        "elif a==20:\n",
        "  print(\"a is 20\")\n",
        "else:\n",
        "  print(\"a is not equal to 10\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a is 20\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eRq5pOcmz1Np",
        "colab_type": "code",
        "outputId": "2edc30b4-ff2f-46e6-982d-746a74cae448",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "### try yourself ###\n",
        "\n",
        "year=int(input(\"enter the year you want to check:\"))\n",
        "\n",
        "#given the year, print if it is a leap year or not\n",
        "\n",
        "##Write your code here\n",
        "if year%400==0:\n",
        "  print(\"leap\")\n",
        "elif year%100==0:\n",
        "  print(\"not a leap year\")\n",
        "elif year%4==0:\n",
        "  print(\"leap year\")\n",
        "else:\n",
        "  print(\"not a leap year\")\n",
        "##end code"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter the year you want to check:2019\n",
            "not a leap year\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vR_FFWFy3pCf",
        "colab_type": "text"
      },
      "source": [
        "#Iterative Statements\n",
        "\n",
        "There are two types of iterative statements on python namely for and while . The blocks of code defined under these lines \n",
        "\n",
        "##For loop\n",
        "\n",
        "The basic syntax for a for-loop is :\n",
        "\n",
        "\n",
        "```\n",
        "for iterating_var in sequence:\n",
        "   statement(s)\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QidSRnLw6Xh-",
        "colab_type": "code",
        "outputId": "cb7ccf90-1a9e-4d35-bd1c-3dbcfd1d36ac",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        }
      },
      "source": [
        "a=[1,2,3,4,5]\n",
        "\n",
        "\n",
        "#print all elements of a\n",
        "\n",
        "for i in a:\n",
        "  print(i)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DKWuy2nt6WhH",
        "colab_type": "text"
      },
      "source": [
        "###range()\n",
        " \n",
        "The range function is used to obtain a range of integer values depending on the arguments passed to it. It's basic syntax is-\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "range(start,stop,step)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tk-tXI417ubF",
        "colab_type": "code",
        "outputId": "b135b2be-62ff-4c45-d76d-599e26f57115",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "print(range(0,12,3))                         #range func\n",
        "print(list(range(0,12,3)))                         #converting it to list"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "range(0, 12, 3)\n",
            "[0, 3, 6, 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hEgRw8wE8TnE",
        "colab_type": "code",
        "outputId": "317234f7-9f33-473d-b9fe-39601ecbdecc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 364
        }
      },
      "source": [
        "## using range in a for loop ##\n",
        "for i in range(0,20,2):\n",
        "  print(i)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n",
            "12\n",
            "13\n",
            "14\n",
            "15\n",
            "16\n",
            "17\n",
            "18\n",
            "19\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pEhJpzRJ-j95",
        "colab_type": "text"
      },
      "source": [
        "##While Loop\n",
        "\n",
        "The only difference between while and for loop is that while tests a conditions and iterates only if it is true, whereas for is used to iterate over some range or sequence of values. The basic syntax for while loop is:\n",
        "\n",
        "\n",
        "```\n",
        "while condition:\n",
        "    statement(s)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KBaah1bl_Qwg",
        "colab_type": "code",
        "outputId": "b961d87f-4942-4ab0-dcb9-d41c1a096770",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 173
        }
      },
      "source": [
        "i=1\n",
        "while i in range(1,10):\n",
        "  print(i)\n",
        "  i=i+1## print the first 10 natural numbers using while loop"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VSTWBTCC_gNs",
        "colab_type": "text"
      },
      "source": [
        "###break, continue and pass \n",
        "\n",
        "**break-** used to break out of an iterating block \n",
        "\n",
        "**continue-** used to trigger the next iteration by skipping over the rest of the code block \n",
        "\n",
        "**pass-** this statement is passed over, i.e. nothing happens when this statement is encountered"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6tR0YN4iAa2D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(1,11):\n",
        "  ###try all the tree statements inside an if block here \n",
        "  if i==5:\n",
        "    break             #try replacing break with continue and pass\n",
        "  print(i)\n",
        "  \n",
        "  ##print value of i\n",
        "  ###end code\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UStcZZCyA0Ke",
        "colab_type": "text"
      },
      "source": [
        "### \"else\" with for and while loops\n",
        "\n",
        "Python supports having an else statement associated with a loop statement.\n",
        "\n",
        "*   If the else statement is used with a for loop, the else statement is executed when the loop has exhausted iterating the list.\n",
        "*   If the else statement is used with a while loop, the else statement is executed when the condition becomes false.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IT4mxS6uB2NL",
        "colab_type": "code",
        "outputId": "aeae3766-952d-47b6-ee4f-ffb8cc955194",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        }
      },
      "source": [
        "\n",
        "for i in range(0,10):\n",
        "  print(i)\n",
        "  if i==5:\n",
        "    break\n",
        "else:\n",
        "  print(\"loop finished\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LsjDpmwPN7SJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l=[23,43,5,34,5,63,87,88,4444,1]\n",
        "key=\n",
        "\n",
        "###### using for loop, check if the key is present in the list l and print its location if found\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FW-AHm3nFj-e",
        "colab_type": "text"
      },
      "source": [
        "###Nested loops"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LZkKRaHfF5Bw",
        "colab_type": "code",
        "outputId": "a5c1f656-5a38-418d-e9b2-c9d03e2858ac",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 5945
        }
      },
      "source": [
        "for i in range(2,20):\n",
        "  for k in range(1,10):\n",
        "    print(i,k)\n",
        "    print(\"inner\")### try yourself ####\n",
        "  print(\"outer\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2 1\n",
            "inner\n",
            "2 2\n",
            "inner\n",
            "2 3\n",
            "inner\n",
            "2 4\n",
            "inner\n",
            "2 5\n",
            "inner\n",
            "2 6\n",
            "inner\n",
            "2 7\n",
            "inner\n",
            "2 8\n",
            "inner\n",
            "2 9\n",
            "inner\n",
            "outer\n",
            "3 1\n",
            "inner\n",
            "3 2\n",
            "inner\n",
            "3 3\n",
            "inner\n",
            "3 4\n",
            "inner\n",
            "3 5\n",
            "inner\n",
            "3 6\n",
            "inner\n",
            "3 7\n",
            "inner\n",
            "3 8\n",
            "inner\n",
            "3 9\n",
            "inner\n",
            "outer\n",
            "4 1\n",
            "inner\n",
            "4 2\n",
            "inner\n",
            "4 3\n",
            "inner\n",
            "4 4\n",
            "inner\n",
            "4 5\n",
            "inner\n",
            "4 6\n",
            "inner\n",
            "4 7\n",
            "inner\n",
            "4 8\n",
            "inner\n",
            "4 9\n",
            "inner\n",
            "outer\n",
            "5 1\n",
            "inner\n",
            "5 2\n",
            "inner\n",
            "5 3\n",
            "inner\n",
            "5 4\n",
            "inner\n",
            "5 5\n",
            "inner\n",
            "5 6\n",
            "inner\n",
            "5 7\n",
            "inner\n",
            "5 8\n",
            "inner\n",
            "5 9\n",
            "inner\n",
            "outer\n",
            "6 1\n",
            "inner\n",
            "6 2\n",
            "inner\n",
            "6 3\n",
            "inner\n",
            "6 4\n",
            "inner\n",
            "6 5\n",
            "inner\n",
            "6 6\n",
            "inner\n",
            "6 7\n",
            "inner\n",
            "6 8\n",
            "inner\n",
            "6 9\n",
            "inner\n",
            "outer\n",
            "7 1\n",
            "inner\n",
            "7 2\n",
            "inner\n",
            "7 3\n",
            "inner\n",
            "7 4\n",
            "inner\n",
            "7 5\n",
            "inner\n",
            "7 6\n",
            "inner\n",
            "7 7\n",
            "inner\n",
            "7 8\n",
            "inner\n",
            "7 9\n",
            "inner\n",
            "outer\n",
            "8 1\n",
            "inner\n",
            "8 2\n",
            "inner\n",
            "8 3\n",
            "inner\n",
            "8 4\n",
            "inner\n",
            "8 5\n",
            "inner\n",
            "8 6\n",
            "inner\n",
            "8 7\n",
            "inner\n",
            "8 8\n",
            "inner\n",
            "8 9\n",
            "inner\n",
            "outer\n",
            "9 1\n",
            "inner\n",
            "9 2\n",
            "inner\n",
            "9 3\n",
            "inner\n",
            "9 4\n",
            "inner\n",
            "9 5\n",
            "inner\n",
            "9 6\n",
            "inner\n",
            "9 7\n",
            "inner\n",
            "9 8\n",
            "inner\n",
            "9 9\n",
            "inner\n",
            "outer\n",
            "10 1\n",
            "inner\n",
            "10 2\n",
            "inner\n",
            "10 3\n",
            "inner\n",
            "10 4\n",
            "inner\n",
            "10 5\n",
            "inner\n",
            "10 6\n",
            "inner\n",
            "10 7\n",
            "inner\n",
            "10 8\n",
            "inner\n",
            "10 9\n",
            "inner\n",
            "outer\n",
            "11 1\n",
            "inner\n",
            "11 2\n",
            "inner\n",
            "11 3\n",
            "inner\n",
            "11 4\n",
            "inner\n",
            "11 5\n",
            "inner\n",
            "11 6\n",
            "inner\n",
            "11 7\n",
            "inner\n",
            "11 8\n",
            "inner\n",
            "11 9\n",
            "inner\n",
            "outer\n",
            "12 1\n",
            "inner\n",
            "12 2\n",
            "inner\n",
            "12 3\n",
            "inner\n",
            "12 4\n",
            "inner\n",
            "12 5\n",
            "inner\n",
            "12 6\n",
            "inner\n",
            "12 7\n",
            "inner\n",
            "12 8\n",
            "inner\n",
            "12 9\n",
            "inner\n",
            "outer\n",
            "13 1\n",
            "inner\n",
            "13 2\n",
            "inner\n",
            "13 3\n",
            "inner\n",
            "13 4\n",
            "inner\n",
            "13 5\n",
            "inner\n",
            "13 6\n",
            "inner\n",
            "13 7\n",
            "inner\n",
            "13 8\n",
            "inner\n",
            "13 9\n",
            "inner\n",
            "outer\n",
            "14 1\n",
            "inner\n",
            "14 2\n",
            "inner\n",
            "14 3\n",
            "inner\n",
            "14 4\n",
            "inner\n",
            "14 5\n",
            "inner\n",
            "14 6\n",
            "inner\n",
            "14 7\n",
            "inner\n",
            "14 8\n",
            "inner\n",
            "14 9\n",
            "inner\n",
            "outer\n",
            "15 1\n",
            "inner\n",
            "15 2\n",
            "inner\n",
            "15 3\n",
            "inner\n",
            "15 4\n",
            "inner\n",
            "15 5\n",
            "inner\n",
            "15 6\n",
            "inner\n",
            "15 7\n",
            "inner\n",
            "15 8\n",
            "inner\n",
            "15 9\n",
            "inner\n",
            "outer\n",
            "16 1\n",
            "inner\n",
            "16 2\n",
            "inner\n",
            "16 3\n",
            "inner\n",
            "16 4\n",
            "inner\n",
            "16 5\n",
            "inner\n",
            "16 6\n",
            "inner\n",
            "16 7\n",
            "inner\n",
            "16 8\n",
            "inner\n",
            "16 9\n",
            "inner\n",
            "outer\n",
            "17 1\n",
            "inner\n",
            "17 2\n",
            "inner\n",
            "17 3\n",
            "inner\n",
            "17 4\n",
            "inner\n",
            "17 5\n",
            "inner\n",
            "17 6\n",
            "inner\n",
            "17 7\n",
            "inner\n",
            "17 8\n",
            "inner\n",
            "17 9\n",
            "inner\n",
            "outer\n",
            "18 1\n",
            "inner\n",
            "18 2\n",
            "inner\n",
            "18 3\n",
            "inner\n",
            "18 4\n",
            "inner\n",
            "18 5\n",
            "inner\n",
            "18 6\n",
            "inner\n",
            "18 7\n",
            "inner\n",
            "18 8\n",
            "inner\n",
            "18 9\n",
            "inner\n",
            "outer\n",
            "19 1\n",
            "inner\n",
            "19 2\n",
            "inner\n",
            "19 3\n",
            "inner\n",
            "19 4\n",
            "inner\n",
            "19 5\n",
            "inner\n",
            "19 6\n",
            "inner\n",
            "19 7\n",
            "inner\n",
            "19 8\n",
            "inner\n",
            "19 9\n",
            "inner\n",
            "outer\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KECG0lNUHQ6w",
        "colab_type": "text"
      },
      "source": [
        "#Strings\n",
        "\n",
        "In python, strings are intangible. This means that once decalred, they cannot be modified at a later stage. Some of the important functionalities related to string are-\n",
        "\n",
        "\n",
        "\n",
        "*   concatenation\n",
        "*   repetition\n",
        "*   slicing \n",
        "*   range slicing\n",
        "*   formatting\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hrPy05erIbyA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "s1=\"This is, a string\"\n",
        "s2=\"string\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2KvM7xahNehH",
        "colab_type": "code",
        "outputId": "3ea1461d-97e6-4890-f924-2f22d61c724c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "## accessing individual elements\n",
        "print(s1[5])     #accesasing from forward direction\n",
        "print(s1[-2])     #accesasing from backward direction"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "i\n",
            "n\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yHaajme5I4yN",
        "colab_type": "code",
        "outputId": "d0b5f07e-05a5-406b-9d27-8b9fc2464ef7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "### concatenation  ###\n",
        "\n",
        "print(s1+s2)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This is, a stringstring\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XYRyFlWdIib-",
        "colab_type": "code",
        "outputId": "f6951de1-2a23-4650-f352-dfa8439396da",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "\n",
        "### repetition  ###\n",
        "print(s2*3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "stringstringstring\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wCxql7zTIlOs",
        "colab_type": "code",
        "outputId": "bbe1f21a-57fa-44ff-e2ae-75274d970463",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        }
      },
      "source": [
        "###  slicing  ###\n",
        "\n",
        "s3=s1[0:11]\n",
        "print(s3)\n",
        "\n",
        "s3=s1[-3:-1]\n",
        "print(s3)\n",
        "\n",
        "s3=s1[:11]\n",
        "print(s3)\n",
        "\n",
        "s3=s1[-5:]\n",
        "print(s3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This is a s\n",
            "in\n",
            "This is a s\n",
            "tring\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FxXxRC9_JCF-",
        "colab_type": "code",
        "outputId": "72cc4afe-1220-47be-cb9e-2962730df730",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "\n",
        "### formatting  ###\n",
        "a=3.142857\n",
        "\n",
        "print(\"the value of pi is %0.2f\" %(a) )              # %d,%s,%f,%c,%e,%o,%x\n",
        "\n",
        "\n",
        "\n",
        "## try using dictionaries "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "the value of pi is 3.14\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QkvaUqJEXwo-",
        "colab_type": "code",
        "outputId": "2d5c1056-28ae-4b9a-db21-3cc7e58ea83d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "# splitting into a list\n",
        "\n",
        "l=s1.split()\n",
        "print(l)\n",
        "\n",
        "\n",
        "l=s1.split(\",\")\n",
        "print(l)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['This', 'is,', 'a', 'string']\n",
            "['This is', ' a string']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-kpVHVf_LNTN",
        "colab_type": "text"
      },
      "source": [
        "Some of the important functions associated with strings are -\n",
        "\n",
        "len()\n",
        "\n",
        "upper()\n",
        "\n",
        "lower()\n",
        "\n",
        "isupper()\n",
        "\n",
        "islower()\n",
        "\n",
        "find()\n",
        "\n",
        "count()\n",
        "\n",
        "isalpha()\n",
        "\n",
        "isalnum()\n",
        "\n",
        "isdigit()\n",
        "\n",
        "\n",
        "**Note-** use dir(str) to find out all of these functions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hrEW5kyyMDO7",
        "colab_type": "text"
      },
      "source": [
        "#Lists\n",
        "\n",
        "python list is probably the most important data type in terms of usage and applications. They can contain more than ine type of variable in them. Following are the basic operations that can be performed on a list-"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "3biYC1nPPXxO",
        "outputId": "5ae86139-9253-4e85-dedb-a0c6ada116b7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "a=[1,2,3,4,5,6,7,8]\n",
        "\n",
        "print(dir(list))\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n",
            "[1, 2, 3, 4, 5, 6, 7, 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aDC1JUINOyjC",
        "colab_type": "code",
        "outputId": "fac7b3d2-b6b6-410d-e041-9258af400ea9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "### accessing elements of a list  ###\n",
        "print(a[5])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g1eXYS2HO74H",
        "colab_type": "code",
        "outputId": "765bb199-1437-40ec-af76-372b277cc41b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "### slicing  ###\n",
        "print(a[5])\n",
        "\n",
        "#similar to strings\n",
        "\n",
        "print(a[::-1])     #reversing the list"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[8, 7, 6, 5, 4, 3, 2, 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AXdT6VMbPafp",
        "colab_type": "code",
        "outputId": "4ddaa6a4-c6ce-4813-edca-e24f23ae4665",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "### deleting elements  ###\n",
        "\n",
        "del a[5]\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 7, 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "COLVz6RZP1SY",
        "colab_type": "code",
        "outputId": "f3391d54-b98a-4e9c-edb9-65a94b4cc098",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        }
      },
      "source": [
        "##  in case you need help with any function\n",
        "\n",
        "print(help(list.insert))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on method_descriptor:\n",
            "\n",
            "insert(...)\n",
            "    L.insert(index, object) -- insert object before index\n",
            "\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tR8jrch1NzMm",
        "colab_type": "code",
        "outputId": "832e16b8-881f-4798-916c-6cd5da47992a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "###  insertion  ###\n",
        "a.insert(5,6)\n",
        "\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tEOx8fpiNmu9",
        "colab_type": "code",
        "outputId": "8e008aa4-ec92-4593-9b9a-9bfd738a409a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "###  append  ###\n",
        "a.append(10)\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8, 10, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6PoLSvAZOf5h",
        "colab_type": "code",
        "outputId": "ae2eeb55-0b0c-4093-e223-3219e19c7bc6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "### reversing  ###\n",
        "a.reverse()\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10, 10, 8, 7, 6, 5, 4, 3, 2, 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PkzVWUK9OmXV",
        "colab_type": "code",
        "outputId": "c1028913-7286-46ce-98fb-5de69b59545e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "### sorting  ###\n",
        "a.sort()\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8, 10, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RDk-KasXOo3q",
        "colab_type": "code",
        "outputId": "11a13de3-e64c-4d8b-be76-4f35939bc834",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "###  pop  ###\n",
        "a.pop()\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UfcCtIsETI2Y",
        "colab_type": "text"
      },
      "source": [
        "##List Comprehensions\n",
        "\n",
        "A way to initialize a list in a much simpler way."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sUYHJJNqTYT9",
        "colab_type": "code",
        "outputId": "c7a1cfe2-2878-42cb-cff7-bf52f4a70395",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        }
      },
      "source": [
        "l=[i*i for i in range(1,51)]## using for \n",
        "\n",
        "print(l)\n",
        "\n",
        "l=[i*i for i in range(1,51) if i%2==0]## using for and if\n",
        "\n",
        "print(l)\n",
        "\n",
        "l=[i*i if i%2==0 else 0 for i in range(1,51)]##using for, if and else\n",
        "\n",
        "print(l)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500]\n",
            "[4, 16, 36, 64, 100, 144, 196, 256, 324, 400, 484, 576, 676, 784, 900, 1024, 1156, 1296, 1444, 1600, 1764, 1936, 2116, 2304, 2500]\n",
            "[0, 4, 0, 16, 0, 36, 0, 64, 0, 100, 0, 144, 0, 196, 0, 256, 0, 324, 0, 400, 0, 484, 0, 576, 0, 676, 0, 784, 0, 900, 0, 1024, 0, 1156, 0, 1296, 0, 1444, 0, 1600, 0, 1764, 0, 1936, 0, 2116, 0, 2304, 0, 2500]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "23HPAjFAUTg1",
        "colab_type": "text"
      },
      "source": [
        "#Tuples\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HvP2d7zbUSs0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#immutable (or unchangeable) and ordered\n",
        "#tuple vs list \n",
        "#tuples are immutable lists\n",
        "# you cannot add values either\n",
        "foo = (1,2,3,4,5)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aIjiUbNSG2Un",
        "colab_type": "code",
        "outputId": "11dc002e-af22-410f-836e-bb37a5d84416",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "# slicing \n",
        "\n",
        "numbers =(1,2,3,4,5)\n",
        "print(numbers[:-1])\n",
        "\n",
        "#reverse slicing\n",
        "\n",
        "print(numbers[::-1])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1, 2, 3, 4)\n",
            "(5, 4, 3, 2, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DaqI5s3NIgTK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# for single element tuple declare them with a comma\n",
        "baz = (1,)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cldJO82tVtB9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# tuple based assignment\n",
        "\n",
        "\n",
        "a,b=10,20\n",
        "\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EKN-nYjjWZ6J",
        "colab_type": "code",
        "outputId": "20e05313-6534-4803-b3ae-4aef217c0258",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 306
        }
      },
      "source": [
        "# tuples support following basic operations\n",
        "\n",
        "t=foo + numbers         # concatenation\n",
        "print(t)\n",
        "\n",
        "t=foo*3                  #repetation\n",
        "print(t)\n",
        "\n",
        "\n",
        "for i in t:\n",
        "  print(i)           #iteration over tuple"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)\n",
            "(1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5)\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AMM1KUzmUXi2",
        "colab_type": "text"
      },
      "source": [
        "#Dictionaries\n",
        "\n",
        "These are a set of key-value pairs. Each key, which is unique, corresponds to a value which can be accesses only by using the dictionary name and key."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5y3FnmlBU886",
        "colab_type": "code",
        "outputId": "87f732a5-0bcf-4c6e-9c72-f3d2882918c8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "### Initialising dictionaries \n",
        "\n",
        "temp={\"pi\":3.14,\"chi\":2.0} ###Standard\n",
        "print(temp)\n",
        "\n",
        "\n",
        "### with lists\n",
        "\n",
        "list1=[1,2,3,4,5]\n",
        "\n",
        "list2=[\"one\",\"two\",'three',\"four\",\"five\"]\n",
        "\n",
        "temp2=dict(zip(list2,list1))                #here list2 elements serve as keys and list1 elements as corresponding values\n",
        "print(temp2)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'pi': 3.14, 'chi': 2.0}\n",
            "{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RaKVTJb3XA-M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# accessing elements\n",
        "\n",
        "print(temp2[\"one\"])\n",
        "print(temp[\"pi\"])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6W3JoQL8XE6c",
        "colab_type": "code",
        "outputId": "2b4a5acb-efe9-4499-8c48-66b9ba091c23",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# creating new entries\n",
        "\n",
        "temp[\"new\"]=2019\n",
        "print(temp)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'pi': 3.14, 'chi': 2.0, 'new': 2019}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-cNr7HWXHS0",
        "colab_type": "code",
        "outputId": "6b631387-6c1e-48e2-af64-e64c95fdd51a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# dict to string; returns a printable string versionof the dictionary\n",
        "\n",
        "dstr=str(temp)\n",
        "\n",
        "print(dstr,type(dstr))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'pi': 3.14, 'chi': 2.0, 'new': 2019} <class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7pGbsRy4XfJQ",
        "colab_type": "code",
        "outputId": "aa5008a0-8cb7-4ffe-f24b-cdac9167088e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "# printing keys and values\n",
        "\n",
        "print(temp.keys())\n",
        "print(list(temp.keys()))\n",
        "\n",
        "print(temp.values())\n",
        "print(list(temp.values()))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict_keys(['pi', 'chi', 'new'])\n",
            "['pi', 'chi', 'new']\n",
            "dict_values([3.14, 2.0, 2019])\n",
            "[3.14, 2.0, 2019]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qJudtK8SRgCM",
        "colab_type": "text"
      },
      "source": [
        "#Functions\n",
        "\n",
        "Functions encourage modularity in code and improves readability. Each function is executed only when it is called and terminates as seen as the functional block ends, or a return statement is encountered.\n",
        "\n",
        "The syntax for function declaration is as follows-\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "def func_name(arg_1,arg_2,...):\n",
        "    statement(s)\n",
        "    return\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WUQ-cvx1QomU",
        "colab_type": "code",
        "outputId": "0bef5a31-0b9f-43b4-f918-630f374dc984",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "### create the function to take a list and return value obtained on multiplying all its elements \n",
        "### Write your code here\n",
        "def func(a):\n",
        "  sum=0\n",
        "  for i in a:\n",
        "    sum+=i\n",
        "  return sum,a\n",
        "\n",
        "### end code here\n",
        "\n",
        "a=[i for i in range(1,11)]\n",
        "\n",
        "s,b=func(a);\n",
        "print(s,b)\n",
        "\n",
        "###note that in python there is no storage limit for a variable"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "55 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ZS5cq1EQs7E",
        "colab_type": "text"
      },
      "source": [
        "#Packages\n",
        "\n",
        "To use external packages, and the objects and functions defined in them, we have to first import them into the program. The main keywords used for this purpose are **import, from** and **as**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1Ovt6JNlRQzy",
        "colab_type": "code",
        "outputId": "26f9f20a-1e97-4bee-ad17-297ac2c6a48e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "##let's import some packages\n",
        "import math \n",
        "\n",
        "print(math.pi)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e1vYPPt2SCG2",
        "colab_type": "code",
        "outputId": "6b0d1244-c0f8-4f19-97d2-0d4734f44237",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "from math import pi\n",
        "\n",
        "print(pi)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IHsyiQ0hSU41",
        "colab_type": "code",
        "outputId": "548d0ec7-8ad4-482e-da28-8982f8a66246",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 214
        }
      },
      "source": [
        "from math import pi as pi_alias\n",
        "\n",
        "print(pi_alias)\n",
        "print(pi)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n"
          ],
          "name": "stdout"
        },
        {
          "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-1-c514a2c1ca18>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpi_alias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpi\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 'pi' is not defined"
          ]
        }
      ]
    }
  ]
}