Day1_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNoSjMuBhcfy3e797BcvWSM"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ej2Ie9iv1PYj",
        "outputId": "53243c49-a7d3-4604-b717-50e858776c08"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome to Code From Basics\n"
          ]
        }
      ],
      "source": [
        "print(\"Welcome to Code From Basics\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Featurs of Python**\n",
        "\n",
        "1. Easy to Learn\n",
        "2. Open source\n",
        "3. Dynamically Typed\n",
        "4. Pure Object Oriented Programming\n",
        "5. GUI Programming\n",
        "6. Rich Library in various fields\n",
        "7. Good Performance\n",
        "8. Platform Independent(Cross Platform)\n",
        "9. Community\n",
        "10. Interpreted"
      ],
      "metadata": {
        "id": "L8wieM7v1YWQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num=10\n",
        "a=10\n",
        "print(num)\n",
        "\n",
        "# dynamically types\n",
        "\n",
        "# Data Analyst\n",
        "# Data Engineer\n",
        "# ML Engineer\n",
        "# Data Scientist\n",
        "# Web Developer\n",
        "# AI Engineer\n",
        "# Image processing\n",
        "# Devops\n",
        "# ETL\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 108
        },
        "id": "lHbtQFli1dRm",
        "outputId": "b36e8135-eae9-4566-d21e-50a509a0661f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "invalid syntax (<ipython-input-1-438ad1ea5948>, line 5)",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-438ad1ea5948>\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m    dynamically types\u001b[0m\n\u001b[0m                ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Operators in Python\n",
        "1. Arithmetic Operator\n",
        "2. Relational Operator\n",
        "3. Bitwise Operator\n",
        "4. Assignment Operator\n",
        "5. Membership Operator\n",
        "6. Identity Operator\n",
        "7. Logical Operator"
      ],
      "metadata": {
        "id": "IkObWLoMEc6g"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " # Arithmetic Operator\n",
        "\n",
        " num1=10\n",
        " num2=3\n",
        " print(num1,\"+\",num2,\"=\",num1+num2)\n",
        " print(num1,\"-\",num2,\"=\",num1-num2)\n",
        " print(num1,\"*\",num2,\"=\",num1*num2)\n",
        " print(num1,\"/\",num2,\"=\",num1/num2)\n",
        " print(num1,\"//\",num2,\"=\",num1//num2)#floor division only quotient (without decimal)\n",
        " print(num1,\"%\",num2,\"=\",num1%num2)#reminder\n",
        " print(num1,\"**\",num2,\"=\",num1**num2)#exp\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jSgH9Z7qEa5s",
        "outputId": "435dee04-736a-43d9-d4ed-5a3c01990012"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10 + 3 = 13\n",
            "10 - 3 = 7\n",
            "10 * 3 = 30\n",
            "10 / 3 = 3.3333333333333335\n",
            "10 // 3 = 3\n",
            "10 % 3 = 1\n",
            "10 ** 3 = 1000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Relational Operator\n",
        "\n",
        "print(num1,\"<\",num2,\"=\",num1<num2)\n",
        "print(num1,\"<=\",num2,\"=\",num1<=num2)\n",
        "print(num1,\">\",num2,\"=\",num1>num2)\n",
        "print(num1,\">=\",num2,\"=\",num1>=num2)\n",
        "print(num1,\"==\",num2,\"=\",num1==num2)\n",
        "print(num1,\"!=\",num2,\"=\",num1!=num2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xsSuzi13FDMl",
        "outputId": "3eb3e0fc-841d-442a-c4ee-e1e2bddf1bde"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10 < 3 = False\n",
            "10 <= 3 = False\n",
            "10 > 3 = True\n",
            "10 >= 3 = True\n",
            "10 == 3 = False\n",
            "10 != 3 = True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Bitwise operator\n",
        "print(~num1)#negative of the next number\n",
        "print(num1<<2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H07UjbEWHIcJ",
        "outputId": "9297c2a4-fff4-4324-d702-366ab17eda6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-11\n",
            "40\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment operator\n",
        "\n",
        "acctBalance=1000\n",
        "#deposit 500 rupees into the account\n",
        "acctBalance+=500 #new value of acctBalance is 1500 acctBalance+=500\n",
        "print(\"After depositing 500 Rs\",acctBalance)\n",
        "\n",
        "#withdraw 100 Rupees\n",
        "acctBalance-=100\n",
        "print(\"After withdrawing 100 Rs\",acctBalance)\n",
        "\n",
        "#getting interest of 10%\n",
        "\n",
        "acctBalance*=1.10\n",
        "print(\"After getting interest\",acctBalance)\n",
        "\n",
        "#\n",
        "acctBalance/=2\n",
        "print(\"After paying loan\",acctBalance)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WVxvC4l2HOdG",
        "outputId": "7833520e-ccbd-49cc-a5d6-9356d449ef00"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "After depositing 500 Rs 1500\n",
            "After withdrawing 100 Rs 1400\n",
            "After getting interest 1540.0000000000002\n",
            "After paying loan 770.0000000000001\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# membership operator- re\n",
        "\n",
        "friends=['Hari','Vishnu','John']\n",
        "print('Hari' in friends)#True\n",
        "print('Hari' not in friends)#False\n",
        "print('Dinesh' not in friends)\n",
        "print('an' in 'I love Python Programming an Python programming is easy')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KlSvubqTIIaw",
        "outputId": "56aceb33-376c-4eea-8468-1fca9eb1fef5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# identity operator\n",
        "val1=10\n",
        "val2='10'\n",
        "val3=9\n",
        "print(val1)\n",
        "print(id(val1))\n",
        "print(id(val2))\n",
        "print(val1 is val2)#returns True if both are avaialable in same memory\n",
        "print(val1 is not val2)#return False if both are not available in same memory\n",
        "print(val1 is val3)\n",
        "print(val1 is not val3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9s_HJ9SUJgeO",
        "outputId": "4a3fcc4c-777f-44c0-b626-283a15b92680"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "140075145576976\n",
            "140075138176624\n",
            "False\n",
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Logical operator and or not\n",
        "# and both condition must be true, then output is true\n",
        "# print(True and True)# true\n",
        "# print(True and False)\n",
        "# print(False and True)\n",
        "# print(False and False)\n",
        "\n",
        "print(7>3 and 6>3)# true\n",
        "print(7>4 and 6>7)# false\n",
        "# print(False and True)\n",
        "# print(False and False)\n",
        "\n",
        "print(7>3 or 6>3)# true\n",
        "print(7>4 or 6>7)# true\n",
        "print(False or True)\n",
        "print(8>9 or 7>9)\n",
        "\n",
        "#not means reverse of the actual answer\n",
        "print(not(7>3 and 6>3))#not(true)-> false\n",
        "print(not(7>4 and 6>7))#not(false)-> true\n",
        "\n",
        "isPresent\n",
        "isRegister\n",
        "hasCar\n",
        "hasPhone\n",
        "\n",
        "not isPresent\n",
        "not isRegister\n",
        "\n",
        "first-name-Person\n",
        "first_name_person"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v8bz9J8GVr6O",
        "outputId": "ceabc2ca-491e-4da5-ccdb-1a24193a63a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "True\n",
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1+True-> in python true is 1 or nonzero, false means ZeroD\n",
        "print(5>True)\n",
        "print(not 5)\n",
        "print(1<15<10) #1<15 and 15<10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MuYLw0UKaJGl",
        "outputId": "b90bc44e-4625-4af7-ac79-3af9713653cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# expression will have some output\n",
        "result=(10+20)*30/2-7;#PEMDAS\n",
        "print(result)\n",
        "\n",
        "# 10+600/2-7\n",
        "# 10+300-7\n",
        "# 310-7\n",
        "# 303"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xVXuHSd9aL1E",
        "outputId": "61a163b5-07d1-4ba6-d438-ebfe4e1d7b90"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "443.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Getting Input from user**"
      ],
      "metadata": {
        "id": "7OLY0_sTXVog"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "username=input(\"enter your name\")\n",
        "print(\"you have entered\",username)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XUhXHK5QXSn8",
        "outputId": "1cbca193-fab3-4a98-c0e6-d98eea9e04a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter your nameDinesh\n",
            "you have entered Dinesh\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "number=input(\"enter a number\") #20\n",
        "number=int(number) #convert the string number into integer number\n",
        "print(\"type of the number is\",type(number))#int\n",
        "number=number+3 # will add 3 + value of the number\n",
        "print(\"final\",number)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QCMQ5BBuXfxs",
        "outputId": "656a38d9-115c-47ad-c5b1-96ba078296e2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter a number34\n",
            "type of the number is <class 'int'>\n",
            "final 37\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find a simple interest\n",
        "# 1. principal( get from user)\n",
        "# 2. interest 10.4%\n",
        "# 3. Rate of Interest 24 months\n"
      ],
      "metadata": {
        "id": "ctSKITuoZHoU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Conditional Statements"
      ],
      "metadata": {
        "id": "r02ZK1pwhuN4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "age=19\n",
        "if(age>18):# executes only for True statements\n",
        "  print(\"You are eligible to vote\")\n",
        "else:#will execute for false statment only\n",
        "  print(\"You are not eligible to vote\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2WEQXRHchtp5",
        "outputId": "eecd8525-26da-4075-a045-af7140308c45"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "You are eligible to vote\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "number=int(input(\"Enter a number\"))\n",
        "if(number>0):\n",
        "  print(\"Number is positive\")\n",
        "elif(number<0):\n",
        "  print(\"Number is negative\")\n",
        "else:\n",
        "  print(\"Number is zero\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sm9-KJheibMG",
        "outputId": "4348368f-7c1f-4613-ac5a-4f0cd60469cc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number-9\n",
            "Number is negative\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Any non zero value is true\n",
        "\n",
        "if(-10):\n",
        "  print(\"True\")\n",
        "else:\n",
        "  print(\"False\")\n",
        "\n",
        "\n",
        "if(0):\n",
        "  print(\"True\")\n",
        "else:\n",
        "  print(\"False\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hQWYbNWJjSFY",
        "outputId": "cb3a861e-67d9-466e-c410-5485f80f0da2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#loops- will execute until it reaches the last element or condition fails\n",
        "\n",
        "#for loop is definite\n",
        "for i in [1,2,3,4,5]:#[] list () it tupble {} dictionary\n",
        "  print(i,i**3,sep='-',end='\\t') #1-1 2-4 3-9 4-16 5-25\n",
        "print(\"\\n\")\n",
        "for i in \"Good Morning\":\n",
        "  print(i,end=' ')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZXEPQFhWkF5a",
        "outputId": "0c704915-0423-4d2c-9653-d8a6906ad4bf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1-1\t2-8\t3-27\t4-64\t5-125\t\n",
            "\n",
            "G o o d   M o r n i n g "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lst=[11,22,33,44,55] #len(lst) is 5\n",
        "#    0, 1 ,2 ,3 ,4      #index\n",
        "# ------------------------\n",
        "#   -5,-4,-3,-2,-1      negative index\n",
        "print(lst[1])#22\n",
        "print(lst[2])#33\n",
        "print(lst[-1])\n",
        "\n",
        "#moving from left to right -> Ascending Order\n",
        "idx=0\n",
        "print('inside while loop')\n",
        "while(idx<len(lst)):  #0<5 1<5\n",
        "  print(lst[idx])     #lst[0]->11 lst[1]->2\n",
        "  idx+=1#idx will be taken to next value\n",
        "print('print in reverse')\n",
        "\n",
        "# moving from right to left  -> Descending order\n",
        "idx=len(lst)-1 # 5-1\n",
        "while(idx>=0):\n",
        "  print(lst[idx])\n",
        "  idx-=1   #idx will be taken to next value\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UvR0bqPLkkpy",
        "outputId": "07f2704a-9fd9-4fb7-d544-da88d0e7e697"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "22\n",
            "33\n",
            "inside while loop\n",
            "11\n",
            "22\n",
            "33\n",
            "44\n",
            "55\n",
            "print in reverse\n",
            "55\n",
            "44\n",
            "33\n",
            "22\n",
            "11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(list(range(5)))# 0-4\n",
        "print(list(range(1,5)))# 1-4\n",
        "print(list(range(10,30,2)))# 2 is the step value"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bq0nagFTpMyp",
        "outputId": "3ad00a88-e9f8-41d2-db77-165c69a49d07"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 3, 4]\n",
            "[1, 2, 3, 4]\n",
            "[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(10,30,2): #starts with 10 till 30 and takes even number, ends with last number(here it is 30)\n",
        "  print(i,end=' ')"
      ],
      "metadata": {
        "id": "9bDypZ8TpR1h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d2a7dea8-5289-4028-d48a-173aa572df30"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10 12 14 16 18 20 22 24 26 28 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "t4Y-ipYi-ANm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Difference between for loop and while loop\n",
        "\n",
        "**in for loop** you can say how many iterations it will take to complete the execution\n",
        "\n",
        "**in while loop** you can use when you don't know number of iteration\n",
        "\n"
      ],
      "metadata": {
        "id": "8K73HrDq-BKN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# get the input from user until he stops and give the sum of the numbers\n",
        "\n",
        "total=0\n",
        "while(True):\n",
        "  number=int(input('Enter your number'))\n",
        "  total+=number\n",
        "  choice=input('would you like to enter another or type no to exit')\n",
        "  if(choice in ('No','no')):\n",
        "    break\n",
        "\n",
        "print('total',total)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-fm9RR-A-Vn6",
        "outputId": "b7808626-be47-44ab-bb46-146b4d672af4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your number10\n",
            "would you like to enter another or type no to exityes\n",
            "Enter your number20\n",
            "would you like to enter another or type no to exitno\n",
            "total 30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(10,41):\n",
        "  if(i%2==0):\n",
        "    continue\n",
        "  print(i,end=' ')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GW19vAVK_rIb",
        "outputId": "15fd6d1b-4a34-4ca3-9714-7f678fd95b30"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "List in Python\n",
        "\n",
        "1. Mutable(data can be changed)\n",
        "2. List elements are iterated using its index number\n",
        "3. list elements are enclosed with square brackets\n",
        "4. we can slice the data using :\n",
        "5. list can have any data type ex;[True, 10, 10.56, 'A',\"Hello\",[77,876]]\n",
        "6. we can traverse the elements using for loop and while loop\n"
      ],
      "metadata": {
        "id": "HpUnA-d3Bchy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst=list() #emptylist\n",
        "\n",
        "print(lst)\n",
        "lst2=[]\n",
        "print(lst2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JMZJtD2P_uzt",
        "outputId": "ae2c4971-bde5-4dac-fcc1-75a8d8ddcd62"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n",
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mylist=list(range(11,25))\n",
        "# print(\"mylist at the beginning\",mylist) #[11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]\n",
        "\n",
        "# #accessing elements using index number\n",
        "\n",
        "# print(mylist[0])#accessing 1st element\n",
        "# print(mylist[4])#accessing 5th element\n",
        "# print(mylist[-1])#accessing last element\n",
        "# print(mylist[-2])#accessing second last element\n",
        "\n",
        "#slicing-> taking a portion of data from dataset\n",
        "\n",
        "# print(mylist[4:11]) #mylist[start:end]-> from start index to end index -1\n",
        "\n",
        "# print(mylist[4:11:2])#mylist[start:end:step]\n",
        "\n",
        "# Take away from the above slicing\n",
        "# 1. moving from left to right -> forward direction\n",
        "# 2. number before the : should be smaller than number after the :\n",
        "\n",
        "#[11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]\n",
        "# -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1\n",
        "#negative number for slicing, in negative -7 is lesser than -4\n",
        "# print(mylist[])\n",
        "\n",
        "# print(mylist[-7:-1])#[18, 19, 20, 21, 22, 23]\n",
        "# print(mylist[-8:-3])#[17, 18, 19, 20, 21]\n",
        "# print(mylist[-3:-8]) #not work -3 is greater than -8\n",
        "\n",
        "\n",
        "# to print data from start index number without passing end index number\n",
        "# print(mylist[7:])# start with 7 and end at the last element\n",
        "# print(mylist[:7])# start with 0 and end at the 7-1 (6)\n",
        "\n",
        "#print full list dont give any index number inside square bracket except colon\n",
        "\n",
        "print(\"full list\",mylist[:])\n",
        "\n",
        "\n",
        "#how list is mutable\n",
        "# change the starting number from 11 to 121\n",
        "\n",
        "mylist[0]=121 # [121, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]\n",
        "print(\"After changing the 11 to 121\", mylist)\n",
        "\n",
        "\n",
        "\n",
        "#for loop picks the number from mylist and print the output as a individual number\n",
        "for i in mylist:\n",
        "  print(i,i*i,sep='**',end='|')\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EZkUSvk4CHTL",
        "outputId": "594928f9-9d18-4ae7-b0ae-d1c058592bc6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "full list [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]\n",
            "After changing the 11 to 121 [121, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]\n",
            "121**14641|12**144|13**169|14**196|15**225|16**256|17**289|18**324|19**361|20**400|21**441|22**484|23**529|24**576|"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numbers=[56,78,34]\n",
        "list_sumofdigits=[]\n",
        "for i in numbers:\n",
        "  q=i//10 #quotient\n",
        "  r=i%10 #reminder\n",
        "  list_sumofdigits.append(q+r)\n",
        "print(list_sumofdigits)"
      ],
      "metadata": {
        "id": "225eEAFdCbGt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15ad4a02-df4c-4754-efd5-6341a6fad9c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[11, 15, 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "methods in a list"
      ],
      "metadata": {
        "id": "_-RJ6E70vu5C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst=[33,44,55,66,77]\n",
        "#adding one element to the list at the end- append\n",
        "lst.append(109)\n",
        "print(lst)\n",
        "\n",
        "#to add mulitiple elements-> extend\n",
        "lst2=[1,2,3]\n",
        "lst.extend(lst2)\n",
        "print(lst)\n",
        "\n",
        "#to delete an element\n",
        "#method 1\n",
        "lst.remove(44)\n",
        "print(lst)\n",
        "\n",
        "#remove using index- pop\n",
        "# method2\n",
        "\n",
        "lastelement=lst.pop()\n",
        "print(\"element remove\",lastelement)\n",
        "print(lst)\n",
        "\n",
        "element3=lst.pop(2)\n",
        "print(\" 3rd element remove\",element3)\n",
        "print('after deleteing 3rd element',lst)\n",
        "\n",
        "#method 3\n",
        "\n",
        "del lst[:3]\n",
        "print(\"after using del lst[:3]\",lst)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "56lJpwLnvDmI",
        "outputId": "98a6c1f1-1ef6-4f79-8886-385e76a97f99"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[33, 44, 55, 66, 77, 109]\n",
            "[33, 44, 55, 66, 77, 109, 1, 2, 3]\n",
            "[33, 55, 66, 77, 109, 1, 2, 3]\n",
            "element remove 3\n",
            "[33, 55, 66, 77, 109, 1, 2]\n",
            " 3rd element remove 66\n",
            "after deleteing 3rd element [33, 55, 77, 109, 1, 2]\n",
            "after using del lst[:3] [109, 1, 2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# print(\"sum\",sum(lst) )#[109, 1, 2]\n",
        "# print(\"max\",max(lst))\n",
        "# print(\"min\",min(lst))\n",
        "# print(\"len\",len(lst))\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RM7aZoA3wQO3",
        "outputId": "9ff06bce-e442-48b1-ebad-739914448bfe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "before sort [1, 2, 3, 3, 109]\n",
            "sorted [109, 3, 3, 2, 1]\n",
            "after sort [1, 2, 3, 3, 109]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lst2=[3,6,4,1]\n",
        "# lst2.sort()\n",
        "print(sorted(lst2))\n",
        "print(lst2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gQ41mhni1cND",
        "outputId": "f9689cf3-0155-4a39-f9ed-4496bd517e4b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 3, 4, 6]\n",
            "[3, 6, 4, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tuples\n",
        "\n",
        "1. It is immutable\n",
        "2. elements can be accessed using its index number like List and String\n",
        "3. Elements are enclosed with ()\n",
        "4. we have only two functions in tuples index,count\n"
      ],
      "metadata": {
        "id": "UJnSM-6lmtRH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating Tuples\n",
        "\n",
        "t1=()\n",
        "print(t1)\n",
        "t2=tuple()\n",
        "print(t2)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2FPGR5QAmZ3M",
        "outputId": "c3d5bd1b-e19e-45f5-eb3d-30712bd5eddb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "()\n",
            "()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# creating tuple with some content\n",
        "GenAI=('Deepseek','Chat GPT','Copilot')\n",
        "print(GenAI)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h1xZCykvmsWT",
        "outputId": "b630d118-7ca9-4a39-ab7a-24d98e2cfca9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Deepseek', 'Chat GPT', 'Copilot')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#length of the tuple\n",
        "print(len(GenAI))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VSEzl3fHnbcL",
        "outputId": "a773a4a1-bf0d-44f1-ae40-4afedebd4ed2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "('Deepseek','Chat GPT','Copilot')<br/>\n",
        "\n",
        "```\n",
        "# This is formatted as code\n",
        "'Deepseek','Chat GPT','Copilot')\n",
        "  0            1         2        -> Index\n",
        "```\n",
        "\n",
        "\n",
        "  "
      ],
      "metadata": {
        "id": "k1ALBEwunitX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#accessing the elements using it index\n",
        "\n",
        "print(GenAI[1])\n",
        "\n",
        "print(GenAI[len(GenAI)-1])# Last"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HtGh6pt5nl4y",
        "outputId": "7f9dd8e5-8722-41fa-bc47-432240842456"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Chat GPT\n",
            "Deepseek\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "```\n",
        "Negative Indexing- beginning from the end, -1 refers to last Item,list/tuple/string\n",
        "('Banana','Orange','Guava','Lemon')\n",
        "  -4          -3     -2       -1  \n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "7efeK68vpuEW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits=('Banana','Orange','Guava','Lemon')\n",
        "print(fruits[-1])\n",
        "print(fruits[-2])\n",
        "fruits[0][1]#Banana[1]->a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "cJMZ8zoEoAu9",
        "outputId": "3a1e5bb9-6cf9-48b6-8af7-4e18821d0299"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Lemon\n",
            "Guava\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'a'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Slicing of Tuple\n",
        "\n",
        "```\n",
        "\n",
        "[:]-> full tuple\n",
        "[1:]-> from 1st index to last index\n",
        "[:4]-> from 0th index to 4-1 index(3)\n",
        "\n",
        "('Banana','Orange','Guava','Lemon','Papaya') # 5\n",
        "   -5        -4     -3      -2       -1\n",
        "   0          1      2       3        4\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "nSD--2rEqvSL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits=('Banana','Orange','Guava','Lemon','Papaya')\n",
        "print(fruits[:])\n",
        "print(fruits[1:])\n",
        "print(fruits[:4])  #fruits[:4-1]\n",
        "\n",
        "#Negative Indexing\n",
        "print(\"fruits[-4:]\",fruits[-4:])\n",
        "print(\"fruits[-3:-1]\",fruits[-3:-1])# fruits[-3:-1-1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ez98TbL2quex",
        "outputId": "1a1d800d-6936-44ea-834c-f0e536ace600"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Banana', 'Orange', 'Guava', 'Lemon', 'Papaya')\n",
            "('Orange', 'Guava', 'Lemon', 'Papaya')\n",
            "('Banana', 'Orange', 'Guava', 'Lemon')\n",
            "fruits[-4:] ('Orange', 'Guava', 'Lemon', 'Papaya')\n",
            "fruits[-3:-1] ('Guava', 'Lemon')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(fruits)\n",
        "# fruits[0]=\"SweetLine\" #TypeError: 'tuple' object does not support item assignment\n",
        "\n",
        "#convert the tuple to list\n",
        "fruits=list(fruits)#convert the tuple to list\n",
        "print(fruits)\n",
        "fruits[0]=\"SweetLime\"\n",
        "print(fruits)\n",
        "fruits=tuple(fruits)\n",
        "print(fruits)#convert the list to tuple"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bi1QAjfjtHYj",
        "outputId": "9b545f8b-9274-44ae-e0a2-7752451b6ca0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['SweetLime', 'Orange', 'Guava', 'Lemon', 'Papaya']\n",
            "['SweetLime', 'Orange', 'Guava', 'Lemon', 'Papaya']\n",
            "['SweetLime', 'Orange', 'Guava', 'Lemon', 'Papaya']\n",
            "('SweetLime', 'Orange', 'Guava', 'Lemon', 'Papaya')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Checking the element is already available in tuple"
      ],
      "metadata": {
        "id": "swkLCQrxt4vs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "print('Orange' in fruits)\n",
        "if('Orange' in fruits):\n",
        "  print(\"Orange is available in fruits\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-44nteRftJfU",
        "outputId": "c1ddb82b-ebeb-4f54-baf5-d7e155091339"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "Orange is available in fruits\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "veggies=('Tomato','Potato','Onion')\n",
        "fruits_veggies=fruits+veggies\n",
        "print(fruits_veggies)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VsoJD8xwuIOo",
        "outputId": "eea6898e-f8a0-4e5d-dde3-9f72e87f2081"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('SweetLime', 'Orange', 'Guava', 'Lemon', 'Papaya', 'Tomato', 'Potato', 'Onion')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#delete Veggies deleting a tuple\n",
        "del veggies\n",
        "# print(veggies)# NameError: name 'veggies' is not defined"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 176
        },
        "id": "b_O6jSjBuXe3",
        "outputId": "9bff14b7-21a5-422b-9d49-5eb171e6e26b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'veggies' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-35-3f508858f8ae>\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#delete Veggies deleting a tuple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mveggies\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mveggies\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 'veggies' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#functions in tuples\n",
        "print(\"fruits_veggies.count('Orange')\",fruits_veggies.count('Orange'))\n",
        "print(\"fruits_veggies.index('Lemon')\",(fruits_veggies.index('Lemon')))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KD3Bi88QuoRB",
        "outputId": "45e77c46-797d-4ecc-c281-0b4a1da39696"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "fruits_veggies.count('Orange') 1\n",
            "fruits_veggies.index('Lemon') 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "OrGk9uh6vhOw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Enumerate-To print the index of the element in the list using python"
      ],
      "metadata": {
        "id": "uQSFQaXfwYt6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i,e in enumerate(fruits_veggies):\n",
        "  print(f'Index-{i},Element{i+1}-{e}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fywbshrWwcaq",
        "outputId": "b07e2f23-154e-4279-cf31-d2cbaa7649b3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Index-0,Element1-SweetLime\n",
            "Index-1,Element2-Orange\n",
            "Index-2,Element3-Guava\n",
            "Index-3,Element4-Lemon\n",
            "Index-4,Element5-Papaya\n",
            "Index-5,Element6-Tomato\n",
            "Index-6,Element7-Potato\n",
            "Index-7,Element8-Onion\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "positive_index_of_Guava=fruits.index('Lemon')\n",
        "print(positive_index_of_Guava)\n",
        "# negativeIndex is length of the tuple - positve index\n",
        "negativeIndex_of_Guava=positive_index_of_Guava-len(fruits)\n",
        "print(negativeIndex_of_Guava)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zbYoWT7owq4M",
        "outputId": "0230b280-6e30-424f-ad2b-c2124ac73daa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "-2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Getting negative index\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "('Banana','Orange','Guava','Lemon','Papaya') # 5\n",
        "   -5        -4     -3      -2       -1\n",
        "   0          1      2       3        4\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "fuhPtCnJxrgn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Unpacking Demo"
      ],
      "metadata": {
        "id": "9ljmiHFI4Noa"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "uIWivKjg0SBH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a,b,*c = [1,2,6,3]\n",
        "print(a,b,c)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J9YsefT2xq8c",
        "outputId": "fce0d2ed-3707-4b6f-d724-1287c2811f1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 2 [6, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Set**\n",
        "1. No duplicates are allowed\n",
        "2. Elements doesn't have index(unindex)\n",
        "3. Order of insertion is not guranteed(unordered)\n",
        "4. accessing set can be done using only for loop\n",
        "5. Elements are enclosed with {}\n"
      ],
      "metadata": {
        "id": "Dq7YR5OQ0SUB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "emptyset=set()\n",
        "print(emptyset)\n",
        "emptyset2={} #this is dictionary not a set\n",
        "print(emptyset2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SuRNmTgD2bzh",
        "outputId": "2e3f0078-b433-4294-8ae7-7f3fc9c891a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "set()\n",
            "{}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "books={'C Programming','Python Programming','Masterting DataScience','Mastering Data Engineering'}"
      ],
      "metadata": {
        "id": "KNP_7x_w4wkp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(books)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QQd98I7c43o3",
        "outputId": "82085844-8408-4d64-a8a9-241b0c9e7891"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Masterting DataScience', 'Python Programming', 'C Programming', 'Mastering Data Engineering'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Accessing Items in set\n",
        "we use loops"
      ],
      "metadata": {
        "id": "UuG80d2A5SI9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# books[0]#error  TypeError: 'set' object is not subscriptable"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "id": "AMmBfmv-5RmL",
        "outputId": "9a76f100-d7c4-44d1-c5f9-ed3377fd79fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "'set' object is not subscriptable",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-78-e13351c3e920>\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbooks\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'set' object is not subscriptable"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Adding Item(Books) to a set"
      ],
      "metadata": {
        "id": "sIrbZv7Z5irX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "books.add(\"Machine Learning\") # add() function will allow only one item to add\n",
        "print(books)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LiLgkBiB45Gk",
        "outputId": "873d52e5-64b8-43e5-a9ac-ba374122581a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Python Programming', 'Machine Learning', 'Masterting DataScience', 'C Programming', 'Mastering Data Engineering'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Check the Item(book) already available in the Books set"
      ],
      "metadata": {
        "id": "QhAA4dIR5vN_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Machine Learning' in books)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tz_CMwqH50AI",
        "outputId": "a6b17f33-b51c-4b13-ce63-3f8db8d02ada"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To add multiple items into a set"
      ],
      "metadata": {
        "id": "wVbQYact6CIu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#adding two items {'Deep Learning','NLP'}\n",
        "books.update({'Deep Learning','NLP'})\n",
        "print(books)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h7TlfQoO6Bud",
        "outputId": "0d20bb34-c562-4f31-8825-2b58d09fb970"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Deep Learning', 'Python Programming', 'Machine Learning', 'Masterting DataScience', 'NLP', 'C Programming', 'Mastering Data Engineering'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Removing Items from a set"
      ],
      "metadata": {
        "id": "-svrwgzN6VFo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "books.remove('C Programming')\n",
        "print(books)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FsclRnV56LKz",
        "outputId": "94b93bd5-5d84-468c-c587-3e8c417715e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Deep Learning', 'Python Programming', 'Machine Learning', 'Masterting DataScience', 'NLP', 'Mastering Data Engineering'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "removeedBook=books.pop()\n",
        "removeedBook"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "i4Lpel5E6qUP",
        "outputId": "86906eb3-631a-4d30-84fa-c063c37db44a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Deep Learning'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#remove all the elements and books set will be empty(not deleted)\n",
        "books.clear()\n",
        "print(books)\n",
        "books.add(\"C Programming\")\n",
        "print(books)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eGdv5gN06x3n",
        "outputId": "811e8e4d-cee4-40cd-9902-418ff29f8fc7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "set()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "del books\n",
        "# print(books.add(\"C Programming\"))# NameError: name 'books' is not defined"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 158
        },
        "id": "NMVraQx27Edr",
        "outputId": "7642b90e-ebfb-4f65-9f78-f4622ac4ef08"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'books' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-88-b327a7539d84>\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mbooks\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[0mbooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"C Programming\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m# NameError: name 'books' is not defined\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'books' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Converting List to Set and Set to List"
      ],
      "metadata": {
        "id": "ejCJ_hyo8jxw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "names=['Raju','Vishu','Jagan','Kalai','Raju','Vishu','Jagan']\n",
        "print(names.count('Raju'))\n",
        "names_set=set(names)\n",
        "print(names_set)\n",
        "names=list(names_set)\n",
        "print(names)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qa511M9a7hNz",
        "outputId": "da170478-bcea-48f3-c6c5-5344a59b428b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "{'Raju', 'Jagan', 'Vishu', 'Kalai'}\n",
            "['Raju', 'Jagan', 'Vishu', 'Kalai']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Joining sets**"
      ],
      "metadata": {
        "id": "kb_JKfCCAp7Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "girls_marks={56,78,98,65,91,50}\n",
        "boys_marks={79,78,61,71,60,56}\n",
        "class_marks=girls_marks.union(boys_marks)\n",
        "print(class_marks)# this will remove duplicate marks\n",
        "print(\"girls-\",girls_marks)\n",
        "print(\"boys-\",boys_marks)\n",
        "# we can add fruits and Veggies\n",
        "\n",
        "#add all the marks from boysmarks to girls marks-> {56,78,98,65,91,50,79,97,61,71,60}\n",
        "# girls_marks.update(boys_marks)\n",
        "# print(girls_marks)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PiQ5GggJApmd",
        "outputId": "3bc4a74f-32e2-47ce-99d0-a860fa6c2494"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{65, 98, 71, 78, 79, 50, 56, 91, 60, 61}\n",
            "girls- {65, 98, 50, 56, 91, 78}\n",
            "boys- {71, 56, 60, 61, 78, 79}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(girls_marks.intersection(boys_marks)) #only common values will be printed\n",
        "print(girls_marks.intersection_update(boys_marks)) #only common values will be printed\n",
        "\n",
        "s1={1,2,4,5}\n",
        "s2={1,4,5}\n",
        "s1.intersection_update(s2)#1\n",
        "print(s1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7RT9li_NCDki",
        "outputId": "3883df62-b108-4a74-9ab2-fc6e7b0e6c75"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{56}\n",
            "None\n",
            "{1, 4, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Subset and Superset\n",
        "# Kitchen is a subset of Home\n",
        "# Home is a supertset of Kitchen\n",
        "print(girls_marks.issubset(class_marks))\n",
        "print(class_marks.issuperset(girls_marks))\n",
        "print(s1.issuperset(s2))# if all the elements of s2 is present in s1, then it is superset"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0JUXbzT-DQia",
        "outputId": "3c04dd5f-b260-41b6-8444-e51568cfeb48"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#differnce between\n",
        "girls_marks={56,78,98,65,91,50}\n",
        "boys_marks={79,78,61,71,60,56}\n",
        "dummy={78,2,3}\n",
        "print(girls_marks.difference(boys_marks))\n",
        "print(boys_marks.difference(girls_marks))\n",
        "# print(girls_marks.difference_update(boys_marks))\n",
        "\n",
        "wholenumber={1,2,3,4,5,6,7,8,9,10}\n",
        "even={2,4,6,8,10}\n",
        "print(wholenumber.difference(even)) #1,3,5,7,9\n",
        "\n",
        "#Symmetric\n",
        "print(girls_marks.symmetric_difference(boys_marks))#uncommon values from both sets (except 56,78)\n",
        "#symmetric update\n",
        "girls_marks.symmetric_difference_update(boys_marks)\n",
        "print(\"after symmetric differene\",girls_marks)\n",
        "print(boys_marks.isdisjoint(dummy))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gg555dr6D_cO",
        "outputId": "095d79fc-9a66-44b3-8f25-a37f986758fb"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{65, 98, 91, 50}\n",
            "{60, 61, 79, 71}\n",
            "{1, 3, 5, 7, 9}\n",
            "{65, 71, 79, 91, 98, 50, 60, 61}\n",
            "after symmetric differene {65, 71, 79, 91, 98, 50, 60, 61}\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Dictionaries in Python**\n",
        "\n",
        "1. Elements in the dictionary is a Key,Value Pair\n",
        "2. Key cannot be duplicated\n",
        "3. Value can be duplicated\n",
        "4. Dictionary values are mutable(Changeable)\n",
        "5. Accessing the Dictionary elements using Key, not by index(no index in dictionary)\n",
        "6. Elements are enclosed with {}\n",
        "\n",
        "Ex:{\"key1\":\"val1\",\"key2\":\"val2\",\"key3\":\"val3\",\"key4\":\"val4\"}\n"
      ],
      "metadata": {
        "id": "foX_Xo62OALg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#creating a empty dictionary\n",
        "emptydict={}\n",
        "print(emptydict)\n",
        "emptydict2=dict()\n",
        "print(emptydict2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RNU1kROzN_2P",
        "outputId": "c46621b9-b3f3-4c8e-a107-cd5e6eb4a6bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{}\n",
            "{}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# prompt: create a dictionary name students with following keys firstname,lastname, age, class, year, skills is a list, country address is dictionary\n",
        "\n",
        "students = {\n",
        "    'firstname': 'John',\n",
        "    'lastname': 'Doe',\n",
        "    'age': 20,\n",
        "    'class': '10th',\n",
        "    'year': 2024,\n",
        "    'skills': ['Python', 'Java', 'C++'],\n",
        "    'country': 'USA',\n",
        "    'address': {\n",
        "        'street': '123 Main St',\n",
        "        'city': 'Anytown',\n",
        "        'zip': '12345'\n",
        "    }\n",
        "}\n",
        "\n",
        "print(students)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gS6RtHPOR_VS",
        "outputId": "32dbb722-1f6c-4a7d-e9ff-e37d0a720f12"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'firstname': 'John', 'lastname': 'Doe', 'age': 20, 'class': '10th', 'year': 2024, 'skills': ['Python', 'Java', 'C++'], 'country': 'USA', 'address': {'street': '123 Main St', 'city': 'Anytown', 'zip': '12345'}}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#to print firstname\n",
        "print(\"firstname\",students['firstname'])\n",
        "print(\"age\",students['age'])\n",
        "print(\"1st skill\",students['skills'][0])\n",
        "print(\"city\",students['address']['city'])\n",
        "print(\"lastname\",students['lastname'])\n",
        "print(\"number of skills\",len(students['skills']))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N1xfrUFEShPq",
        "outputId": "4e87d6c7-ffa4-4d76-9c18-6d66dadb7809"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "firstname John\n",
            "age 20\n",
            "1st skill Python\n",
            "city Anytown\n",
            "lastname Doe\n",
            "number of skills 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#print keys\n",
        "print(students.keys())\n",
        "print(students.values())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "paCc9mZyUwUP",
        "outputId": "1ed0cc16-fb09-4f32-d950-5200fbf4a1ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_keys(['firstname', 'lastname', 'age', 'class', 'year', 'skills', 'country', 'address'])\n",
            "dict_values(['John', 'Doe', 20, '10th', 2024, ['Python', 'Java', 'C++'], 'USA', {'street': '123 Main St', 'city': 'Anytown', 'zip': '12345'}])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#accessing values using get method,  to avoid errors in the key\n",
        "\n",
        "print(students['age1'])#if key is not present, it will raise an error and program will not execute the lines after that\n",
        "print(students.get('age1'))# if the key is not available it will show None and execute the lines after that"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ctQ6HzkzVPkx",
        "outputId": "6aa61f65-7272-45ce-f44a-bc49f2e4d285"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#MOdifying the dictionary values\n",
        "print(\" before modifying firstname\",students['firstname'])\n",
        "students['firstname']='Peter' # modified the John to Peter\n",
        "print(\" after Modifying firstname\",students['firstname'])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fkrHZPfsV7me",
        "outputId": "7a6f8648-9763-4a8f-b2eb-07b4b974640b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " before modifying firstname John\n",
            " after Modifying firstname Peter\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#checking the key is already exist in the Students Dictionary\n",
        "print('firstname' in students)\n",
        "print('isMarried' in students)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A93qZ8vJWh5Y",
        "outputId": "83d12ff8-6c3f-4cf7-9688-15ffe824eb90"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Removing Keys and value Paris from a Dictionary\n",
        "1. pop(key)- removes the item with the specified Key Value\n",
        "2. popItem()- removes the last time\n",
        "3. del: removes an item with specified key name\n",
        "\n"
      ],
      "metadata": {
        "id": "oy9Bsf5r9aR7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Removing Keys and value Paris from a Dictionary\n",
        "print(students)\n",
        "# removedItem=students.pop('lastname')\n",
        "# print(removedItem)\n",
        "print(\"after removing lastname\",students)\n"
      ],
      "metadata": {
        "id": "oTeKmg1GWsF8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4651b69-d708-4ffa-fc10-0b3712c4e752"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'firstname': 'John', 'age': 20, 'class': '10th', 'year': 2024, 'skills': ['Python', 'Java', 'C++'], 'country': 'USA', 'address': {'street': '123 Main St', 'city': 'Anytown', 'zip': '12345'}}\n",
            "after removing lastname {'firstname': 'John', 'age': 20, 'class': '10th', 'year': 2024, 'skills': ['Python', 'Java', 'C++'], 'country': 'USA', 'address': {'street': '123 Main St', 'city': 'Anytown', 'zip': '12345'}}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#using popItem\n",
        "removedItem=students.popitem()\n",
        "print(removedItem)\n",
        "print(students)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Us0rPNQd9tiL",
        "outputId": "4bb60bc5-2217-44c0-8ee2-e4a76e680ccd"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('address', {'street': '123 Main St', 'city': 'Anytown', 'zip': '12345'})\n",
            "after removing lastname {'firstname': 'John', 'age': 20, 'class': '10th', 'year': 2024, 'skills': ['Python', 'Java', 'C++'], 'country': 'USA'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# del\n",
        "# del students['skills']\n",
        "print(students)\n",
        "\n",
        "#dictionary is a collection of key and value pair tuple\n",
        "print(students.items()) #[(firstname','John'),('age',20)]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fUXgAVib-fo9",
        "outputId": "3c069df6-2eee-4123-da68-ea71118ca0ea"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'firstname': 'John', 'age': 20, 'class': '10th', 'year': 2024, 'country': 'USA'}\n",
            "dict_items([('firstname', 'John'), ('age', 20), ('class', '10th'), ('year', 2024), ('country', 'USA')])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Deleting the dictionary\n",
        "students.clear()\n",
        "print(students)\n",
        "\n",
        "# All data will be removed, but students variable still exist in Memory, we can reuse it\n",
        "# remember the bag example\n",
        "students['fullname']=\"John Doe\"\n",
        "print(students)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DuTcyoDs_AvX",
        "outputId": "4d41f8a0-d2d7-421e-dc11-323652d60705"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{}\n",
            "{'fullname': 'John Doe'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "del students\n",
        "# print(students)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 158
        },
        "id": "9HQ2bjIO_mu3",
        "outputId": "41bcba19-7c6a-436b-d6f1-ff2ea470cd42"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'students' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-dbb51843fee9>\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mstudents\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[0mstudents\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 'students' is not defined"
          ]
        }
      ]
    }
  ]
}