Notebooks/03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "Introduction to Python for Bioinformatics - available at https://github.com/kipkurui/Python4Bioinformatics.\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In simple terms, It is the the collection or group of data in a particular structure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are the most commonly used data structure. Think of it as a sequence of data that is enclosed in square brackets and data are separated by a comma. Each of these data can be accessed by calling it's index value.\n",
    "\n",
    "Lists are declared by just equating a variable to '[ ]' or list.\n",
    "\n",
    "Unlike strings, lists are mutable. That is, items can be added, or removed from a list without creating a new one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can directly assign the sequence of data to a list x as shown."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = ['apple', 'orange']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python, indexing starts from 0 as already seen for strings. Thus now the list x, which has two elements will have apple at 0 index and orange at 1 index. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing can also be done in reverse order. That is the last element can be accessed first. Here, indexing starts from -1. Thus index value -1 will be orange and index -2 will be apple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'orange'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might have already guessed, x[0] == x[-2], x[1] == x[-1]. This concept can be extended towards lists with more many elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = ['carrot','potato']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have declared two lists x and y each containing its own data. Now, these two lists can again be put into another list say z which will have it's data as two lists. This list inside a list is called as nested lists and is how an array would be declared which we will see later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['apple', 'orange'], ['carrot', 'potato']]\n"
     ]
    }
   ],
   "source": [
    "z  = [x,y]\n",
    "print( z )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'carrot'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z[1][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing in nested lists can be quite confusing if you do not understand how indexing works in python. So let us break it down and then arrive at a conclusion.\n",
    "\n",
    "Let us access the data 'apple' in the above nested list.\n",
    "First, at index 0 there is a list ['apple','orange'] and at index 1 there is another list ['carrot','potato']. Hence z[0] should give us the first list which contains 'apple' and 'orange'. From this list we can take the second element (index 1) to get 'orange'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "orange\n"
     ]
    }
   ],
   "source": [
    "print(z[0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists do not have to be homogenous. Each element can be of a different type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1+2j)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"this is a valid list\",2,3.6,(1+2j),[\"a\",\"sublist\"]][-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing was only limited to accessing a single element, Slicing on the other hand is accessing a sequence of data inside the list. In other words \"slicing\" the list.\n",
    "\n",
    "Slicing is done by defining the index values of the first element and the last element from the parent list that is required in the sliced list. It is written as parentlist[ a : b ] where a,b are the index values from the parent list. If a or b is not defined then the index value is considered to be the first value for a if a is not defined and the last value for b when b is not defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "num = [0,1,2,3,4,5,6,7,8,9]\n",
    "print(num[0:4])\n",
    "print(num[:8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also slice a parent list with a fixed length or step length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "num2 = num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "num2[2] = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 12, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 12, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built in List Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To find the length of the list or the number of elements in a list, **len( )** is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the list consists of all integer elements then **min( )** and **max( )** gives the minimum and maximum value in the list. Similarly **sum** is the sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min = 0   max = 9   total = 45\n"
     ]
    }
   ],
   "source": [
    "print(\"min =\",min(num),\"  max =\",max(num),\"  total =\",sum(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can be concatenated by adding, '+' them. The resultant list will contain all the elements of the lists that were added. The resultant list will not be a nested list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 4, 7]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] + [5,4,7]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There might arise a requirement where you might need to check if a particular element is there in a predefined list. Consider the below list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on list object:\n",
      "\n",
      "class list(object)\n",
      " |  list(iterable=(), /)\n",
      " |  \n",
      " |  Built-in mutable sequence.\n",
      " |  \n",
      " |  If no argument is given, the constructor creates a new empty list.\n",
      " |  The argument must be an iterable if specified.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __iadd__(self, value, /)\n",
      " |      Implement self+=value.\n",
      " |  \n",
      " |  __imul__(self, value, /)\n",
      " |      Implement self*=value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(self, /)\n",
      " |      Return a reverse iterator over the list.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the list in memory, in bytes.\n",
      " |  \n",
      " |  append(self, object, /)\n",
      " |      Append object to the end of the list.\n",
      " |  \n",
      " |  clear(self, /)\n",
      " |      Remove all items from list.\n",
      " |  \n",
      " |  copy(self, /)\n",
      " |      Return a shallow copy of the list.\n",
      " |  \n",
      " |  count(self, value, /)\n",
      " |      Return number of occurrences of value.\n",
      " |  \n",
      " |  extend(self, iterable, /)\n",
      " |      Extend list by appending elements from the iterable.\n",
      " |  \n",
      " |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      " |      Return first index of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  insert(self, index, object, /)\n",
      " |      Insert object before index.\n",
      " |  \n",
      " |  pop(self, index=-1, /)\n",
      " |      Remove and return item at index (default last).\n",
      " |      \n",
      " |      Raises IndexError if list is empty or index is out of range.\n",
      " |  \n",
      " |  remove(self, value, /)\n",
      " |      Remove first occurrence of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  reverse(self, /)\n",
      " |      Reverse *IN PLACE*.\n",
      " |  \n",
      " |  sort(self, /, *, key=None, reverse=False)\n",
      " |      Sort the list in ascending order and return None.\n",
      " |      \n",
      " |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n",
      " |      order of two equal elements is maintained).\n",
      " |      \n",
      " |      If a key function is given, apply it once to each list item and sort them,\n",
      " |      ascending or descending, according to their function values.\n",
      " |      \n",
      " |      The reverse flag can be set to sort in descending order.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  __class_getitem__(...) from builtins.type\n",
      " |      See PEP 585\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "names = ['Earth','Air','Fire','Water']\n",
    "help(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_list(names, find): \n",
    "    for item in names:\n",
    "        if item == find:\n",
    "            return True\n",
    "            break\n",
    "    else:\n",
    "        return False\n",
    "    #return tag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'check_list' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_5834/1168291492.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcheck_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnames\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Firse'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mhelp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'check_list' is not defined"
     ]
    }
   ],
   "source": [
    "check_list(names, 'Firse')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check if 'Fire' and 'Rajath' is present in the list names. A conventional approach would be to use a for loop and iterate over the list and use the if condition. But in python you can use 'a in b' concept which would return 'True' if a is present in b and 'False' if not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Fire' in names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Space' in names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a list with string elements, **max( )** and **min( )** are still applicable and return the first/last element in lexicographical order. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max = z\n",
      "min = az\n"
     ]
    }
   ],
   "source": [
    "mlist = ['bzaa','ds','nc','az','z','klm']\n",
    "print(\"max =\",max(mlist))\n",
    "print(\"min =\",min(mlist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the first index of each element is considered and thus z has the highest ASCII value thus it is returned and minimum ASCII is a. But what if numbers are declared as strings?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max = 94\n",
      "min = 1\n"
     ]
    }
   ],
   "source": [
    "nlist = ['1','94','93','1000']\n",
    "print(\"max =\",max(nlist))\n",
    "print('min =',min(nlist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even if the numbers are declared in a string the first index of each element is considered and the maximum and minimum values are returned accordingly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But if you want to find the **max( )** string element based on the length of the string then another parameter `key` can be used to specify the function to use for generating the value on which to sort. Hence finding the longest and shortest string in `mlist` can be doen using the `len` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "max(iterable, *[, default=obj, key=func]) -> value\n",
       "max(arg1, arg2, *args, *[, key=func]) -> value\n",
       "\n",
       "With a single iterable argument, return its biggest item. The\n",
       "default keyword-only argument specifies an object to return if\n",
       "the provided iterable is empty.\n",
       "With two or more arguments, return the largest argument.\n",
       "\u001b[0;31mType:\u001b[0m      builtin_function_or_method\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "longest = bzaa\n",
      "shortest = z\n"
     ]
    }
   ],
   "source": [
    "print('longest =',max(mlist, key=len))\n",
    "print('shortest =',min(mlist, key=len))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any other built-in or user defined function can be used.\n",
    "\n",
    "#### List Methods\n",
    "A string can be converted into a list by using the **list()** function, or more usefully using the **split()** method, which breaks strings up based on spaces.\n",
    "\n",
    "What we've seen so far are functions, which are stand alone and can be applied to any object. However, there are functions that are specific to lists. These are applied on a list using **.** eg. `mlist.split()`. Here, `split()` is a method applied on a string to generate a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', ' ', '!'] ['Hello', 'World', '!!']\n"
     ]
    }
   ],
   "source": [
    "print(list('hello world !'),'Hello   World !!'.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', ' ', '!']"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list('hello world !')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['He', '', 'o   Wor', 'd !!']"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s='Hello   World !!'\n",
    "s.split(sep='l')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**append( )** is a method used to add a *single element* at the end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 4, 8, 7, 1]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,1,4,8,7]\n",
    "lst.append(1)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Appending a list to a list would create a sublist. If a nested list is not what is desired then the **extend( )** function can be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.append([10,11,12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = lst + [10,11,12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.extend([10,11,12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 4, 8, 7, 1, 10, 11, 12]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 4, 8, 7, 1, 10, 11, 12]\n"
     ]
    }
   ],
   "source": [
    "lst.extend([10,11,12])\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**count( )** is used to count the number of a particular element that is present in the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst.count(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**index( )** is used to find the index value of a particular element. Note that if there are multiple elements of the same value then the first index value of that element is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst.index(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**insert(x,y)** is used to insert a element y at a specified index value x. **append( )** function made it only possible to insert at the end. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 7, 1, 10, 11, 'name', 12]\n"
     ]
    }
   ],
   "source": [
    "lst.insert(5, 'name')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[5] = 'names'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 7, 1, 10, 11, 'names', 12]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.insert(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 7, 1, 10, 11, 5, 'names', 12]"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**insert(x,y)** inserts but does not replace element. If you want to replace the element with another element you simply assign the value to that particular index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 7, 1, 10, 11, 'Python', 'names', 12]\n"
     ]
    }
   ],
   "source": [
    "lst[5] = 'Python'\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**pop( )** function return the last element in the list. This is similar to the operation of a stack. Hence it wouldn't be wrong to tell that lists can be used as a stack."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index value can be specified to pop a ceratin element corresponding to that index value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mlst\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\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[0;31mDocstring:\u001b[0m\n",
       "Remove first occurrence of value.\n",
       "\n",
       "Raises ValueError if the value is not present.\n",
       "\u001b[0;31mType:\u001b[0m      builtin_function_or_method\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lst.remove()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**pop( )** is used to remove element based on it's index value which can be assigned to a variable. One can also remove element by specifying the element itself using the **remove( )** method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 7, 1, 10, 11, 'names', 12]\n"
     ]
    }
   ],
   "source": [
    "lst.remove('Python')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternative to **remove** function but with using index value is **del**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 1, 10, 11, 'names', 12]\n"
     ]
    }
   ],
   "source": [
    "del lst[1]\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The entire elements present in the list can be reversed by using the **reverse()** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.append([5,4,2,8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5, 4, 2, 8], 8, 1, 10, 11, 'names', 12]\n"
     ]
    }
   ],
   "source": [
    "lst.reverse()\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the nested list [5,4,2,8] is treated as a single element of the parent list lst. Thus the elements inside the nested list is not reversed.\n",
    "\n",
    "Python offers built in operation **sort( )** to arrange the elements in ascending order. Alternatively **sorted()** can be used to construct a copy of the list in sorted order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.remove('names')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 11, 10, 8, 1]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "lst.sort(reverse=True)\n",
    "print(lst)\n",
    "print(sorted([3,2,1])) # another way to sort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For descending order, By default the reverse condition will be False for reverse. Hence changing it to True would arrange the elements in descending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 10, 8, 7, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "lst.sort(reverse=True)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly for lists containing string elements, **sort( )** would sort the elements based on it's ASCII value in ascending and by specifying reverse=True in descending."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Air', 'Earth', 'Fire', 'Water']\n",
      "['Water', 'Fire', 'Earth', 'Air']\n"
     ]
    }
   ],
   "source": [
    "names.sort()\n",
    "print(names)\n",
    "names.sort(reverse=True)\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To sort based on length key=len should be specified as shown."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Air', 'Fire', 'Water', 'Earth']\n",
      "['Water', 'Earth', 'Fire', 'Air']\n"
     ]
    }
   ],
   "source": [
    "names.sort(key=len)\n",
    "print(names)\n",
    "print(sorted(names,key=len,reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copying a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment of a list does not imply copying. It simply creates a second reference to the same list. Most of new python programmers get caught out by this initially. Consider the following,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 1, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "lista= [2,1,4,3]\n",
    "listb = lista\n",
    "print(listb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, We have declared a list, lista = [2,1,4,3]. This list is copied to listb by assigning it's value and it get's copied as seen. Now we perform some random operations on lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A = [1, 2, 3, 9]\n",
      "B = [1, 2, 3, 9]\n"
     ]
    }
   ],
   "source": [
    "lista.sort()\n",
    "lista.pop()\n",
    "lista.append(9)\n",
    "print(\"A =\",lista)\n",
    "print(\"B =\",listb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To understand what is going on, hop over to [Python Visualizer](https://goo.gl/nrgJeU). As you will see in the visualizer, and the image below, lista and listb both refer to the same object. NB: Everything is an object in python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"800\" height=\"500\" frameborder=\"0\" src=\"http://pythontutor.com/iframe-embed.html#code=lista%3D%20%5B2,1,4,3%5D%0Alistb%20%3D%20lista%0Aprint%28listb%29%0Alista.sort%28%29%0Alista.pop%28%29%0Alista.append%289%29%0Aprint%28%22A%20%3D%22,lista%29%0Aprint%28%22B%20%3D%22,listb%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=8&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\"> </iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<iframe width=\"800\" height=\"500\" frameborder=\"0\" src=\"http://pythontutor.com/iframe-embed.html#code=lista%3D%20%5B2,1,4,3%5D%0Alistb%20%3D%20lista%0Aprint%28listb%29%0Alista.sort%28%29%0Alista.pop%28%29%0Alista.append%289%29%0Aprint%28%22A%20%3D%22,lista%29%0Aprint%28%22B%20%3D%22,listb%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=8&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\"> </iframe>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"execution.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "listb has also changed though no operation has been performed on it. This is because you have assigned the same memory space of lista to listb. So how do fix this?\n",
    "\n",
    "If you recall, in slicing we had seen that parentlist[a:b] returns a list from parent list with start index a and end index b and if a and b is not mentioned then by default it considers the first and last element. We use the same concept here. By doing so, we are assigning the data of lista to listb as a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting with:\n",
      "A = [2, 1, 4, 3]\n",
      "B = [2, 1, 4, 3]\n",
      "Finnished with:\n",
      "A = [1, 2, 3, 9]\n",
      "B = [2, 1, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [2,1,4,3]\n",
    "listb = lista[:] # make a copy by taking a slice from beginning to end\n",
    "print(\"Starting with:\")\n",
    "print(\"A =\",lista)\n",
    "print(\"B =\",listb)\n",
    "lista.sort()\n",
    "lista.pop()\n",
    "lista.append(9)\n",
    "print(\"Finnished with:\")\n",
    "print(\"A =\",lista)\n",
    "print(\"B =\",listb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehension\n",
    "A very powerful concept in Python (that also applies to Tuples, sets and dictionaries as we will see below), is the ability to define lists using list comprehension (looping) expression. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "my_list = [i**2 for i in [1,2,3]]\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "my_list = []\n",
    "for i in [1,2,3]:\n",
    "    my_list.append(i**2)\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen this constructs a new list by taking each element of the original `[1,2,3]` and squaring it. We can have multiple such implied loops to get for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15, 17, 25, 27, 35, 37]\n"
     ]
    }
   ],
   "source": [
    "#[10*i+j for i in [1,2,3] for j in [5,7]]\n",
    "\n",
    "mylist = []\n",
    "for i in [1,2,3]:\n",
    "    for j in [5,7]:\n",
    "        mylist.append(10*i+j)\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally the looping can be filtered using an **if** expression with the **for** - **in** construct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 17, 37]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "into_list = []\n",
    "for i in [1,2,3]:\n",
    "    if i%2==1:\n",
    "        for j in [4,5,7]:\n",
    "            if j >= i+4: # keep odd i and  j larger than i+3 only\n",
    "                into_list.append(10*i+j)\n",
    "into_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 17, 37]"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[10*i+j for i in [1,2,3] if i%2==1 for j in [4,5,7] if j >= i+4] # keep odd i and  j larger than i+3 only       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are similar to lists but only big difference is the elements inside a list can be changed (mutable) but in tuple it cannot be changed. Think of tuples as something which has to be True for a particular something and cannot be True for no other values. For better understanding, Recall **divmod()** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 1)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "xyz = divmod(10,3)\n",
    "print(xyz)\n",
    "print(type(xyz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the quotient has to be 3 and the remainder has to be 1. These values cannot be changed whatsoever when 10 is divided by 3. Hence divmod returns these values in a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To define a tuple, A variable is assigned to paranthesis ( ) or tuple( )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup = ()\n",
    "tup2 = tuple()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to directly declare a tuple it can be done by using a comma at the end of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(27, 3, 7)"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "27,3,7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "27 when multiplied by 2 yields 54, But when multiplied with a tuple the data is repeated twice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Values can be assigned while declaring a tuple. It takes a list as input and converts it into a tuple or it takes a string and converts it into a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "('H', 'e', 'l', 'l', 'o')\n"
     ]
    }
   ],
   "source": [
    "tup3 = tuple([1,2,3])\n",
    "print(tup3)\n",
    "tup4 = tuple('Hello')\n",
    "print(tup4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It follows the same indexing and slicing as Lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "('H', 'e', 'l')\n"
     ]
    }
   ],
   "source": [
    "print(tup3[1])\n",
    "tup5 = tup4[:3]\n",
    "print(tup5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mapping one tuple to another\n",
    "Tupples can be used as the left hand side of assignments and are matched to the correct right hand side elements - assuming they have the right length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha beta gamma\n",
      "Alpha Beta Gamma\n",
      "this is ok\n"
     ]
    }
   ],
   "source": [
    "(a,b,c)= ('alpha','beta','gamma') # are optional\n",
    "a,b,c= 'alpha','beta','gamma' # The same as the above\n",
    "print(a,b,c)\n",
    "a,b,c = ['Alpha','Beta','Gamma'] # can assign lists\n",
    "print(a,b,c)\n",
    "[a,b,c]=('this','is','ok') # even this is OK\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More complex nexted unpackings of values are also possible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n",
      "1 (2, 3) 4\n"
     ]
    }
   ],
   "source": [
    "(w,(x,y),z)=(1,(2,3),4)\n",
    "print(w,x,y,z)\n",
    "(w,xy,z)=(1,(2,3),4)\n",
    "print(w,xy,z) # notice that xy is now a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built In Tuple functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**count()** function counts the number of specified element that is present in the tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d=tuple('a string with many \"a\"s')\n",
    "d.count('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**index()** function returns the index of the specified element. If the elements are more than one then the index of the first element of that specified element is returned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.index('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = ('test', 1, 2,[2,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('test', 1, 2, [2, 4, 5])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets are mainly used to eliminate repeated numbers in a sequence/list. It is also used to perform some standard set operations.\n",
    "\n",
    "Sets are declared as set() which will initialize a empty set. Also `set([sequence])` can be executed to declare a set with elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "set1 = set()\n",
    "print(type(set1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "set0 = set([1,2,2,3,3,4])\n",
    "set0 = {1,2,2,3,3,4} # equivalent to the above\n",
    "print(set0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "elements 2,3 which are repeated twice are seen only once. Thus in a set each element is distinct.\n",
    "\n",
    "However be warned that **{}** is **NOT** a set, but a dictionary (see next chapter of this tutorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = {}\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = set([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2 = set([2,3,4,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**union( )** function returns a set which contains all the elements of both the sets without repition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1.union(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**add( )** will add a particular element into the set. Note that the index of the newly added element is arbitrary and can be placed anywhere not neccessarily in the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3}"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1.add(0)\n",
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 5}"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**intersection( )** function outputs a set which contains all the elements that are in both sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set2.intersection(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**difference( )** function ouptuts a set which contains elements that are in set1 and not in set2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set2.difference(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**symmetric_difference( )** function ouputs a function which contains elements that are in one of the sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 4, 5}"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1.symmetric_difference(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**issubset( ), isdisjoint( ), issuperset( )** is used to check if the set1/set2 is a subset, disjoint or superset of set2/set1 respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "seta = {1,2,3}\n",
    "setb = {1,2,3,4,5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seta.issubset(setb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seta.isdisjoint(setb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setb.issuperset(seta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**pop( )** is used to remove an arbitrary element in the set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "set1.pop()\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**remove( )** function deletes the specified element from the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3}"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1.remove(2)\n",
    "set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**clear( )** is used to clear all the elements and make that set an empty set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1.clear()\n",
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.update(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = (i**2 for i in [1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "generator"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'78':[78]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'78': [78]}"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 65}"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[78]"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict['78']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = {10,3,2,4,5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 5, 10}"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}