python_data_types.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "python data types.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "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/dineshreddy221/Python/blob/main/python_data_types.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "$$ Python\\ Data\\ Types\\ and\\ Functions $$"
      ],
      "metadata": {
        "id": "jtw3vztPsqSe"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n0tRsJzKygg_",
        "outputId": "3038da05-f861-4edf-c17d-e2a58cb18372"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "integer number : 7\n",
            "float number : 44.5\n"
          ]
        }
      ],
      "source": [
        "# integer\n",
        "number = 7\n",
        "float_num = 44.5\n",
        "print(\"integer number :\", number)\n",
        "print(\"float number :\",float_num)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Taking user input.\n",
        "num = int(input())\n",
        "float_number = float(input())\n",
        "print(\"integer number :\",num)\n",
        "print(\"float number :\", float_number)\n",
        "print(\"float number {:.2f}\".format(float_number)) # rounding 2decimal."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FatOz-GcyyN6",
        "outputId": "6d937dd8-ec53-490f-e32e-ce88c9e4c0fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "34\n",
            "65.8769\n",
            "integer number : 34\n",
            "float number : 65.8769\n",
            "float number 65.88\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "name = \"dinesh is a nice guy\"\n",
        "print(type(name))\n",
        "print(name)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lqs7rOEUzAEE",
        "outputId": "517446dd-e8de-47cf-8ec4-e2db8ba56dda"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "dinesh is a nice guy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# capitalize only the first character of a string\n",
        "name.capitalize()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "PLlk4dkO0voP",
        "outputId": "f188321e-89e3-4ae8-ab73-ca2cd98c596f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Dinesh is a nice guy'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 238
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "name.casefold()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "bat6XLch00oH",
        "outputId": "1e6432eb-c950-43ca-b911-cd70bb86c709"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'dinesh is a nice guy'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 239
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# It makes the name as center and we can fill the single character, it takes **two arguments**, one argument is integer and another is any character or \n",
        "# by default it takes spaces as fill character in second argument. \n",
        "name.center(67,\"*\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "fN-KZu7G1yTM",
        "outputId": "35a0e311-29b0-4ae1-a804-6306e4c78aa8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'************************dinesh is a nice guy***********************'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 240
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# it tells us that the character count of a string and it takes **one argument**\n",
        "name.count(\"boy\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-PL-MSqe1_DV",
        "outputId": "115a261e-e9d3-4fe4-c53a-6139c418b3bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 241
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "name.encode()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_Ph3oqal3dcK",
        "outputId": "9f9989f5-1220-417f-9404-1d686b2b1c6a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "b'dinesh is a nice guy'"
            ]
          },
          "metadata": {},
          "execution_count": 242
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# it gives a boolean value when it endswith mentioned character True or False.\n",
        "y = name.endswith(\"y\")\n",
        "d = name.endswith(\"d\")\n",
        "print(\"endswith with y :\", y)\n",
        "print(\"endswith with d :\",d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q7h_5fS942Xu",
        "outputId": "69ee74a3-3bab-45d3-b079-779f608d1581"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "endswith with y : True\n",
            "endswith with d : False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# it gives a boolean value when it startswith mentioned character True or False.\n",
        "s = name.startswith(\"d\")\n",
        "I = name.startswith(\"i\")\n",
        "print(\"starts with d :\",s)\n",
        "print(\"starts witg i :\",I)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8RoVK1tC5IM0",
        "outputId": "1baa8194-a51a-4123-a186-0a9e2f6343f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "starts with d : True\n",
            "starts witg i : False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find gives us the indexing position of a character or a string.\n",
        "index = name.find(\"boy\")\n",
        "print(index)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-qbRNZSY6EIj",
        "outputId": "c56e8a1d-0c3a-4391-c6ef-9540f6a43e20"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# formating the name inside a placeholder\n",
        "print(\"is {}\".format(name))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OCZaCgUr6mB2",
        "outputId": "191abdde-72f3-443b-d69c-5231e9f82439"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "is dinesh is a nice guy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mydict = {\"a\":1, \"b\":2, \"c\":3, \"d\":5}\n",
        "format_string = '{a} {c} {d}'.format_map(mydict)\n",
        "print(format_string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "63oFX8Jz7pQp",
        "outputId": "bbaaafc6-99df-4633-93e9-6f4d72bdc00d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 3 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# mapping the lists to dictionary with zipping the each elements of all the attributes and formatting to adictionary.\n",
        "lst = [1,2,\"a\",3,\"ee\"]\n",
        "lst1 = [23,32,34,65,76]\n",
        "mydict = dict(zip(lst,lst1))\n",
        "string = (\"{}\".format(mydict))\n",
        "print(string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zCKujoGr84YJ",
        "outputId": "ab583b0e-065c-495d-8cf2-a1bed9447245"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1: 23, 2: 32, 'a': 34, 3: 65, 'ee': 76}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(type(string))  # the dictionary converted to a string because format is a string method.\n",
        "print(type(mydict))  # zipping the each element in the different list combining a dictionary"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LXrWCYne-TaT",
        "outputId": "83dd6804-03a0-4d85-fdac-8c0423a28eb7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "<class 'dict'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lst = []\n",
        "for element in name:\n",
        "  lst.append(element)\n",
        "  word_lst = \"\".join(lst)\n",
        "print(len(lst))\n",
        "print(word_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ua3nYqLpXn3U",
        "outputId": "31d3d150-67db-4934-d558-38fbcdadb909"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "21\n",
            "dinesh is a smart boy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IzdLHHCYYhux",
        "outputId": "b83657c1-3be1-46cc-beee-44139b215af0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 133
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# index and find both gives the indexes of particular attribute\n",
        "# indexing position of **is**\n",
        "print(\"index 'is' :\",name.index(\"is\"))\n",
        "print(\"find 'is' :\",name.find(\"is\"))\n",
        "# indexing position of **boy**\n",
        "print(\"index 'is' :\",name.index(\"boy\"))\n",
        "print(\"find 'is' :\",name.find(\"boy\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "81iqYuknacm7",
        "outputId": "11421958-90aa-47a8-9a1c-8949d467ccb3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "index 'is' : 7\n",
            "find 'is' : 7\n",
            "index 'is' : 18\n",
            "find 'is' : 18\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isalnum means it gives bollean value of True if condition True, Flase if it is not a alnumeric.\n",
        "if name.isalnum() == True:\n",
        "  print(\"name is alnumeric\")\n",
        "else:\n",
        "  print(\"name is not a alnumeric\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3m-vlfi7bmzb",
        "outputId": "61aff968-b691-4461-fc8e-5b2c28b0172e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name is not a alnumeric\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# checking the name is alphabetical or not\n",
        "item = \"bus007\"\n",
        "if item.isalpha() ==True:\n",
        "  print(\"name is alphabetical\")\n",
        "else:\n",
        "  print(\"name is not a alphabetical\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y3oG5F8Uc16b",
        "outputId": "9affb720-287a-49b1-82a1-83435b93cb2c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name is not a alphabetical\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# ascii means it gives bollean value of True if condition True, Flase if it is not a ascii.\n",
        "if name.isascii() == True:\n",
        "  print(\"name is ascii\")\n",
        "else:\n",
        "  print(\"name is not ascii\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h6MyfGcSdyz6",
        "outputId": "1f240506-8116-4b86-d7ba-6c011a127213"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name is ascii\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isalnum means it gives bollean value of True if condition True, Flase if it is not a alnumeric.\n",
        "num_str = \"2345765\"\n",
        "if num_str.isalnum() == True:\n",
        "  print(\"num_str is alnumeric\")\n",
        "else:\n",
        "  print(\"num_str is not a alnumeric\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-vpL90vrd-We",
        "outputId": "47f3d625-83c6-4626-b54c-df1fd3f5d21c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_str is alnumeric\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isdecimal \n",
        "float_str = \"8888889\"\n",
        "if float_str.isdecimal() ==True:\n",
        "  print(\"float_str is decimal\")\n",
        "else:\n",
        "  print(\"float_str is not a decimal\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aFqzxYkreX8c",
        "outputId": "020c5613-4550-41f3-a6f5-a3610629eb24"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "float_str is decimal\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isdigit \n",
        "digit_str = \"8888889\"\n",
        "if digit_str.isdecimal() ==True:\n",
        "  print(\"It is a digit\")\n",
        "else:\n",
        "  print(\"It is not a digit\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xTar6w-LfKRG",
        "outputId": "db55efd8-1425-4261-d159-a7290a8fcbda"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It is a digit\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# islower\n",
        "if name.islower() ==True:\n",
        "  print(\"It is a lowercase\")\n",
        "else:\n",
        "  print(\"It is not a lowercase\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MIRpQAKkgM8P",
        "outputId": "ec860423-bfb1-4d8a-f175-455c23ab27c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It is a lowercase\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isupper\n",
        "if name.isupper() ==True:\n",
        "  print(\"It is a uppercase\")\n",
        "else:\n",
        "  print(\"It is not a uppercase\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "74WTn6pVgeHU",
        "outputId": "8a9f5988-8e0f-4126-931a-8c322af8cd0b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It is not a uppercase\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# isnumeric\n",
        "if name.isnumeric() ==True:\n",
        "  print(\"It is a numeric\")\n",
        "else:\n",
        "  print(\"It is not a numeric\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "euSo7j8-g7fY",
        "outputId": "20213b5d-eea4-4056-a8b9-189e196791bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It is not a numeric\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# checking the name condition and converting the first characters capital is condition is True other convert all the characters to uppercase.\n",
        "if name.islower() ==True:\n",
        "  print(name.title())\n",
        "else:\n",
        "  print(name.upper())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "anjU8brFhFz3",
        "outputId": "8aa9f10f-2b28-4bbd-90f9-9c82dc75a970"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dinesh Is A Smart Boy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Join function in python joins the string'\n",
        "str_join = [\"welcome to my home\",\"hgfda\"]\n",
        "str_join = \" \".join(str_join) # joining the strings of list with space.\n",
        "print(str_join)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P7WAR_RrhiBO",
        "outputId": "1f6dc9f3-2e65-4f0c-dd8a-641a5f7e7e8c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "welcome to my home hgfda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Maketrans and translate methods"
      ],
      "metadata": {
        "id": "cdXt1KwBi2lU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# maketrans changes the string of charaters to another like replace.\n",
        "change = name.maketrans(\"Boy\",\"boy\")\n",
        "# Create a mapping table, and use it in the translate() method to replace any \"Boy\" characters with a \"boy\" character\n",
        "# returns a copy of the string in which all characters have been translated using table \n",
        "print(name.translate(change))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QuLQmejGiOHo",
        "outputId": "5e6c0fc9-4b7b-4378-baaf-a9eda156da0a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dinesh is a smart boy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Partition"
      ],
      "metadata": {
        "id": "nOhgxqX3ktrJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# parition means splitting with a particular word, the forward and backward words are in a string.\n",
        "name.partition(\"a\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X5j9wwVGkqzs",
        "outputId": "f9a0b2f2-e779-48c5-da94-819365c13f19"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('dinesh is ', 'a', ' smart boy')"
            ]
          },
          "metadata": {},
          "execution_count": 208
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Replace"
      ],
      "metadata": {
        "id": "Xf1VYPEAlTyA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Replacing the smart boy with nice guy.\n",
        "repl_name = name.replace(\"smart boy\",\"nice guy\")\n",
        "print(\"replaced the name :\", repl_name.capitalize())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "64lsK_Nmk5m-",
        "outputId": "67826705-1f4a-46d9-b92d-df89d04cfe41"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "replaced the name : Dinesh is a nice guy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* rfind"
      ],
      "metadata": {
        "id": "j_LqfjbInFS9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# difference between find and rfind \n",
        "print(\"rfind s: \",name.rfind(\"s\"))  # it checks the entire sentence and gives the last found indexing number\n",
        "\n",
        "# whenever it found the character it immediately gives us the index of that character without searching the entire sentence\n",
        "print(\"find s: \", name.find(\"s\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HR2JljQLlzbz",
        "outputId": "280e256a-852f-4292-d8f6-65bffe053667"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rfind s:  12\n",
            "find s:  4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* rindex"
      ],
      "metadata": {
        "id": "zzvqAPIjoWfg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# difference of rindex and index\n",
        "print(\"rindex of 'a':\", name.rindex('a'))\n",
        "print(name)\n",
        "# \n",
        "print(\"index of 'a': \", name.index('a'))\n",
        "print(name)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lgvGlNWtmYwv",
        "outputId": "51b953fd-7f5d-4fff-b8c5-5ea8e2ba5d58"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rindex of 'a': 14\n",
            "dinesh is a smart boy\n",
            "index of 'a':  10\n",
            "dinesh is a smart boy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* rpartition"
      ],
      "metadata": {
        "id": "2AzVspG2o8Y7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# diference between rpartition and partition\n",
        "print(\"rpartition of 'a':\\n \", name.rpartition('a'))\n",
        "print(name.center(27,\"*\"))\n",
        "print(\"partition of 'a':\\n\", name.partition('a'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qUwZZNAAotl8",
        "outputId": "69ff173d-8f71-4968-db41-c15e09f8a970"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rpartition of 'a':\n",
            "  ('dinesh is a sm', 'a', 'rt boy')\n",
            "***dinesh is a smart boy***\n",
            "partition of 'a':\n",
            " ('dinesh is ', 'a', ' smart boy')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* rsplit"
      ],
      "metadata": {
        "id": "rXgoX9Vqp6AU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# diference between rsplit and split\n",
        "print(\"rsplit of ' ':\\n \", name.rsplit(' '))\n",
        "print(\"split of ' ':\\n\", name.split(' '))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BoJAQpaqphB_",
        "outputId": "efce6ffd-8a1a-4e2f-ed25-1458952cf40e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rsplit of ' ':\n",
            "  ['dinesh', 'is', 'a', 'smart', 'boy']\n",
            "split of ' ':\n",
            " ['dinesh', 'is', 'a', 'smart', 'boy']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Swapcase"
      ],
      "metadata": {
        "id": "-583GiFjq28a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# If the input string is in small case it swaps the result to upper case.\n",
        "# If the input string is in upper case it swaps the result to lower case.\n",
        "name.swapcase()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "4r0L8FNFqOHS",
        "outputId": "27bfd91e-e96d-4139-eaa2-e3a31728dd40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'DINESH IS A SMART BOY'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 234
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "$$ Lists\\ Data\\ Type $$"
      ],
      "metadata": {
        "id": "zIOFo99M4WlC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [1,2,\"a\",\"b\",4]\n",
        "print(lst)"
      ],
      "metadata": {
        "id": "qSARN7dLsZZ2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "94547ca7-7b41-4ced-fdbc-ea766ebe3434"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 'a', 'b', 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# list is a heterogenous data\n",
        "het_lst = [1,2,\"ab\",\"re\",[2,34,45],(\"fjaj\",\"sadh\",223,34),{\"add\",\"addew\",1,2},{\"hash\":12,\"thar\":21}]\n",
        "print(het_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QuHJcUp64kQT",
        "outputId": "fc258b61-dcaf-441c-d91a-b68761a07335"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 'ab', 're', [2, 34, 45], ('fjaj', 'sadh', 223, 34), {1, 'add', 2, 'addew'}, {'hash': 12, 'thar': 21}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"list object: \",het_lst[2])\n",
        "print(\"list inside list: \", het_lst[4][2])\n",
        "print(\"tuple inside a list: \", het_lst[5][3])\n",
        "print(\"dictionary inside a list: \",het_lst[7]['hash'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gwuW9nQq49g0",
        "outputId": "d92b763c-fea4-4f7e-a167-7b7997a37156"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "list object:  ab\n",
            "list inside list:  45\n",
            "tuple inside a list:  34\n",
            "dictionary inside a list:  12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "* list functions"
      ],
      "metadata": {
        "id": "2zA7P6-U7ZAm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# adding the element using append method\n",
        "het_lst.append([1232,1222])\n",
        "print(het_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wqk1JdR56Pcd",
        "outputId": "0e244328-8a5d-43de-b4df-61b217335243"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 'ab', 're', [2, 34, 45], ('fjaj', 'sadh', 223, 34), {1, 'add', 2, 'addew'}, {'hash': 12, 'thar': 21}, [1232, 1222], [1232, 1222], [1232, 1222]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# removing the last element using remove method by mentioning the element\n",
        "het_lst.remove([1232,1222])\n",
        "print(het_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XOf1o2GE7jd-",
        "outputId": "38215934-311c-4f03-e09d-c6131369cd09"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 'ab', 're', [2, 34, 45], ('fjaj', 'sadh', 223, 34), {1, 'add', 2, 'addew'}, {'hash': 12, 'thar': 21}, [1232, 1222], [1232, 1222]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# removing the last element from list using pop\n",
        "het_lst.pop()\n",
        "print(het_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ufk3u-VO76Iu",
        "outputId": "1a38d092-9735-4745-9156-f142a5e5a032"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 'ab', 're', [2, 34, 45], ('fjaj', 'sadh', 223, 34), {1, 'add', 2, 'addew'}, {'hash': 12, 'thar': 21}, [1232, 1222]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# pop in list removes the last element from list.\n",
        "if het_lst[8][0]==1232:\n",
        "  het_lst.pop()\n",
        "else:\n",
        "  print(het_lst)"
      ],
      "metadata": {
        "id": "co-r6C9x7_7o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(het_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WjsiJpzG8Xu5",
        "outputId": "bed13e87-d4d2-44c2-afb6-2a1975b0812e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 'ab', 're', [2, 34, 45], ('fjaj', 'sadh', 223, 34), {1, 'add', 2, 'addew'}, {'hash': 12, 'thar': 21}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# reversing the list\n",
        "het_lst.reverse()\n",
        "print(het_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NmCyT3ZX8Z_r",
        "outputId": "b9472359-559d-455b-c929-38a3c44c79bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[{'hash': 12, 'thar': 21}, {1, 'add', 2, 'addew'}, ('fjaj', 'sadh', 223, 34), [2, 34, 45], 're', 'ab', 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# sorting the list \n",
        "lst = [1,2,344345,567,765,543,34,4]\n",
        "lst.sort()\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D56ug3gg9dJl",
        "outputId": "4445ee17-e5d1-45fe-d8fa-3acf75947d54"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 4, 34, 543, 567, 765, 344345]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# reversing the list\n",
        "lst.reverse()\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XVTaWjMP94D-",
        "outputId": "b8deddf1-e39e-4a1b-8dde-e67cf31d689c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[344345, 765, 567, 543, 34, 4, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# insert in lst using positional argument using indexing\n",
        "lst.insert(2,[23,32])\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PRsV9c9F-Vzc",
        "outputId": "8cd3b28f-acf6-44da-e110-d79bff3b42e5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[344345, 765, [23, 32], 567, 543, 34, 4, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# extend jut add elements not the data type of elements.\n",
        "lst.extend({\"12\":34,\"sd\":43})\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "38eeiEZe-u5L",
        "outputId": "9f1e505c-86f9-4fdc-9082-8071c9fb65a0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[344345, 765, [23, 32], 567, 543, 34, 4, 2, 1, '1', '2', 34, 43, 12, '12', 'sd']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# using for loop.\n",
        "ls = []\n",
        "for i in range(0,20):\n",
        "  ls.append(i)\n",
        "print(ls)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PMBELM1p-2Wk",
        "outputId": "6379c62e-8e72-49b4-849b-dafb093fc56e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# printing the even and odd numbers in the range of 20.\n",
        "even_lst =[]\n",
        "odd_lst = []\n",
        "for i in range(1,len(ls)):\n",
        "  if ls[i]%2==0:\n",
        "      even_lst.append(ls[i])\n",
        "  else:\n",
        "      odd_lst.append(ls[i])\n",
        "print(\"Even numbers: \\n\",even_lst)\n",
        "print(\"Odd numbers: \\n\",odd_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V9IB1MdW_o5T",
        "outputId": "fa6b0c15-70ea-4916-a0e6-7c40603b2e58"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Even numbers: \n",
            " [2, 4, 6, 8, 10, 12, 14, 16, 18]\n",
            "Odd numbers: \n",
            " [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "nTjH-HEzAITl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "$$ Tuple\\ Data\\ Type $$"
      ],
      "metadata": {
        "id": "6VeYB-vwBgOD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tp = 1,2,3,4,5,5,66,7,89,7\n",
        "tup = (12,23,34,4,5,56,67,76)\n",
        "print(\"without paranthesis: \\n\",tp)\n",
        "print(type(tp))\n",
        "print(\"with paranthesis: \\n\",tup)\n",
        "print(type(tup))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1PPZyYFyBmSn",
        "outputId": "e1967e40-2a4f-4739-c2c4-64b8692161b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "without paranthesis: \n",
            " (1, 2, 3, 4, 5, 5, 66, 7, 89, 7)\n",
            "<class 'tuple'>\n",
            "with paranthesis: \n",
            " (12, 23, 34, 4, 5, 56, 67, 76)\n",
            "<class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# count of tuple\n",
        "print(\"count of 3 :\",tp.count(3))\n",
        "print(\"count of 796 :\",tup.count(796))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cc8hO3f1BuAM",
        "outputId": "e694b22f-7d30-4dc3-c03e-87c8e4425b63"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "count of 3 : 1\n",
            "count of 796 : 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# index of tuple\n",
        "print(\"count of 3 :\",tp.index(3))\n",
        "print(\"count of 76 :\",tup.index(76))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AixyiYHECdyi",
        "outputId": "76c3141a-0f34-451d-8af9-f45cc6283ea0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "count of 3 : 2\n",
            "count of 76 : 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Intializing the two empty lists\n",
        "greater = []\n",
        "lesser = []\n",
        "# taking the n as input\n",
        "n=int(input())\n",
        "for i in range(len(tp)):\n",
        "  if tp[i]>n:\n",
        "    greater.append(tp[i])\n",
        "  else:\n",
        "    lesser.append(tp[i])\n",
        "print(\"greater than {}:\".format(n),greater)\n",
        "print(\"less than {} :\".format(n),lesser)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NywDhwBwCsZW",
        "outputId": "827425dd-27a4-4012-a109-748c8cd42cb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "50\n",
            "greater than 50: [66, 89]\n",
            "less than 50 : [1, 2, 3, 4, 5, 5, 7, 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "64PhsGJQDR3U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "$$ Dictionary\\ Data\\ Types $$"
      ],
      "metadata": {
        "id": "6GRx8j4DFmc8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# The key of \"r\" is having twice and the latest key value is ubdated the old \"r\" value.\n",
        "dic = {\"a\":1,\"s\":3,\"r\":5,\"r\":65}\n",
        "print(dic)\n",
        "print(type(dic))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J7x3K8ANFrLO",
        "outputId": "ba7fbe1f-cb40-4d25-fd84-e7a4ff992995"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'a': 1, 's': 3, 'r': 65}\n",
            "<class 'dict'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "$ Methods $"
      ],
      "metadata": {
        "id": "gRNvDb75GSbK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# when we print the dictionary keys we get keys from dictionary with list of keys\n",
        "keys = dic.keys()\n",
        "print(\"keys of dictionary: \",keys)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aGWHJ4uvF53r",
        "outputId": "7b4ffbd4-6f99-40c7-aeab-1c62fce6a276"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "keys of dictionary:  dict_keys(['a', 's', 'r'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# when we print the dictionary keys we get values from dictionary with list of values.\n",
        "values = dic.values()\n",
        "print(\"values of dictionary:\",values)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tlvZBF7VGfn6",
        "outputId": "41acd2fe-a3ba-4266-c934-d5a0c7aaf855"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "values of dictionary: dict_values([1, 3, 65])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# seq − This is the list of values which would be used for dictionary keys preparation.\n",
        "\n",
        "# value − This is optional, if provided then value would be set to this value\n",
        "key = dic.fromkeys(\"a\",98)\n",
        "print(\"keys values of s:\",key)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3ok2ImMuG2Lk",
        "outputId": "48c23500-cc51-4e59-d4f4-69bac5746f95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "keys values of s: {'a': 98}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "item = dic.items()\n",
        "print(\"key value pair in tuple:\",item)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sJ3xGDBXHa5-",
        "outputId": "343e3fa0-253b-456e-e872-ad8c4c5c299a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "key value pair in tuple: dict_items([('a', 1), ('s', 3), ('r', 65)])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pop_items = dic.popitem()\n",
        "print(\"pop items:\", pop_items)\n",
        "print(dic)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jCyTzakiIgl8",
        "outputId": "281fdad5-6ad8-4ef9-d2e3-14df57e2c9ae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pop items: ('r', 65)\n",
            "{'a': 1, 's': 3}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pop_values = dic.pop(\"a\")\n",
        "print(\"removing the key value pair:\",pop_values)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7Ika_lJkIynQ",
        "outputId": "577c7935-0805-4007-f524-5c28a5183d47"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "removing the key value pair: 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"remaining keyvalue pair in dictionary:\",dic)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eqYRGpYmJClx",
        "outputId": "e3ab0213-d832-4390-df50-920209c18836"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "remaining keyvalue pair in dictionary: {'s': 3}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "hW5naKD4Jaah"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "$$ Set\\ Data\\ Type $$"
      ],
      "metadata": {
        "id": "8CyHe4ccJoyM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sets = {1,2,34,5,56,5,34,32,45,\"asf\"}\n",
        "print(\"Unions:\",sets)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PuDThu4oJvIR",
        "outputId": "1c355d9f-a73e-4c93-b551-89e18c4291fc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Unions: {32, 1, 2, 34, 5, 45, 56, 'asf'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sets.add(656)\n",
        "print(\"add element to set:\",sets)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cV_z4EjeJ6Ya",
        "outputId": "dcb45336-bfc3-4bd4-ec1a-f4652d4f33a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "add element to set: {32, 1, 2, 34, 5, 45, 656, 56, 'asf'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sets1 = {12,34,45,56,671,1,78,8}\n",
        "s=sets.difference(sets1)\n",
        "print(\"difference between 2 sets:\",s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u4FcvN0zL3pQ",
        "outputId": "c583de79-301b-4f3f-847c-ca2fb106ceb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "difference between 2 sets: {32, 2, 'asf', 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Returns the symmetric difference of two sets as a new set\n",
        "s1=sets.symmetric_difference(sets1)\n",
        "print(\"sym_difference between 2 sets:\",s1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X-a0tW6YMQwB",
        "outputId": "89c5ddd5-5c7b-4c6c-d484-945d18e28879"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sym_difference between 2 sets: {32, 2, 5, 8, 12, 78, 'asf', 671}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The update() method accepts lists, strings, tuples as well as other sets as its arguments. In all of these cases, duplicate elements are avoided.\n",
        "# difference ubdate Removes all elements of another set from this set\n",
        "# intersection Returns the intersection of two sets as a new set\n",
        "# Updates the set with the intersection of itself and another\n",
        "# isdisjoint Returns True if two sets have a null intersection\n",
        "# issubset Returns True if another set contains this set\n",
        "# issuperset Returns True if this set contains another set\n",
        "# Updates a set with the symmetric difference of itself and another --> symmetric differrence update"
      ],
      "metadata": {
        "id": "hOPXlbp8Ml0u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Removes all elements of another set from this set\n",
        "diff_sets1 = {12,23,34,45,56,2}\n",
        "diff_sets2 = {23,34,43,54,55,4}\n",
        "s2=diff_sets1.difference_update(diff_sets2)\n",
        "print(\"difference update:\",s2)\n",
        "print(sets,sets1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nyyeO4v6OS07",
        "outputId": "087b5228-b57b-44b3-c592-cad5e35b23d6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "difference update: None\n",
            "set() {1, 34, 8, 12, 45, 78, 56, 671}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Returns the intersection of two sets as a new set\n",
        "s3=sets.intersection(sets1)\n",
        "print(\"intersection of 2 sets\",s3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5_nxFK7YOqyr",
        "outputId": "50cb25f4-54fc-48bd-a80b-688614dce87e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "intersection of 2 sets set()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sets2 = {1,2,3,4,5,6,5}\n",
        "sets3 = {12,23,1,23,3,4}\n",
        "s4 = sets2.difference(sets3)\n",
        "print(\"intesection update:\",s4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dYmzUdxwPINO",
        "outputId": "e1f707fe-b45b-4c4d-ddf5-7732b90891b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "intesection update: {2, 5, 6}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s5 = sets2.symmetric_difference(sets3)\n",
        "print(s5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XUlmsb33PrOb",
        "outputId": "fd6e3e65-a4e8-4218-d1de-fb6dba2f58be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{2, 5, 6, 23, 12}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "blnseddEQDQl"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}