002B_Python_DataStructures.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyN08MP+1DH8xu6k/KtW5nmW",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MohanVishe/Notes/blob/main/002B_Python_DataStructures.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Data Structure**\n",
        "- A data structure is a collection of data elements (such as numbers or characters—or even other data structures) that is structured in some way.\n",
        "- The most basic data structure in Python is the \"sequence.\"\n",
        "\n",
        "## 1.**Lists in Python**\n",
        "- Lists are one of the Sequence Data structures.\n",
        "- Lists are collections of items (Strings, integers, or even other lists).\n",
        "- Lists are enclosed in square brackets `[ ]`.\n",
        "- Each item in the list has an assigned index value.\n",
        "- Each item in a list is separated by a comma.\n",
        "- Lists are mutable, which means they can be changed.\n",
        "\n"
      ],
      "metadata": {
        "id": "4sbvgkq4EiKs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Creation:**"
      ],
      "metadata": {
        "id": "wTPl5onMyVYD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst=list()\n",
        "emptyList = []\n",
        "lst = ['one', 'two', 'three', 'four']  # list of strings\n",
        "lst2 = [1, 2, 3, 4]  # list of integers\n",
        "lst3 = [[1, 2], [3, 4]]  # list of lists\n",
        "lst4 = [1, 'ramu', 24, 1.24]  # list of different datatypes"
      ],
      "metadata": {
        "id": "ZwpIQmEgElPE"
      },
      "execution_count": 145,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ll3I-1EoT1PT",
        "outputId": "1dc8b71f-6c78-423f-88e6-b2ed8824f559"
      },
      "execution_count": 146,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 146
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Length:**"
      ],
      "metadata": {
        "id": "GLIdjtMPEpRf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = ['one', 'two', 'three', 'four']\n",
        "# find the length of a list\n",
        "print(len(lst))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NM8L78tnEr5u",
        "outputId": "635c26f4-d967-4a9f-9dec-fdcd8626cbb4"
      },
      "execution_count": 147,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Append:**"
      ],
      "metadata": {
        "id": "SlulRzkTEuEl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = ['one', 'two', 'three', 'four']\n",
        "lst.append('five')  # append will add the item at the end\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-PvSnRx8EvyX",
        "outputId": "e3631517-14fc-4cbb-fe92-0a6c674dd72c"
      },
      "execution_count": 148,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['one', 'two', 'three', 'four', 'five']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Insert:**"
      ],
      "metadata": {
        "id": "y1IavcgAExks"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = ['one', 'two', 'four']\n",
        "lst.insert(2, \"three\")  # will add element 'three' at location 2\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f6gOI_TbE0MQ",
        "outputId": "59f94854-457d-4452-811f-5b638d6ff148"
      },
      "execution_count": 149,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['one', 'two', 'three', 'four']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Remove:**"
      ],
      "metadata": {
        "id": "pSHBMGHCE9-s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "lst = ['one', 'two', 'three', 'four', 'two']\n",
        "lst.remove('two')  # it will remove the first occurrence of 'two' in the list\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "phx9_q-LE9bv",
        "outputId": "751a454f-c122-4e88-94b8-4fc6c8c3ab9f"
      },
      "execution_count": 150,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['one', 'three', 'four', 'two']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Append & Extend:**"
      ],
      "metadata": {
        "id": "tcVTG7q4FDHv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = ['one', 'two', 'three', 'four']\n",
        "lst2 = ['five', 'six']\n",
        "# append\n",
        "lst.append(lst2)\n",
        "print(lst)\n",
        "\n",
        "# extend will join the list with list1\n",
        "lst.extend(lst2)\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u_Fg4VNAFGlQ",
        "outputId": "cd21a1e9-66f2-40f3-f129-fc090d83818a"
      },
      "execution_count": 151,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['one', 'two', 'three', 'four', ['five', 'six']]\n",
            "['one', 'two', 'three', 'four', ['five', 'six'], 'five', 'six']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Extend Using \"+\"**"
      ],
      "metadata": {
        "id": "eAeWtQLOF4wM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst=[232,231,12]\n",
        "lst2=[34343,212,311]\n",
        "print(lst+lst2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ytptI3O4F5Y2",
        "outputId": "7b15a6d4-b86b-4734-b9fb-0a964753e2aa"
      },
      "execution_count": 152,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[232, 231, 12, 34343, 212, 311]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "**List Delete:**"
      ],
      "metadata": {
        "id": "seCp9k-4FJk2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = ['one', 'two', 'three', 'four', 'five']\n",
        "del lst[1]  # using 'del' to remove item based on index position\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zGR2BE1iFL5k",
        "outputId": "3ef09acf-a948-419f-e98c-aefa0720dbdc"
      },
      "execution_count": 153,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['one', 'three', 'four', 'five']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# or we can use pop() method\n",
        "a = lst.pop(1)\n",
        "print(a)\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xlGBxrANGiOp",
        "outputId": "d8b38656-3761-49f3-9903-b46e6252547c"
      },
      "execution_count": 154,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "three\n",
            "['one', 'four', 'five']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lst = ['one', 'two', 'three', 'four']\n",
        "# remove an item from the list\n",
        "lst.remove('three')\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kesiHpFdGljp",
        "outputId": "b970a62a-ec53-4ab5-a883-346b5432c7cd"
      },
      "execution_count": 155,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['one', 'two', 'four']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "**List-related Keywords in Python:**"
      ],
      "metadata": {
        "id": "3whGwGM2FOjP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# keyword 'in' is used to test if an item is in a list\n",
        "lst = ['one', 'two', 'three', 'four']\n",
        "if 'two' in lst:\n",
        "    print('AI')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nx5oE9chFREy",
        "outputId": "ce100f6b-8604-4bec-d219-32930e7a880d"
      },
      "execution_count": 156,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AI\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# keyword 'not' can be combined with 'in'\n",
        "if 'six' not in lst:\n",
        "    print('ML')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SegwEjktGxB4",
        "outputId": "1f2aef1e-2af3-49a5-f340-c18777779a7a"
      },
      "execution_count": 157,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ML\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Reverse:**"
      ],
      "metadata": {
        "id": "cKAdZwM0FUM2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# reverse reverses the entire list\n",
        "lst = ['one', 'two', 'three', 'four']\n",
        "lst.reverse()\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aAoT5o5lFWMR",
        "outputId": "c5e597f7-304c-4a9d-cdfa-4643ab037a55"
      },
      "execution_count": 158,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['four', 'three', 'two', 'one']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Sorting:**"
      ],
      "metadata": {
        "id": "P7whjxLUFZe6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# The easiest way to sort a List is with the sorted(list) function.\n",
        "# The original list is not changed.\n",
        "numbers = [3, 1, 6, 2, 8]\n",
        "sorted_lst = sorted(numbers)\n",
        "print(\"Sorted list:\", sorted_lst)\n",
        "print(\"Original list:\", numbers)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XxeqURUrHD79",
        "outputId": "2365e215-901a-4859-92b1-dca61eaba95d"
      },
      "execution_count": 159,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sorted list: [1, 2, 3, 6, 8]\n",
            "Original list: [3, 1, 6, 2, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print a list in reverse sorted order\n",
        "print(\"Reverse sorted list:\", sorted(numbers, reverse=True))  # Output: [8, 6, 3, 2, 1]\n",
        "print(\"Original list:\", numbers)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cb5bJ9o_HJk_",
        "outputId": "379d33aa-e900-45cc-8517-893afe730840"
      },
      "execution_count": 160,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reverse sorted list: [8, 6, 3, 2, 1]\n",
            "Original list: [3, 1, 6, 2, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b=[(100,2),(200,7),(23,3),(354,4),(44,44)]\n",
        "sorted(b,key=lambda x:x[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xm49tZ1zHPb7",
        "outputId": "aadeb5cb-2920-4b15-ad57-8aa6e7170b78"
      },
      "execution_count": 161,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(100, 2), (23, 3), (354, 4), (200, 7), (44, 44)]"
            ]
          },
          "metadata": {},
          "execution_count": 161
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [1, 20, 5, 5, 4.2]\n",
        "lst.sort()  # Sort the list and store it in itself\n",
        "print(\"Sorted list:\", lst)  # Output: [1, 4.2, 5, 5, 20]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uqojo7pmFdju",
        "outputId": "aa28fda8-c869-40db-c028-ad554c7b9f71"
      },
      "execution_count": 162,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sorted list: [1, 4.2, 5, 5, 20]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Having Multiple References:**"
      ],
      "metadata": {
        "id": "cqN7UoPnFfjp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [1, 2, 3, 4, 5]\n",
        "abc = lst\n",
        "abc.append(6)\n",
        "# original list will also change\n",
        "print(\"Original list:\", lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SDyPOSpOFhRO",
        "outputId": "acb59d2e-a22b-4a4c-ab5e-3e663342c3e0"
      },
      "execution_count": 163,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original list: [1, 2, 3, 4, 5, 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**String Split to Create a List:**"
      ],
      "metadata": {
        "id": "d3hOPNTIFjX5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's take a string\n",
        "s = \"one,two,three,four,five\"\n",
        "slst = s.split(',')\n",
        "print(slst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0_ha5EYnFlw7",
        "outputId": "1c5cc426-9264-4d36-b89e-490bc4ff1821"
      },
      "execution_count": 164,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['one', 'two', 'three', 'four', 'five']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = \"My name is Mohan\"\n",
        "split_lst = s.split()  # Default split is whitespace: space or tab\n",
        "print(split_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8bHIJ2ytIKMb",
        "outputId": "a99a2242-cb4d-4cf2-a409-41ecf8c86c6a"
      },
      "execution_count": 165,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['My', 'name', 'is', 'Mohan']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Indexing:**\n",
        "- Each item in the list has an assigned index value starting from 0.\n",
        "- If you start from last it will start with -1 and so on."
      ],
      "metadata": {
        "id": "I-XQV2xvFow_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [1, 2, 3, 4]\n",
        "print(lst[0])  # Print first element"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bQUsLctFFsfi",
        "outputId": "033df851-ff60-47e9-ec99-fdff10a1690a"
      },
      "execution_count": 166,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#last element\n",
        "print(lst[3])\n",
        "print(lst[len(lst)-1])\n",
        "#last element using negative index\n",
        "print(lst[-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RZtpQD9_RjLV",
        "outputId": "0b6bdaef-38d7-4ec5-89ba-2ebbb3892268"
      },
      "execution_count": 167,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "4\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(lst[1])\n",
        "# Print  element using negative index\n",
        "print(lst[-3])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EURPEPKCIR4O",
        "outputId": "92d9a057-d8b1-4bf9-907b-70344017bc8f"
      },
      "execution_count": 168,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Slicing:**\n",
        "- Accessing parts of segments is called slicing.\n",
        "- The `end` value represents the first value that is not in the selected slice."
      ],
      "metadata": {
        "id": "xcWHCp_WFvSs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = [10, 20, 30, 40, 50, 60, 70, 80]\n",
        "# Print all numbers\n",
        "print(numbers[:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DbuChiPcFyng",
        "outputId": "0c5af09c-1db6-42f3-a4f3-8c8a3fc29b66"
      },
      "execution_count": 169,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 20, 30, 40, 50, 60, 70, 80]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print from index 0 to index 3\n",
        "print(numbers[0:4])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qhwoTMbCEecH",
        "outputId": "5ce148a2-c576-4cd2-bb89-eb46d6cfe34b"
      },
      "execution_count": 170,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 20, 30, 40]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print alternate elements in a list\n",
        "print(numbers[::2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2EHmu3wrIuSa",
        "outputId": "c9cfad54-e259-4d98-e3c3-d165ae382442"
      },
      "execution_count": 171,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 30, 50, 70]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print elements starting from 0 through the rest of the list\n",
        "print(numbers[2::2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7uQDoUKfIypY",
        "outputId": "e77214a5-a0c2-4433-b21e-a78c9912a575"
      },
      "execution_count": 172,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[30, 50, 70]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Count**"
      ],
      "metadata": {
        "id": "lDBsMQA2I_HU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = [1, 2, 3, 1, 3, 4, 2, 5]\n",
        "# Frequency of any element\n",
        "print(numbers.count(1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cDD-RRj-O1Y1",
        "outputId": "26b04a71-c7e9-442d-ad1e-169f0bd2e154"
      },
      "execution_count": 173,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List Looping**"
      ],
      "metadata": {
        "id": "wK4Rwie2PGHY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = ['one', 'two', 'three', 'four']\n",
        "for ele in lst:\n",
        "  print(ele)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0n5WahtvPFBF",
        "outputId": "c372d106-4ae2-45c3-9a49-92f5749a9da7"
      },
      "execution_count": 174,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "one\n",
            "two\n",
            "three\n",
            "four\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##2.**Tuples**\n",
        "\n",
        "- A tuple is similar to a list but with a key difference: it is immutable, meaning you can't change its elements once assigned.\n",
        "- Except for the functions/methods which mutate the list almost all other are applicable for tuples"
      ],
      "metadata": {
        "id": "htg9LYdrSv1M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Tuple Creation**"
      ],
      "metadata": {
        "id": "1HOj8wRNSywU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Empty tuple\n",
        "t = ()\n",
        "# Tuple with integers\n",
        "t = (1, 2, 3)\n",
        "# Tuple with mixed datatypes\n",
        "t = (1, 'raju', 28, 'abc')\n",
        "# Nested tuple\n",
        "t = (1, (2, 3, 4), [1, 'raju', 28, 'abc'])"
      ],
      "metadata": {
        "id": "o93yDlwVS1Hd"
      },
      "execution_count": 175,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(t)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fw7fT47bTuew",
        "outputId": "899ca87a-fc5d-4f2b-9131-73311bcd060e"
      },
      "execution_count": 176,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 176
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Accessing Elements in a Tuple**"
      ],
      "metadata": {
        "id": "ELKw2epxS2xb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = (1, (2, 3, 4), [1, 'raju', 28, 'abc'])\n",
        "# Accessing by index\n",
        "print(t[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B3bI_kucS9v4",
        "outputId": "6a5dfcb0-e263-4f25-ae36-1275d07886a3"
      },
      "execution_count": 177,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2, 3, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Negative index\n",
        "print(t[-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N0sgDx6-S9iX",
        "outputId": "87845932-52f3-480d-ee0d-14fe872f5c98"
      },
      "execution_count": 178,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 'raju', 28, 'abc']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Nested tuple\n",
        "print(t[1])\n",
        "print(t[1][2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vXZIwg89TDSJ",
        "outputId": "56247123-2b00-4cb5-ce77-544182bfeec7"
      },
      "execution_count": 179,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2, 3, 4)\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Slicing\n",
        "print(t[1:4])\n",
        "print(t[:-2])\n",
        "print(t[:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WwPXWXZQS5xg",
        "outputId": "32a94276-9d21-4d74-9bba-9796cf47f9ed"
      },
      "execution_count": 180,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "((2, 3, 4), [1, 'raju', 28, 'abc'])\n",
            "(1,)\n",
            "(1, (2, 3, 4), [1, 'raju', 28, 'abc'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Changing a Tuple**"
      ],
      "metadata": {
        "id": "c7kvzjJwTRbc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tuples are immutable\n",
        "# Nested items in a tuple (e.g., a list) can be changed\n",
        "t = (1, 2, 3, 4, [5, 6, 7])\n",
        "t[4][1] = 'satish'\n",
        "print(t)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QbrsnCTeUC_S",
        "outputId": "5f43b5dd-630b-4ab9-ba65-537bfc8e4875"
      },
      "execution_count": 181,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3, 4, [5, 'satish', 7])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Concatenating tuples\n",
        "t = (1, 2, 3) + (4, 5, 6)\n",
        "print(t)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PW-18mdsUC02",
        "outputId": "cd362016-29f9-4017-dfeb-3d3992e371bb"
      },
      "execution_count": 182,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3, 4, 5, 6)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Repeating elements in a tuple\n",
        "t = (('satish',) * 4)\n",
        "print(t)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QrV1uhGuTSdS",
        "outputId": "759e111b-3388-4e49-c32a-688a25bf7a9c"
      },
      "execution_count": 183,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('satish', 'satish', 'satish', 'satish')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Tuple Deletion**"
      ],
      "metadata": {
        "id": "oao-o8fTTZBF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tuples are immutable and cannot be changed or deleted partially\n",
        "# You can delete the entire tuple\n",
        "t = (1, 2, 3, 4, 5, 6)\n",
        "del t"
      ],
      "metadata": {
        "id": "Wzv487fgTbNn"
      },
      "execution_count": 184,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Tuple Count and Index**"
      ],
      "metadata": {
        "id": "mkf-9uA9TefE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = (1, 2, 3, 1, 3, 3, 4, 1)\n",
        "print(t.count(1))\n",
        "print(t.index(3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HrdR2FIlTeMF",
        "outputId": "831af158-49cf-4b32-a290-5f36fbde6525"
      },
      "execution_count": 185,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Tuple Membership**"
      ],
      "metadata": {
        "id": "cL2kXpuwVT76"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = (1, 2, 3, 4, 5, 6)\n",
        "print(1 in t)\n",
        "print(7 in t)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ctu1xd-iVP9p",
        "outputId": "84583740-2457-44ef-9a57-01830e3d45a9"
      },
      "execution_count": 186,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Built-in Functions for Tuples**"
      ],
      "metadata": {
        "id": "dmL88AlGVY0_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = (4, 5, 1, 2, 3)"
      ],
      "metadata": {
        "id": "dP3ljq_vVsPf"
      },
      "execution_count": 187,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Sort elements (returns a new sorted list, not modifying the tuple)\n",
        "sorted(t)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nzpz34SnVyys",
        "outputId": "1f7393d2-62cb-454a-b8f1-bf0a18f5edc2"
      },
      "execution_count": 188,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 188
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the largest and smallest elements in a tuple\n",
        "print(max(t))\n",
        "print(min(t))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JFZ3lQabV1B7",
        "outputId": "b1b97d2c-fd67-4d49-e7c5-3e779f13a99d"
      },
      "execution_count": 189,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get sum of elements\n",
        "print(sum(t))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4W0CERXcVdtc",
        "outputId": "8c1240ba-c661-4644-ea1e-06cbd90c2951"
      },
      "execution_count": 190,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##3.**Sets**\n",
        "\n",
        "- A set is an unordered collection of unique items.\n",
        "- Sets are mutable; you can add or remove items from them.\n",
        "- Sets can be used to perform mathematical set operations like union, intersection, symmetric difference, etc."
      ],
      "metadata": {
        "id": "PomZnyiBWgEv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Set Creation**\n"
      ],
      "metadata": {
        "id": "CmcFzY_xWib4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a set of integers\n",
        "s = {1, 2, 3}\n",
        "\n",
        "# Creating a set from a list\n",
        "s = set([1, 2, 3, 1])\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qn9v5Ew6Wksy",
        "outputId": "95730ae5-d7ba-41b4-c032-666f8cba772f"
      },
      "execution_count": 191,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Initializing an empty set\n",
        "s = set()\n",
        "print(type(s))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d4n4Wwp8Y15H",
        "outputId": "2270de21-bd51-4656-d4b2-f6c6f614d61c"
      },
      "execution_count": 192,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'set'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Elements of set should be immutable**"
      ],
      "metadata": {
        "id": "bPC0pSVWp609"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s={[10,232,232],53,34,23}\n",
        "# we can use tuple,string as element but not set,list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 200
        },
        "id": "UuRftu8kpj4o",
        "outputId": "1a51053b-113a-4bad-8214-4147df11c13a"
      },
      "execution_count": 193,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-193-46d43c2f635f>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m232\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m232\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m53\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m34\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m23\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;31m# we can use tuple,string as element but not set,list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Adding Elements to a Set**"
      ],
      "metadata": {
        "id": "Hy4At2kTWo7U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = {1, 3}\n",
        "\n",
        "# Adding a single element using add()\n",
        "s.add(2)\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Al91saT5WrSu",
        "outputId": "e3be1096-7be2-4962-ec36-01aeffcd70a9"
      },
      "execution_count": 194,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Adding multiple elements using update()\n",
        "s.update([5, 6, 1])\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wQRnwvjgY78e",
        "outputId": "5bfd0c7e-e234-469c-d152-0ac1505a2d57"
      },
      "execution_count": 195,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 5, 6}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Adding elements from a list and another set\n",
        "s.update([8, 9], {10, 2, 3})\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CNrcBjoMY8NM",
        "outputId": "73197ef9-7db7-4567-9ea4-22d3e8da6832"
      },
      "execution_count": 196,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 5, 6, 8, 9, 10}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Removing Elements from a Set**"
      ],
      "metadata": {
        "id": "cbMmZsQ8WtPX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = {1, 2, 3, 5, 4}\n",
        "# Removing an element using discard()\n",
        "s.discard(4)\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wax30fjmZGHS",
        "outputId": "10af649d-2032-4269-b77c-c0592abc4f3c"
      },
      "execution_count": 197,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Removing an element using remove()\n",
        "s.remove(2)\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vqnb9aOcZF-2",
        "outputId": "26f2975c-f38c-490e-a1f0-b64b46ef1825"
      },
      "execution_count": 198,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 3, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Removing an element not present in the set using discard()\n",
        "s.discard(7) #(using remove() give keyError)\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dvFmBpizW58_",
        "outputId": "a35052f1-5aa2-4869-999b-843e4833ede2"
      },
      "execution_count": 199,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 3, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Removing a random element using pop()\n",
        "s.pop()  # Removes a random element\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HC4dBv9bZUYq",
        "outputId": "902b3e62-33f7-4dc0-dd64-bea22648c7ad"
      },
      "execution_count": 200,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{3, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Python Set Operations**"
      ],
      "metadata": {
        "id": "yuPQ95prW8HC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "set1 = {1, 2, 3, 4, 5}\n",
        "set2 = {3, 4, 5, 6, 7}\n",
        "\n",
        "# Union of two sets using | operator\n",
        "print(set1 | set2)\n",
        "print(set1.union(set2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uTxWzuiwXJD9",
        "outputId": "0d3a56c5-6423-4efd-87af-f27abcfdf3c7"
      },
      "execution_count": 201,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4, 5, 6, 7}\n",
            "{1, 2, 3, 4, 5, 6, 7}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Intersection of two sets using & operator\n",
        "print(set1 & set2)\n",
        "print(set1.intersection(set2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EsnafaOfnULh",
        "outputId": "b9dfa4a8-4155-4eee-ad05-b95846c66bd7"
      },
      "execution_count": 202,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{3, 4, 5}\n",
            "{3, 4, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Set Difference: Elements in set1 but not in set2\n",
        "print(set1 - set2)\n",
        "\n",
        "# Symmetric Difference: Elements in both sets but not common\n",
        "print(set1 ^ set2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GLiAY00dnLJg",
        "outputId": "d616ce36-3022-4786-9d5f-b01053de0a72"
      },
      "execution_count": 203,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2}\n",
            "{1, 2, 6, 7}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "**Frozen Sets**\n",
        "\n",
        "- Frozen sets are similar to sets but are immutable."
      ],
      "metadata": {
        "id": "q2GZPPXaXU1z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "set1 = frozenset([1, 2, 3, 4])\n",
        "set2 = frozenset([3, 4, 5, 6])\n",
        "\n",
        "# Adding elements to a frozen set (raises an error)\n",
        "# Frozen sets don't support indexing\n",
        "# Operations on frozen sets (Union,Intersection,Symmetric difference )"
      ],
      "metadata": {
        "id": "HVjWUJ3uXXDP"
      },
      "execution_count": 204,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "**Note:** Frozen sets are hashable and can be used as dictionary keys, unlike sets.:\n",
        "\n",
        " - means they can be used as dictionary keys, while regular sets are not hashable and cannot be used as dictionary keys."
      ],
      "metadata": {
        "id": "-Qf8hImtWYh-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a frozen set\n",
        "frozen_set = frozenset([1, 2, 3])\n",
        "\n",
        "# Creating a dictionary with a frozen set as a key\n",
        "my_dict = {frozen_set: \"Hello, world!\"}\n",
        "\n",
        "# Accessing the dictionary using the frozen set as a key\n",
        "print(my_dict[frozen_set])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wdg3PC7onsaC",
        "outputId": "606bc385-11a3-4e8d-8414-31a339df2487"
      },
      "execution_count": 205,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, world!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Attempting to use a regular set as a key will result in a TypeError\n",
        "my_set = {1, 2, 3}\n",
        "\n",
        "my_dict = {my_set: \"This will raise a TypeError\"}"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 218
        },
        "id": "--hDrKm_oS0Z",
        "outputId": "0eafb109-7796-47dd-9783-da44841f5ac5"
      },
      "execution_count": 206,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-206-6ddb66700052>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mmy_set\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmy_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0mmy_set\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"This will raise a TypeError\"\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: unhashable type: 'set'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##4.**Dictionaries in Python**\n",
        "\n",
        "- A dictionary is an unordered collection of key-value pairs.\n",
        "- Each key in a dictionary is unique.\n",
        "- Dictionaries are mutable; you can add, modify, or remove key-value pairs.\n",
        "\n",
        "**Dictionary Creation**"
      ],
      "metadata": {
        "id": "rjCQTjI8qy9D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating an empty dictionary\n",
        "my_dict = {}\n",
        "\n",
        "# Dictionary with integer keys\n",
        "my_dict = {1: 'abc', 2: 'xyz'}\n",
        "\n",
        "# Dictionary with mixed keys\n",
        "my_dict = {'name': 'satish', 1: ['abc', 'xyz']}\n",
        "\n",
        "# Creating an empty dictionary using dict()\n",
        "my_dict = dict()\n",
        "\n",
        "# Creating a dictionary from a list of tuples\n",
        "my_dict = dict([(1, 'abc'), (2, 'xyz')])"
      ],
      "metadata": {
        "id": "t0aeQbe5qzyv"
      },
      "execution_count": 207,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Accessing Elements in a Dictionary**"
      ],
      "metadata": {
        "id": "9IQNcprPq3Yd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict = {'name': 'satish', 'age': 27, 'address': 'guntur'}\n",
        "# Accessing values by key\n",
        "print(my_dict['name'])\n",
        "# Accessing a key that doesn't exist raises KeyError"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gh8ptsEuq5ni",
        "outputId": "e1c79b94-df9a-4bfe-a928-d55339dad19e"
      },
      "execution_count": 208,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "satish\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Using get() method to access a key\n",
        "print(my_dict.get('address'))\n",
        "print(my_dict.get('degree'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a9YyVzxdr7WG",
        "outputId": "c3afe0fc-7325-4858-dace-efedef3e2626"
      },
      "execution_count": 209,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "guntur\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Call index on that value and even call on that method\n",
        "employee={\"Name\":\"Mohan\",\"Skill\":[\"Python\",\"Machine Learning\",\"Deep Learning\"]}\n",
        "employee[\"Skill\"]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9GOpMQmbsotc",
        "outputId": "bd3c6f95-fb8a-4b94-a9ca-b24f8d85e98e"
      },
      "execution_count": 210,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Python', 'Machine Learning', 'Deep Learning']"
            ]
          },
          "metadata": {},
          "execution_count": 210
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "employee[\"Skill\"][0].upper()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "k6b3fBTKtKOK",
        "outputId": "cd570721-f9e5-4912-aa8d-e96d7815f702"
      },
      "execution_count": 211,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'PYTHON'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 211
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Adding or Modifying Elements in a Dictionary**"
      ],
      "metadata": {
        "id": "dHpRX0Xkq7hu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict = {'name': 'satish', 'age': 27, 'address': 'guntur'}\n",
        "\n",
        "# Modifying an existing key's value\n",
        "my_dict['name'] = 'raju'\n",
        "print(my_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VqoozTq8q-5X",
        "outputId": "934d2a0f-c33a-45bf-92f8-c077d994ceb2"
      },
      "execution_count": 212,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'raju', 'age': 27, 'address': 'guntur'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Adding a new key-value pair\n",
        "my_dict['degree'] = 'M.Tech'\n",
        "print(my_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vM1c5FS4sZ77",
        "outputId": "37a801e8-dfeb-4946-df84-25f9401d7d6f"
      },
      "execution_count": 213,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'raju', 'age': 27, 'address': 'guntur', 'degree': 'M.Tech'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "**Deleting or Removing Elements from a Dictionary**"
      ],
      "metadata": {
        "id": "w3RHu-ndrE5f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict = {'name': 'satish', 'age': 27, 'address': 'guntur'}\n",
        "\n",
        "# Removing a particular item by key and returning its value\n",
        "print(my_dict.pop('age'))\n",
        "print(my_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L4htBlhWrGi2",
        "outputId": "3fa40309-338e-4d37-8144-bf905bb50bb1"
      },
      "execution_count": 214,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "27\n",
            "{'name': 'satish', 'address': 'guntur'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Removing an arbitrary key-value pair using popitem()\n",
        "my_dict.popitem()\n",
        "print(my_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O6YjRMYAu1Cq",
        "outputId": "a44b7dba-d3d1-4a00-e300-c3354328cec1"
      },
      "execution_count": 215,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'satish'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Deleting a particular key-value pair using del\n",
        "squares = {2: 4, 3: 9, 4: 16, 5: 25}\n",
        "del squares[2]\n",
        "print(squares)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tvSzlW7NuuQD",
        "outputId": "1487b3db-c262-42bf-e2d4-eefd006a986d"
      },
      "execution_count": 216,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{3: 9, 4: 16, 5: 25}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Removing all items using clear()\n",
        "squares.clear()\n",
        "print(squares)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qG_JTIkhu4v_",
        "outputId": "a1478381-e9ab-453a-aac6-194dcf6c4019"
      },
      "execution_count": 217,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Dictionary Methods**"
      ],
      "metadata": {
        "id": "puzOIhbfrLv0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "squares = {2: 4, 3: 9, 4: 16, 5: 25}\n",
        "# Creating a copy of a dictionary\n",
        "my_dict = squares.copy()\n",
        "print(my_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sw2kW1XrwVad",
        "outputId": "282ceaf3-db8a-43bb-b14c-9e492d2965b3"
      },
      "execution_count": 218,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{2: 4, 3: 9, 4: 16, 5: 25}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a dictionary using fromkeys()\n",
        "subjects = {}.fromkeys(['Math', 'English', 'Hindi'], 0)\n",
        "print(subjects)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qE5jeXqixwhz",
        "outputId": "9f3ad593-deae-47b9-fdd7-48694c98b100"
      },
      "execution_count": 219,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Math': 0, 'English': 0, 'Hindi': 0}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Getting a view of dictionary items\n",
        "print(squares.items())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b_V9MqpFxzvw",
        "outputId": "fc049a12-1685-4a4d-c26a-dd0f938bbc2c"
      },
      "execution_count": 220,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_items([(2, 4), (3, 9), (4, 16), (5, 25)])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Getting a view of dictionary keys\n",
        "print(squares.keys())\n",
        "\n",
        "# Getting a view of dictionary values\n",
        "print(squares.values())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fQjzeX2Ixzkr",
        "outputId": "e3d5fa43-aee7-4857-e235-061a1a682974"
      },
      "execution_count": 221,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_keys([2, 3, 4, 5])\n",
            "dict_values([4, 9, 16, 25])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**zip() function**"
      ],
      "metadata": {
        "id": "UprwJCMwzZi1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "L1=[\"cat\",\"name\",\"skill\",\"box\",\"a\"]\n",
        "L2=[3,4,5,3,1]\n",
        "dict(zip(L1,L2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xJQuWc6Szgq-",
        "outputId": "c887b0fe-2c9c-45f7-83a0-cf39cff563fd"
      },
      "execution_count": 222,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'cat': 3, 'name': 4, 'skill': 5, 'box': 3, 'a': 1}"
            ]
          },
          "metadata": {},
          "execution_count": 222
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##5.**Strings**\n",
        "\n",
        "- A string is a sequence of characters.\n",
        "- Internally, computers deal with numbers (binary), so characters are encoded using encoding schemes like ASCII and Unicode.\n",
        "- In Python, strings are sequences of Unicode characters."
      ],
      "metadata": {
        "id": "Cw5a3uo20Xny"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Creating Strings**"
      ],
      "metadata": {
        "id": "4koccaLg0Z9l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Single quotes\n",
        "myString = 'Hello'\n",
        "\n",
        "# Double quotes\n",
        "myString = \"Hello\"\n",
        "\n",
        "# Triple quotes for multiline strings or docstrings\n",
        "myString = '''Hello'''"
      ],
      "metadata": {
        "id": "Tgvol4aH0dHu"
      },
      "execution_count": 223,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "**Accessing Characters in a String**"
      ],
      "metadata": {
        "id": "eiIulgBD0l7m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myString = \"Hello\"\n",
        "\n",
        "# Accessing individual characters using indexing\n",
        "print(myString[0])\n",
        "print(myString[-1])\n",
        "\n",
        "# Slicing to access a range of characters\n",
        "print(myString[2:5])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bgUiRHSI0mkS",
        "outputId": "ac5dc631-fa2c-4c3d-8f4f-bdffc6c14ee0"
      },
      "execution_count": 224,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "H\n",
            "o\n",
            "llo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Changing or Deleting a String**\n"
      ],
      "metadata": {
        "id": "ZcOlpaIK0s_I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myString = \"Hello\"\n",
        "\n",
        "# Strings are immutable; you can't change individual characters\n",
        "myString[4] = 's'  # Raises TypeError"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 218
        },
        "id": "SjlegZok0w5I",
        "outputId": "7a72f505-6c2b-465d-aa94-7fe952206eca"
      },
      "execution_count": 225,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-225-ffbe2c16ee76>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Strings are immutable; you can't change individual characters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmyString\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m's'\u001b[0m  \u001b[0;31m# Raises TypeError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Deleting a string\n",
        "del myString"
      ],
      "metadata": {
        "id": "I89-71uh1jYN"
      },
      "execution_count": 226,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**String Operations**\n",
        "\n",
        "**Concatenation**"
      ],
      "metadata": {
        "id": "MC3O8t6W07IH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s1 = \"Hello \"\n",
        "s2 = \"Satish\"\n",
        "\n",
        "# Concatenation using the + operator\n",
        "print(s1 + s2)\n",
        "\n",
        "# Repetition using the * operator\n",
        "print(s1 * 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ruz5M_A009mJ",
        "outputId": "d5da977f-23fc-47b7-c44d-1da9d6901bcb"
      },
      "execution_count": 227,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Satish\n",
            "Hello Hello Hello \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Iterating Through a String**"
      ],
      "metadata": {
        "id": "RCT0HH_O1AOr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for letter in \"Hello World\":\n",
        "    print(letter)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yh9NWWVt1EnC",
        "outputId": "60d38a6d-42f2-488a-a080-32e8ed025103"
      },
      "execution_count": 228,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "H\n",
            "e\n",
            "l\n",
            "l\n",
            "o\n",
            " \n",
            "W\n",
            "o\n",
            "r\n",
            "l\n",
            "d\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**String Methods**"
      ],
      "metadata": {
        "id": "uD1W2N0P1LKv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Converting to lowercase and uppercase\n",
        "print(\"Hello\".lower())\n",
        "print(\"Hello\".upper())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u5Vh-OHQ2P9-",
        "outputId": "a9f83a0a-3960-4355-bf56-68efa1e9e537"
      },
      "execution_count": 229,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n",
            "HELLO\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Splitting a string\n",
        "print(\"This will split all words in a list\".split())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "24yoQ8j32TDg",
        "outputId": "eb457817-c841-40e6-da59-806834e75799"
      },
      "execution_count": 230,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['This', 'will', 'split', 'all', 'words', 'in', 'a', 'list']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Joining a list of words into a string\n",
        "print(' '.join(['This', 'will', 'split', 'all', 'words', 'in', 'a', 'list']))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GZ0T7rGD1N6H",
        "outputId": "04e51acb-6712-4eac-bf58-00c0f1aa436b"
      },
      "execution_count": 231,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This will split all words in a list\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Finding a substring\n",
        "print(\"Good Morning\".find(\"Mo\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2rNsiPlt2b5Z",
        "outputId": "7e7893cc-f1b7-4d1c-b06b-8988851692ad"
      },
      "execution_count": 232,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Replacing a substring\n",
        "s1 = \"Bad morning\"\n",
        "s2 = s1.replace(\"Bad\", \"Good\")\n",
        "print(s1)\n",
        "print(s2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g0AWU7cn2hqV",
        "outputId": "6fb0e2d9-51f0-4fc3-8516-263f1c73ea7e"
      },
      "execution_count": 233,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Bad morning\n",
            "Good morning\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Sorting Words in Alphabetic Order**"
      ],
      "metadata": {
        "id": "DzAUDmwX1UUE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myStr = \"python Program to Sort words in Alphabetic Order\"\n",
        "words = myStr.split()\n",
        "words.sort()\n",
        "for word in words:\n",
        "    print(word)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "reITzSGG1V3g",
        "outputId": "489a247c-557b-4caa-f9a7-6c2d2c6d4911"
      },
      "execution_count": 234,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Alphabetic\n",
            "Order\n",
            "Program\n",
            "Sort\n",
            "in\n",
            "python\n",
            "to\n",
            "words\n"
          ]
        }
      ]
    }
  ]
}