Python_Advance_final.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python-Advance_final.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "25g_pGYth-Se",
        "Hshx3BGalhdK",
        "bhAPhLBsr4fG",
        "sUmfYCuxwDHu",
        "rGkW4GX61pol",
        "6KTbpeHA3zcN"
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "25g_pGYth-Se"
      },
      "source": [
        "#while loop in Python Programming\n",
        "A while loop statement in Python programming language repeatedly executes a target statement as long as a given condition is true."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vMEwucoOhzZy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2fd827c7-1964-48dc-a3a7-e3a4ac11b6e6"
      },
      "source": [
        "# while statement is like if statement.  \n",
        "i = 0\n",
        "while i<5:\n",
        "  print (i)\n",
        "  i= i+1"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bzBFobjqi0yi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "239f42e2-89df-4a4b-92f6-c2e6e1050db7"
      },
      "source": [
        "# A break statement is used to break from a loop\n",
        "i = 0\n",
        "while i<15:\n",
        "  if i==12:\n",
        "    break\n",
        "  print (i)\n",
        "  i= i+1"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LcsOIxJzjy1R",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ee60a5c4-9fe7-4a38-9d16-f42b64ac25ed"
      },
      "source": [
        "# A continue statement stops the flow and goes back again to the starting point of block. \n",
        "# \n",
        "# continue - goes back to start of the block\n",
        "\n",
        "i = 0\n",
        "while i<20:\n",
        "  if (i % 2==0):\n",
        "    i=i+1\n",
        "    print (\"Inside continue\",i)\n",
        "    continue\n",
        "  i=i+2  \n",
        "  print (i)\n",
        "  i= i+1"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Inside continue 1\n",
            "3\n",
            "Inside continue 5\n",
            "7\n",
            "Inside continue 9\n",
            "11\n",
            "Inside continue 13\n",
            "15\n",
            "Inside continue 17\n",
            "19\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2eXllkhHkQ9m",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "529cafe7-aa8a-4aa6-d160-8caef6af3ab1"
      },
      "source": [
        "#Using else Statement with While Loop\n",
        "count = 0\n",
        "while count < 15:\n",
        "   print (count, \" is  less than 5\")\n",
        "   count = count + 1\n",
        "else:\n",
        "   print (count, \" is not less than 5\")"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0  is  less than 5\n",
            "1  is  less than 5\n",
            "2  is  less than 5\n",
            "3  is  less than 5\n",
            "4  is  less than 5\n",
            "5  is  less than 5\n",
            "6  is  less than 5\n",
            "7  is  less than 5\n",
            "8  is  less than 5\n",
            "9  is  less than 5\n",
            "10  is  less than 5\n",
            "11  is  less than 5\n",
            "12  is  less than 5\n",
            "13  is  less than 5\n",
            "14  is  less than 5\n",
            "15  is not less than 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hshx3BGalhdK"
      },
      "source": [
        "#for loop in Python Programming\n",
        "Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XR50GT2_kYmU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "843b5dc4-9d13-49a4-c9dd-c1de11f08b71"
      },
      "source": [
        "#Print each fruit in a fruit list:\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for x in fruits:\n",
        "  print(x)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9h0K790JmzQf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b4a47cf-f118-40ed-f695-c7581366175c"
      },
      "source": [
        "# Program to find the sum of all numbers stored in a list\n",
        "\n",
        "# List of numbers\n",
        "numbers = [6, 5, 3, -8, 4, 2, 5, 4, 11]\n",
        "\n",
        "# variable to store the sum\n",
        "sum = 0\n",
        "\n",
        "# iterate over the list\n",
        "for val in numbers:\n",
        "\tsum = sum+val\n",
        "\n",
        "print(\"The sum is\", sum)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The sum is 32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Q6yCbJLm2F-"
      },
      "source": [
        "#range function\n",
        "#We can generate a sequence of numbers using range() function.\n",
        "print(range(10))\n",
        "\n",
        "print(list(range(10)))\n",
        "\n",
        "print(list(range(2, 8)))\n",
        "\n",
        "print(list(range(2, 20, 3)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dFQgnNYcnZJs"
      },
      "source": [
        "#Loop through the letters in the word \"banana\":\n",
        "\n",
        "for x in \"banana\":\n",
        "  print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MVSFPF_6nrNh"
      },
      "source": [
        "#for loop with else\n",
        "#A for loop can have an optional else block as well. The else part is executed if the items in the sequence used in for loop exhausts.\n",
        "\n",
        "digits = [0, 1, 5, 32]\n",
        "\n",
        "for i in digits:\n",
        "    print(i)\n",
        "else:\n",
        "    print(\"No items left.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IvhBhXGCog9r"
      },
      "source": [
        "#break statement in for loop\n",
        "#Exit the loop when x is \"banana\":\n",
        "\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for x in fruits:\n",
        "  print(x)\n",
        "  if x == \"cherry\":\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y6P3HdmPorzO"
      },
      "source": [
        "# program to display student's marks from record\n",
        "student_name = 'Sandeep'\n",
        "\n",
        "marks = {'Ankush': 90, 'Divyam': 55, 'Sanjay': 77}\n",
        "\n",
        "for student in marks:\n",
        "    if student == student_name:\n",
        "        print(marks[student])\n",
        "        break\n",
        "else:\n",
        "    print('No entry with that name found.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bhAPhLBsr4fG"
      },
      "source": [
        "#nested loops in Python programming\n",
        "Python programming language allows to use one loop inside another loop. Following section shows few examples to illustrate the concept."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "35VPrPHppG0j"
      },
      "source": [
        "#The following program uses a nested for loop to find the prime numbers from 2 to 100 −\n",
        "i = 2\n",
        "while(i < 100):\n",
        "   j = 2\n",
        "   while(j <= (i/j)):\n",
        "      if not(i%j): break\n",
        "      j = j + 1\n",
        "   if (j > i/j) : print (i, \" is prime\")\n",
        "   i = i + 1\n",
        "\n",
        "print (\"Good bye!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-S72i67nsI1R"
      },
      "source": [
        "#nested loop\n",
        "for i in range(1, 5): \n",
        "    for j in range(i): \n",
        "         print(i, end=' ') \n",
        "    print() "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ycpk0VQTuJ_Y"
      },
      "source": [
        "#Functions\n",
        "Functions help to reuse code. They bring modularity and simplicity to code"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s63dUsKrsodA"
      },
      "source": [
        "# functions in python are created using def statement\n",
        "def name_philospher():\n",
        "  print ('Bertrand Russell')\n"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "noWbacmCJ3_o"
      },
      "source": [
        "name_philospher() "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7gCcehEFumy7"
      },
      "source": [
        "# One can pass arguments to functions\n",
        "# name is an argument for the function name_of_philosphers\n",
        "\n",
        "def name_philospher(name, country):\n",
        "  print (name,country)\n"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aDEk0IbiJ-zu"
      },
      "source": [
        "name_philospher('Bertrand Russell', '- United Kingdom') \n",
        "name_philospher('Carl Marx', '- Germany') "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OoZweM0QuyT1"
      },
      "source": [
        "#function can  return values\n",
        "\n",
        "def name_of_philospher(name,country):\n",
        "  str = \"The philosopher {} lived in  country {}\".format(name,country)\n",
        "  return str\n",
        "\n",
        "name = name_of_philospher('Bertrand Russell','United Kingdom')\n",
        "print (name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lWO-1C6CvG5q"
      },
      "source": [
        "# function can return multiple values\n",
        "# The function adds and subtsracts two numbers\n",
        "def add_and_substract(num1,num2):\n",
        "    add = num1+num2\n",
        "    diff = num1-num2\n",
        "    return add,diff\n",
        "  \n",
        "add,diff = add_and_substract(10,2) \n",
        "\n",
        "print (\"The sum is =\",add)\n",
        "print (\"The difference is =\",diff)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-JFJgyELvhPv"
      },
      "source": [
        "# Functions are just like normal variables. They can be assigned and reassigned to variables\n",
        "\n",
        "def add_and_substract(num1,num2):\n",
        "    \"\"\"\n",
        "     The function adds and subtsracts two numbers\n",
        "    \"\"\" \n",
        "    add = num1+num2\n",
        "    diff = num1-num2\n",
        "    return add,diff\n",
        "  \n",
        "operation = add_and_substract\n",
        "\n",
        "num1, num2 = operation(10,2)\n",
        "print (num1, num2)\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pSXRTqf_vlzp"
      },
      "source": [
        "# The special syntax, *args and **kwargs in function definitions is used to pass a variable number of arguments to a function.\n",
        "\n",
        "# The single asterisk form (*args) is used to pass a non-keyworded, variable-length argument list, \n",
        "# and the double asterisk form is used to pass a keyworded, variable-length argument list. \n",
        "\n",
        "\n",
        "def add_numbers(*args):\n",
        "  \n",
        "  for i in args:\n",
        "    print (i)\n",
        "\n",
        "add_numbers(1,2,3,4,5)    \n",
        "\n",
        "\n",
        "\n",
        "def add_numbers(**kwargs):\n",
        "    for key in kwargs:\n",
        "        print (\"another keyword arg: {}: {}\".format(key, kwargs[key]))\n",
        "   \n",
        "  \n",
        "add_numbers(num1=1,num2=2,num3=3,num4=4,num5=5)    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sUmfYCuxwDHu"
      },
      "source": [
        "#Dictionary\n",
        "Python dictionary is an unordered collection of items. Each item of a dictionary has a key/value pair."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dFWEfNBVzLbs"
      },
      "source": [
        "#Accessing Values in Dictionary\n",
        "dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}\n",
        "print (\"dict['Name']: \", dict['Name'])\n",
        "print (\"dict['Age']: \", dict['Age'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zi8b7SsIvv0G"
      },
      "source": [
        "# Dictionaries are data structures used to map key to values\n",
        "\n",
        "philosphers = {\"United Kingdom\":\"Bertrand Russell\", \"Germany\":\"Karl Marx\"}\n",
        "\n",
        "print (philosphers[\"United Kingdom\"])\n",
        "print (philosphers[\"Germany\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_9orzU0Wwepl"
      },
      "source": [
        "# Accessing a Index which is not part of dictionary results in a keyerror\n",
        "\n",
        "philosphers = {\"United Kingdom\":\"Bertrand Russell\", \"Germany\":\"Karl Marx\"}\n",
        "\n",
        "print (philosphers[\"India\"])  # This will result in a KeyError"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qMB2_uXGwvbm"
      },
      "source": [
        "philosphers = {\"UK\":\"Bertrand Russell\", \"Germany\":\"Karl Marx\", \"India\":None}\n",
        "\n",
        "philosphers[\"India\"] = \"AryaBhatt\"              #One can assign a existing key to new value\n",
        "philosphers[\"United Kingdom\"] = \"John Mill\" #One can assign a existing key to new value\n",
        "philosphers[\"United States\"] = \"John Dewey\" # One can create a new key and assign a value\n",
        "\n",
        "print (philosphers)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i9dMlW3owxK_"
      },
      "source": [
        "# One can determine whether a key is present in dictionary or not (using \"in\" and \"not in\")\n",
        "\n",
        "philosphers = {\"UK\":\"Bertrand Russell\", \"Germany\":\"Karl Marx\", \"India\":\"Arya Bhatt\"}\n",
        "\n",
        "print (\"India\" in philosphers)\n",
        "print (\"Brazil\" in philosphers)\n",
        "print (\"Brazil\" not in philosphers)\n",
        "\n",
        "\n",
        "print(philosphers)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_79fk3vvw8Ym"
      },
      "source": [
        "# using keys, values and items in dictionary\n",
        "\n",
        "philosphers = {\"UK\":\"Bertrand Russell\", \"Germany\":\"Karl Marx\", \"India\":\"Arya Bhatt\"}\n",
        "\n",
        "print (philosphers.keys())\n",
        "\n",
        "print(type(philosphers.keys()))\n",
        "\n",
        "print (philosphers.values())\n",
        "print(type(philosphers.values()))\n",
        "\n",
        "print (philosphers.items())\n",
        "print(type(philosphers.items()))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JRc1lEzJxBpY"
      },
      "source": [
        "# A get method is like an index with added advantage that one can specify a default value \n",
        "# if the index is not found This prevents keyerror\n",
        "\n",
        "philosphers = {\"UK\":\"Bertrand Russell\", \"Germany\":\"Karl Marx\", \"India\":\"Arya Bhatt\"}\n",
        "\n",
        "print (philosphers.get(\"Russia\",\"No philospher set for Russia\"))  # No keyerror\n",
        "print (philosphers.get(\"Russia\"))  # By default a None value will be returned\n",
        "print (philosphers[\"Russia\"])   # A keyerror occurs"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KtRUjXbhx6tg"
      },
      "source": [
        "#List\n",
        "A list denotes a container object in python and it is used to store indexed list of items. A list can contain different types of items for e.g. string, integer or other list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QAcWa48fxIrB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 83
        },
        "outputId": "b86d226b-2d66-41b7-b281-48598cbb7bbf"
      },
      "source": [
        "word_list = ['This', 'is', 'good']  # A list of 3 items\n",
        "\n",
        "print (word_list[0]) # prints the first  item. Index starts at 0.\n",
        "print (word_list[1]) # prints the second item\n",
        "print (word_list[2]) # print the third item\n",
        "\n",
        "\n",
        "# An empty list is created with empty bracket\n",
        "empty = []\n",
        "print (empty)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This\n",
            "is\n",
            "good\n",
            "[]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_7I7RqIT0FvX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "7b26d5e6-8a56-464b-a54a-f6b1901bcd9c"
      },
      "source": [
        "# Negative indexing in lists\n",
        "my_list = ['p','r','o','b','e']\n",
        "\n",
        "print(my_list[-1])\n",
        "\n",
        "print(my_list[-5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "e\n",
            "p\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CI9-jD1R0T7v",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 83
        },
        "outputId": "76cfca55-e083-4851-d040-66ea61d3d3e3"
      },
      "source": [
        "# List slicing in Python\n",
        "\n",
        "my_list = ['S','a','n','j','a','y']\n",
        "\n",
        "# elements 3rd to 5th\n",
        "print(my_list[2:5])\n",
        "\n",
        "# elements beginning to 4th\n",
        "print(my_list[:-5])\n",
        "\n",
        "# elements 6th to end\n",
        "print(my_list[5:])\n",
        "\n",
        "# elements beginning to end\n",
        "print(my_list[:])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['n', 'j', 'a']\n",
            "['S']\n",
            "['y']\n",
            "['S', 'a', 'n', 'j', 'a', 'y']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fcoFT5Lf03wm",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "7486409e-630b-451d-ad95-63e167a25534"
      },
      "source": [
        "# Correcting mistake values in a list\n",
        "odd = [2, 4, 6, 8]\n",
        "\n",
        "# change the 1st item    \n",
        "odd[0] = 1            \n",
        "\n",
        "print(odd)\n",
        "\n",
        "# change 2nd to 4th items\n",
        "odd[1:4] = [3, 5, 7]  \n",
        "\n",
        "print(odd)    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 4, 6, 8]\n",
            "[1, 3, 5, 7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HFf_Xrjr0_Ba",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "dd17a231-04f2-48c3-eab7-f04bb4b5fbc1"
      },
      "source": [
        "# Appending and Extending lists in Python\n",
        "odd = [1, 3, 5]\n",
        "\n",
        "odd.append(7)\n",
        "\n",
        "print(odd)\n",
        "\n",
        "odd.extend([9, 11, 13])\n",
        "\n",
        "print(odd)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 3, 5, 7]\n",
            "[1, 3, 5, 7, 9, 11, 13]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u0xNZYt_1DX9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "5b240efd-b03f-465f-b72f-067ad4714817"
      },
      "source": [
        "# Concatenating \n",
        "odd = [1, 3, 5]\n",
        "\n",
        "print(odd + [9, 7, 5])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 3, 5, 9, 7, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "07pBL1I61NjN",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "1b358ade-ef2e-45ba-972e-0e3629c819fa"
      },
      "source": [
        "# Deleting list items\n",
        "my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']\n",
        "\n",
        "# delete one item\n",
        "del my_list[2]\n",
        "\n",
        "print(my_list)\n",
        "\n",
        "# delete multiple items\n",
        "del my_list[1:5]\n",
        "\n",
        "print(my_list)\n",
        "# delete entire list\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['p', 'r', 'b', 'l', 'e', 'm']\n",
            "['p', 'm']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vpfo1G7kuyRd"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DT41UsDe1fMc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 83
        },
        "outputId": "2f508b69-9385-4bd0-d92c-8de1f95f095e"
      },
      "source": [
        "# Python list methods\n",
        "my_list = [3, 8, 1, 6, 0, 8, 4]\n",
        "\n",
        "# Output: 1\n",
        "print(my_list.index(8))\n",
        "\n",
        "# Output: 2\n",
        "print(my_list.count(8))\n",
        "\n",
        "my_list.sort()\n",
        "\n",
        "# Output: [0, 1, 3, 4, 6, 8, 8]\n",
        "print(my_list)\n",
        "\n",
        "my_list.reverse()\n",
        "\n",
        "# Output: [8, 8, 6, 4, 3, 1, 0]\n",
        "print(my_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "[0, 1, 3, 4, 6, 8, 8]\n",
            "[8, 8, 6, 4, 3, 1, 0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iemv69sHz9Jt"
      },
      "source": [
        "# A list can contain items of multiple types\n",
        "\n",
        "generic_list = [1,\"String\",[1,2,3], 5]\n",
        "\n",
        "print ('Value at {} is {} of type {}'.format(0,generic_list[0],type(generic_list[0])))\n",
        "print ('Value at {} is {} of type {}'.format(1,generic_list[1],type(generic_list[1])))\n",
        "print ('Value at {} is {} of type {}'.format(2,generic_list[2],type(generic_list[2])))\n",
        "print ('Value at {} is {} of type {}'.format(3,generic_list[3],type(generic_list[3])))\n",
        "\n",
        "\n",
        "# nested list access\n",
        "\n",
        "print ('Accessing {} value from nested list {} = {}'.format(1,generic_list[2] ,generic_list[2][1]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rGkW4GX61pol"
      },
      "source": [
        "#Tuples\n",
        "A tuple in Python is similar to a list. The difference between the two is that we cannot change the elements of a tuple once it is assigned whereas we can change the elements of a list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o_2bt9om0sH9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 83
        },
        "outputId": "92ff12b4-6a1e-475b-ce85-7936a31f5ba3"
      },
      "source": [
        "# Different types of tuples\n",
        "\n",
        "# Empty tuple\n",
        "my_tuple = ()\n",
        "print(my_tuple)\n",
        "\n",
        "# Tuple having integers\n",
        "my_tuple = (1, 2, 3)\n",
        "print(my_tuple)\n",
        "\n",
        "# tuple with mixed datatypes\n",
        "my_tuple = (1, \"Hello\", 3.4)\n",
        "print(my_tuple)\n",
        "\n",
        "# nested tuple\n",
        "my_tuple = (\"mouse\", [8, 4, 6], (1, 2, 3))\n",
        "print(my_tuple)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "()\n",
            "(1, 2, 3)\n",
            "(1, 'Hello', 3.4)\n",
            "('mouse', [8, 4, 6], (1, 2, 3))\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rsfLyczV15E3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 83
        },
        "outputId": "d14ebb89-4129-4630-ece7-076dcc13562a"
      },
      "source": [
        "my_tuple = 3, 4.6, \"dog\"\n",
        "print(my_tuple)\n",
        "\n",
        "# tuple unpacking is also possible\n",
        "a, b, c = my_tuple\n",
        "\n",
        "print(a)      # 3\n",
        "print(b)      # 4.6\n",
        "print(c)      # dog"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(3, 4.6, 'dog')\n",
            "3\n",
            "4.6\n",
            "dog\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xrLZREFr1_RX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 66
        },
        "outputId": "22a77c9f-187e-42d4-a743-519848698260"
      },
      "source": [
        "my_tuple = (\"hello\")\n",
        "print(type(my_tuple))  # <class 'str'>\n",
        "\n",
        "# Creating a tuple having one element\n",
        "my_tuple = (\"hello\",)\n",
        "print(type(my_tuple))  # <class 'tuple'>\n",
        "\n",
        "# Parentheses is optional\n",
        "my_tuple = \"hello\"\n",
        "print(type(my_tuple))  # <class 'tuple'>"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'str'>\n",
            "<class 'tuple'>\n",
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qEkeZQx-2Lox",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "46b54a09-8c2c-420a-fd89-009f56352d9a"
      },
      "source": [
        "# Accessing tuple elements using indexing\n",
        "my_tuple = ('p','e','r','m','i','t')\n",
        "\n",
        "print(my_tuple[0])   # 'p' \n",
        "print(my_tuple[5])   # 't'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "p\n",
            "t\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PjYgCUhn2R46",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "bc7ffc73-1ebd-434b-bb92-862a6ac531fe"
      },
      "source": [
        "# nested tuple\n",
        "n_tuple = (\"mouse\", [8, 4, 6], (1, 2, 3))\n",
        "\n",
        "# nested index\n",
        "print(n_tuple[0][3])       # 's'\n",
        "print(n_tuple[1][1])       # 4"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "s\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DTlIjKnF2eRo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "f429f522-2d5b-4205-fbf2-0eeb993988ee"
      },
      "source": [
        "# Negative indexing for accessing tuple elements\n",
        "my_tuple = ('p', 'e', 'r', 'm', 'i', 't')\n",
        "\n",
        "# Output: 't'\n",
        "print(my_tuple[-1])\n",
        "\n",
        "# Output: 'p'\n",
        "print(my_tuple[-6])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "t\n",
            "p\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vnadefnt2jE7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 83
        },
        "outputId": "f79e021c-1fce-4c42-a852-a896c43c1a9e"
      },
      "source": [
        "# Accessing tuple elements using slicing\n",
        "my_tuple = ('s','a','n','j','a','y','I','N','D')\n",
        "\n",
        "# elements 2nd to 4th\n",
        "# Output: ('r', 'o', 'g')\n",
        "print(my_tuple[1:4])\n",
        "\n",
        "# elements beginning to 2nd\n",
        "# Output: ('p', 'r')\n",
        "print(my_tuple[:-7])\n",
        "\n",
        "# elements 8th to end\n",
        "# Output: ('i', 'z')\n",
        "print(my_tuple[7:])\n",
        "\n",
        "# elements beginning to end\n",
        "# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')\n",
        "print(my_tuple[:])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "('a', 'n', 'j')\n",
            "('s', 'a')\n",
            "('N', 'D')\n",
            "('s', 'a', 'n', 'j', 'a', 'y', 'I', 'N', 'D')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0AGtTV_h2oF6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "31a38de1-c73e-41a2-e560-db6c0f823f6b"
      },
      "source": [
        "# Changing tuple values\n",
        "my_tuple = (4, 2, 3, [6, 5])\n",
        "\n",
        "\n",
        "# However, item of mutable element can be changed\n",
        "my_tuple[3][0] = 9   \n",
        "print(my_tuple)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4, 2, 3, [9, 5])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XevTspiU2_BM"
      },
      "source": [
        "# Concatenation\n",
        "# Output: (1, 2, 3, 4, 5, 6)\n",
        "print((1, 2, 3) + (4, 5, 6))\n",
        "\n",
        "# Repeat\n",
        "# Output: ('Repeat', 'Repeat', 'Repeat')\n",
        "print((\"Repeat\",) * 3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8BWJWjbL3Wsa"
      },
      "source": [
        "# Deleting tuples\n",
        "my_tuple = ('S', 'A', 'N', 'J', 'A', 'Y')\n",
        "\n",
        "# Can delete an entire tuple\n",
        "del my_tuple\n",
        "\n",
        "# NameError: name 'my_tuple' is not defined\n",
        "print(my_tuple)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6KTbpeHA3zcN"
      },
      "source": [
        "#Python Exception Handling\n",
        "Exceptions occur when something wrong happens in the code. The program stops immediately.\n",
        "Exceptions can be raised for multiple reasons. For e.g.\n",
        "\n",
        "ImportError - An import fails\n",
        "\n",
        "IndexError - A list is indexed with out of range error\n",
        "\n",
        "SytanxError - Some syntax error\n",
        "\n",
        "TypeError - A function is called with a wrong type of variable\n",
        "\n",
        "ValueError - A function is called with inappropriate value"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GbMoshF13aPT"
      },
      "source": [
        "#import nump1 #Import Error\n",
        "\n",
        "#list = [1,2,3]\n",
        "#list[4]        # Index Error\n",
        "\n",
        "\n",
        "#list = {1,2,3] # Syntax error\n",
        "\n",
        "\n",
        "#x = int('One') # This causes a value error\n",
        "\n",
        "def add_num(num1,num2):\n",
        "    return int(num1)+int(num2)   #value error\n",
        "  \n",
        "add_num(\"One\",\"Two\")      "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EnsDyBze4iXF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "1cac2196-7788-4cd8-f931-1bf066e69437"
      },
      "source": [
        "# To handle exceptions we use try/except statement. Try contains code that might throw an exception\n",
        "try:\n",
        "  num1 = 8\n",
        "  num2 = 0\n",
        "  x = num1/num2           # This line throws exception. The code stops immediately. \n",
        "  print (\"This statement will not be printed\") # This line is not executed.\n",
        "  \n",
        "except ZeroDivisionError:\n",
        "   print (\"Zero Division Error\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Zero Division Error\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hDDfDKsX4tt9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "44729bbe-09e1-4d8c-a17a-999146f73523"
      },
      "source": [
        "# A try statement can have multiple except blocks\n",
        "\n",
        "try:\n",
        "  variable = 10\n",
        "  print(variable+\"hello\")\n",
        "  print(variable/2)\n",
        "  \n",
        "except ZeroDivisionError:  \n",
        "  print(\"Divided by Zero\")\n",
        "except(ValueError, TypeError):\n",
        "  print(\"Error Occured\")\n",
        "  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Error Occured\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fSHjnsoX5MxR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "ba94c6bf-5f50-412c-efad-72d5712dd542"
      },
      "source": [
        "# An except statement without any exception specified will catch all errors\n",
        "\n",
        "try:\n",
        "  \n",
        "  4/0\n",
        "  \n",
        "except:\n",
        "  print (\"Error Occured\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Error Occured\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ytFd54Oi5Ri_"
      },
      "source": [
        "# To ensure that code runs no matter a finally block will be used\n",
        "try:\n",
        "  print(\"Step 1\")\n",
        "  4/0                            # An exception happen here\n",
        "except ZeroDivisionError:        # The exception is caught here   \n",
        "  print (\"Divided by Zero\")      # This is printed\n",
        "  \n",
        "finally:\n",
        "  print(\"This will be always executed\")  # This will be executed whether there is exception or not"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XEcbQso-5XY0"
      },
      "source": [
        "# Code in finally statement always runs even if there is an exception in above block\n",
        "\n",
        "try:\n",
        "  print (8/0)\n",
        "except ZeroDivisionError:\n",
        "  print (unknown_data)  # This will trigger an exception\n",
        "finally:\n",
        "  print (\"This will always be executed\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hGTpt0Q25gBW"
      },
      "source": [
        "# Exceptions can be raised by giving details about arguments\n",
        "\n",
        "name = \"123\"\n",
        "raise NameError(\"Invalid Name\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Autn9yKh5jnt"
      },
      "source": [
        "def my_func():\n",
        "  try:\n",
        "    4/0   # This raises ZeroDivisionError\n",
        "  \n",
        "  except Exception as ex:\n",
        "    template = \"An exception of type {0} occurred. Arguments:\\n{1!r}\"\n",
        "    message = template.format(type(ex).__name__, ex.args)\n",
        "    print (message)\n",
        "    raise # The ZeroDivisionError is propogated out\n",
        "   \n",
        "  \n",
        "def another_func():\n",
        "  try:\n",
        "    my_func()\n",
        "  except ZeroDivisionError: # The ZeroDivisionError is caught\n",
        "      print ('Error')\n",
        "      \n",
        "another_func()      \n",
        "   "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "flyw1efJ5pul"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}