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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "any_obj_list = [\"Hello\", 1, True, [5.0, 5/2], None]\n",
    "print(any_obj_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a list of Strings\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(comp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# len() gives how many values are there inside a list\n",
    "print(len(comp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accessing by index\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(comp[len(comp)-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Last value is accessed by -1\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(comp[-1])\n",
    "print(comp[-5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IndexError exception while trying to access index that doesn't exist\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(comp[20])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(comp[0:2])\n",
    "print(comp[:])\n",
    "print(comp[:2])\n",
    "print(comp[2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": [
    "# 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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = []\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# index(arg) method is used to find the index of an element in the list\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(comp.index(\"NM\"))\n",
    "\n",
    "# Throws ValueError if not in list\n",
    "print(comp.index(\"XYZ\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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(\"Python\")\n",
    "comp.append(\"English\")\n",
    "print(comp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "insert() method is used to insert an element in a particular index of the list.\n",
    "\"\"\"\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(comp)\n",
    "\n",
    "comp.insert(20, \"Python\") # even if you add element in larger index, it'll always be added at the end the list\n",
    "comp.insert(0, \"English\") \n",
    "\n",
    "print(comp)\n",
    "print(comp.index(\"Python\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['OOP', 'CSA', 'NM', 'MGMT', 'OS', ['Python', 'English']]\n"
     ]
    }
   ],
   "source": [
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "extra = [\"Python\", \"English\"]\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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "If you want to merge two list together, you can use extend() method.\n",
    "\"\"\"\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "extra = [\"Python\", \"English\"]\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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "extending a list by using extend method can also be done via the \"+\" operator.\n",
    "\"\"\"\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "extra = [\"Python\", \"English\"]\n",
    "comp += extra\n",
    "print(comp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "comp.remove(\"OOP\")\n",
    "print(comp)\n",
    "print(comp.index(\"CSA\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## List as a Stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "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 = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\", \"XYZ\"]\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": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x = [5, 6, 1, 4, 0, 9]\n",
    "x.sort(reverse=True) # ascending\n",
    "print(x)\n",
    "\n",
    "print(\"==============\")\n",
    "\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "comp.sort()\n",
    "print(comp)\n",
    "\n",
    "y = [1, 2, 3, \"a\", \"b\"]\n",
    "y.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [5, 6, 1, 4, 0, 9]\n",
    "x.sort(reverse=True) # descending\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reversing a list\n",
    "x = [5, 6, 1, 4, 0, 9]\n",
    "x.reverse()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [5, 6, 1, 4, 0, 9]\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\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": null,
   "metadata": {},
   "outputs": [],
   "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": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w\n"
     ]
    }
   ],
   "source": [
    "print(max(\"Hello world\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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 = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(\"OOP\" in comp)\n",
    "print(\"XYZ\" in comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looping over a List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOP\n",
      "CSA\n",
      "NM\n",
      "MGMT\n",
      "OS\n"
     ]
    }
   ],
   "source": [
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "for sub in comp:\n",
    "    print(sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'OOP')\n",
      "(1, 'CSA')\n",
      "(2, 'NM')\n",
      "(3, 'MGMT')\n",
      "(4, 'OS')\n"
     ]
    }
   ],
   "source": [
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "for index, sub in enumerate(comp):\n",
    "    print(index, sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 'OOP')\n",
      "(101, 'CSA')\n",
      "(102, 'NM')\n",
      "(103, 'MGMT')\n",
      "(104, 'OS')\n"
     ]
    }
   ],
   "source": [
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\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": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOP= CSA= NM= MGMT= OS\n"
     ]
    }
   ],
   "source": [
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(\"= \".join(comp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOP--CSA--NM--MGMT--OS\n",
      "['OOP', 'CSA', 'NM', 'MGMT', 'OS']\n"
     ]
    }
   ],
   "source": [
    "# You can olny join list of Strings\n",
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "joined = \"--\".join(comp)\n",
    "print(joined)\n",
    "list_from_join = joined.split(\"--\")\n",
    "print(list_from_join)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['OOP', 'CSA', 'NM', 'MGMT', 'OS']\n",
      "['Python', 'CSA', 'NM', 'MGMT', 'OS']\n"
     ]
    }
   ],
   "source": [
    "comp = [\"OOP\", \"CSA\", \"NM\", \"MGMT\", \"OS\"]\n",
    "print(comp)\n",
    "comp[0] = \"Python\"\n",
    "print(comp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "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": 12,
   "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": 13,
   "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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 14,
     "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup = (1, 2, 3, 4)\n",
    "print(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 'Ram')\n",
      "(101, 'Sita')\n",
      "(102, 'Gopal')\n",
      "(103, 'Hari')\n"
     ]
    }
   ],
   "source": [
    "tup = (\"Ram\", \"Sita\", \"Gopal\", \"Hari\")\n",
    "for idx, each in enumerate(tup, start=100):\n",
    "    print(idx, each)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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-18-6f4befbacdd8>\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;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[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtup\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[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tup = (\"Ram\", \"Sita\", \"Gopal\", \"Hari\")\n",
    "tup[0] = \"Shyam\" # Throws exception because tuple is immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'tuple'>\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "tup = (\"a\", )\n",
    "print(type(tup))\n",
    "print(len(tup))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "tup = (1,) #without comma, one value is treated as a native data type\n",
    "print(type(tup))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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,)\n",
    "print(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b', 1)\n"
     ]
    }
   ],
   "source": [
    "tup_1 = (\"a\", \"b\")\n",
    "tup = (1, )\n",
    "merged = tup_1+tup\n",
    "print(merged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n",
      "False\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(8 in tup)\n",
    "print(31 not in tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Value unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'tuple'>\n",
      "2\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "x, y, z = (1, 2, (3, 4))\n",
    "print(type(z))\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "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": 31,
   "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": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "<type '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": null,
   "metadata": {},
   "outputs": [],
   "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": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set([1, 2, 3])\n",
      "<type 'set'>\n",
      "set([])\n",
      "<type '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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = {} # we don't initialize set like this\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = {\"Hello\", 1, 1.5, (\"OK\", None), \"Hello\"}\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = {1, 2, 3, 4, 3}\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set(['OS', 'MGMT', 'CSA', 'OOP', 'NM'])\n",
      "set(['OS', 'MGMT', 'CSA', 'OOP', '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": null,
   "metadata": {},
   "outputs": [],
   "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": 35,
   "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": 36,
   "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": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set(['is', 'Ram', 'my', 'name'])\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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}