Python Notebooks/Python_Fundamentals_Datatypes.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python_Fundamentals - Datatypes.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## Datatypes in Python"
      ],
      "metadata": {
        "id": "beSf5W1vT6AT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In python everything is an object where datatypes are their respective classes. It describes the kind of value that tells what operations can be performed on these particular data.\n",
        "Python has many build in datatypes like `integer`, `float`, `string`, `boolean`, `string`, `list` etc.. lets checkout the various datatypes in Python \n",
        "\n",
        " "
      ],
      "metadata": {
        "id": "3DMxVbIGRq9S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Numerical DataTypes"
      ],
      "metadata": {
        "id": "4Q5IbNuZT2gP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Integer Datatype\n",
        "\n",
        "\n",
        "Integer datatype represents numbers without decimal points.\n",
        "\n",
        "eg: 10, -2, 3, 5"
      ],
      "metadata": {
        "id": "ToYPF01KTEv5"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CXd-TzfxEBsP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8245e387-fe2a-4e52-a67e-e39af51418e0"
      },
      "source": [
        "#you can check the datatype of a variable using the function `type`\n",
        "\n",
        "x = 4 \n",
        "y = -5\n",
        "print(type(x), type(y))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'int'> <class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Float Datatype\n",
        "\n",
        "They respresents real numbers i.e, numbers with decimal points\n",
        "\n",
        "eg: 3.3, -5.0, 6"
      ],
      "metadata": {
        "id": "qBhhC-4WT_2T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 3.0\n",
        "y = 5.4\n",
        "z = -7.0\n",
        "\n",
        "print(type(x), type(y), type(z))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sgcn-JP4Tikr",
        "outputId": "3db01087-1781-4158-c2bb-3abd46ef63d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'float'> <class 'float'> <class 'float'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Complex Numbers\n",
        "\n",
        "Complex numbers are numbers with both real and imaginery parts. The imaginery part is represented by `j` along with number."
      ],
      "metadata": {
        "id": "anYSgBoOMdJD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 2 + 3j\n",
        "f = 5.0j\n",
        "\n",
        "print(type(x), type(f))"
      ],
      "metadata": {
        "id": "_isGq7E8Uq8M",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4cab5009-ed4a-4749-891b-920a72721cb7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'complex'> <class 'complex'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Sequence Datatype\n",
        "\n",
        "Ordered collections of similar or unsimilar datatypes is called sequence datatype. It allows us to store elements efficiently in an ordered manner.\n",
        "\n",
        "* List\n",
        "* Tuples\n",
        "* Strings \n",
        "\n",
        "are the common sequence datatypes in Python."
      ],
      "metadata": {
        "id": "4rNPK81nNGeJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####List \n",
        "\n",
        "* List is an ordered collection of data.\n",
        "* Elements in a list can be of different dataypes.\n",
        "* The values in a list can be changed.  i.e, mutable"
      ],
      "metadata": {
        "id": "PG0kredGNxoB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# List can be created putting a sequence in a square bracket\n",
        "lst = []\n",
        "print(lst)\n",
        "\n",
        "lst = [0, 2, 3, 4]\n",
        "print(lst)\n",
        "\n",
        "lst = [\"Hello\", \"Python\"]\n",
        "print(lst)\n",
        "\n",
        "lst = [\"Hello\", \"Python\", 3]\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S9_Ej_4qM-1Q",
        "outputId": "1a7abafb-20d7-497a-e363-e59a1686e2b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n",
            "[0, 2, 3, 4]\n",
            "['Hello', 'Python']\n",
            "['Hello', 'Python', 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Elements in a list can be accessed using the index number.The indices starts from 0. The negative numbers as index the elements from the end."
      ],
      "metadata": {
        "id": "gh2oKXsDYRLQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [1, 2, 'Techno', 4, 'For', 6, 'Life']\n",
        "print(lst[2]) # prints the 3rd element in the  array\n",
        "\n",
        "print(lst[-1]) #prints the  last elements in the array"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qdLCJdgXYPzY",
        "outputId": "b2803e67-ea59-406b-d099-4aa5715b1263"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Techno\n",
            "Life\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The length of a list can be found using the function len()"
      ],
      "metadata": {
        "id": "cW4dTscLZ9kn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(lst)) #returns the number of elements in the list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X16D9kTnZQS1",
        "outputId": "cd7bd255-4853-4f18-cde2-1de922a89d63"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Adding Elements to The List\n",
        "\n",
        "New elements can be added to list using the following methods...\n",
        "* `append()` : Adds one element at a time to the end of a list. For adding multiple elements you need to use a loop\n",
        "\n",
        "* `extend()` : Can be used to add multiple elements to the end of a list at the sametime.\n",
        "\n",
        "* `insert()` : Can be used to add element at the desired position of a list.\n"
      ],
      "metadata": {
        "id": "tsSCbEc6aRLn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst.append(\"Everyone\") # adds element to the last\n",
        "print(lst)\n",
        "\n",
        "lst.extend(\"7\") #The input needs to be an iterable\n",
        "print(lst)\n",
        "\n",
        "lst.extend([\"Enlarge\", 8])\n",
        "print(lst)\n",
        "\n",
        "lst.insert(1, \"Human\") # contains 2 arguments first argument is position, second argument - value\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "emLRfi_1aQSK",
        "outputId": "6137f711-6308-4403-8051-ff7b39507e58"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 'Techno', 4, 'For', 6, 'Life', 'Everyone']\n",
            "[1, 2, 'Techno', 4, 'For', 6, 'Life', 'Everyone', '7']\n",
            "[1, 2, 'Techno', 4, 'For', 6, 'Life', 'Everyone', '7', 'Enlarge', 8]\n",
            "[1, 'Human', 2, 'Techno', 4, 'For', 6, 'Life', 'Everyone', '7', 'Enlarge', 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Removing Elements from List\n",
        "\n",
        "`remove()` : The remove function can be used to remove first occurance of the element in the list. It raises an error if an element is not present in the list.\n",
        "\n",
        "`pop()` : function can be used to remove and return the element but by default it removes only the last element of the set. You can give index of element to pop function to remove the element at paricular position.\n",
        "\n",
        "`del` : keyword can be used to delete the indexed element in the list\n"
      ],
      "metadata": {
        "id": "j3zwTS6zg9tP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst.remove(\"Everyone\")\n",
        "print(lst)\n",
        "\n",
        "lst.pop()\n",
        "print(lst)\n",
        "\n",
        "lst.pop(-2)\n",
        "print(lst)\n",
        "\n",
        "del lst[-1]\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xGPgPbKgdZTG",
        "outputId": "82079cc9-7054-41ce-da42-003de3335cc4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 'Human', 2, 'Techno', 4, 'For', 6, 'Life', '7', 'Enlarge', 8]\n",
            "[1, 'Human', 2, 'Techno', 4, 'For', 6, 'Life', '7', 'Enlarge']\n",
            "[1, 'Human', 2, 'Techno', 4, 'For', 6, 'Life', 'Enlarge']\n",
            "[1, 'Human', 2, 'Techno', 4, 'For', 6, 'Life']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can use `in` and `not in` to check the presence of an element in a sequence."
      ],
      "metadata": {
        "id": "zin0luTQlLMA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Techno\" in lst)\n",
        "\n",
        "print(\"Techno\" not in lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pPzEBnJIkwFm",
        "outputId": "6c4d175a-6aad-454e-bded-c7c2e275c3f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Sorting Elements in a Lists\n",
        "\n",
        "Sorting refers to the arranging of elements in an List in the increasing or decreaseing  order. Following methoda are used for sorting the elements in a list\n",
        "\n",
        "`sorted(lst)`, `lst.sort()`"
      ],
      "metadata": {
        "id": "skLXPe-po7IA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [5, 0, 3, 7, 9, 2]\n",
        "\n",
        "# returns a sorted array while keeing the original array intact\n",
        "print(sorted(lst))\n",
        "# arrange list in reverse order\n",
        "print(sorted(lst, reverse = True))\n",
        "\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "\n",
        "# Arranges the original list in increasing order\n",
        "lst.sort()\n",
        "print(lst)\n",
        "# Arrange the lst in reverse order\n",
        "lst.sort(reverse = True)\n",
        "print(lst)"
      ],
      "metadata": {
        "id": "F5G1s_LpliEz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3e6fe0d6-7d9a-4adc-f38b-9bbaa54f9dc5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 2, 3, 5, 7, 9]\n",
            "[9, 7, 5, 3, 2, 0]\n",
            "\n",
            "\n",
            "[0, 2, 3, 5, 7, 9]\n",
            "[9, 7, 5, 3, 2, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### List Slicing\n",
        "\n",
        "Slicing of a list is performed to get elements in a particular range.."
      ],
      "metadata": {
        "id": "QtMWy9TlsJQV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(lst[:]) #prints the entire list\n",
        "\n",
        "print(lst[2:]) #print elements from index 2 to the end\n",
        "\n",
        "print(lst[:4]) # print the elements from beginning till index 4 (not including it)\n",
        "\n",
        "print(lst[2:5]) #print from the second index element till the 5th index (not including it)\n",
        "\n",
        "print(lst[::-1]) #print elements in the reverse order"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o_y_apGEp7gb",
        "outputId": "3c82bb01-5479-4a66-f197-491fc2160527"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[9, 7, 5, 3, 2, 0]\n",
            "[5, 3, 2, 0]\n",
            "[9, 7, 5, 3]\n",
            "[5, 3, 2]\n",
            "[0, 2, 3, 5, 7, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#looping in alist\n",
        "\n",
        "print(\"First method\")\n",
        "for i  in lst:\n",
        "  print(i,)\n",
        "\n",
        "print(\"\\n\")\n",
        "print(\"The second method\")\n",
        "for i in range(len(lst)):\n",
        "  print(lst[i])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vkekGoUDuFXT",
        "outputId": "9a357047-68ae-4f84-92c3-a6e74f7cc81b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First method\n",
            "9\n",
            "7\n",
            "5\n",
            "3\n",
            "2\n",
            "0\n",
            "\n",
            "\n",
            "The second method\n",
            "9\n",
            "7\n",
            "5\n",
            "3\n",
            "2\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### List Comprehension\n",
        "\n",
        "Creating a new list from a sequence"
      ],
      "metadata": {
        "id": "cw7bKi66t7Ja"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nwlst = [i for i in lst]\n",
        "print(nwlst)\n",
        "\n",
        "nwlst = [i for i in lst if i > 2]\n",
        "print(nwlst)\n",
        "\n",
        "nwlst = [i+1 for i in lst if i >2]\n",
        "print(nwlst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D3FmBzBAtQok",
        "outputId": "990fb5d5-1c33-4399-d979-1a1aefe43b67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[9, 7, 5, 3, 2, 0]\n",
            "[9, 7, 5, 3]\n",
            "[10, 8, 6, 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Tuples\n",
        "\n",
        "Tuples are similar to list in the manner that tuples are used to store multiple values in a single variable and is ordered. The major difference between list and tuples is that tuples are **immutable** i.e, the values in tuples are unchangeable.Tuples are created using `()` in python."
      ],
      "metadata": {
        "id": "qF2kce2Hsywk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = ()\n",
        "print(t)\n",
        "\n",
        "t = ('Adam', 'Joan', 3)\n",
        "print(t)"
      ],
      "metadata": {
        "id": "JSIvS2f2vMV5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ef9a58cb-e9db-4d13-ee00-5162a91d57bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "()\n",
            "('Adam', 'Joan', 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Single string tuple without coma is considered as type string..."
      ],
      "metadata": {
        "id": "T-tFri5KvcLd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = ('Adam')\n",
        "print(type(t))\n",
        "\n",
        "t = ('Adam',)\n",
        "print(type(t)) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PjSslsbtvZ9o",
        "outputId": "55c94227-dfb4-47e4-c09f-707074a8783b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "<class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Elements in a tuple can be accessed using the index of the element using `[]`. "
      ],
      "metadata": {
        "id": "mR2hYRanv8_N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = (0, 'techno', 3, 'mad', 4, 'lyf', 5, 'forever')\n",
        "print(t[4])\n",
        "\n",
        "print(t[-1]) # prints the last elements"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7Dh1a0nuvzjp",
        "outputId": "445a6bc4-4fde-406f-b98d-51e6a2ba6232"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "forever\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Length Of a Tuple\n",
        "\n",
        "Similar to a list you can find the length of a tuple using the function `len()`"
      ],
      "metadata": {
        "id": "B2o1c1WnsIL9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(t))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O-6W2O1csWfj",
        "outputId": "33cac38a-b667-438b-a152-a9d417e7c5ab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Changing or Deleting Element In A Tuple\n",
        "\n",
        "Since tuples are immutable we cannot change the values inside the tuple. Lets go through examples... "
      ],
      "metadata": {
        "id": "kBctHiERpXfT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t[1] = \"Raghu\""
      ],
      "metadata": {
        "id": "6K6aI5lZwqbG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "outputId": "8de8739f-e249-4f7d-d8b5-55c2c41e52ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-2-69beee5fcc0e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Raghu\"\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": "markdown",
      "source": [
        "If there are mutable elements in a tuple you can change the values inside it"
      ],
      "metadata": {
        "id": "rGx_nDaFp3xx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tple = (0, 1, 3, [2, 4, 5])\n",
        "tple[3][2] = 9\n",
        "\n",
        "#You can notice here the value 5 in  list is changed to 9\n",
        "print(tple)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hG3zshk8p2PX",
        "outputId": "76d4f555-4a47-4f16-eef5-723e4f5e2d18"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0, 1, 3, [2, 4, 9])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Eventhough you cannot elements in a tuple you can delete the tuple as a whole using the `del`  function"
      ],
      "metadata": {
        "id": "RhP6A4Rers14"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "del tple\n",
        "print(tple)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 182
        },
        "id": "yFpleCUBqDmf",
        "outputId": "3e934462-536d-4f82-e110-dd61a36131fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-11-89203d076ac3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mtple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'tple' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Slicing A Tuple\n",
        "\n",
        "You can get the elements of a tuple in particular range by slicing the tuple. Slicing in Tuple is very similar to that in lists."
      ],
      "metadata": {
        "id": "w5qupO0atIrP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = (0, 'techno', 3, 'mad', 4, 'lyf', 5, 'forever')"
      ],
      "metadata": {
        "id": "A9bdsJ65uEsf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(t[:]) #prints the entire tuple\n",
        "\n",
        "print(t[2:]) #print elements from index 2 to the end\n",
        "\n",
        "print(t[:4]) # print the elements from beginning till index 4 (not including it)\n",
        "\n",
        "print(t[2:5]) #print from the second index element till the 5th index (not including it)\n",
        "\n",
        "print(t[::-1]) #print elements in the reverse order"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wFTzhpCUrmdw",
        "outputId": "4a6642ed-8063-4a02-f030-aa3d9aadcce1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0, 'techno', 3, 'mad', 4, 'lyf', 5, 'forever')\n",
            "(3, 'mad', 4, 'lyf', 5, 'forever')\n",
            "(0, 'techno', 3, 'mad')\n",
            "(3, 'mad', 4)\n",
            "('forever', 5, 'lyf', 4, 'mad', 3, 'techno', 0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Sorting a Tuple\n",
        "\n",
        "You can use the `sorted()` function to return a new sorted tuple."
      ],
      "metadata": {
        "id": "3O4eVod7uWKT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = [5, 0, 3, 7, 9, 2]\n",
        "\n",
        "new_t = sorted(t)\n",
        "# returns a sorted tuple while keeing the original array intact\n",
        "print(new_t)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rliEuSYwuJ5d",
        "outputId": "422a6af4-2024-46ac-ada3-dcec8290770b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 2, 3, 5, 7, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Strings\n",
        "\n",
        "Strings are one of the most popular datatypes in python. Strings are collection of characters enclosed in `'a'`, `\"a\"`, `'''a'''`, `\"\"\"a\"\"\"`. The characters are encoded in unicode."
      ],
      "metadata": {
        "id": "j1KoirnO6YoT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Creating a String\n",
        "You can create a string by putting characters inside `''` ,`\"\"` . `''''''`\n"
      ],
      "metadata": {
        "id": "6nwe5GhqAJvN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st = \"Hey Techno\" \n",
        "print(st)\n",
        "\n",
        "st = 'Hey you'\n",
        "print(st)\n",
        "\n",
        "st = '''Good job Learning'''\n",
        "print(st)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5jDvRuWqGkVI",
        "outputId": "f49f4f07-562a-4b36-fe19-7dab384254bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hey Techno\n",
            "Hey you\n",
            "Good job Learning\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Accessing the Elements in a String\n",
        "\n",
        "You can access elements in any sequence data type using `[]`.\n",
        "\n"
      ],
      "metadata": {
        "id": "rJvzCuZoHSSz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st = \"Hello all lets learn python\"\n",
        "\n",
        "print(st[0])\n",
        "\n",
        "print(st[5]) # prints space"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z4iyncaJHGB3",
        "outputId": "598e28fe-6677-46b3-fedc-896e9bab29c4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "H\n",
            " \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can find the length of a string using the function `len()`"
      ],
      "metadata": {
        "id": "QKFiSScjP_RQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(st)) # prints the total number of characters including space"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7j1p_tMkP4l_",
        "outputId": "1887fde5-0a07-403d-9aaa-d05dff9f176c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "27\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Slicing Strings\n",
        "\n",
        "You can separate out sub strings in particular range by slicing the string."
      ],
      "metadata": {
        "id": "ztCEbYDpSALg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(st[:]) #prints the entire string\n",
        "\n",
        "print(st[2:]) #print elements from index 2 to the end\n",
        "\n",
        "print(st[:4]) # print the elements from beginning till index 4 (not including it)\n",
        "\n",
        "print(st[2:5]) #print from the second index element till the 5th index (not including it)\n",
        "\n",
        "print(st[::-1]) #print elements in the reverse order"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rWAxN1QHQKMg",
        "outputId": "c714e6c6-6165-4fb5-a255-dcd1e983838e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello all lets learn python\n",
            "llo all lets learn python\n",
            "Hell\n",
            "llo\n",
            "nohtyp nrael stel lla olleH\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Changing Values in Strings\n",
        "\n",
        "Strings are immutable datatype ie, you cannot change the elements in a string"
      ],
      "metadata": {
        "id": "FpkP2WtGSjnN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st[0] = 'h'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "dMLJUaDeSd7s",
        "outputId": "c8019d3a-90c5-49da-896a-81f610c3fadd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-4965ba32a45a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mst\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'h'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You cannot delete the elements in strings but can delete the string as a whole"
      ],
      "metadata": {
        "id": "fSQ5OUoWVVbh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "del st[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "kLl2a28mVOTN",
        "outputId": "d8711c8d-315f-430c-d336-0700ae7d03df"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-7-4d5fabdf2f38>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mst\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: 'str' object doesn't support item deletion"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "del st"
      ],
      "metadata": {
        "id": "4zdo8VVyYd_P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(st)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "U8f9a-UFYi_1",
        "outputId": "a4d3ade9-6552-46d1-f566-e4d18da14ada"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-9-7906f3753e9a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mst\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'st' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can concatenate string using `+`"
      ],
      "metadata": {
        "id": "rQP_i62-Y8cu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st1 = \"Hello\"\n",
        "st2 = \" Techno\"\n",
        "print(st1 + st2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KUhv_SpKYliW",
        "outputId": "85c4c10a-5778-4b3e-8387-3d225f34b6e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Techno\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "There  many methods in string for modifying the strings"
      ],
      "metadata": {
        "id": "bW_lAA5WZPsO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(st1.lower()) # converts string to lower case\n",
        "print(st1.upper()) # converts string to upper case\n",
        "print(st1.replace(\"e\",\"a\")) # replaces  'e' with 'a'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KFXgFvRYZL48",
        "outputId": "deba4438-9a9f-4769-e904-d06b6dc75f52"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n",
            "HELLO\n",
            "Hallo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "st = \"Hello Techno\"\n",
        "print(st.split()) # splits at space and returns list\n",
        "\n",
        "print(st.split(\"e\")) #splits at 'e' and returns a list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M8Z8ML3xZ-ey",
        "outputId": "40c1787c-823b-4ed2-ecdf-65b9c5a27d36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Hello', 'Techno']\n",
            "['H', 'llo T', 'chno']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Dictionaries\n",
        "\n",
        "It is an unordered collection of elements.It is stored in pairs containing `key : value` pairs. Unlike sequqnces dictionaries are indexed using the keys. The keys in dictionary should be unique i.e, there shouldnot be any duplicates.\n",
        "\n",
        "Keys are created using `{}`\n",
        "\n"
      ],
      "metadata": {
        "id": "IQxy6go1Lh9I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#here name, Username, age are keys\n",
        "# Techno , Technomad, ? are values\n",
        "dct = {\"name\": \"Techno\", \"Username\": \"Technomad\", \"age\":\"?\"} \n",
        "print(dct)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qQ4t_cfR7AY5",
        "outputId": "d426130c-7a57-4f0f-cda2-44f9856820dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Techno', 'Username': 'Technomad', 'age': '?'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The elements in a dictionary can be accessed using the key-value"
      ],
      "metadata": {
        "id": "mVxp2unt83Qh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(dct['Username']) "
      ],
      "metadata": {
        "id": "kbDcu3nOaFFY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "16411f76-5206-4f71-82e9-12ea361de7c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Technomad\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "you can also use `.get('key')` to get the values the advantage is that it will not return error if the key is not available in the dictionary"
      ],
      "metadata": {
        "id": "3Wm5Z-z19bPh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(dct['Userage']) # Returns error"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "bdT8sBTB9QzG",
        "outputId": "438a7615-ce63-418c-d9af-792efa11fd3a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-4-32f2a16035ff>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdct\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Userage'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 'Userage'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(dct.get('Username'))\n",
        "print(dct.get('Userage')) # will return None by default you can change it if you want\n",
        "print(dct.get('Userage', '23')) # will return 23 if the key is not in the dictionary"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jNY4_veM9xkT",
        "outputId": "f7b71bd2-3b9b-4476-9375-f1e119918f24"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Technomad\n",
            "None\n",
            "23\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dictionaries are mutable. i.e, we can change the values in a dictionary."
      ],
      "metadata": {
        "id": "uFVGhgGfG92H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dct[\"name\"] = \"Raj\" # changing values in a dictionary\n",
        "print(dct)\n",
        "\n",
        "dct[\"Userage\"] = 22 # Adding new element to the dictionary\n",
        "print(dct)"
      ],
      "metadata": {
        "id": "W9Pc8rUp98-D",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "880e42a1-3f3a-42d6-83fb-bac804051869"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Raj', 'Username': 'Technomad', 'age': '?'}\n",
            "{'name': 'Raj', 'Username': 'Technomad', 'age': '?', 'Userage': 22}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The length of a dictionary"
      ],
      "metadata": {
        "id": "Xqbv19hIHnfK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(dct)) # number key - value pairs in dictionary"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rBkxJ6c9HUBg",
        "outputId": "23c8e73c-1b5c-4b83-f076-1eb7675be21b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Deleting the Elements in a Dictionary"
      ],
      "metadata": {
        "id": "wxenBIfsKd-D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "del dct['Userage'] #deletes the particular element in the dictionary\n",
        "print(dct)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZCx6JouXHts6",
        "outputId": "23e4a664-ca47-4272-f160-546f712d80bd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Raj', 'Username': 'Technomad', 'age': '?'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dct.pop('age') # delets and returns the delered value"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "XP5kkOHaKucM",
        "outputId": "3c1d22fe-4820-456f-db2b-e5153a176aed"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'?'"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(dct)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DldJpR6mK9JO",
        "outputId": "0abe1ac4-f6e8-4158-83df-d3690e731b85"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Raj', 'Username': 'Technomad'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dct.popitem() # deletes an randomitem\n",
        "print(dct)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jL81UpqdK_Rj",
        "outputId": "961f207f-6170-428f-abf8-383889727e51"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Raj'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dct['Username'] = 'Technomad'\n",
        "print(dct)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KJn80vMvLhni",
        "outputId": "f0f07664-67f7-4fb2-cb12-c3364414dcc1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Raj', 'Username': 'Technomad'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dct.clear() #clears the entire dictionary"
      ],
      "metadata": {
        "id": "7C4ogqOqLTpF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(dct)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V7SzY5H3Lp3i",
        "outputId": "e17de56e-b874-4a78-d8eb-3919396235ec"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "del dct # deletes the dictionary from the memory\n",
        "print(dct)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 182
        },
        "id": "cwnpT4AFLr0q",
        "outputId": "a3d8ac25-c63c-4164-f36d-36ff4367cb84"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-23-8aa615dbeea1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mdct\u001b[0m \u001b[0;31m# deletes the dictionary from the memory\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdct\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'dct' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Some built-in functions dictionary"
      ],
      "metadata": {
        "id": "uzVpxCxbMsgl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dct = {\"name\": \"Techno\", \"Username\": \"Technomad\", \"age\":\"?\"} \n",
        "print(dct.items()) #returns key-value as list of tuples"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j_dEKliJL48Z",
        "outputId": "c53642fd-64de-4e2e-d04f-a579a866b1f7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_items([('name', 'Techno'), ('Username', 'Technomad'), ('age', '?')])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(dct.keys()) # returns list of keys"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "InQrgZTdQJR6",
        "outputId": "fdd95f11-6272-48a7-f31a-2b16a828a477"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_keys(['name', 'Username', 'age'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(dct.values()) # returns the list of values"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "61cCIlsNQSj0",
        "outputId": "5930aa8b-ddb3-4c58-f71d-61cad6fa6295"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_values(['Techno', 'Technomad', '?'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "These functions can be used to loop through inside the keys and values of dictionary"
      ],
      "metadata": {
        "id": "TtMCX9RtQdKS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in dct.keys():\n",
        "  print(i +':'+dct[i]) # prints key and values"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6GE_-4FLQc-k",
        "outputId": "a48a1582-751a-4459-aad4-d4f0faba03ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name:Techno\n",
            "Username:Technomad\n",
            "age:?\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Sets\n",
        "\n",
        "Sets are unordered collection of items. Sets are mutabe and donot contain any dupicates. Since sets are unordered you cannot access elements using their indices.\n",
        "\n",
        "Sets are created using `{}`."
      ],
      "metadata": {
        "id": "AJEaPpm3Mek4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st = {}\n",
        "print(st)\n",
        "\n",
        "\n",
        "st = {\"apple\", \"banana\", \"mango\", \"apple\"}\n",
        "print(st) #here you can see the repeated apple is not stored in memory"
      ],
      "metadata": {
        "id": "KtxSzAt3QsI7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c74c907-2c21-446d-facf-f11d3e4cbec4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{}\n",
            "{'banana', 'mango', 'apple'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "M8ZlfAuao4-Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can get the length of set using `len()`"
      ],
      "metadata": {
        "id": "FL-ZwvGnebKN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(st))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mr3N7M36d-fR",
        "outputId": "f89d7251-9ef9-4302-8060-10f7c54dbaa0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Adding Elements to a Set\n",
        "\n",
        "You can add elements to a set using `.add()` function. You can also add elements from other iterables to set using `.update()` function "
      ],
      "metadata": {
        "id": "faznI4CWer52"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st.add('orange')\n",
        "print(st)\n",
        "\n",
        "st.update(['jackfruit','guava'])\n",
        "print(st)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zUKtIJjyekT6",
        "outputId": "75158732-0e5f-4136-f9e2-78a04feedec0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'banana', 'mango', 'apple', 'orange'}\n",
            "{'mango', 'orange', 'guava', 'jackfruit', 'banana', 'apple'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Removing Elements from a Set\n",
        "\n",
        "You can delete elements in a set using the following methods\n",
        "\n",
        "`.discard()` - removes value from set, doesnot raises error if the value is not in the set.\n",
        "\n",
        "`.remove()` - removes value from set,  raises error if the value is not present.\n",
        "\n",
        "`.pop()` - removes a random element\n",
        "\n",
        "`.clear()` - removes all the elements from the set"
      ],
      "metadata": {
        "id": "vQDYmdfrgkP8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st.discard(\"mango\")\n",
        "print(st)\n",
        "\n",
        "st.remove('guava')\n",
        "print(st)\n",
        "\n",
        "st.pop()\n",
        "print(st)\n",
        "\n",
        "st.clear()\n",
        "print(st)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k3m5bMf_gEaz",
        "outputId": "3cc44a12-74ed-4102-d99e-de73e35a7d93"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'orange', 'guava', 'jackfruit', 'banana', 'apple'}\n",
            "{'orange', 'jackfruit', 'banana', 'apple'}\n",
            "{'jackfruit', 'banana', 'apple'}\n",
            "set()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "st.remove('guava') # error"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "ZyppfDLhkhap",
        "outputId": "1a5dbb3a-48a9-4109-f19a-fbadfa1914b9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-d4a7a1e64fd5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mst\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'guava'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 'guava'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "st.discard('guava') #no error"
      ],
      "metadata": {
        "id": "FqPPoixDk0TZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Set Operations"
      ],
      "metadata": {
        "id": "1El_36CWlFp6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st1 = {0, 1, 2, 3, 4}\n",
        "st2 = {3, 4, 5, 6, 7, 8}\n",
        "\n",
        "# Union \n",
        "# return elements in st1 and st2 without duplicate\n",
        "print(st1|st2) \n",
        "print(st1.union(st2))\n",
        "\n",
        "# Intersection\n",
        "# returns elements present in both st1 and st2 without duplicates\n",
        "print(st1 & st2)\n",
        "print(st1.intersection(st2))\n",
        "\n",
        "# Difference\n",
        "# elements in first set but not in second set\n",
        "print(st1 - st2)\n",
        "print(st1.difference(st2))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bmULVgN2k3Px",
        "outputId": "d573f7f3-d16c-4667-c529-e3307a45013f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{0, 1, 2, 3, 4, 5, 6, 7, 8}\n",
            "{0, 1, 2, 3, 4, 5, 6, 7, 8}\n",
            "{3, 4}\n",
            "{3, 4}\n",
            "{0, 1, 2}\n",
            "{0, 1, 2}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Frozen sets\n",
        "\n",
        "These are immutable sets. It remains same after its creation"
      ],
      "metadata": {
        "id": "3BSG9M7wpVQz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frzn_st = frozenset([\"Techno\", \"mad\", \"lyf\"])\n",
        "print(frzn_st)\n",
        "\n",
        "frzn_st.add(\"forever\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "id": "-nFkXbQeorrW",
        "outputId": "0a71d0f0-eda5-4989-ebd4-3fc0dfae1802"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "frozenset({'lyf', 'Techno', 'mad'})\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-19-d725675c562e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfrzn_st\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mfrzn_st\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"forever\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'frozenset' object has no attribute 'add'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "WuwR6tgVpyhG"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}