02_Lists_Tuple_ Sets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Datastructures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## The builtins data structures are: lists, tuples, sets and dictionaries\n",
    "\n",
    "* Lists, tuples are ordered sequences of objects. (like strings)\n",
    "* Set and dictionaries are uordered.\n",
    "* List, tuples and set can contain any type of objects. \n",
    "* Lists and tuples are like arrays. \n",
    "* Tuples are immutables whereas lists are mutables so they can be extended or reduced at will. \n",
    "* Sets are mutable unordered sequence of unique elements whereas frozensets are immutable sets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can define an empty list by using two enclosing square brackets `[]`. Just like array in other programming language. Or you can use `list()` method without any arguments and assign it to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 | 0 | <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# defining a empty list\n",
    "\n",
    "my_list_1 = []\n",
    "my_list_2 = list()\n",
    "\n",
    "print(len(my_list_1), len(my_list_2), type(my_list_1), sep=\" | \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[123]\n"
     ]
    }
   ],
   "source": [
    "l = list()\n",
    "l.append(123)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List is like an array but unlike other programming languages, list can contain any type of objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 1, True, [5.0, 2.5], None]\n"
     ]
    }
   ],
   "source": [
    "any_obj_list = [\"Hello\", 1, True, [5.0, 5/2], None]\n",
    "print(any_obj_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony']\n"
     ]
    }
   ],
   "source": [
    "# This is a list of Strings\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(comp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# len() gives how many values are there inside a list\n",
    "print(len(comp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sony\n"
     ]
    }
   ],
   "source": [
    "# Accessing by index\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(comp[len(comp)-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sony\n",
      "Apple\n"
     ]
    }
   ],
   "source": [
    "# Last value is accessed by -1\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(comp[-1])\n",
    "print(comp[-5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-4b65ed43090f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# IndexError exception while trying to access index that doesn't exist\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mcomp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m\"Apple\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Samsung\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Lenovo\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"LG\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Sony\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcomp\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m20\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;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# IndexError exception while trying to access index that doesn't exist\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(comp[20])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Samsung']\n",
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony']\n",
      "['Apple', 'Samsung']\n",
      "['Lenovo', 'LG', 'Sony']\n"
     ]
    }
   ],
   "source": [
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(comp[0:2])\n",
    "print(comp[:])\n",
    "print(comp[:2])\n",
    "print(comp[2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hel'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing can be done in string as well because string is also squence of characters.\n",
    "a = \"Hello\"\n",
    "a[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "2\n",
      "8\n",
      "[2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1]\n",
      "[2, 3, 4, 5]\n",
      "[2, 3, 4, 5, 6, 7]\n",
      "[4, 5, 6, 7]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n",
      "[0, 2, 4]\n",
      "[2, 4]\n",
      "[9, 7, 5, 3, 1]\n",
      "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# Let's look at all the possible slicing and pay high attention to the output\n",
    "a = list(range(10))\n",
    "print(a)\n",
    "print(a[2])\n",
    "print(a[-2])\n",
    "print(a[2:])\n",
    "print(a[:2])\n",
    "print(a[2:6])\n",
    "print(a[2:-2])\n",
    "print(a[-6:-2])\n",
    "print(a[:])\n",
    "print(a[::2])\n",
    "print(a[2::2])\n",
    "print(a[:6:2])\n",
    "print(a[2:6:2])\n",
    "print(a[::-2])\n",
    "print(a[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Same slicing techniques used in above string can be applied to lists as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List methods\n",
    "Everyting in Python is an object and List is also definately an object. Hence, in OOP concept, object are likely to have a methods (behaviour)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = []\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "'XYZ' is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-f8ef03cd4fd7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Throws ValueError if not in list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcomp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"XYZ\"\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;31mValueError\u001b[0m: 'XYZ' is not in list"
     ]
    }
   ],
   "source": [
    "# index(arg) method is used to find the index of an element in the list\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(comp.index(\"Samsung\"))\n",
    "\n",
    "# Throws ValueError if not in list\n",
    "print(comp.index(\"XYZ\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony']\n",
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony', 'Sharp', 'Xiaomi']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "append(arg) method is used to add element in the list. \n",
    "While adding a new element using append method, the newly \n",
    "added element is added at the end of the list.\n",
    "Adding an element in a list\n",
    "\"\"\" \n",
    "print(comp)\n",
    "comp.append(\"Sharp\")\n",
    "comp.append(\"Xiaomi\")\n",
    "print(comp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony']\n",
      "['Xiaomi', 'Apple', 'Samsung', 'Lenovo', 'LG', 'Sony', 'Sharp']\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "insert() method is used to insert an element in a particular index of the list.\n",
    "\"\"\"\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(comp)\n",
    "\n",
    "comp.insert(20, \"Sharp\") # even if you add element in larger index, it'll always be added at the end the list\n",
    "comp.insert(0, \"Xiaomi\") \n",
    "\n",
    "print(comp)\n",
    "print(comp.index(\"Sharp\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony', ['Sharp', 'Xiaomi']]\n"
     ]
    }
   ],
   "source": [
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "extra = [\"Sharp\", \"Xiaomi\"]\n",
    "comp.append(extra) # wrong implementation because it'll just add the whole list at the end of the comp list\n",
    "print(comp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony', 'Sharp', 'Xiaomi']\n",
      "[1, 2, 3]\n",
      "[1, 2, 3, 'a', 'b']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "If you want to merge two list together, you can use extend() method.\n",
    "\"\"\"\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "extra = [\"Sharp\", \"Xiaomi\"]\n",
    "comp.extend(extra)\n",
    "print(comp)\n",
    "\n",
    "x = [1,2,3]\n",
    "y = [\"a\", \"b\"]\n",
    "print(x)\n",
    "x.extend(y)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony', 'Sharp', 'Xiaomi']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "extending a list by using extend method can also be done via the \"+\" operator.\n",
    "\"\"\"\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "extra = [\"Sharp\", \"Xiaomi\"]\n",
    "comp += extra\n",
    "print(comp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Samsung', 'Lenovo', 'Sony']\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "comp.remove(\"LG\")\n",
    "print(comp)\n",
    "print(comp.index(\"Sony\")) # Index is changed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## List as a Stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Popped :  Samsung\n",
      "['Apple', 'Lenovo', 'LG', 'Sony']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "List data structure can be used to simulate the stack data structure.\n",
    "For this, to extract the topmost element in the list, you can use pop() method.\n",
    "pop() method always returns last value in the list like in stack.\n",
    "Note: pop() method manipulates the list.\n",
    "\"\"\"\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "popped = comp.pop(1)\n",
    "print(\"Popped : \", popped)\n",
    "print(comp)\n",
    "# comp.push() -> comp.append(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other important methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 6, 5, 4, 1, 0]\n",
      "==============\n",
      "['Apple', 'LG', 'Lenovo', 'Samsung', 'Sony']\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-146210e4102d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"a\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"b\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#Bug (Can't compare integers and string)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "x = [5, 6, 1, 4, 0, 9]\n",
    "x.sort(reverse=True) # ascending\n",
    "print(x)\n",
    "\n",
    "print(\"==============\")\n",
    "\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "comp.sort()\n",
    "print(comp)\n",
    "\n",
    "y = [1, 2, 3, \"a\", \"b\"]\n",
    "y.sort() #Bug (Can't compare integers and string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 6, 5, 4, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "x = [5, 6, 1, 4, 0, 9]\n",
    "x.sort(reverse=True) # descending\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 0, 4, 1, 6, 5]\n"
     ]
    }
   ],
   "source": [
    "# Reversing a list\n",
    "x = [5, 6, 1, 4, 0, 9]\n",
    "x.reverse()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 6, 5, 4, 1, 0]\n",
      "['Apple', 'LG', 'Lenovo', 'Samsung', 'Sony']\n"
     ]
    }
   ],
   "source": [
    "x = [5, 6, 1, 4, 0, 9]\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "sorted_x = sorted(x, reverse=True)\n",
    "sorted_comp = sorted(comp)\n",
    "print(sorted_x)\n",
    "print(sorted_comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUM:  25.3\n",
      "MAX:  9\n",
      "MIN:  0\n"
     ]
    }
   ],
   "source": [
    "x = [5.3, 6, 1, 4, 0, 9]\n",
    "print(\"SUM: \", sum(x))\n",
    "print(\"MAX: \", max(x))\n",
    "print(\"MIN: \", min(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w\n"
     ]
    }
   ],
   "source": [
    "print(max(\"Hello world\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Check whether an element is in the list or not\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(\"Apple\" in comp)\n",
    "print(\"Xaiomi\" in comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looping over a List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple\tSamsung\tLenovo\tLG\tSony\t"
     ]
    }
   ],
   "source": [
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "for sub in comp:\n",
    "    print(sub, end='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Apple\n",
      "1 Samsung\n",
      "2 Lenovo\n",
      "3 LG\n",
      "4 Sony\n"
     ]
    }
   ],
   "source": [
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "for index, sub in enumerate(comp):\n",
    "    print(index, sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 Apple\n",
      "101 Samsung\n",
      "102 Lenovo\n",
      "103 LG\n",
      "104 Sony\n"
     ]
    }
   ],
   "source": [
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "for index, sub in enumerate(comp, start=100):\n",
    "    print(index, sub)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Joining elements in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple= Samsung= Lenovo= LG= Sony\n"
     ]
    }
   ],
   "source": [
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(\"= \".join(comp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple--Samsung--Lenovo--LG--Sony\n",
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony']\n"
     ]
    }
   ],
   "source": [
    "# You can olny join list of Strings\n",
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "joined = \"--\".join(comp)\n",
    "print(joined)\n",
    "list_from_join = joined.split(\"--\")\n",
    "print(list_from_join)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "x = \"a+b+c+d\"\n",
    "list_plus = x.split(\"+\")\n",
    "print(list_plus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists are mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Samsung', 'Lenovo', 'LG', 'Sony']\n",
      "['Sharp', 'Samsung', 'Lenovo', 'LG', 'Sony']\n"
     ]
    }
   ],
   "source": [
    "comp = [\"Apple\", \"Samsung\", \"Lenovo\", \"LG\", \"Sony\"]\n",
    "print(comp)\n",
    "comp[0] = \"Sharp\"\n",
    "print(comp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 1, True]\n",
      "['a', 1, True]\n",
      "\n",
      "\n",
      "['b', 1, True]\n",
      "['b', 1, True]\n",
      "\n",
      "\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "list_1 = [\"a\", 1, True]\n",
    "list_2 = list_1\n",
    "print(list_1)\n",
    "print(list_2)\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "list_1[0] = \"b\"\n",
    "print(list_1)\n",
    "print(list_2)\n",
    "\n",
    "print(\"\\n\")\n",
    "print(list_1 is list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multidimension List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "n_list = [\n",
    "            [1,2,3],\n",
    "            [4,5,6]\n",
    "         ]\n",
    "print(n_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How many?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,4,5,0,2,3,4,6,7,8,5,6,7,8,8,8,2]\n",
    "print(x.count(-1)) # How many -1 are there in the list x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1, 2, 3]\n",
    "l*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuple is very similar to the list data structure but, tuples are immutable. [Can't be changed]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "0\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# Empty tuple\n",
    "tup = ()\n",
    "tup = tuple()\n",
    "\n",
    "print(tup)\n",
    "print(len(tup))\n",
    "print(type(tup))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "tup = (1, 2, 3, 4)\n",
    "print(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "no_paran_tup = 1, 2, 3, 4\n",
    "print(no_paran_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "tuple index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-42-122bdb0b230e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtup\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\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[0mtup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Just like List, index out ot bound expection is thrown if tried to access index that is out of bound\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: tuple index out of range"
     ]
    }
   ],
   "source": [
    "tup = (1, 2, 3, 4)\n",
    "print(tup[5]) # Just like List, index out ot bound expection is thrown if tried to access index that is out of bound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Just like list, tuple is iterable and you can loop over it\n",
    "tup = (1, 2, 3, 4)\n",
    "for each in tup:\n",
    "    print(each)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 Ram\n",
      "101 Sita\n",
      "102 Gopal\n",
      "103 Hari\n"
     ]
    }
   ],
   "source": [
    "names = (\"Ram\", \"Sita\", \"Gopal\", \"Hari\")\n",
    "for idx, each in enumerate(names, start=100):\n",
    "    print(idx, each)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-45-67ef6f325e39>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnames\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"Ram\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Sita\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Gopal\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Hari\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnames\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\"Shyam\"\u001b[0m \u001b[0;31m# Throws exception because tuple is immutable\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"
     ]
    }
   ],
   "source": [
    "names = (\"Ram\", \"Sita\", \"Gopal\", \"Hari\")\n",
    "names[0] = \"Shyam\" # Throws exception because tuple is immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Often confused if we want to make a single value tuple. This can be achieved by adding an extra comma (,) at the end\n",
    "tup = (\"a\", )\n",
    "print(type(tup))\n",
    "print(len(tup))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "tup = (1) #without comma, one value is treated as a native data type\n",
    "print(type(tup))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "tup = (1, 2, 3)\n",
    "print(tup)\n",
    "tup = tup + (4,) # This creates new tuple in memory instead of using the old tup object\n",
    "print(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2)\n",
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "tup = (1, 2)\n",
    "print(tup*6)\n",
    "print(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b', 1)\n",
      "ID of tup_1: 4437977736 | ID of tup: 4439969184 | ID of merged: 4439915688\n"
     ]
    }
   ],
   "source": [
    "tup_1 = (\"a\", \"b\")\n",
    "tup = (1, )\n",
    "merged = tup_1+tup\n",
    "print(merged)\n",
    "\n",
    "# tup_1, tup and merged all are different objects in the memory\n",
    "print(f\"ID of tup_1: {id(tup_1)} | ID of tup: {id(tup)} | ID of merged: {id(merged)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "tup = (1, 2, 4, 1, 3, 2, 5, 2, 4)\n",
    "print(tup.count(2))\n",
    "print(tup.index(2))\n",
    "print(3 in tup)\n",
    "print(31 not in tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Value unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "2\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "x, y, z = (1, 2, (3, 4))\n",
    "print(type(x))\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "x, y, z = range(3)\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "too many values to unpack (expected 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-54-4c91422a53a7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# This results in error because 4 values are being unpacked to 3 variables\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: too many values to unpack (expected 3)"
     ]
    }
   ],
   "source": [
    "# This results in error because 4 values are being unpacked to 3 variables\n",
    "x, y, z = range(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 3, b = 5\n",
      "\n",
      "After swapping\n",
      "a = 5, b = 3\n"
     ]
    }
   ],
   "source": [
    "# Swapping two values\n",
    "a = 3\n",
    "b = 5\n",
    "print(\"a = {}, b = {}\".format(a, b))\n",
    "a, b = (b, a)\n",
    "print(\"\\nAfter swapping\")\n",
    "print(\"a = {}, b = {}\".format(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type conversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 3)\n",
    "str_a = str(a)\n",
    "print(str_a)\n",
    "print(type(str_a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 3)\n",
    "list_a = list(a)\n",
    "print(list_a)\n",
    "print(type(list_a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n",
      "<class 'set'>\n",
      "set()\n",
      "<class 'set'>\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "s = {1, 2, 3}\n",
    "print(s)\n",
    "print(type(s))\n",
    "s = set()\n",
    "print(s)\n",
    "print(type(s))\n",
    "print(len(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "s = {} # we don't initialize set like this because this is a dictionary. Use set() constructor\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('OK', None), 1, 1.5, 'Hello'}"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = {\"Hello\", 1, 1.5, (\"OK\", None), \"Hello\"}\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "s = {1, 2, 3, 4, 3}\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Helloo', 1, 'Hello', 1.5, 2, ('OK', None)}\n",
      "<class 'set'>\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "s = {\"Hello\", 1, 1.5, (\"OK\", None)}\n",
    "s.update((\"Helloo\", 2))\n",
    "print(s)\n",
    "print(type(s))\n",
    "print(len(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'OOP', 'MGMT', 'OS', 'CSA', 'NM'}\n",
      "{'OOP', 'MGMT', 'OS', 'CSA', 'NM'}\n"
     ]
    }
   ],
   "source": [
    "comp = {\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"}\n",
    "print(comp)\n",
    "comp_one = {\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\", \"OOP\"}\n",
    "print(comp_one) # since set can contain only unique elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a', 'e'}\n",
      "{'o', 'u', 'i'}\n",
      "{'b', 'a', 'o', 'g', 'f', 'e', 'c', 'd', 'u', 'i'}\n"
     ]
    }
   ],
   "source": [
    "set_one = {\"a\", \"e\", \"i\", \"o\", \"u\"}\n",
    "set_two = {\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\"}\n",
    "\n",
    "print(set_one.intersection(set_two))\n",
    "print(set_one.difference(set_two))\n",
    "print(set_one.union(set_two))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "set_one = {\"a\", \"e\", \"i\", \"o\", \"u\"}\n",
    "set_sub = {\"a\", \"e\"}\n",
    "print(set_one.issuperset(set_sub))\n",
    "print(set_sub.issubset(set_one))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "set_one = {\"a\", \"e\", \"i\", \"o\", \"u\"}\n",
    "set_sub = {\"a\", \"e\"}\n",
    "set_one.clear()\n",
    "print(set_one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Ram', 'name', 'is', 'my'}\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Hello my name is Ram\"\n",
    "str2 = \"Ram is my name\"\n",
    "\n",
    "str1_lst = str1.split(\" \")\n",
    "str2_lst = str2.split(\" \")\n",
    "\n",
    "str1_set = set(str1_lst)\n",
    "str2_set = set(str2_lst)\n",
    "\n",
    "print(str1_set.intersection(str2_set))\n",
    "print(str2_set.issubset(str1_set))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}