TUPLE()andSETS.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "##                                 **TUPLE**\n",
        "\n"
      ],
      "metadata": {
        "id": "-QHUeVoV2JwX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a=[]\n",
        "b=()\n",
        "type(a)\n",
        "type(b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q-SpoCzH6Hvh",
        "outputId": "81f9443b-6e71-48ad-dcc4-e3bd33ac97db"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6HABQKemZDKH",
        "outputId": "47c32540-835b-4a92-f070-9fe3a0b6137a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Mercury', 'Venus', \"Aj's planet\"]\n"
          ]
        }
      ],
      "source": [
        "# Tuples- Unmodifiable/immutables lists\n",
        "# # syntax= ( )\n",
        "# use case\n",
        "# if You are a data scientist at ISRO,\n",
        "# you dont want anyone to change the items- list are mutable\n",
        "# you can't change tuple. So, you can use tuples for immutability\n",
        "a=[\"Mercury\",\"Venus\",\"Earth\"]\n",
        "a[2]=\"Aj's planet\"\n",
        "print(a)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a[2]=9\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6PW2GPHFZneM",
        "outputId": "028f5ede-1bf2-4e60-90f1-abc630e7d3e4"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Mercury', 'Venus', 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#most of the list concepts also work as tuples"
      ],
      "metadata": {
        "id": "9gNz5cP3aOsV"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a=(1,5,7)\n",
        "type(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DNSZYXWoab2R",
        "outputId": "f129c0b0-b629-45fd-bb3c-c1f084b4de8a"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a=[5]\n",
        "type(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y-iS99o9ae47",
        "outputId": "e833801c-7d3a-4099-f326-24b7f97825de"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a=(5)\n",
        "type(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HkHaoHNxarvW",
        "outputId": "d7decf31-e750-439b-c29c-b827e50eb06b"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Single value inside () remains is not treated as tuple,\n",
        "# It requires more than 1 value to be tuple\n",
        "print(type((3+5)*4),type((3,5)))\n",
        "print(type(\"disha\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YLyNoNYOaxj1",
        "outputId": "93c5b9a2-5d1a-4e0a-ec54-cda8a8907389"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'int'> <class 'tuple'>\n",
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#tuple slicing\n",
        "tup=a[2:5]\n",
        "type(tup)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NZ2oUWEpbHna",
        "outputId": "6e70a08c-405b-4a80-efbf-96afe39e098f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b=(1,5,8)\n",
        "type(b)"
      ],
      "metadata": {
        "id": "_qf3eFyQb7-W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "684ae581-b8ae-43cd-d7bd-419fe792ef5b"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#List are mutable\n",
        "a=[1,5,7]\n",
        "a[2]=9\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yRaY9nUw27n5",
        "outputId": "d271bf85-da98-483e-f18a-b5986475edd4"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 5, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Tuples are not mutable/ immutable\n",
        "b=(1,5,7)\n",
        "b[2]=9"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "id": "4vYneAzN3YrC",
        "outputId": "8430779e-eb79-46df-e58d-d5db097ec039"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "'tuple' object does not support item assignment",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-6-90f95fdec8f5>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#Tuples are not mutable/ immutable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mb\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# length function in tuple/ same as in List\n",
        "a=(1,2,3,4,5,6,7)\n",
        "len(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BK2RrUuc4G8B",
        "outputId": "695c71a4-349c-48a9-a822-c1876bbb6b2a"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Indexing is also same as list\n",
        "a[2]"
      ],
      "metadata": {
        "id": "8em9yNt79jI3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Slicing is also same as list\n",
        "print(a[2:5])\n",
        "print(type((a[2:5])))\n",
        "print(a[3:4])\n",
        "print(type(a[3:4]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9F7JPtqR93PI",
        "outputId": "62ff104a-957e-40eb-d459-e432a0bfd501"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(3, 4, 5)\n",
            "<class 'tuple'>\n",
            "(4,)\n",
            "<class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Properties of a Tuple\n",
        "a=()\n",
        "type(a)\n",
        "len(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JRQC7XN697yr",
        "outputId": "86fb77bf-3fdb-4ab8-b0fb-f37657d94d29"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#typecasting tuples"
      ],
      "metadata": {
        "id": "dix3jvEX_hzo"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a=[4,7,1,3]\n",
        "type(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tTy6j0s1_2eU",
        "outputId": "ca672643-4dc4-43d3-ddb9-2b59eaee5f22"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b=tuple(a)\n",
        "type(b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8tBqVUWm_7z6",
        "outputId": "edc6b842-e8d4-41b2-e943-bde07ec14125"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Packing and Unpacking"
      ],
      "metadata": {
        "id": "MKYAgptpAGU9"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Unpacking for tuples\n",
        "a= (4,6,1)\n",
        "type(a)\n",
        "x,y,z=a\n",
        "print(x,y,z)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0u0nkxxPAlGC",
        "outputId": "ed8f04b8-34fa-49e5-d49b-14e2a7695eff"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4 6 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Unpacking also works in list\n",
        "a=[4,6,1]\n",
        "type(a)\n",
        "x,y,z=a\n",
        "print(x,y,z)\n",
        "#x,y=a ❌ERROR not enough values to unpack\n",
        "#w,x,y,z=a ❌ERROR too many values to unpack"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1cNuhzntBr6h",
        "outputId": "740217c7-ac9f-4996-8f07-2ec2147ab499"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4 6 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#What will be the answer of print(e)\n",
        "a=(4,6,1)\n",
        "e,f=a[:2]\n",
        "print(e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NXx8E41TByYH",
        "outputId": "fd6312b6-dc6c-4266-f49f-8821154e6fc5"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Packing\n",
        "#By default if we create a variable and assign multiple values it creates tuple not list\n",
        "a=20,40,30\n",
        "print(type(a))\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7ko1CE98DwfF",
        "outputId": "1973009a-666e-400c-d93e-3a57660abc98"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'tuple'>\n",
            "(20, 40, 30)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a=20,40,\"Disha\"\n",
        "print(type(a))\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fn3mINWIEC9g",
        "outputId": "04427dec-ee67-43e1-d315-503ad3cc22c4"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'tuple'>\n",
            "(20, 40, 'Disha')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Packing\n",
        "def solve():\n",
        "  return 2,5,3\n",
        "a=solve()\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qTjn9SnnE2gx",
        "outputId": "1e0510cc-1a53-458e-a1d4-cc7b3f923dd3"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2, 5, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#iterating over a list of tuples\n",
        "a=[(1,\"DN\"),(2,\"tup\"),(3,\"listus\"),(4,\"iteru\")]\n",
        "print(type(a))\n",
        "print(type(a[0]))\n",
        "print(a[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gVR4IjBKE7cN",
        "outputId": "1c08c4dc-87f7-4eb6-a173-dea6a2d87a9f"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'>\n",
            "<class 'tuple'>\n",
            "(1, 'DN')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for ele in a:\n",
        "  print(ele)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FQBNmsgZGaul",
        "outputId": "f622816b-f930-43f1-c6e9-1e993da968e3"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 'DN')\n",
            "(2, 'tup')\n",
            "(3, 'listus')\n",
            "(4, 'iteru')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('''\n",
        "Roll no: 1 is DN\n",
        "Roll no: 2 is tup\n",
        "Roll no: 3 is listus\n",
        "Roll no: 4 is iteru\n",
        "''')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5CIUUuLwGwbk",
        "outputId": "399fc82c-09df-480a-8ae0-5b6c383b4f83"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Roll no: 1 is DN\n",
            "Roll no: 2 is tup\n",
            "Roll no: 3 is listus\n",
            "Roll no: 4 is iteru\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#1 Solution\n",
        "a=[(1,\"DN\"),(2,\"tup\"),(3,\"listus\"),(4,\"iteru\")]\n",
        "for i in range(len(a)):\n",
        "  print(\"Roll no:\",a[i][0],\"is\",a[i][1] )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lYPiknSzHrz4",
        "outputId": "56c7b318-d6e4-4d28-9a16-f7aef66ca216"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Roll no: 1 is DN\n",
            "Roll no: 2 is tup\n",
            "Roll no: 3 is listus\n",
            "Roll no: 4 is iteru\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#2 Solution\n",
        "for ele in a:\n",
        "  roll_no,name=ele #unpacking\n",
        "  print(f\"Roll no: {roll_no} is {name}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0Os9EcDnII57",
        "outputId": "67ab21e4-3b22-46e2-b166-88c66f4a944b"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Roll no: 1 is DN\n",
            "Roll no: 2 is tup\n",
            "Roll no: 3 is listus\n",
            "Roll no: 4 is iteru\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3 Solution\n",
        "for ele in a:\n",
        "  print(f'Roll no: {ele[0]} is {ele[1]}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "41UXX4HwJKqQ",
        "outputId": "cf609cf7-f25b-43b5-b6bd-e95af13b402b"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Roll no: 1 is DN\n",
            "Roll no: 2 is tup\n",
            "Roll no: 3 is listus\n",
            "Roll no: 4 is iteru\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#4 Solution\n",
        "for roll_no, name in a:\n",
        "  print(f'Roll no: {roll_no} is {name}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cNcfgBHbJuqp",
        "outputId": "1cc2bd2d-37df-4784-e465-cc3be2f78168"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Roll no: 1 is DN\n",
            "Roll no: 2 is tup\n",
            "Roll no: 3 is listus\n",
            "Roll no: 4 is iteru\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a=3\n",
        "b=5\n",
        "#after swapping\n",
        "a=5\n",
        "b=3"
      ],
      "metadata": {
        "id": "4TX58JURKIMC"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a=3\n",
        "b=5\n",
        "a=b\n",
        "b=a\n",
        "print(a,b)\n",
        "#issue orginal value of a is lost"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XIWiCzFQdvFq",
        "outputId": "65b5c447-07ad-4806-dba4-828492b07f1c"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# swapping using 3rd variable\n",
        "a=3\n",
        "b=5\n",
        "\n",
        "temp=a\n",
        "a=b\n",
        "b=temp\n",
        "print(a,b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kmOaz1CavNGO",
        "outputId": "b99133ce-4601-4e7d-a632-a882e25c9bf8"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#python based logic\n",
        "a=3\n",
        "b=5\n",
        "a,b=b,a\n",
        "print(a,b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LlN2Dx96vuai",
        "outputId": "fe4d8848-9613-4b9e-ae95-098b680ed53a"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **SETS**"
      ],
      "metadata": {
        "id": "ma1LkuTW2l4a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Sets\n",
        "# 💡Sets are unique collection of elements\n",
        "# 💡We reperesent a set using curly braces{}\n",
        "# 💡Sets can store strings,tuples,booleans inside them all at once\n",
        "# 💡🫢Sets cannot store Lists, Sets and dictionaries within them\n",
        "#     (Reason is related to mutability and immutability)"
      ],
      "metadata": {
        "id": "96ajUzRuyD46"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s={1,3,6,2,1,5,6,2}\n",
        "type(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0uRZdcBxzrTJ",
        "outputId": "11cc0f75-df9c-4e08-805d-4a12d97410b9"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "set"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(s) # will show only one occurance of elements\n",
        "# sets are unordered because their output gets automatically sorted,\n",
        "# Also, Indexing is not possible in sets because not matter in which order you\n",
        "# give input it will get sorted and printed"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qryc7An1z22u",
        "outputId": "eea5df99-3e25-4667-f71d-27580634ad50"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 5, 6}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# s[0]\n",
        "#❌ERROR: 'set' object is not subscriptable"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 181
        },
        "id": "MyV75ELfz7td",
        "outputId": "eb0906dd-0363-4036-88b3-a147e59b1341"
      },
      "execution_count": 10,
      "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-10-c9c96910e542>\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;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": "code",
      "source": [
        "a=[]\n",
        "b=()\n",
        "c={}\n",
        "type(c) # both set and dictionaries are created using {}"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dMJYERIq09SZ",
        "outputId": "f1e6b607-6921-4f3f-d71a-e715e0bcf83b"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# creating an empty set using set function\n",
        "s=set()\n",
        "type(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sk89RtKC1cmR",
        "outputId": "2943097e-3007-4fd8-8285-ee102505760e"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "set"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# TUPLE + TUPLE = extended TUPLE\n",
        "x=(1,2,3)\n",
        "y=(4,5,6)\n",
        "z=x+y\n",
        "print(z)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pzCjvnjT2_uq",
        "outputId": "8457f975-97cd-4bb9-ae0c-07dfbd324359"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3, 4, 5, 6)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Methods on sets\n",
        "s={1,4,3}\n",
        "len(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2R3kumY_3-v-",
        "outputId": "7581619a-024e-4446-c6ae-f50b82ac01cd"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s.add(2)\n",
        "print(s)\n",
        "len(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M0Grbr3V5ru3",
        "outputId": "aebf3d39-b9fd-4ea9-a68f-cd75b1e4075d"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4}\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s.add(5)\n",
        "print(s)\n",
        "len(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AZfytLhB48p3",
        "outputId": "6a7d90f0-0e01-40c1-dbf8-4941ce430403"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4, 5}\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# removing an elementfrom a set"
      ],
      "metadata": {
        "id": "HNMbPrmD5_Tp"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s={1,4,3}\n",
        "s.add(5) #.add to add an element\n",
        "s.remove(4) #.remove an element\n",
        "s.pop() # remove an element randomly # reason- because its unordered\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rt9rdkeY6ww7",
        "outputId": "048742d3-c501-439c-94a8-85f93d921895"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 3, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#update(): to add multiple elements into a set\n",
        "t=(5,6,3,4)\n",
        "s={9,8,2,1,5,4}\n",
        "s.update(t)\n",
        "len(s)\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "seIbEZ5S6ypg",
        "outputId": "e7841e41-0bba-4065-a175-0f703d8a7aba"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4, 5, 6, 8, 9}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Question:\n",
        "Take a string as input.\n",
        "Print the number of unique characters in the string\n",
        "'''\n",
        "user_input=input()\n",
        "print(set(user_input))\n",
        "print(len(set(user_input)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Ots_FRR8b4S",
        "outputId": "59d83566-9e79-4593-dacd-1f0cd3513727"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "disha nashier\n",
            "{'r', 'h', 'i', 's', ' ', 'd', 'e', 'a', 'n'}\n",
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits={\"apple\",\"banana\",\"cherry\"}\n",
        "fruits.add(\"orange\")\n",
        "print(fruits)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pigoaW1w9xi6",
        "outputId": "28f03ec5-f4d6-4e55-9923-73d49266a8e7"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'cherry', 'orange', 'apple', 'banana'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits.update([\"mango\",\"grape\"])\n",
        "print(len(fruits))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eiNYcDi_-qm6",
        "outputId": "b150a6f1-06bb-4866-c91c-2acf178f0a4c"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#set operations\n",
        "# *Venn diagram\n",
        "# 1. Intersection of two sets- common elements between A and B\n",
        "# 2. Union of two sets- all elements in A and B\n",
        "# 3. SET DIFFERENCE- A-B -all the elements in A that are not present in B\n",
        "# A-B = A-(A intersection B)\n",
        "# B-A= B-(B intersection A)\n",
        "# ❌A-B = B-A (Not necesserly)\n",
        "# ⭐ SYMMETRIC DIFFERENCE - unioin of (A-B) and (B-A)\n",
        "# ⭐ SYMMETRIC DIFFERENCE-  difference of (A union B) and (A intersection B)"
      ],
      "metadata": {
        "id": "geIKjxQq_RXf"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# You can either use \"intersection\" keyword or \"&\" symbol\n",
        "a={2,3,4,5}\n",
        "b={1,4,3,8,6,7}\n",
        "print(a.intersection(b))\n",
        "print(a&b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YmBsRexLFfgR",
        "outputId": "16cc1201-db70-4129-d284-66acf6dcbc8e"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{3, 4}\n",
            "{3, 4}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#union\n",
        "print(a.union(b))\n",
        "print(a|b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R7Q_SCZNFthY",
        "outputId": "7a52facc-c1d4-4464-d9c8-0ef4946a68d1"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4, 5, 6, 7, 8}\n",
            "{1, 2, 3, 4, 5, 6, 7, 8}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#difference\n",
        "a={2,3,4,5}\n",
        "b={1,4,3,8,6,7}\n",
        "print(a.difference(b))\n",
        "print(a-b)\n",
        "print(b-a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WrmePGHPGPc4",
        "outputId": "3b484fa8-c62c-4793-c0df-6ca558e99ac4"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{2, 5}\n",
            "{2, 5}\n",
            "{8, 1, 6, 7}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#symmetric difference\n",
        "a^b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rYnmflzKHkyC",
        "outputId": "599b70fd-cf72-4a23-a5f2-e2dc76680b15"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1, 2, 5, 6, 7, 8}"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(a.symmetric_difference(b))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9e44E1xrI0wP",
        "outputId": "e3743242-c39f-4129-c549-900c48c8d711"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 5, 6, 7, 8}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## ---------Question------\n",
        "# you are given a string as input\n",
        "# Ascertain wheather that string contains a binary number or not\n",
        "# Sample Input-1\n",
        "# \"0011010101ab\"\n",
        "# Sample Input-2\n",
        "# \"010010101010\"\n",
        "# Sample Output-1\n",
        "# \"Not Binary!\"\n",
        "# Sample output-2\n",
        "# \"Binary!\""
      ],
      "metadata": {
        "id": "UP-511pKJAde"
      },
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# in case of set order does not matter\n",
        "print({2,5}=={5,2})\n",
        "# in case of list order matter\n",
        "print([2,5]==[5,2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gqiPKiOXK1n_",
        "outputId": "fe40cd26-0839-47dd-b2ae-0c736a57506d"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def solve(s):\n",
        "  s1= set(s)\n",
        "  if s1 =={\"0\",\"1\"}:\n",
        "    return\"Binary\"\n",
        "  else:\n",
        "    return\"Not Binary\""
      ],
      "metadata": {
        "id": "iEPur7iCKl61"
      },
      "execution_count": 70,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(solve(\"0011010101ab\"))\n",
        "print(solve(\"010010101010\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jc0ulUSMMLKH",
        "outputId": "f60273f3-6c00-4a40-8843-9ad5604e7a0f"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Not Binary\n",
            "Binary\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "GFevkDbCMSAw"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}