Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!DOCTYPE html>\n",
    "<html>\n",
    "<body>\n",
    "<div align=\"center\">\n",
    "<h2>Prepared by Asif Bhat</h2>\n",
    "    \n",
    "<h1>Python Tutorial</h1>\n",
    "</div>\n",
    "</body>\n",
    "</html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import keyword\n",
    "import operator\n",
    "from datetime import datetime\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keywords"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keywords are the reserved words in Python and can't be used as an identifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "print(keyword.kwlist) # List all Python Keywords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(keyword.kwlist) # Python contains 35 keywords"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Identifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An identifier is a name given to entities like class, functions, variables, etc. It helps to differentiate one entity from another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-13-37e58aaf2d3b>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-13-37e58aaf2d3b>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    1var = 10 # Identifier can't start with a digit\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "1var = 10 # Identifier can't start with a digit "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-14-cfbf60736601>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-14-cfbf60736601>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    val2@ = 35 # Identifier can't use special symbols\u001b[0m\n\u001b[1;37m          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "val2@ = 35 # Identifier can't use special symbols "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-15-f7061d4fc9ba>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-15-f7061d4fc9ba>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    import = 125 # Keywords can't be used as identifiers\u001b[0m\n\u001b[1;37m           ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "import = 125 # Keywords can't be used as identifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Correct way of defining an identifier \n",
    "(Identifiers can be a combination of letters in lowercase (a to z) or uppercase (A to Z) or digits (0 to 9) or an underscore)\n",
    "\"\"\"\n",
    "\n",
    "val2 = 10 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_ = 99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comments in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comments can be used to explain the code for more readabilty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Single line comment\n",
    "val1  = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiple \n",
    "# line \n",
    "# comment\n",
    "val1  = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Multiple \n",
    "line \n",
    "comment\n",
    "'''\n",
    "val1  = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Multiple \n",
    "line \n",
    "comment\n",
    "\"\"\"\n",
    "val1  = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instructions that a Python interpreter can execute. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Single line statement\n",
    "p1 = 10 + 20\n",
    "p1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Single line statement\n",
    "p2 = ['a' , 'b' , 'c' , 'd']\n",
    "p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "290"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiple line statement\n",
    "p1 = 20 + 30 \\\n",
    "     + 40 + 50 +\\\n",
    "     + 70 + 80\n",
    "p1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiple line statement\n",
    "p2 = ['a' , \n",
    "      'b' , \n",
    "      'c' , \n",
    "      'd' \n",
    "     ]\n",
    "p2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indentation refers to the spaces at the beginning of a code line. It is very important as Python uses indentation to indicate a block of code.If the indentation is not correct we will endup with <b>IndentationError</b> error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P is equal to 10\n"
     ]
    }
   ],
   "source": [
    "p = 10\n",
    "if p == 10:\n",
    "    print ('P is equal to 10') # correct indentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-38-d7879ffaae93>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-38-d7879ffaae93>\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    print ('P is equal to 10')\u001b[0m\n\u001b[1;37m        ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "# if indentation is skipped we will encounter \"IndentationError: expected an indented block\"\n",
    "p = 10\n",
    "if p == 10:\n",
    "print ('P is equal to 10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,5):\n",
    "    print(i)               # correct indentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-43-4a6de03bf63e>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-43-4a6de03bf63e>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    print(i)\u001b[0m\n\u001b[1;37m        ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "# if indentation is skipped we will encounter \"IndentationError: expected an indented block\"\n",
    "for i in range(0,5):\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,5): print(i)  # correct indentation but less readable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "j=20\n",
    "for i in range(0,5):\n",
    "    print(i) # inside the for loop\n",
    "print(j) # outside the for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Docstrings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Docstrings provide a convenient way of associating documentation with functions, classes, methods or modules. \n",
    "\n",
    "2) They appear right after the definition of a function, method, class, or module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(num):\n",
    "    '''Square Function :- This function will return the square of a number'''\n",
    "    return num**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Square Function :- This function will return the square of a number'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square.__doc__  # We can access the Docstring using __doc__ method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evenodd(num):\n",
    "    '''evenodd Function :- This function will test whether a numbr is Even or Odd'''\n",
    "    if num % 2 == 0:\n",
    "        print(\"Even Number\")\n",
    "    else:\n",
    "        print(\"Odd Number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd Number\n"
     ]
    }
   ],
   "source": [
    "evenodd(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Even Number\n"
     ]
    }
   ],
   "source": [
    "evenodd(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'evenodd Function :- This function will test whether a numbr is Even or Odd'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evenodd.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Python variable is a reserved memory location to store values.A variable is created the moment you first assign a value to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140735029552432"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "id() function returns the “identity” of the object. \n",
    "The identity of an object - Is an integer\n",
    "                          - Guaranteed to be unique\n",
    "                          - Constant for this object during its lifetime. \n",
    "'''\n",
    "id(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0x7fff6d71a530'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hex(id(p)) # Memory address of the variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, int, '0x7fff6d71a3f0')"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = 20  #Creates an integer object with value 20 and assigns the variable p to point to that object.\n",
    "q = 20  # Create new reference q which will point to value 20. p & q will be pointing to same memory location.\n",
    "r = q  # variable r will also point to the same location where p & q are pointing/\n",
    "p , type(p), hex(id(p)) # Variable P is pointing to memory location '0x7fff6d71a3f0' where value 20 is stored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, int, '0x7fff6d71a3f0')"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q , type(q), hex(id(q)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, int, '0x7fff6d71a3f0')"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r , type(r), hex(id(r)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"variable.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = 20\n",
    "p = p + 10 # Variable Overwriting\n",
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Assigment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "2.57\n",
      "Python Language\n"
     ]
    }
   ],
   "source": [
    "intvar = 10 # Integer variable\n",
    "floatvar = 2.57 # Float Variable\n",
    "strvar = \"Python Language\" # String variable\n",
    "\n",
    "print(intvar)\n",
    "print(floatvar)\n",
    "print(strvar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Assignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "2.57\n",
      "Python Language\n"
     ]
    }
   ],
   "source": [
    "intvar , floatvar , strvar = 10,2.57,\"Python Language\" # Using commas to separate variables and their corresponding values.\n",
    "print(intvar)\n",
    "print(floatvar)\n",
    "print(strvar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44 44 44 44\n"
     ]
    }
   ],
   "source": [
    "p1 = p2 = p3 = p4 = 44 # All variables pointing to same value\n",
    "print(p1,p2,p3,p4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Types "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numeric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "<class 'int'>\n",
      "28\n",
      "10  is Integer? True\n"
     ]
    }
   ],
   "source": [
    "val1 = 10  # Integer data type\n",
    "print(val1)\n",
    "print(type(val1)) # type of object\n",
    "print(sys.getsizeof(val1)) # size of integer object in bytes \n",
    "print(val1, \" is Integer?\", isinstance(val1, int)) # val1 is an instance of int class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "92.78\n",
      "<class 'float'>\n",
      "24\n",
      "92.78  is float? True\n"
     ]
    }
   ],
   "source": [
    "val2 = 92.78 # Float data type\n",
    "print(val2)\n",
    "print(type(val2)) # type of object\n",
    "print(sys.getsizeof(val2)) # size of float object in bytes\n",
    "print(val2, \" is float?\", isinstance(val2, float)) # Val2 is an instance of float class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25+10j)\n",
      "<class 'complex'>\n",
      "32\n",
      "(25+10j)  is complex? True\n"
     ]
    }
   ],
   "source": [
    "val3 = 25 + 10j # Complex data type\n",
    "print(val3)\n",
    "print(type(val3)) # type of object\n",
    "print(sys.getsizeof(val3)) # size of float object in bytes\n",
    "print(val3, \" is complex?\", isinstance(val3, complex)) # val3 is an instance of complex class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.getsizeof(int()) # size of integer object in bytes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.getsizeof(float())  # size of float object in bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.getsizeof(complex()) # size of complex object in bytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean data type can have only two possible values __true__ or __false__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool1 = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool2 = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(bool1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(bool2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(bool1, bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool (False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO PYTHON\n"
     ]
    }
   ],
   "source": [
    "str1 = \"HELLO PYTHON\"\n",
    "\n",
    "print(str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "mystr = 'Hello World' # Define string using single quotes\n",
    "print(mystr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "mystr = \"Hello World\" # Define string using double quotes\n",
    "print(mystr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello               \n",
      "            World \n"
     ]
    }
   ],
   "source": [
    "mystr = '''Hello               \n",
    "            World '''   # Define string using triple quotes\n",
    "print(mystr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "           World\n"
     ]
    }
   ],
   "source": [
    "mystr = \"\"\"Hello\n",
    "           World\"\"\"  # Define string using triple quotes\n",
    "print(mystr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Happy Monday Everyone\n"
     ]
    }
   ],
   "source": [
    "mystr = ('Happy '\n",
    "         'Monday '\n",
    "         'Everyone')\n",
    "print(mystr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Woohoo Woohoo Woohoo Woohoo Woohoo '"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2 = 'Woohoo '\n",
    "mystr2 = mystr2*5\n",
    "mystr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mystr2) # Length of string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"string.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO PYTHON'"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[0] # First character in string \"str1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'N'"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[len(str1)-1] # Last character in string using len function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'N'"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[-1] # Last character in string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'P'"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[6] #Fetch 7th element of the string "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' '"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO'"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[0:5] # String slicing - Fetch all characters from 0 to 5 index location excluding the character at loc 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PYTHON'"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[6:12] # String slicing - Retreive all characters between 6 - 12 index loc excluding index loc 12."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THON'"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[-4:] # Retreive last four characters of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PYTHON'"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[-6:] # Retreive last six characters of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELL'"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[:4] # Retreive first four characters of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO '"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1[:6] # Retreive first six characters of the string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update & Delete String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO PYTHON'"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-214-ea670ff3ec72>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#Strings are immutable which means elements of a string cannot be changed once they have been assigned.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mstr1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'HOLAA'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "#Strings are immutable which means elements of a string cannot be changed once they have been assigned.\n",
    "str1[0:5] = 'HOLAA' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'srt1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-215-7fcc0cc83dcc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mstr1\u001b[0m \u001b[1;31m# Delete a string\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msrt1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'srt1' is not defined"
     ]
    }
   ],
   "source": [
    "del str1 # Delete a string\n",
    "print(srt1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HelloAsif\n"
     ]
    }
   ],
   "source": [
    "# String concatenation\n",
    "s1 = \"Hello\"\n",
    "s2 = \"Asif\"\n",
    "s3 = s1 + s2\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Asif\n"
     ]
    }
   ],
   "source": [
    "# String concatenation\n",
    "s1 = \"Hello\"\n",
    "s2 = \"Asif\"\n",
    "s3 = s1 + \" \" + s2\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating through a String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr1 = \"Hello Everyone\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "E\n",
      "v\n",
      "e\n",
      "r\n",
      "y\n",
      "o\n",
      "n\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "# Iteration  \n",
    "for i in mystr1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'H')\n",
      "(1, 'e')\n",
      "(2, 'l')\n",
      "(3, 'l')\n",
      "(4, 'o')\n",
      "(5, ' ')\n",
      "(6, 'E')\n",
      "(7, 'v')\n",
      "(8, 'e')\n",
      "(9, 'r')\n",
      "(10, 'y')\n",
      "(11, 'o')\n",
      "(12, 'n')\n",
      "(13, 'e')\n"
     ]
    }
   ],
   "source": [
    "for i in enumerate(mystr1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'H'),\n",
       " (1, 'e'),\n",
       " (2, 'l'),\n",
       " (3, 'l'),\n",
       " (4, 'o'),\n",
       " (5, ' '),\n",
       " (6, 'E'),\n",
       " (7, 'v'),\n",
       " (8, 'e'),\n",
       " (9, 'r'),\n",
       " (10, 'y'),\n",
       " (11, 'o'),\n",
       " (12, 'n'),\n",
       " (13, 'e')]"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(mystr1)) # Enumerate method adds a counter to an iterable and returns it in a form of enumerate object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# String membership\n",
    "\n",
    "mystr1 = \"Hello Everyone\"\n",
    "\n",
    "print ('Hello' in mystr1) # Check whether substring \"Hello\" is present in string \"mysrt1\"\n",
    "print ('Everyone' in mystr1) # Check whether substring \"Everyone\" is present in string \"mysrt1\"\n",
    "print ('Hi' in mystr1) # Check whether substring \"Hi\" is present in string \"mysrt1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Partitioning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Natural language processing with Python ', 'and', ' R and Java')\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "The partition() method searches for a specified string and splits the string into a tuple containing three elements.\n",
    "\n",
    " - The first element contains the part before the argument string.\n",
    "\n",
    " - The second element contains the argument string.\n",
    "\n",
    " - The third element contains the part after the argument string.\n",
    "\"\"\"\n",
    "\n",
    "str5 = \"Natural language processing with Python and R and Java\"\n",
    "L = str5.partition(\"and\") \n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Natural language processing with Python and R ', 'and', ' Java')\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "The rpartition() method searches for the last occurence of the specified string and splits the string into a tuple \n",
    "containing three elements.\n",
    "\n",
    " - The first element contains the part before the argument string.\n",
    "\n",
    " - The second element contains the argument string.\n",
    "\n",
    " - The third element contains the part after the argument string.\n",
    "\"\"\"\n",
    "\n",
    "str5 = \"Natural language processing with Python and R and Java\"\n",
    "L = str5.rpartition(\"and\") \n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   Hello Everyone  '"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2 = \"   Hello Everyone  \"\n",
    "mystr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Everyone'"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.strip() # Removes white space from begining & end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   Hello Everyone'"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.rstrip() # Removes all whitespaces at the end of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Everyone  '"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.lstrip() # Removes all whitespaces at the begining of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*********Hello Everyone***********All the Best**********'"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2 = \"*********Hello Everyone***********All the Best**********\"\n",
    "mystr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Everyone***********All the Best'"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.strip('*') # Removes all '*' characters from begining & end of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*********Hello Everyone***********All the Best'"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.rstrip('*') # Removes all '*' characters at the end of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Everyone***********All the Best**********'"
      ]
     },
     "execution_count": 275,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.lstrip('*') # Removes all '*' characters at the begining of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr2 = \"   Hello Everyone  \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   hello everyone  '"
      ]
     },
     "execution_count": 277,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.lower() # Return whole string in lowercase "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   HELLO EVERYONE  '"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.upper() # Return whole string in uppercase "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   Hollo Everyone  '"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.replace(\"He\" , \"Ho\") #Replace substring \"He\" with \"Ho\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HelloEveryone'"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr2.replace(\" \" , \"\") # Remove all whitespaces using replace function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr5 = \"one two Three one two two three\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr5.count(\"one\") # Number of times substring \"one\" occurred in string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr5.count(\"two\") # Number of times substring \"two\" occurred in string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr5.startswith(\"one\")  # Return boolean value True if string starts with \"one\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr5.endswith(\"three\") # Return boolean value True if string ends with \"three\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr4 = \"one two three four one two two three five five six seven six seven one one one ten eight ten nine eleven ten ten nine\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one',\n",
       " 'two',\n",
       " 'three',\n",
       " 'four',\n",
       " 'one',\n",
       " 'two',\n",
       " 'two',\n",
       " 'three',\n",
       " 'five',\n",
       " 'five',\n",
       " 'six',\n",
       " 'seven',\n",
       " 'six',\n",
       " 'seven',\n",
       " 'one',\n",
       " 'one',\n",
       " 'one',\n",
       " 'ten',\n",
       " 'eight',\n",
       " 'ten',\n",
       " 'nine',\n",
       " 'eleven',\n",
       " 'ten',\n",
       " 'ten',\n",
       " 'nine']"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = mystr4.split() # Split String into substrings\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost of item1 , item2 and item3 are 40 , 55 and 77\n"
     ]
    }
   ],
   "source": [
    "# Combining string & numbers using format method\n",
    "item1 = 40\n",
    "item2 = 55\n",
    "item3 = 77\n",
    "\n",
    "res = \"Cost of item1 , item2 and item3 are {} , {} and {}\"\n",
    "\n",
    "print(res.format(item1,item2,item3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost of item3 , item2 and item1 are 77 , 55 and 40\n"
     ]
    }
   ],
   "source": [
    "# Combining string & numbers using format method\n",
    "item1 = 40\n",
    "item2 = 55\n",
    "item3 = 77\n",
    "\n",
    "res = \"Cost of item3 , item2 and item1 are {2} , {1} and {0}\"\n",
    "\n",
    "print(res.format(item1,item2,item3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                          WELCOME EVERYONE                                          \n"
     ]
    }
   ],
   "source": [
    "str2 = \" WELCOME EVERYONE \"\n",
    "str2 = str2.center(100) # center align the string using a specific character as the fill character.\n",
    "print(str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***************************************** WELCOME EVERYONE *****************************************\n"
     ]
    }
   ],
   "source": [
    "str2 = \" WELCOME EVERYONE \"\n",
    "str2 = str2.center(100,'*') # center align the string using a specific character ('*') as the fill character.\n",
    "print(str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                 WELCOME EVERYONE \n"
     ]
    }
   ],
   "source": [
    "str2 = \" WELCOME EVERYONE \"\n",
    "str2 = str2.rjust(50) # Right align the string using a specific character as the fill character.\n",
    "print(str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "******************************** WELCOME EVERYONE \n"
     ]
    }
   ],
   "source": [
    "str2 = \" WELCOME EVERYONE \"\n",
    "str2 = str2.rjust(50,'*') # Right align the string using a specific character ('*') as the fill character.\n",
    "print(str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n"
     ]
    }
   ],
   "source": [
    "str4 = \"one two three four five six seven\"\n",
    "loc = str4.find(\"five\") # Find the location of word 'five' in the string \"str4\"\n",
    "print(loc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n"
     ]
    }
   ],
   "source": [
    "str4 = \"one two three four five six seven\"\n",
    "loc = str4.index(\"five\") # Find the location of word 'five' in the string \"str4\"\n",
    "print(loc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "mystr6 = '123456789'\n",
    "print(mystr6.isalpha()) # returns True if all the characters in the text are letters\n",
    "print(mystr6.isalnum())  # returns True if a string contains only letters or numbers or both\n",
    "print(mystr6.isdecimal()) # returns True if all the characters are decimals (0-9)\n",
    "print(mystr6.isnumeric()) # returns True if all the characters are numeric (0-9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "mystr6 = 'abcde'\n",
    "print(mystr6.isalpha()) # returns True if all the characters in the text are letters\n",
    "print(mystr6.isalnum())  # returns True if a string contains only letters or numbers or both\n",
    "print(mystr6.isdecimal()) # returns True if all the characters are decimals (0-9)\n",
    "print(mystr6.isnumeric()) # returns True if all the characters are numeric (0-9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "mystr6 = 'abc12309'\n",
    "print(mystr6.isalpha()) # returns True if all the characters in the text are letters\n",
    "print(mystr6.isalnum())  # returns True if a string contains only letters or numbers or both\n",
    "print(mystr6.isdecimal()) # returns True if all the characters are decimals (0-9)\n",
    "print(mystr6.isnumeric()) # returns True if all the characters are numeric (0-9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "mystr7 = 'ABCDEF'\n",
    "print(mystr7.isupper())  # Returns True if all the characters are in upper case\n",
    "print(mystr7.islower())  # Returns True if all the characters are in lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "mystr8 = 'abcdef'\n",
    "print(mystr8.isupper())  # Returns True if all the characters are in upper case\n",
    "print(mystr8.islower())  # Returns True if all the characters are in lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "51\n"
     ]
    }
   ],
   "source": [
    "str6 = \"one two three four one two two three five five six one ten eight ten nine eleven ten ten nine\"\n",
    "\n",
    "loc = str6.rfind(\"one\") # last occurrence of word 'one' in string \"str6\"\n",
    "print(loc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "51\n"
     ]
    }
   ],
   "source": [
    "loc = str6.rindex(\"one\") # last occurrence of word 'one' in string \"str6\"\n",
    "\n",
    "print(loc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   abc def ghi'"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "txt = \"   abc def ghi   \"\n",
    "\n",
    "txt.rstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc def ghi   '"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "txt = \"   abc def ghi   \"\n",
    "\n",
    "txt.lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc def ghi'"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "txt = \"   abc def ghi   \"\n",
    "\n",
    "txt.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Escape Character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-252-0fa35a74da86>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-252-0fa35a74da86>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    mystr = \"My favourite TV Series is \"Game of Thrones\"\"\u001b[0m\n\u001b[1;37m                                           ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "#Using double quotes in the string is not allowed.\n",
    "mystr = \"My favourite TV Series is \"Game of Thrones\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My favourite series is \"Game of Thrones\"\n"
     ]
    }
   ],
   "source": [
    "#Using escape character to allow illegal characters\n",
    "mystr = \"My favourite series is \\\"Game of Thrones\\\"\"\n",
    "print(mystr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) List is an ordered sequence of items. \n",
    "\n",
    "2) We can have different data types under a list. E.g we can have integer, float and string items in a same list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 423,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = []      # Empty List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 491,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print(type(list1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2 = [10,30,60]      # List of integers numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "metadata": {},
   "outputs": [],
   "source": [
    "list3 = [10.77,30.66,60.89]       # List of float numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "metadata": {},
   "outputs": [],
   "source": [
    "list4 = ['one','two' , \"three\"]   # List of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "metadata": {},
   "outputs": [],
   "source": [
    "list5 = ['Asif', 25 ,[50, 100],[150, 90]]    # Nested Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {},
   "outputs": [],
   "source": [
    "list6 = [100, 'Asif', 17.765]   # List of mixed data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "metadata": {},
   "outputs": [],
   "source": [
    "list7 = ['Asif', 25 ,[50, 100],[150, 90] , {'John' , 'David'}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 430,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list6) #Length of list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"list.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 432,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 432,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2[0] # Retreive first element of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 433,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'one'"
      ]
     },
     "execution_count": 433,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4[0] # Retreive first element of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 434,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 434,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4[0][0] # Nested indexing - Access the first character of the first list element "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'three'"
      ]
     },
     "execution_count": 435,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4[-1] # Last item of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[150, 90]"
      ]
     },
     "execution_count": 436,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list5[-1]  # Last item of the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 437,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = ['one' , 'two' , 'three' , 'four' , 'five' , 'six' , 'seven' , 'eight']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 438,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three']"
      ]
     },
     "execution_count": 438,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[0:3] # Return all items from 0th to 3rd index location excluding the item at loc 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 439,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['three', 'four', 'five']"
      ]
     },
     "execution_count": 439,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[2:5] # List all items from 2nd to 5th index location excluding the item at loc 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three']"
      ]
     },
     "execution_count": 440,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[:3] # Return first three items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 441,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two']"
      ]
     },
     "execution_count": 441,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[:2]  # Return first two items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['six', 'seven', 'eight']"
      ]
     },
     "execution_count": 442,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[-3:] # Return last three items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['seven', 'eight']"
      ]
     },
     "execution_count": 443,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[-2:] # Return last two items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'eight'"
      ]
     },
     "execution_count": 444,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[-1] # Return last item of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 445,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight']"
      ]
     },
     "execution_count": 445,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[:] # Return whole list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add , Remove & Change Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 446,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight']"
      ]
     },
     "execution_count": 446,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']"
      ]
     },
     "execution_count": 447,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.append('nine') # Add an item to the end of the list  \n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 448,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']"
      ]
     },
     "execution_count": 448,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.insert(9,'ten') # Add item at index location 9\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 449,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one',\n",
       " 'ONE',\n",
       " 'two',\n",
       " 'three',\n",
       " 'four',\n",
       " 'five',\n",
       " 'six',\n",
       " 'seven',\n",
       " 'eight',\n",
       " 'nine',\n",
       " 'ten']"
      ]
     },
     "execution_count": 449,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.insert(1,'ONE') # Add item at index location 1\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 450,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']"
      ]
     },
     "execution_count": 450,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.remove('ONE') # Remove item \"ONE\"\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 451,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']"
      ]
     },
     "execution_count": 451,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.pop() # Remove last item of the list\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 452,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight']"
      ]
     },
     "execution_count": 452,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.pop(8) # Remove item at index location 8\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 453,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven']"
      ]
     },
     "execution_count": 453,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del mylist[7] # Remove item at index location 7\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 454,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 'four', 'five', 'six', 'seven']"
      ]
     },
     "execution_count": 454,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Change value of the string\n",
    "mylist[0] = 1\n",
    "mylist[1] = 2\n",
    "mylist[2] = 3\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 455,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 455,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.clear()  # Empty List / Delete all items in the list\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 456,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'mylist' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-456-50c7849aa2cb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mmylist\u001b[0m \u001b[1;31m# Delete the whole list\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mmylist\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'mylist' is not defined"
     ]
    }
   ],
   "source": [
    "del mylist # Delete the whole list\n",
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copy List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 457,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 458,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist1 = mylist # Create a new reference \"mylist1\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 459,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1537348392776, 1537348392776)"
      ]
     },
     "execution_count": 459,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(mylist) , id(mylist1) # The address of both mylist & mylist1 will be the same as both are pointing to same list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 460,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist2 = mylist.copy() # Create a copy of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1537345955016"
      ]
     },
     "execution_count": 461,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(mylist2) # The address of mylist2 will be different from mylist because mylist2 is pointing to the copy of the existing list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 463,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']"
      ]
     },
     "execution_count": 463,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 464,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']"
      ]
     },
     "execution_count": 464,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist1 # mylist1 will be also impacted as it is pointing to the same list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 465,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']"
      ]
     },
     "execution_count": 465,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist2 # Copy of list won't be impacted due to changes made on the original list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Join Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 466,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['one', 'two', 'three', 'four']\n",
    "list2 = ['five', 'six', 'seven', 'eight']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 467,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight']"
      ]
     },
     "execution_count": 467,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list3 = list1 + list2 # Join two lists by '+' operator\n",
    "list3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 468,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight']"
      ]
     },
     "execution_count": 468,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1.extend(list2) #Append list2 with list1\n",
    "list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 469,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight']"
      ]
     },
     "execution_count": 469,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 470,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 470,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'one' in list1 # Check if 'one' exist in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 471,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 471,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ten' in list1 # Check if 'ten' exist in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 472,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Three is present in the list\n"
     ]
    }
   ],
   "source": [
    "if 'three' in list1: # Check if 'three' exist in the list\n",
    "    print('Three is present in the list')\n",
    "else:\n",
    "    print('Three is not present in the list')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 473,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eleven is not present in the list\n"
     ]
    }
   ],
   "source": [
    "if 'eleven' in list1:  # Check if 'eleven' exist in the list\n",
    "    print('eleven is present in the list')\n",
    "else:\n",
    "    print('eleven is not present in the list')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reverse & Sort List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 474,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight']"
      ]
     },
     "execution_count": 474,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 475,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['eight', 'seven', 'six', 'five', 'four', 'three', 'two', 'one']"
      ]
     },
     "execution_count": 475,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1.reverse() # Reverse the list\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 476,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight']"
      ]
     },
     "execution_count": 476,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = list1[::-1] # Reverse the list\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 477,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 9, 12, 34, 88, 99]"
      ]
     },
     "execution_count": 477,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist3 = [9,5,2,99,12,88,34]\n",
    "mylist3.sort()   # Sort list in ascending order\n",
    "mylist3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 478,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[99, 88, 34, 12, 9, 5, 2]"
      ]
     },
     "execution_count": 478,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist3 = [9,5,2,99,12,88,34]\n",
    "mylist3.sort(reverse=True)  # Sort list in descending order\n",
    "mylist3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 584,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 21, 33, 65, 88, 98]"
      ]
     },
     "execution_count": 584,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist4 = [88,65,33,21,11,98]\n",
    "sorted(mylist4)        # Returns a new sorted list and doesn't change original list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 585,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[88, 65, 33, 21, 11, 98]"
      ]
     },
     "execution_count": 585,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loop through a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 481,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight']"
      ]
     },
     "execution_count": 481,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 482,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n",
      "two\n",
      "three\n",
      "four\n",
      "five\n",
      "six\n",
      "seven\n",
      "eight\n"
     ]
    }
   ],
   "source": [
    "for i in list1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 483,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'one')\n",
      "(1, 'two')\n",
      "(2, 'three')\n",
      "(3, 'four')\n",
      "(4, 'five')\n",
      "(5, 'six')\n",
      "(6, 'seven')\n",
      "(7, 'eight')\n"
     ]
    }
   ],
   "source": [
    "for i in enumerate(list1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 485,
   "metadata": {},
   "outputs": [],
   "source": [
    "list10 =['one', 'two', 'three', 'four', 'one', 'one', 'two', 'three']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 486,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 486,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list10.count('one') # Number of times item \"one\" occurred in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 487,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 487,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list10.count('two') # Occurence of item 'two' in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 489,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 489,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list10.count('four') #Occurence of item 'four' in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### All / Any"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The __all()__ method returns:\n",
    "\n",
    "- __True__ - If all elements in a list are true\n",
    "- __False__ - If any element in a list is false\n",
    "\n",
    "\n",
    "The __any()__ function returns True if any element in the list is True. If not, any() returns False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 816,
   "metadata": {},
   "outputs": [],
   "source": [
    "L1 = [1,2,3,4,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 817,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 817,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all(L1) # Will Return false as one value is false (Value 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 818,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 818,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any(L1)  # Will Return True as we have items in the list with True value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 819,
   "metadata": {},
   "outputs": [],
   "source": [
    "L2 = [1,2,3,4,True,False]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 820,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 820,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all(L2) # Returns false as one value is false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 821,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 821,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any(L2)  # Will Return True as we have items in the list with True value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 822,
   "metadata": {},
   "outputs": [],
   "source": [
    "L3 = [1,2,3,True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 823,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 823,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all(L3) # Will return True as all items in the list are True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 824,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 824,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any(L3) # Will Return True as we have items in the list with True value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- List Comprehensions provide an elegant way to create new lists.\n",
    "\n",
    "- It consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['W', 'E', 'L', 'C', 'O', 'M', 'E']"
      ]
     },
     "execution_count": 287,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystring = \"WELCOME\"\n",
    "mylist = [ i for i in mystring ] # Iterating through a string Using List Comprehension\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38]"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist1 = [ i for i in range(40) if i % 2 == 0] # Display all even numbers between 0 - 40 using List Comprehension\n",
    "mylist1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39]"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist2 = [ i for i in range(40) if i % 2 == 1] # Display all odd numbers between 0 - 40 using List Comprehension\n",
    "mylist2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 325,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist3 = [num**2 for num in range(10)] # calculate square of all numbers between 0 - 10 using List Comprehension\n",
    "mylist3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Lcomprehension.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[20, 30, 40, 50, 60, 70, 80]"
      ]
     },
     "execution_count": 317,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiple whole list by 10\n",
    "list1 = [2,3,4,5,6,7,8]\n",
    "list1 = [i*10 for i in list1]\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 36, 72, 108, 144, 180]"
      ]
     },
     "execution_count": 299,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#List all numbers divisible by 3 , 9 & 12 using nested \"if\" with List Comprehension\n",
    "mylist4 = [i for i in range(200) if i % 3 == 0 if i % 9 == 0 if i % 12 == 0]\n",
    "mylist4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is Even Number\n",
      "1 is odd number\n",
      "2 is Even Number\n",
      "3 is odd number\n",
      "4 is Even Number\n",
      "5 is odd number\n",
      "6 is Even Number\n",
      "7 is odd number\n",
      "8 is Even Number\n",
      "9 is odd number\n"
     ]
    }
   ],
   "source": [
    "# Odd even test\n",
    "l1 = [print(\"{} is Even Number\".format(i)) if i%2==0 else print(\"{} is odd number\".format(i)) for i in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2', '3', '4', '5', '6', '7', '8', '9']"
      ]
     },
     "execution_count": 315,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract numbers from a string\n",
    "mystr = \"One 1 two 2 three 3 four 4 five 5 six 6789\"\n",
    "numbers = [i for i in mystr if i.isdigit()]\n",
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['O',\n",
       " 'n',\n",
       " 'e',\n",
       " 't',\n",
       " 'w',\n",
       " 'o',\n",
       " 't',\n",
       " 'h',\n",
       " 'r',\n",
       " 'e',\n",
       " 'e',\n",
       " 'f',\n",
       " 'o',\n",
       " 'u',\n",
       " 'r',\n",
       " 'f',\n",
       " 'i',\n",
       " 'v',\n",
       " 'e',\n",
       " 's',\n",
       " 'i',\n",
       " 'x']"
      ]
     },
     "execution_count": 316,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract letters from a string\n",
    "\n",
    "mystr = \"One 1 two 2 three 3 four 4 five 5 six 6789\"\n",
    "numbers = [i for i in mystr if i.isalpha()]\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Tuple is similar to List except that the objects in tuple are immutable which means we cannot change the elements of a tuple once assigned. \n",
    "\n",
    "2. When we do not want to change the data over time, tuple is a preferred data type.\n",
    "\n",
    "3. Iterating over the elements of a tuple is faster compared to iterating over a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 533,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup1 = ()      # Empty tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 534,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup2 = (10,30,60)      # tuple of integers numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 535,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup3 = (10.77,30.66,60.89)       # tuple of float numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 536,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup4 = ('one','two' , \"three\")   # tuple of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 537,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup5 = ('Asif', 25 ,(50, 100),(150, 90))   # Nested tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 538,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup6 = (100, 'Asif', 17.765)   # Tuple of mixed data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 539,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup7 = ('Asif', 25 ,[50, 100],[150, 90] , {'John' , 'David'} , (99,22,33))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 540,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 540,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(tup7) #Length of list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 541,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 541,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup2[0] # Retreive first element of the tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 542,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'one'"
      ]
     },
     "execution_count": 542,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup4[0] # Retreive first element of the tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 543,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 543,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup4[0][0] # Nested indexing - Access the first character of the first tuple element "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 544,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'three'"
      ]
     },
     "execution_count": 544,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup4[-1] # Last item of the tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 545,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 90)"
      ]
     },
     "execution_count": 545,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup5[-1]  # Last item of the tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 560,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple = ('one' , 'two' , 'three' , 'four' , 'five' , 'six' , 'seven' , 'eight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 547,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 'two', 'three')"
      ]
     },
     "execution_count": 547,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[0:3] # Return all items from 0th to 3rd index location excluding the item at loc 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 548,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('three', 'four', 'five')"
      ]
     },
     "execution_count": 548,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[2:5] # List all items from 2nd to 5th index location excluding the item at loc 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 549,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 'two', 'three')"
      ]
     },
     "execution_count": 549,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[:3] # Return first three items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 550,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 'two')"
      ]
     },
     "execution_count": 550,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[:2]  # Return first two items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 551,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('six', 'seven', 'eight')"
      ]
     },
     "execution_count": 551,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[-3:] # Return last three items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 552,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('seven', 'eight')"
      ]
     },
     "execution_count": 552,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[-2:] # Return last two items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 553,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'eight'"
      ]
     },
     "execution_count": 553,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[-1] # Return last item of the tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 554,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight')"
      ]
     },
     "execution_count": 554,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[:] # Return whole tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove & Change Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 555,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight')"
      ]
     },
     "execution_count": 555,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 556,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object doesn't support item deletion",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-556-667a276aa503>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mdel\u001b[0m \u001b[0mmytuple\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion"
     ]
    }
   ],
   "source": [
    "del mytuple[0] # Tuples are immutable which means we can't DELETE tuple items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-557-4cf492702bfd>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmytuple\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "mytuple[0] = 1 # Tuples are immutable which means we can't CHANGE tuple items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {},
   "outputs": [],
   "source": [
    "del mytuple # Deleting entire tuple object is possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loop through a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 570,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight')"
      ]
     },
     "execution_count": 570,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 571,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n",
      "two\n",
      "three\n",
      "four\n",
      "five\n",
      "six\n",
      "seven\n",
      "eight\n"
     ]
    }
   ],
   "source": [
    "for i in mytuple:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 572,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'one')\n",
      "(1, 'two')\n",
      "(2, 'three')\n",
      "(3, 'four')\n",
      "(4, 'five')\n",
      "(5, 'six')\n",
      "(6, 'seven')\n",
      "(7, 'eight')\n"
     ]
    }
   ],
   "source": [
    "for i in enumerate(mytuple):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 573,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple1 =('one', 'two', 'three', 'four', 'one', 'one', 'two', 'three')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 574,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 574,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple1.count('one') # Number of times item \"one\" occurred in the tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 575,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 575,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple1.count('two') # Occurence of item 'two' in the tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 576,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 576,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple1.count('four') #Occurence of item 'four' in the tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 577,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight')"
      ]
     },
     "execution_count": 577,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 578,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 578,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'one' in mytuple # Check if 'one' exist in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 579,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 579,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ten' in mytuple # Check if 'ten' exist in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 581,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Three is present in the tuple\n"
     ]
    }
   ],
   "source": [
    "if 'three' in mytuple: # Check if 'three' exist in the list\n",
    "    print('Three is present in the tuple')\n",
    "else:\n",
    "    print('Three is not present in the tuple')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 583,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eleven is not present in the tuple\n"
     ]
    }
   ],
   "source": [
    "if 'eleven' in mytuple:  # Check if 'eleven' exist in the list\n",
    "    print('eleven is present in the tuple')\n",
    "else:\n",
    "    print('eleven is not present in the tuple')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index Position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 586,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight')"
      ]
     },
     "execution_count": 586,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 587,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 587,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple.index('one') # Index of first element equal to 'one'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 590,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 590,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple.index('five') # Index of first element equal to 'five'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 591,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 'two', 'three', 'four', 'one', 'one', 'two', 'three')"
      ]
     },
     "execution_count": 591,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 593,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 593,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple1.index('one') # Index of first element equal to 'one'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 594,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple2 = (43,67,99,12,6,90,67)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 595,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 12, 43, 67, 67, 90, 99]"
      ]
     },
     "execution_count": 595,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(mytuple2)  # Returns a new sorted list and doesn't change original tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 596,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[99, 90, 67, 67, 43, 12, 6]"
      ]
     },
     "execution_count": 596,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(mytuple2, reverse=True) # Sort in descending order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Unordered & Unindexed collection of items.\n",
    "\n",
    "2) Set elements are unique. Duplicate elements are not allowed.\n",
    "\n",
    "3) Set elements are immutable (cannot be changed).\n",
    "\n",
    "4) Set itself is mutable. We can add or remove items from it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 634,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 634,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset = {1,2,3,4,5} # Set of numbers\n",
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 635,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 635,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(myset) #Length of the set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 636,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 636,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set = {1,1,2,2,3,4,5,5}\n",
    "my_set                    # Duplicate elements are not allowed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 637,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1.79, 2.08, 3.99, 4.56, 5.45}"
      ]
     },
     "execution_count": 637,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset1 = {1.79,2.08,3.99,4.56,5.45} # Set of float numbers\n",
    "myset1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 638,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Asif', 'John', 'Tyrion'}"
      ]
     },
     "execution_count": 638,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset2 = {'Asif' , 'John' , 'Tyrion'} # Set of Strings\n",
    "myset2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 639,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(11, 22, 32), 10, 20, 'Hola'}"
      ]
     },
     "execution_count": 639,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset3 = {10,20, \"Hola\", (11, 22, 32)} # Mixed datatypes\n",
    "myset3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 640,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-640-d23fdc3a319e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmyset3\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"Hola\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m11\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m22\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m32\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m \u001b[1;31m# set doesn't allow mutable items like lists\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mmyset3\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "myset3 = {10,20, \"Hola\", [11, 22, 32]} # set doesn't allow mutable items like lists\n",
    "myset3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 641,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "myset4 = set() # Create an empty set\n",
    "print(type(myset4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 673,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'four', 'one', 'three', 'two'}"
      ]
     },
     "execution_count": 673,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set1 = set(('one' , 'two' , 'three' , 'four'))\n",
    "my_set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loop through a Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 776,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eight\n",
      "one\n",
      "seven\n",
      "three\n",
      "five\n",
      "two\n",
      "six\n",
      "four\n"
     ]
    }
   ],
   "source": [
    "myset = {'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight'}\n",
    "\n",
    "for i in myset:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 777,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'eight')\n",
      "(1, 'one')\n",
      "(2, 'seven')\n",
      "(3, 'three')\n",
      "(4, 'five')\n",
      "(5, 'two')\n",
      "(6, 'six')\n",
      "(7, 'four')\n"
     ]
    }
   ],
   "source": [
    "for i in enumerate(myset):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 675,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'eight', 'five', 'four', 'one', 'seven', 'six', 'three', 'two'}"
      ]
     },
     "execution_count": 675,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 676,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 676,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'one' in myset # Check if 'one' exist in the set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 677,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 677,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ten' in myset # Check if 'ten' exist in the set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 678,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Three is present in the set\n"
     ]
    }
   ],
   "source": [
    "if 'three' in myset: # Check if 'three' exist in the set\n",
    "    print('Three is present in the set')\n",
    "else:\n",
    "    print('Three is not present in the set')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 679,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eleven is not present in the set\n"
     ]
    }
   ],
   "source": [
    "if 'eleven' in myset:  # Check if 'eleven' exist in the list\n",
    "    print('eleven is present in the set')\n",
    "else:\n",
    "    print('eleven is not present in the set')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add & Remove Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 680,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'eight', 'five', 'four', 'one', 'seven', 'six', 'three', 'two'}"
      ]
     },
     "execution_count": 680,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 681,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'NINE', 'eight', 'five', 'four', 'one', 'seven', 'six', 'three', 'two'}"
      ]
     },
     "execution_count": 681,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset.add('NINE') # Add item to a set using add() method\n",
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 683,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ELEVEN',\n",
       " 'NINE',\n",
       " 'TEN',\n",
       " 'TWELVE',\n",
       " 'eight',\n",
       " 'five',\n",
       " 'four',\n",
       " 'one',\n",
       " 'seven',\n",
       " 'six',\n",
       " 'three',\n",
       " 'two'}"
      ]
     },
     "execution_count": 683,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset.update(['TEN' , 'ELEVEN' , 'TWELVE'])  # Add multiple item to a set using update() method\n",
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 684,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ELEVEN',\n",
       " 'TEN',\n",
       " 'TWELVE',\n",
       " 'eight',\n",
       " 'five',\n",
       " 'four',\n",
       " 'one',\n",
       " 'seven',\n",
       " 'six',\n",
       " 'three',\n",
       " 'two'}"
      ]
     },
     "execution_count": 684,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset.remove('NINE') # remove item in a set using remove() method\n",
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 685,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ELEVEN',\n",
       " 'TWELVE',\n",
       " 'eight',\n",
       " 'five',\n",
       " 'four',\n",
       " 'one',\n",
       " 'seven',\n",
       " 'six',\n",
       " 'three',\n",
       " 'two'}"
      ]
     },
     "execution_count": 685,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset.discard('TEN') # remove item from a set using discard() method\n",
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 688,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 688,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset.clear() # Delete all items in a set\n",
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 689,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'myset' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-689-0912ea1b8932>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mmyset\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mmyset\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'myset' is not defined"
     ]
    }
   ],
   "source": [
    "del myset # Delete the set object\n",
    "myset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copy Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 705,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'eight', 'five', 'four', 'one', 'seven', 'six', 'three', 'two'}"
      ]
     },
     "execution_count": 705,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset = {'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight'}\n",
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 706,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'eight', 'five', 'four', 'one', 'seven', 'six', 'three', 'two'}"
      ]
     },
     "execution_count": 706,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset1 = myset  # Create a new reference \"myset1\" \n",
    "myset1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 707,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1537349033320, 1537349033320)"
      ]
     },
     "execution_count": 707,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(myset) , id(myset1)  # The address of both myset & myset1 will be the same as both are pointing to same set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 708,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'eight', 'five', 'four', 'one', 'seven', 'six', 'three', 'two'}"
      ]
     },
     "execution_count": 708,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set = myset.copy() # Create a copy of the list\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 710,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1537352902024"
      ]
     },
     "execution_count": 710,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(my_set) # The address of my_set will be different from myset because my_set is pointing to the copy of the existing set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 711,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'eight', 'five', 'four', 'nine', 'one', 'seven', 'six', 'three', 'two'}"
      ]
     },
     "execution_count": 711,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset.add('nine')\n",
    "myset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 712,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'eight', 'five', 'four', 'nine', 'one', 'seven', 'six', 'three', 'two'}"
      ]
     },
     "execution_count": 712,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset1 # myset1 will be also impacted as it is pointing to the same Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 713,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'eight', 'five', 'four', 'one', 'seven', 'six', 'three', 'two'}"
      ]
     },
     "execution_count": 713,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set # Copy of the set won't be impacted due to changes made on the original Set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Operation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 757,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = {1,2,3,4,5}\n",
    "B = {4,5,6,7,8}\n",
    "C = {8,9,10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 758,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8}"
      ]
     },
     "execution_count": 758,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A | B  # Union of A and B (All elements from both sets. NO DUPLICATES)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 759,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8}"
      ]
     },
     "execution_count": 759,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.union(B) # Union of A and B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 760,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 760,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.union(B, C)  # Union of A, B and C."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 761,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 761,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Updates the set calling the update() method with union of A , B & C. \n",
    "\n",
    "For below example Set A will be updated with union of A,B & C.\n",
    "\"\"\"\n",
    "A.update(B,C)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/3/30/Venn0111.svg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 762,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = {1,2,3,4,5}\n",
    "B = {4,5,6,7,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 763,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 763,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A & B  # Intersection of A and B (Common items in both sets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 764,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-764-f01b60f4d31d>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-764-f01b60f4d31d>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    A.intersection(B)  Intersection of A and B\u001b[0m\n\u001b[1;37m                                  ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "A.intersection(B)  Intersection of A and B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 765,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 765,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Updates the set calling the intersection_update() method with the intersection of sets.\n",
    "\n",
    "For below example Set A will be updated  with the intersection of A & B.\n",
    "\"\"\"\n",
    "A.intersection_update(B)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/9/99/Venn0001.svg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 766,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = {1,2,3,4,5}\n",
    "B = {4,5,6,7,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 767,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 767,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A - B  # set of elements that are only in A but not in B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 768,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 768,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.difference(B) # Difference of sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 769,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 7, 8}"
      ]
     },
     "execution_count": 769,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B- A  # set of elements that are only in B but not in A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 770,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 7, 8}"
      ]
     },
     "execution_count": 770,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.difference(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 771,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 7, 8}"
      ]
     },
     "execution_count": 771,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Updates the set calling the difference_update() method with the difference of sets.\n",
    "\n",
    "For below example Set B will be updated  with the difference of B & A.\n",
    "\"\"\"\n",
    "B.difference_update(A)\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/5/5a/Venn0010.svg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Symmetric Difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 772,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = {1,2,3,4,5}\n",
    "B = {4,5,6,7,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 773,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 6, 7, 8}"
      ]
     },
     "execution_count": 773,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A ^ B # Symmetric difference (Set of elements in A and B but not in both. \"EXCLUDING THE INTERSECTION\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 774,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 6, 7, 8}"
      ]
     },
     "execution_count": 774,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.symmetric_difference(B)  # Symmetric difference of sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 775,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 6, 7, 8}"
      ]
     },
     "execution_count": 775,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Updates the set calling the symmetric_difference_update() method with the symmetric difference of sets.\n",
    "\n",
    "For below example Set A will be updated  with the symmetric difference of A & B.\n",
    "\"\"\"\n",
    "\n",
    "A.symmetric_difference_update(B)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/4/46/Venn0110.svg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subset , Superset & Disjoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 784,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = {1,2,3,4,5,6,7,8,9}\n",
    "B = {3,4,5,6,7,8}\n",
    "C = {10,20,30,40}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 785,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 785,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.issubset(A) # Set B is said to be the subset of set A if all elements of B are in A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 786,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 786,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.issuperset(B) # Set A is said to be the superset of set B if all elements of B are in A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 787,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 787,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.isdisjoint(A) # Two sets are said to be disjoint sets if they have no common elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 788,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 788,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.isdisjoint(A) # Two sets are said to be disjoint sets if they have no common elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other Builtin functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 789,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 789,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 790,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 790,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 791,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 791,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 792,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 792,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 793,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 793,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 795,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9)]"
      ]
     },
     "execution_count": 795,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 798,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 8, 7, 6, 5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 798,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D= sorted(A,reverse=True)\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 799,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 799,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Dictionary is a mutable data type in Python. \n",
    "\n",
    "- A python dictionary is a collection of key and value pairs separated by a colon (:) & enclosed in curly braces {}.\n",
    "\n",
    "- Keys must be unique in a dictionary, duplicate values are allowed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"dict.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Dictionary "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 947,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 947,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = dict() # empty dictionary\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 948,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 948,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {}   # empty dictionary\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 949,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'one', 2: 'two', 3: 'three'}"
      ]
     },
     "execution_count": 949,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {1:'one' , 2:'two' , 3:'three'} # dictionary with integer keys\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 950,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'one', 2: 'two', 3: 'three'}"
      ]
     },
     "execution_count": 950,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = dict({1:'one' , 2:'two' , 3:'three'}) # Create dictionary using dict()\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 951,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 'one', 'B': 'two', 'C': 'three'}"
      ]
     },
     "execution_count": 951,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {'A':'one' , 'B':'two' , 'C':'three'} # dictionary with character keys\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'one', 'A': 'two', 3: 'three'}"
      ]
     },
     "execution_count": 318,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {1:'one' , 'A':'two' , 3:'three'} # dictionary with mixed keys\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys([1, 'A', 3])"
      ]
     },
     "execution_count": 319,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict.keys() # Return Dictionary Keys using keys() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['one', 'two', 'three'])"
      ]
     },
     "execution_count": 320,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict.values() # Return Dictionary Values using values() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([(1, 'one'), ('A', 'two'), (3, 'three')])"
      ]
     },
     "execution_count": 321,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict.items() # Access each key-value pair within a dictionary "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 955,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'one', 2: 'two', 'A': ['asif', 'john', 'Maria']}"
      ]
     },
     "execution_count": 955,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {1:'one' , 2:'two' , 'A':['asif' , 'john' , 'Maria']} # dictionary with mixed keys\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 956,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'one',\n",
       " 2: 'two',\n",
       " 'A': ['asif', 'john', 'Maria'],\n",
       " 'B': ('Bat', 'cat', 'hat')}"
      ]
     },
     "execution_count": 956,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {1:'one' , 2:'two' , 'A':['asif' , 'john' , 'Maria'],  'B':('Bat' , 'cat' , 'hat')} # dictionary with mixed keys\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'one',\n",
       " 2: 'two',\n",
       " 'A': {'Name': 'asif', 'Age': 20},\n",
       " 'B': ('Bat', 'cat', 'hat')}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {1:'one' , 2:'two' , 'A':{'Name':'asif' , 'Age' :20},  'B':('Bat' , 'cat' , 'hat')} # dictionary with mixed keys\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 957,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'c': None, 'd': None, 'a': None, 'b': None}"
      ]
     },
     "execution_count": 957,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys = {'a' , 'b' , 'c' , 'd'}\n",
    "mydict3 = dict.fromkeys(keys)   # Create a dictionary from a sequence of keys\n",
    "mydict3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 958,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'c': 10, 'd': 10, 'a': 10, 'b': 10}"
      ]
     },
     "execution_count": 958,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys = {'a' , 'b' , 'c' , 'd'}\n",
    "value = 10\n",
    "mydict3 = dict.fromkeys(keys , value)  # Create a dictionary from a sequence of keys with value\n",
    "mydict3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 959,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'c': [10, 20, 30], 'd': [10, 20, 30], 'a': [10, 20, 30], 'b': [10, 20, 30]}"
      ]
     },
     "execution_count": 959,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys = {'a' , 'b' , 'c' , 'd'}\n",
    "value = [10,20,30]\n",
    "mydict3 = dict.fromkeys(keys , value)  # Create a dictionary from a sequence of keys with value list\n",
    "mydict3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 960,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'c': [10, 20, 30, 40],\n",
       " 'd': [10, 20, 30, 40],\n",
       " 'a': [10, 20, 30, 40],\n",
       " 'b': [10, 20, 30, 40]}"
      ]
     },
     "execution_count": 960,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value.append(40)\n",
    "mydict3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 961,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'one', 2: 'two', 3: 'three', 4: 'four'}"
      ]
     },
     "execution_count": 961,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {1:'one' , 2:'two' , 3:'three' , 4:'four'}\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 962,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'one'"
      ]
     },
     "execution_count": 962,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict[1] # Access item using key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 963,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'one'"
      ]
     },
     "execution_count": 963,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict.get(1) # Access item using get() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 964,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 74123, 'DOB': 1991, 'job': 'Analyst'}"
      ]
     },
     "execution_count": 964,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1 = {'Name':'Asif' , 'ID': 74123 , 'DOB': 1991 , 'job' :'Analyst'}\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 965,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Asif'"
      ]
     },
     "execution_count": 965,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1['Name']  # Access item using key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 966,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Analyst'"
      ]
     },
     "execution_count": 966,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1.get('job')  # Access item using get() method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add, Remove & Change Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 967,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1991, 'Address': 'Hilsinki'}"
      ]
     },
     "execution_count": 967,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1 = {'Name':'Asif' , 'ID': 12345 , 'DOB': 1991 , 'Address' : 'Hilsinki'}\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 968,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1992, 'Address': 'Delhi'}"
      ]
     },
     "execution_count": 968,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1['DOB'] = 1992  # Changing Dictionary Items\n",
    "mydict1['Address'] = 'Delhi'\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 969,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1995, 'Address': 'Delhi'}"
      ]
     },
     "execution_count": 969,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1 = {'DOB':1995}\n",
    "mydict1.update(dict1)\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 970,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif',\n",
       " 'ID': 12345,\n",
       " 'DOB': 1995,\n",
       " 'Address': 'Delhi',\n",
       " 'Job': 'Analyst'}"
      ]
     },
     "execution_count": 970,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1['Job'] = 'Analyst' # Adding items in the dictionary\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 971,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1995, 'Address': 'Delhi'}"
      ]
     },
     "execution_count": 971,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1.pop('Job') # Removing items in the dictionary using Pop method\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 972,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Address', 'Delhi')"
      ]
     },
     "execution_count": 972,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1.popitem() # A random item is removed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 973,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1995}"
      ]
     },
     "execution_count": 973,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 974,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'DOB': 1995}"
      ]
     },
     "execution_count": 974,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del[mydict1['ID']] # Removing item using del method\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 975,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 975,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1.clear() # Delete all items of the dictionary using clear method\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 976,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'mydict1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-976-da2fba4eca0f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mmydict1\u001b[0m \u001b[1;31m# Delete the dictionary object\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mmydict1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'mydict1' is not defined"
     ]
    }
   ],
   "source": [
    "del mydict1 # Delete the dictionary object\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copy Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 977,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1991, 'Address': 'Hilsinki'}"
      ]
     },
     "execution_count": 977,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {'Name':'Asif' , 'ID': 12345 , 'DOB': 1991 , 'Address' : 'Hilsinki'}\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 978,
   "metadata": {},
   "outputs": [],
   "source": [
    "mydict1 = mydict # Create a new reference \"mydict1\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 979,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1537346312776, 1537346312776)"
      ]
     },
     "execution_count": 979,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(mydict) , id(mydict1) # The address of both mydict & mydict1 will be the same as both are pointing to same dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 980,
   "metadata": {},
   "outputs": [],
   "source": [
    "mydict2 = mydict.copy() # Create a copy of the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 981,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1537345875784"
      ]
     },
     "execution_count": 981,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(mydict2) # The address of mydict2 will be different from mydict because mydict2 is pointing to the copy of the existing dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 982,
   "metadata": {},
   "outputs": [],
   "source": [
    "mydict['Address'] = 'Mumbai'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 983,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1991, 'Address': 'Mumbai'}"
      ]
     },
     "execution_count": 983,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 984,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1991, 'Address': 'Mumbai'}"
      ]
     },
     "execution_count": 984,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1 # mydict1 will be also impacted as it is pointing to the same dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 985,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1991, 'Address': 'Hilsinki'}"
      ]
     },
     "execution_count": 985,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict2 # Copy of list won't be impacted due to the changes made in the original dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loop through a Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 986,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif',\n",
       " 'ID': 12345,\n",
       " 'DOB': 1991,\n",
       " 'Address': 'Hilsinki',\n",
       " 'Job': 'Analyst'}"
      ]
     },
     "execution_count": 986,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1 = {'Name':'Asif' , 'ID': 12345 , 'DOB': 1991 , 'Address' : 'Hilsinki' , 'Job': 'Analyst'}\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 987,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name : Asif\n",
      "ID : 12345\n",
      "DOB : 1991\n",
      "Address : Hilsinki\n",
      "Job : Analyst\n"
     ]
    }
   ],
   "source": [
    "for i in mydict1:\n",
    "    print(i , ':' , mydict1[i]) # Key & value pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 988,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Asif\n",
      "12345\n",
      "1991\n",
      "Hilsinki\n",
      "Analyst\n"
     ]
    }
   ],
   "source": [
    "for i in mydict1:\n",
    "    print(mydict1[i]) # Dictionary items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 989,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1991, 'Job': 'Analyst'}"
      ]
     },
     "execution_count": 989,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1 = {'Name':'Asif' , 'ID': 12345 , 'DOB': 1991 , 'Job': 'Analyst'}\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 990,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 990,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Name' in mydict1 # Test if a key is in a dictionary or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 991,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 991,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Asif' in mydict1  # Membership test can be only done for keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 992,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 992,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ID' in mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 993,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 993,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Address' in mydict1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### All / Any"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The __all()__ method returns:\n",
    "\n",
    "- __True__ - If all all keys of the dictionary are true\n",
    "- __False__ - If any key of the dictionary is false\n",
    "\n",
    "\n",
    "The __any()__ function returns True if any key of the dictionary is True. If not, any() returns False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 995,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1991, 'Job': 'Analyst'}"
      ]
     },
     "execution_count": 995,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1 = {'Name':'Asif' , 'ID': 12345 , 'DOB': 1991 , 'Job': 'Analyst'}\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 996,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 996,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all(mydict1) # Will Return false as one value is false (Value 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 997,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 997,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any(mydict1)  # Will Return True as we have items in the dictionary with True value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 998,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1991, 'Job': 'Analyst', 0: 'test1'}"
      ]
     },
     "execution_count": 998,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1[0] = 'test1'\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 999,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 999,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all(mydict1) # Returns false as one value is false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1000,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1000,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any(mydict1)  # Will Return True as we have items in the dictionary with True value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}"
      ]
     },
     "execution_count": 323,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double = {i:i*2 for i in range(10)} #double each value using dict comprehension\n",
    "double"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}"
      ]
     },
     "execution_count": 327,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square = {i:i**2 for i in range(10)}\n",
    "square"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Dcomprehension.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key = ['one' , 'two' , 'three' , 'four' , 'five']\n",
    "value = [1,2,3,4,5]\n",
    "\n",
    "mydict = {k:v for (k,v) in zip(key,value)} # using dict comprehension to create dictionary\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1.0, 'b': 2.0, 'c': 3.0, 'd': 4.0, 'e': 5.0}"
      ]
     },
     "execution_count": 332,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict1 = {'a':10 , 'b':20 , 'c':30 , 'd':40 , 'e':50}\n",
    "mydict1 = {k:v/10 for (k,v) in mydict1.items()} # Divide all values in a dictionary by 10\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'N',\n",
       " 1: 'a',\n",
       " 2: 't',\n",
       " 3: 'u',\n",
       " 4: 'r',\n",
       " 5: 'a',\n",
       " 6: 'l',\n",
       " 7: ' ',\n",
       " 8: 'L',\n",
       " 9: 'a',\n",
       " 10: 'n',\n",
       " 11: 'g',\n",
       " 12: 'u',\n",
       " 13: 'a',\n",
       " 14: 'g',\n",
       " 15: 'e',\n",
       " 16: ' ',\n",
       " 17: 'P',\n",
       " 18: 'r',\n",
       " 19: 'o',\n",
       " 20: 'c',\n",
       " 21: 'e',\n",
       " 22: 's',\n",
       " 23: 's',\n",
       " 24: 'i',\n",
       " 25: 'n',\n",
       " 26: 'g'}"
      ]
     },
     "execution_count": 334,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = \"Natural Language Processing\"\n",
    "\n",
    "mydict2 = {k:v for (k,v) in enumerate(str1)} # Store enumerated values in a dictionary\n",
    "mydict2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'A',\n",
       " 'b': 'B',\n",
       " 'c': 'C',\n",
       " 'd': 'D',\n",
       " 'e': 'E',\n",
       " 'f': 'F',\n",
       " 'g': 'G',\n",
       " 'h': 'H',\n",
       " 'i': 'I',\n",
       " 'j': 'J',\n",
       " 'k': 'K',\n",
       " 'l': 'L',\n",
       " 'm': 'M',\n",
       " 'n': 'N',\n",
       " 'o': 'O',\n",
       " 'p': 'P',\n",
       " 'q': 'Q',\n",
       " 'r': 'R',\n",
       " 's': 'S',\n",
       " 't': 'T',\n",
       " 'u': 'U',\n",
       " 'v': 'V',\n",
       " 'w': 'W',\n",
       " 'x': 'X',\n",
       " 'y': 'Y',\n",
       " 'z': 'Z'}"
      ]
     },
     "execution_count": 337,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "mydict3 = {i:i.upper() for i in str1} # Lower to Upper Case\n",
    "mydict3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Word Frequency using dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr4 = \"one two three four one two two three five five six seven six seven one one one ten eight ten nine eleven ten ten nine\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one',\n",
       " 'two',\n",
       " 'three',\n",
       " 'four',\n",
       " 'one',\n",
       " 'two',\n",
       " 'two',\n",
       " 'three',\n",
       " 'five',\n",
       " 'five',\n",
       " 'six',\n",
       " 'seven',\n",
       " 'six',\n",
       " 'seven',\n",
       " 'one',\n",
       " 'one',\n",
       " 'one',\n",
       " 'ten',\n",
       " 'eight',\n",
       " 'ten',\n",
       " 'nine',\n",
       " 'eleven',\n",
       " 'ten',\n",
       " 'ten',\n",
       " 'nine']"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = mystr4.split() # Split String into substrings\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['nine',\n",
       " 'one',\n",
       " 'eight',\n",
       " 'two',\n",
       " 'seven',\n",
       " 'ten',\n",
       " 'four',\n",
       " 'five',\n",
       " 'three',\n",
       " 'eleven',\n",
       " 'six']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist1 = set(mylist) # Unique values in a list\n",
    "mylist1 = list (mylist1)\n",
    "mylist1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nine': 2, 'one': 5, 'eight': 1, 'two': 3, 'seven': 2, 'ten': 4, 'four': 1, 'five': 2, 'three': 2, 'eleven': 1, 'six': 2}\n"
     ]
    }
   ],
   "source": [
    "# Calculate frequenct of each word\n",
    "count1 = [0] * len(mylist1)\n",
    "mydict5 = dict()\n",
    "for i in range(len(mylist1)):\n",
    "    for j in range(len(mylist)):\n",
    "        if mylist1[i] == mylist[j]:\n",
    "            count1[i] += 1\n",
    "    mydict5[mylist1[i]] = count1[i]\n",
    "print(mydict5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- __Operators are special symbols in Python which are used to perform operations on variables/values.__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition of 5 and 2 will give :- 7\n",
      "\n",
      "Concatenate string 'x' and 'y' using '+' operaotr :- AsifBhat\n",
      "\n",
      "Subtracting 2 from 5 will give :- 3\n",
      "\n",
      "Multiplying 5 and 2 will give :- 10\n",
      "\n",
      "Dividing 5 by 2 will give :- 2.5\n",
      "\n",
      "Modulo of 5 , 2 will give :- 1\n",
      "\n",
      "5 raised to the power 2 will give :- 25\n",
      "\n",
      "Floor division of 5 by 2 will give :- 2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 2\n",
    "\n",
    "x = 'Asif'\n",
    "y = 'Bhat'\n",
    "\n",
    "# Addition\n",
    "c = a + b\n",
    "print('Addition of {} and {} will give :- {}\\n'.format(a,b,c))\n",
    "\n",
    "#Concatenate string using plus operator\n",
    "z = x+y\n",
    "print ('Concatenate string \\'x\\' and \\'y\\' using \\'+\\' operaotr :- {}\\n'.format(z))\n",
    "  \n",
    "# Subtraction\n",
    "c = a - b\n",
    "print('Subtracting {} from {} will give :- {}\\n'.format(b,a,c))\n",
    "  \n",
    "# Multiplication\n",
    "c = a * b  \n",
    "print('Multiplying {} and {} will give :- {}\\n'.format(a,b,c))\n",
    "  \n",
    "# Division\n",
    "c = a / b\n",
    "print('Dividing {} by {} will give :- {}\\n'.format(a,b,c))\n",
    "  \n",
    "# Modulo of both number  \n",
    "c = a % b\n",
    "print('Modulo of {} , {} will give :- {}\\n'.format(a,b,c))\n",
    "  \n",
    "# Power \n",
    "c = a ** b \n",
    "print('{} raised to the power {} will give :- {}\\n'.format(a,b,c))\n",
    "\n",
    "# Division(floor)\n",
    "c = a // b\n",
    "print('Floor division of {} by {} will give :- {}\\n'.format(a,b,c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparison operators are used to compare values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is x greater than y :-  False\n",
      "\n",
      "Is x less than  y :-  True\n",
      "\n",
      "Is x equal to  y :-  False\n",
      "\n",
      "Is x not equal to y :-  True\n",
      "\n",
      "Is x greater than or equal to y :-  False\n",
      "\n",
      "Is x less than or equal to y :-  True\n"
     ]
    }
   ],
   "source": [
    "x = 20\n",
    "y = 30\n",
    "\n",
    "print('Is x greater than y :- ',x>y)\n",
    "\n",
    "print('\\nIs x less than  y :- ',x<y)\n",
    "\n",
    "print('\\nIs x equal to  y :- ',x==y)\n",
    "\n",
    "print('\\nIs x not equal to y :- ',x!=y)\n",
    "\n",
    "print('\\nIs x greater than or equal to y :- ',x>=y)\n",
    "\n",
    "print('\\nIs x less than or equal to y :- ',x<=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True, True)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'Asif'\n",
    "b = 'Bhat'\n",
    "c = 'Asif'\n",
    "\n",
    "a == b , a ==c , a != b # Comparison operators on string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logical AND operation :-  False\n",
      "Logical OR operation :-  True\n",
      "NOT operation :-  False\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "y = False\n",
    "\n",
    "print('Logical AND operation :- ',x and y) # True if both values are true\n",
    "print('Logical OR operation :- ',x or y) # True if either of the values is true\n",
    "print('NOT operation :- ',not x ) # True if operand is false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bitwise operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Bitwise operators act on bits and performs bit by bit operation.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bitwise AND operation - 2\n",
      "Bitwise OR operation - 22\n",
      "Bitwise XOR operation - 20\n",
      "Bitwise NOT operation - -19\n",
      "Bitwise right shift operation - 4\n",
      "Bitwise left shift operation - 72\n"
     ]
    }
   ],
   "source": [
    "x = 18  # binary form 10010\n",
    "y = 6  # binary form 00110\n",
    "\n",
    "print('Bitwise AND operation - {}'.format(x&y))\n",
    "print('Bitwise OR operation - {}'.format(x|y))\n",
    "print('Bitwise XOR operation - {}'.format(x^y))\n",
    "print('Bitwise NOT operation - {}'.format(~x))\n",
    "print('Bitwise right shift operation - {}'.format(x>>2))\n",
    "print('Bitwise left shift operation - {}'.format(x<<2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize x with value 10 (x=10)) :-  10\n",
      "Add 20 to x :-  30\n",
      "subtract 20 from x :-  10\n",
      "Divide x by 10 :-  1.0\n",
      "Multiply x by 10 :-  10.0\n",
      "x raised to the power 2 :-  100\n",
      "Modulo Division :-  0\n",
      "Floor Division :-  6\n",
      "Bitwise AND :-  2\n",
      "Bitwise OR :-  2\n",
      "Bitwise XOR :-  0\n",
      "Bitwise left shift operation 40\n",
      "Bitwise right shift operation 10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "\n",
    "print('Initialize x with value 10 (x=10)) :- ',x)\n",
    "\n",
    "\n",
    "x+=20 # x = x+20\n",
    "print ('Add 20 to x :- ',x)\n",
    "\n",
    "\n",
    "x-=20 # x = x-20\n",
    "print ('subtract 20 from x :- ',x)\n",
    "\n",
    "\n",
    "x/=10 # x = x/10\n",
    "print ('Divide x by 10 :- ',x)\n",
    "\n",
    "\n",
    "\n",
    "x*=10 # x = x/10\n",
    "print ('Multiply x by 10 :- ',x)\n",
    "\n",
    "x = int(x)\n",
    "\n",
    "\n",
    "x**=2 # x = x/10\n",
    "print ('x raised to the power 2 :- ',x)\n",
    "\n",
    "\n",
    "\n",
    "x%=2\n",
    "print ('Modulo Division :- ',x)\n",
    "\n",
    "\n",
    "x = 20\n",
    "\n",
    "\n",
    "x//=3\n",
    "print ('Floor Division :- ',x)\n",
    "\n",
    "\n",
    "x&=2\n",
    "print('Bitwise AND :- ',x)\n",
    "\n",
    "\n",
    "x|=2\n",
    "print('Bitwise OR :- ',x)\n",
    "\n",
    "\n",
    "x^=2\n",
    "print('Bitwise XOR :- ',x)\n",
    "\n",
    "\n",
    "x = 10\n",
    "\n",
    "\n",
    "x<<=2\n",
    "print('Bitwise left shift operation',x)\n",
    "\n",
    "\n",
    "x>>=2\n",
    "print('Bitwise right shift operation',x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Membership Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Membership Operators are used to test whether a value / variable is present in a sequence.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr = 'Asif Ali Bhat'\n",
    "\n",
    "'Asif' in mystr , 'John' in mystr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr = 'Asif Ali Bhat'\n",
    "\n",
    "'Asif' not in mystr , 'John' not in mystr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A function is a block of organized code written to carry out a specified task.\n",
    "\n",
    "- Functions help break our program into smaller and modular chunks for better readability. \n",
    "\n",
    "- Information can be passed into a function as arguments.\n",
    "\n",
    "- Parameters are specified after the function name inside the parentheses. \n",
    "\n",
    "- We can add as many parameters as we want. Parameters must be separated with a comma.\n",
    "\n",
    "- A function may or may not return data.\n",
    "\n",
    "- In Python a function is defined using the __def__ keyword\n",
    "\n",
    "### Parameter VS Argument\n",
    "\n",
    " - A parameter is the variable listed inside the parentheses in the function definition.\n",
    "\n",
    " - An argument is the value that is sent to the function when it is called.\n",
    "\n",
    "### Three types of functions in Python:-\n",
    "\n",
    "- __Built-in function :-__  Python predefined functions that are readily available for use like min() , max() , sum() , print() etc.\n",
    "\n",
    "- __User-Defined Functions:-__ Function that we define ourselves to perform a specific task.\n",
    "\n",
    "- __Anonymous functions :__ Function that is defined without a name. Anonymous functions are also called as lambda functions. They are not declared with the __def__ keyword.\n",
    "\n",
    "### Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"functions.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modularity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"modularity.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 582,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Python Lovers\n"
     ]
    }
   ],
   "source": [
    "def myfunc():\n",
    "  print(\"Hello Python Lovers\")\n",
    "\n",
    "myfunc()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 585,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name :-  Asif\n",
      "User ID is :-  asif123\n",
      "Country :-  India\n"
     ]
    }
   ],
   "source": [
    "def details(name,userid,country): # Function to print User details\n",
    "    print('Name :- ', name)\n",
    "    print('User ID is :- ', userid)\n",
    "    print('Country :- ',country)\n",
    "    \n",
    "details('Asif' , 'asif123' , 'India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 586,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 586,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def square (n): #function to find square of a number\n",
    "    n= n*n\n",
    "    return n\n",
    "\n",
    "square (10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3  is odd number\n",
      "4  is even number\n",
      " This function will check whether a number is even or odd\n"
     ]
    }
   ],
   "source": [
    "def even_odd (num): #Even odd test\n",
    "    \"\"\" This function will check whether a number is even or odd\"\"\"\n",
    "    if num % 2 ==0:\n",
    "        print (num, ' is even number')\n",
    "    else:\n",
    "        print (num, ' is odd number')\n",
    "\n",
    "even_odd(3)\n",
    "even_odd(4)\n",
    "print(even_odd.__doc__) # Print function documentation string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 590,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Asif Ali Bhat\n"
     ]
    }
   ],
   "source": [
    "def fullname (firstname , middlename ,lastname): #Concatenate Strings\n",
    "    fullname = \"{} {} {}\".format(firstname,middlename,lastname)\n",
    "    print (fullname)\n",
    "\n",
    "fullname('Asif' , 'Ali' , 'Bhat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 591,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Asif Ali Bhat\n"
     ]
    }
   ],
   "source": [
    "def fullname (firstname , middlename ,lastname): #Concatenate Strings\n",
    "    fullname = \"{} {} {}\".format(firstname,middlename,lastname)\n",
    "    print (fullname)\n",
    "\n",
    "fullname(lastname = 'Bhat' , middlename='Ali' , firstname='Asif') # Keyword Arguments. Order of the arguments does not matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 592,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "fullname() missing 2 required positional arguments: 'middlename' and 'lastname'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-592-d194f8b98253>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfullname\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'Asif'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: fullname() missing 2 required positional arguments: 'middlename' and 'lastname'"
     ]
    }
   ],
   "source": [
    "fullname ('Asif') # This will throw error as function is expecting 3 arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 596,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most Populous City :-  Mumbai\n"
     ]
    }
   ],
   "source": [
    "def myfunc(city = 'Mumbai'):\n",
    "    print('Most Populous City :- ', city)\n",
    "    \n",
    "myfunc() # When a function is called without an argument it will use default value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "var1 = 100 # Variable with Global scope.\n",
    "\n",
    "def myfunc():\n",
    "    print(var1) # Value 100 will be displayed due to global scope of var1\n",
    "\n",
    "    \n",
    "myfunc()\n",
    "print(var1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'var2' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-27-6a1c34e80ca2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0mmyfunc1\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mmyfunc2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-27-6a1c34e80ca2>\u001b[0m in \u001b[0;36mmyfunc2\u001b[1;34m()\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mmyfunc2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvar2\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# Value 100 will be displayed due to global scope of var1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0mmyfunc1\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'var2' is not defined"
     ]
    }
   ],
   "source": [
    "def myfunc1():\n",
    "    var2 = 10  # Variable with Local scope\n",
    "    print(var2)\n",
    "\n",
    "\n",
    "def myfunc2():\n",
    "    print(var2) # This will throw error because var2 has a local scope. Var2 is only accessible in myfunc1()\n",
    "\n",
    "myfunc1()\n",
    "myfunc2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "var1 = 100 # Variable with Global scope.\n",
    "\n",
    "def myfunc():\n",
    "    var1 = 99  # Local scope\n",
    "    print(var1)\n",
    "\n",
    "    \n",
    "myfunc()  \n",
    "print(var1) # The original value of var1 (100) will be retained due to global scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"List1\" before calling the function:-  [11, 22, 33, 44, 55]\n",
      "\"List1\" after calling the function:-  [22, 33, 44, 55]\n"
     ]
    }
   ],
   "source": [
    "list1 = [11,22,33,44,55]\n",
    "\n",
    "def myfunc(list1):\n",
    "    del list1[0]\n",
    "\n",
    "print('\"List1\" before calling the function:- ',list1)\n",
    "myfunc(list1)  # Pass by reference (Any change in the parameter within the function is reflected back in the calling function.)\n",
    "print('\"List1\" after calling the function:- ',list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"List1\" before calling the function:-  [11, 22, 33, 44, 55]\n",
      "\"List1\" after calling the function:-  [11, 22, 33, 44, 55, 100]\n"
     ]
    }
   ],
   "source": [
    "list1 = [11,22,33,44,55]\n",
    "\n",
    "def myfunc(list1):\n",
    "    list1.append(100)\n",
    "\n",
    "print('\"List1\" before calling the function:- ',list1)\n",
    "myfunc(list1)  # Pass by reference (Any change in the parameter within the function is reflected back in the calling function.)\n",
    "print('\"List1\" after calling the function:- ',list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"List1\" before calling the function:-  [11, 22, 33, 44, 55]\n",
      "\"List1\" after calling the function:-  [11, 22, 33, 44, 55]\n"
     ]
    }
   ],
   "source": [
    "list1 = [11,22,33,44,55]\n",
    "\n",
    "def myfunc(list1):\n",
    "    list1 = [10,100,1000,10000] # link of 'list1' with previous object is broken now as new object is assigned to 'list1'.\n",
    "\n",
    "print('\"List1\" before calling the function:- ',list1)\n",
    "myfunc(list1)  # Pass by reference (Any change in the parameter within the function is reflected back in the calling function.)\n",
    "print('\"List1\" after calling the function:- ',list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 20)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def swap(a,b):\n",
    "    temp = a\n",
    "    a = b      # link of 'a' with previous object is broken now as new object is assigned to 'a'. \n",
    "    b = temp   # link of 'b' with previous object is broken now as new object is assigned to 'b'. \n",
    "\n",
    "a = 10\n",
    "b = 20\n",
    "swap(a,b)\n",
    "a,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 601,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 601,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def factorial(num):  # Calculate factorial of a number using recursive function call.\n",
    "    if num <=1 :\n",
    "        return 1\n",
    "    else:\n",
    "        return num * factorial(num-1)\n",
    "    \n",
    "factorial(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 618,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 618,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(num):  # Sum of first n natural numbers\n",
    "    if num == 0:\n",
    "        return 0\n",
    "    else:\n",
    "        return num + add(num-1)\n",
    "\n",
    "add(5) # Sum of first five natural numbers (1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many fibonacci numbers you want to generate -10\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n"
     ]
    }
   ],
   "source": [
    "def fiboacci(num):\n",
    "    if num <= 1:\n",
    "        return num\n",
    "    if num == 2:\n",
    "        return 1\n",
    "    else:  \n",
    "        return(fiboacci(num-1) + fiboacci(num-2))  \n",
    "\n",
    "nums = int(input(\"How many fibonacci numbers you want to generate -\"))\n",
    "\n",
    "\n",
    "\n",
    "for i in range(nums):\n",
    "    print(fiboacci(i))  # Generate Fibonacci series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# args & kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " *__args__\n",
    "- When we are not sure about the number of arguments being passed to a function then we can use *args as function parameter.\n",
    "\n",
    "- *args allow us to pass the variable number of __Non Keyword Arguments__ to function.\n",
    "\n",
    "- We can simply use an asterisk * before the parameter name to pass variable length arguments.\n",
    "\n",
    "- The arguments are always passed as a tuple.\n",
    "\n",
    "- We can rename it to anything as long as it is preceded by a single asterisk (*). It's best practice to keep naming it args to make it immediately recognizable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__**kwargs__\n",
    "- **kwargs allows us to pass the variable number of __Keyword Arguments__ to the function.\n",
    "\n",
    "- We can simply use an double asterisk ** before the parameter name to pass variable length arguments.\n",
    "\n",
    "- The arguments are passed as a dictionary.\n",
    "\n",
    "- We can rename it to anything as long as it is preceded by a double asterisk (**). It's best practice to keep naming it kwargs to make it immediately recognizable.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"argument.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 578,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n"
     ]
    }
   ],
   "source": [
    "def add(a,b,c):\n",
    "    return a+b+c\n",
    "    \n",
    "print(add(10,20,30)) # Sum of two numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 577,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-577-565d47b69332>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-577-565d47b69332>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    If we want to make argument list dynamic then *args wil come in picture'''\u001b[0m\n\u001b[1;37m                                                                              \n^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print(add(1,2,3,4)) '''This will throw below error as this function will only take two argumengts. \n",
    "If we want to make argument list dynamic then *args wil come in picture'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 566,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg_1: 1\n",
      "arg_2: 2\n",
      "arg_3: 3\n"
     ]
    }
   ],
   "source": [
    "def some_args(arg_1, arg_2, arg_3):\n",
    "    print(\"arg_1:\", arg_1)\n",
    "    print(\"arg_2:\", arg_2)\n",
    "    print(\"arg_3:\", arg_3)\n",
    "\n",
    "my_list = [2, 3]\n",
    "some_args(1, *my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 524,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "10\n",
      "15\n",
      "21\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "def add1(*args):\n",
    "    return sum(args)\n",
    "\n",
    "print(add(1,2,3))\n",
    "print(add(1,2,3,4))  # *args will take dynamic argument list. So add() function will perform addition of any number of arguments\n",
    "print(add(1,2,3,4,5))\n",
    "print(add(1,2,3,4,5,6))\n",
    "print(add(1,2,3,4,5,6,7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28, 28)"
      ]
     },
     "execution_count": 561,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6,7]\n",
    "tuple1 = (1,2,3,4,5,6,7)\n",
    "\n",
    "add1(*list1) , add1(*tuple1) #tuple & list items will be passed as argument list and sum will be returned for both cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "112"
      ]
     },
     "execution_count": 562,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6,7]\n",
    "list2 = [1,2,3,4,5,6,7]\n",
    "list3 = [1,2,3,4,5,6,7]\n",
    "list4 = [1,2,3,4,5,6,7]\n",
    "\n",
    "add1(*list1 , *list2 , *list3 , *list4 ) #All four lists are unpacked and each individual item is passed to add1() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 511,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Asif', 7412, 41102, 33, 'India', 'Hindi')\n"
     ]
    }
   ],
   "source": [
    "def UserDetails(*args):\n",
    "    print(args)\n",
    "\n",
    "UserDetails('Asif' , 7412 , 41102 , 33 ,  'India' , 'Hindi')\n",
    "\n",
    "''' For the above example we have no idea about the parameters passed e.g 7412 , 41102 , 33 etc.\n",
    "    In such cases we can take help of Keyworded arguments (**kwargs) '''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 517,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Name': 'Asif', 'ID': 7412, 'Pincode': 41102, 'Age': 33, 'Country': 'India', 'Language': 'Hindi'}\n"
     ]
    }
   ],
   "source": [
    "def UserDetails(**kwargs):\n",
    "    print(kwargs)\n",
    "\n",
    "UserDetails(Name='Asif' , ID=7412 , Pincode=41102 , Age= 33 ,  Country= 'India' , Language= 'Hindi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 519,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name :- Asif\n",
      "ID :- 7412\n",
      "Pincode :- 41102\n",
      "Age :- 33\n",
      "Country :- India\n",
      "Language :- Hindi\n"
     ]
    }
   ],
   "source": [
    "def UserDetails(**kwargs):\n",
    "    for key,val in kwargs.items():\n",
    "        print(\"{} :- {}\".format(key,val))\n",
    "\n",
    "UserDetails(Name='Asif' , ID=7412 , Pincode=41102 , Age= 33 ,  Country= 'India' , Language= 'Hindi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 523,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name :- Asif\n",
      "ID :- 7412\n",
      "Pincode :- 41102\n",
      "Age :- 33\n",
      "Country :- India\n",
      "Language :- Hindi\n"
     ]
    }
   ],
   "source": [
    "mydict = {'Name': 'Asif', 'ID': 7412, 'Pincode': 41102, 'Age': 33, 'Country': 'India', 'Language': 'Hindi'}\n",
    "\n",
    "UserDetails(**mydict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 553,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "License No :-  BHT145\n",
      "Full Name :- Asif Ali Bhat\n",
      "Phone Number:-  1234567890\n",
      "Name :- Asif\n",
      "ID :- 7412\n",
      "Pincode :- 41102\n",
      "Age :- 33\n",
      "Country :- India\n",
      "Language :- Hindi\n"
     ]
    }
   ],
   "source": [
    "def UserDetails(licenseNo,  *args , phoneNo=0 , **kwargs): # Using all four arguments types\n",
    "    print('License No :- ', licenseNo)\n",
    "    j=''\n",
    "    for i in args:\n",
    "        j = j+i\n",
    "    print('Full Name :-',j)\n",
    "    print('Phone Number:- ',phoneNo)\n",
    "    for key,val in kwargs.items():\n",
    "        print(\"{} :- {}\".format(key,val))\n",
    "        \n",
    "        \n",
    "name = ['Asif' , ' ' , 'Ali' , ' ','Bhat']\n",
    "mydict = {'Name': 'Asif', 'ID': 7412, 'Pincode': 41102, 'Age': 33, 'Country': 'India', 'Language': 'Hindi'}\n",
    "\n",
    "UserDetails('BHT145' , *name , phoneNo=1234567890,**mydict )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 554,
   "metadata": {},
   "outputs": [],
   "source": [
    "def UserDetails(licenseNo, *args , phoneNo=0, **kwargs): # Using all four arguments types. CORRECT ORDER\n",
    "    print('Nothing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-557-dcd3c92277bc>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-557-dcd3c92277bc>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def UserDetails(licenseNo, **kwargs , *args): # This will fail. *args MUST come before **kwargs in the argument list\u001b[0m\n\u001b[1;37m                                          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def UserDetails(licenseNo, **kwargs , *args): # This will fail. *args MUST come before **kwargs in the argument list\n",
    "    print('Nothing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 564,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (<ipython-input-564-8a3e722c7ed7>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-564-8a3e722c7ed7>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    def UserDetails(ID = 1, licenseNo, *args):\u001b[0m\n\u001b[1;37m                   ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "#The below function will fail. Default argument/positional argument (licenseNo) MUST come before Keyword argument(ID)\n",
    "def UserDetails(ID = 1, licenseNo, *args):\n",
    "    print('Nothing')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda, Filter, Map and Reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Lambda__\n",
    "\n",
    "- A lambda function is an anonymous function (function without a name).\n",
    "\n",
    "\n",
    "- Lambda functions can have any number of arguments but only one expression. The expression is evaluated and returned. \n",
    "\n",
    "\n",
    "- We use lambda functions when we require a nameless function for a short period of time.\n",
    "\n",
    "\n",
    "__Syntax:-__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"lambda1.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Filter__\n",
    "\n",
    "\n",
    "- It is used to filter the iterables/sequence as per the conditions. \n",
    "\n",
    "\n",
    "- Filter function filters the original iterable and passes the items that returns True for the function provided to filter. \n",
    "\n",
    "\n",
    "- It is normally used with Lambda functions to filter list, tuple, or sets.\n",
    "\n",
    "\n",
    "\n",
    "filter() method takes two parameters:\n",
    "\n",
    "- __function__ - function tests if elements of an iterable returns true or false\n",
    "\n",
    "- __iterable__ - Sequence which needs to be filtered, could be sets, lists, tuples, or any iterators\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "__Syntax:__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"filter.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Map__\n",
    "\n",
    "- The map() function applies a given function to each item of an iterable (list, tuple etc.) and returns a list of the results.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "map() function takes two Parameters :\n",
    "\n",
    "-   __function__ :  The function to execute for each item of given iterable.\n",
    "\n",
    "\n",
    "-   __iterable__ : It is a iterable which is to be mapped.\n",
    "\n",
    "\n",
    "__Returns__ : Returns a list of the results after applying the given function to each item of a given iterable (list, tuple etc.)\n",
    "\n",
    "__Syntax:__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"map.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Reduce__\n",
    "\n",
    "- The reduce() function is defined in the __functools__ python module.The reduce() function receives two arguments, a function and an iterable. However, it doesn't return another iterable, instead it returns a single value.\n",
    "\n",
    "\n",
    "__Working:__\n",
    "\n",
    " 1)  Apply a function to the first two items in an iterable and generate a partial result.\n",
    "\n",
    " 2)  The function is then called again with the result obtained in __step 1__ and the next value in the sequence. This process keeps on repeating until there are items in the sequence.\n",
    "\n",
    " 3)  The final returned result is returned and printed on console.\n",
    "\n",
    "\n",
    "\n",
    "__Syntax:__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"reduce.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "addition = lambda a : a + 10  # This lambda function adds value 10 to an argument.\n",
    "print(addition(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "product = lambda a, b : a * b #This lambda function takes two arguments (a,b) and returns their product (a*b).\n",
    "print(product(5, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "addition = lambda a, b, c : a + b + c  #This lambda function takes three arguments (a,b,c) and returns their sum (a+b+c).\n",
    "print(addition(5, 6, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(30, 100, 280)"
      ]
     },
     "execution_count": 364,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = (lambda *args: sum(args))  # This lambda function can take any number of arguments and return thier sum.\n",
    "res(10,20) , res(10,20,30,40) ,  res(10,20,30,40,50,60,70)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60, 150)"
      ]
     },
     "execution_count": 370,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res1 = (lambda **kwargs: sum(kwargs.values())) # This lambda function can take any number of arguments and return thier sum.\n",
    "res1(a = 10 , b= 20 , c = 30) , res1(a = 10 , b= 20 , c = 30, d = 40 , e = 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60, 150)"
      ]
     },
     "execution_count": 386,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res1 = (lambda **kwargs: sum(kwargs.values())) # This lambda function can take any number of arguments and return thier sum.\n",
    "res1(a = 10 , b= 20 , c = 30) , res1(a = 10 , b= 20 , c = 30, d = 40 , e = 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 446,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6000, 12000000)"
      ]
     },
     "execution_count": 446,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# User defined function to find product of numbers\n",
    "def product(nums):  \n",
    "    total = 1\n",
    "    for i in nums:\n",
    "        total *= i  \n",
    "    return total\n",
    "\n",
    "# This lambda function can take any number of arguments and return thier product.\n",
    "res1 = (lambda **kwargs: product(kwargs.values())) \n",
    "res1(a = 10 , b= 20 , c = 30) , res1(a = 10 , b= 20 , c = 30, d = 40 , e = 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "25\n",
      "35\n"
     ]
    }
   ],
   "source": [
    "def myfunc(n):\n",
    "  return lambda a : a + n\n",
    "\n",
    "add10 = myfunc(10)\n",
    "add20 = myfunc(20)\n",
    "add30 = myfunc(30)\n",
    "\n",
    "print(add10(5))\n",
    "print(add20(5))\n",
    "print(add30(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 437,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 437,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "def odd(n):\n",
    "    if n%2 ==1: return True\n",
    "    else: return False\n",
    "    \n",
    "odd_num = list(filter(odd,list1)) # This Filter function filters list1 and passes all odd numbers to filter().\n",
    "odd_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 438,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 438,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8,9]\n",
    "# The below Filter function filters \"list1\" and passes all odd numbers using lambda function to filter().\n",
    "odd_num = list(filter(lambda n: n%2 ==1 ,list1)) \n",
    "odd_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 439,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 6, 10, 14, 18]"
      ]
     },
     "execution_count": 439,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def twice(n):\n",
    "    return n*2\n",
    "  \n",
    "doubles = list(map(twice,odd_num)) # The map function will apply user defined \"twice()\" function on all items of the list\n",
    "doubles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 6, 10, 14, 18]"
      ]
     },
     "execution_count": 440,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doubles = list(map(lambda n:n*2,odd_num)) # This map function will double all items of the list using lambda function.\n",
    "doubles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 441,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 441,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "def add(a,b):\n",
    "    return a+b\n",
    "  \n",
    "sum_all = reduce(add,doubles) # This reduce function will perform sum of all items in the list using user defined \"add()\" func.\n",
    "sum_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 442,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#The below reduce() function will perform sum of all items in the list using lambda function.\n",
    "sum_all = reduce(lambda a,b : a+b,doubles)\n",
    "sum_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 448,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 448,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Putting all together \n",
    "\n",
    "sum_all = reduce(lambda a,b : a+b,list(map(lambda n:n*2,list(filter(lambda n: n%2 ==1 ,list1)))))\n",
    "sum_all"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fmr.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# More examples on Map , Filter , Reduce  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 497,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------\n",
      "[2, 4, 6, 8, 10]\n",
      "[1, 3, 5, 7, 9]\n",
      "--------\n",
      "['TWO', 'FOUR']\n",
      "['one', 'three']\n",
      "--------\n",
      "['one']\n",
      "['88', '99', '102']\n",
      "['one', 'two2', 'three3', '88', '99', '102']\n",
      "--------\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8,9,10]\n",
    "even = list(filter(lambda n: n%2 ==0 ,list1)) # Filter even numbers from the list\n",
    "odd =  list(filter(lambda n: n%2 !=0 ,list1))   # Filter odd numbers from the list\n",
    "\n",
    "print('--------')\n",
    "print(even)\n",
    "print(odd)\n",
    "print('--------')\n",
    "\n",
    "list2 = ['one' , 'TWO' , 'three' , 'FOUR']\n",
    "\n",
    "upper = list(filter(lambda x: x.isupper() , list2)) # filter uppercase strings from the list\n",
    "\n",
    "lower = list(filter(lambda x: x.islower() , list2)) # filter lowercase strings from the list\n",
    "\n",
    "\n",
    "print(upper)\n",
    "print(lower)\n",
    "print('--------')\n",
    "\n",
    "list3 = ['one' , 'two2' , 'three3' ,'88' , '99' , '102']\n",
    "\n",
    "numeric = list(filter(lambda x:x.isnumeric(), list3))  # filter numbers from the list\n",
    "\n",
    "alpha = list(filter(lambda x:x.isalpha(), list3))      # filter character strings from the list\n",
    "\n",
    "alphanum = list(filter(lambda x:x.isalnum(), list3)) # filtr numbers & character strings from the list\n",
    "\n",
    "\n",
    "print(alpha)\n",
    "print(numeric)\n",
    "print(alphanum)\n",
    "print('--------')\n",
    "\n",
    "\n",
    "#Vowel Test\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 501,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------\n",
      "[2, 4, 6, 8]\n",
      "[6, 8, 10, 12]\n",
      "[1, 4, 9, 16]\n",
      "---------------\n",
      "[2, 4, 6, 8]\n",
      "[6, 8, 10, 12]\n",
      "[1, 4, 9, 16]\n",
      "---------------\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,3,4]\n",
    "list2 = [5,6,7,8]\n",
    "\n",
    "def double(x):\n",
    "    return x+x\n",
    "\n",
    "def add(x,y):\n",
    "    return x+y\n",
    "\n",
    "def square(x):\n",
    "    return x*x\n",
    "\n",
    "print('---------------')\n",
    "\n",
    "print(list(map(double, list1))) # Double each number using map & User defined function\n",
    "print(list(map(add, list1, list2))) # add two items  using map & User defined function\n",
    "print(list(map(square, list1))) #Square numbers using map & User defined function\n",
    "\n",
    "print('---------------')\n",
    "\n",
    "print(list(map(lambda x: x + x, list1))) # Double each number using map & lambda\n",
    "print(list(map(lambda x, y: x + y, list1, list2))) # add two items  using map & lambda\n",
    "print(list(map(lambda x: x*x, list1))) #Square numbers using map & lambda\n",
    "\n",
    "print('---------------')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 459,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "10\n",
      "Python Rocks\n",
      "Hello Hello Hello \n",
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "list2 = [1,2,3,4]\n",
    "\n",
    "product = reduce (operator.mul,list2) # Product of all numbers in a list\n",
    "\n",
    "add = reduce(operator.add,list2) # Add all numbers in the list\n",
    "\n",
    "concat_str = reduce(operator.add , ['Python' , ' ' , 'Rocks']) # Concatenate string using reduce \n",
    "\n",
    "prod = reduce(operator.mul,['Hello ' , 3]) #Repeat a string multiple times\n",
    "\n",
    "min_num = reduce(lambda a, b: a if a < b else b, list2) # Minimum number in the list using reduce () & lambda\n",
    "\n",
    "max_num = reduce(lambda a, b: a if a > b else b, list2) # Maximum number in the list using reduce () & lambda\n",
    "\n",
    "print(product)\n",
    "\n",
    "print(add)\n",
    "\n",
    "print(concat_str)\n",
    "\n",
    "print(prod)\n",
    "\n",
    "print(min_num)\n",
    "\n",
    "print(max_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 4)"
      ]
     },
     "execution_count": 461,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def min_func(a, b):\n",
    "        return a if a < b else b\n",
    " \n",
    "\n",
    "def max_func(a, b):\n",
    "    return a if a > b else b\n",
    "\n",
    "min_num = reduce(min_func, list2) # Minimum number in the list using reduce () & User defined min function\n",
    "\n",
    "max_num = reduce(max_func, list2) # Maximum number in the list using reduce () & User defined min function\n",
    "\n",
    "min_num , max_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 474,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------\n",
      "False\n",
      "True\n",
      "False\n",
      "------\n",
      "False\n",
      "True\n",
      "True\n",
      "------\n"
     ]
    }
   ],
   "source": [
    "print('------')\n",
    "print(reduce(lambda a, b: bool(a and b), [0, 0, 1, 0, 0])) # Returns True if all values in the list are True \n",
    "print(reduce(lambda a, b: bool(a and b), [2, 3, 1, 5, 6])) # Returns True if all items in the list are True\n",
    "print(reduce(lambda a, b: bool(a and b), [8, 9, 1, 0, 9])) # Returns True if all values in the list are True\n",
    "\n",
    "print('------')\n",
    "\n",
    "print(reduce(lambda a, b: bool(a or b), [0, 0, 0, 0, 0]))  # Returns True if any item in the list is True\n",
    "print(reduce(lambda a, b: bool(a or b), [2, 3, 1, 5, 6]))  # Returns True if any item in the list is True\n",
    "print(reduce(lambda a, b: bool(a or b), [8, 9, 1, 0, 9]))  # Returns True if any item in the list is True\n",
    "\n",
    "print('------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes & Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A Class is an object constructor or a \"blueprint\" for creating objects.\n",
    "\n",
    "- Objects are nothing but an encapsulation of variables and functions into a single entity. \n",
    "\n",
    "- Objects get their variables and functions from classes.\n",
    "\n",
    "- To create a class we use the keyword __class__.\n",
    "\n",
    "- The first string inside the class is called docstring which gives the brief description about the class.\n",
    "\n",
    "- All classes have a function called $____init____()$ which is always executed when the class is being initiated.\n",
    "\n",
    "- We can use $____init____()$ function to assign values to object properties or other operations that are necessary to perform when the object is being created\n",
    "\n",
    "- The __self__ parameter is a reference to the current instance of the class and is used to access class variables.\n",
    "\n",
    "- __self__ must be the first parameter of any function in the class\n",
    "\n",
    "- The __super()__ builtin function returns a temporary object of the superclass that allows us to access methods of the base class.\n",
    "\n",
    "- __super()__ allows us to avoid using the base class name explicitly and to enable multiple inheritance.\n",
    "\n",
    "\n",
    "__Syntax__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"class.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# Create a class with property \"var1\"\n",
    "class myclass:\n",
    "    var1 = 10\n",
    "    \n",
    "obj1 = myclass() # Create an object of class \"myclass()\"\n",
    "print(obj1.var1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name :-  Asif\n",
      "Employee ID :-  34163\n",
      "Thanks for joining ABC Company Asif!!\n"
     ]
    }
   ],
   "source": [
    "# Create an employee class\n",
    "class Employee:\n",
    "  def __init__(self, name, empid): # __init__() function is used to assign values for name and empid\n",
    "    self.name = name\n",
    "    self.empid = empid\n",
    "  def greet(self): # Class Method\n",
    "    print(\"Thanks for joining ABC Company {}!!\".format(self.name))\n",
    "\n",
    "emp1 = Employee(\"Asif\", 34163)  # Create an employee object\n",
    "\n",
    "print('Name :- ',emp1.name)\n",
    "print('Employee ID :- ',emp1.empid)\n",
    "emp1.greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Basit'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emp1.name = 'Basit' # Modify Object Properties\n",
    "emp1.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Employee' object has no attribute 'empid'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-72-b111c8b828fc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0memp1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mempid\u001b[0m   \u001b[1;31m# Delete Object Properties\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0memp1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mempid\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Employee' object has no attribute 'empid'"
     ]
    }
   ],
   "source": [
    "del emp1.empid   # Delete Object Properties\n",
    "emp1.empid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'emp1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-73-db2cb77ec9fb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0memp1\u001b[0m \u001b[1;31m# Delete the object\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0memp1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'emp1' is not defined"
     ]
    }
   ],
   "source": [
    "del emp1 # Delete the object\n",
    "emp1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name :-  Michael\n",
      "Employee ID :-  34162\n",
      "Thanks for joining ABC Company Michael!!\n"
     ]
    }
   ],
   "source": [
    "emp2 = Employee(\"Michael\", 34162)  # Create an employee object\n",
    "\n",
    "print('Name :- ',emp2.name)\n",
    "print('Employee ID :- ',emp2.empid)\n",
    "emp2.greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'India'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emp2.country = 'India' #instance variable can be created manually\n",
    "emp2.country"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Inheritance is a powerful feature in object oriented programming.\n",
    "\n",
    "\n",
    "- Inheritance provides code reusability in the program because we can use an existing class (Super Class/ Parent Class / Base Class)  to create a new class (Sub Class / Child Class / Derived Class) instead of creating it from scratch.\n",
    "\n",
    "\n",
    "- The child class inherits data definitions and methods from the parent class which facilitates the reuse of features already available. The child class can add few more definitions or redefine a base class method.\n",
    "\n",
    "\n",
    "- Inheritance comes into picture when a new class possesses the '__IS A__' relationship with an existing class. E.g Student is a person. Hence person is the base class and student is derived class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src= \"inheritance1.PNG\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student Details\n",
      "---------------\n",
      "Name :- Asif\n",
      "Age :- 24\n",
      "Gender :- Male\n",
      "Student ID :- 123\n",
      "Fees :- 1200\n",
      "\n",
      "Employee Details\n",
      "---------------\n",
      "Name :- Basit\n",
      "Age :- 36\n",
      "Gender :- Male\n",
      "Employee ID :- 456\n",
      "Salary :- 80000\n"
     ]
    }
   ],
   "source": [
    "class person:   # Parent Class\n",
    "    def __init__(self, name , age , gender):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.gender = gender\n",
    "    \n",
    "    def PersonInfo(self):\n",
    "        print('Name :- {}'.format(self.name))\n",
    "        print('Age :- {}'.format(self.age))\n",
    "        print('Gender :- {}'.format(self.gender))\n",
    "\n",
    "        \n",
    "        \n",
    "        \n",
    "class student(person): # Child Class\n",
    "    def __init__(self,name,age,gender,studentid,fees):\n",
    "        person.__init__(self,name,age,gender)\n",
    "        self.studentid = studentid\n",
    "        self.fees = fees\n",
    "    \n",
    "    def StudentInfo(self):\n",
    "        print('Student ID :- {}'.format(self.studentid))\n",
    "        print('Fees :- {}'.format(self.fees))\n",
    "        \n",
    "\n",
    "        \n",
    "class teacher(person): # Child Class\n",
    "    def __init__(self,name,age,gender,empid,salary):\n",
    "        person.__init__(self,name,age,gender)\n",
    "        self.empid = empid\n",
    "        self.salary = salary\n",
    "    \n",
    "    def TeacherInfo(self):\n",
    "        print('Employee ID :- {}'.format(self.empid))\n",
    "        print('Salary :- {}'.format(self.salary))\n",
    "\n",
    "\n",
    "        \n",
    "stud1 = student('Asif' , 24 , 'Male' , 123 , 1200)\n",
    "print('Student Details')\n",
    "print('---------------')\n",
    "stud1.PersonInfo()    # PersonInfo() method presnt in Parent Class will be accessible by child class\n",
    "stud1.StudentInfo()\n",
    "print()\n",
    "\n",
    "\n",
    "\n",
    "teacher1 = teacher('Basit' , 36 , 'Male' , 456 , 80000)\n",
    "print('Employee Details')\n",
    "print('---------------')\n",
    "teacher1.PersonInfo()    # PersonInfo() method presnt in Parent Class will be accessible by child class\n",
    "teacher1.TeacherInfo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name :- Asif\n",
      "Age :- 24\n",
      "Gender :- Male\n",
      "Student ID :- 123\n",
      "Fees :- 1200\n"
     ]
    }
   ],
   "source": [
    "# super() builtin function allows us to access methods of the base class.\n",
    "\n",
    "class person:   # Parent Class\n",
    "    def __init__(self, name , age , gender):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.gender = gender\n",
    "    \n",
    "    def PersonInfo(self):\n",
    "        print('Name :- {}'.format(self.name))\n",
    "        print('Age :- {}'.format(self.age))\n",
    "        print('Gender :- {}'.format(self.gender))\n",
    "\n",
    "        \n",
    "        \n",
    "        \n",
    "class student(person): # Child Class\n",
    "    def __init__(self,name,age,gender,studentid,fees):\n",
    "        super().__init__(name,age,gender)  \n",
    "        self.studentid = studentid\n",
    "        self.fees = fees\n",
    "    \n",
    "    def StudentInfo(self):\n",
    "        super().PersonInfo()\n",
    "        print('Student ID :- {}'.format(self.studentid))\n",
    "        print('Fees :- {}'.format(self.fees))\n",
    "        \n",
    "stud = student('Asif' , 24 , 'Male' , 123 , 1200)\n",
    "stud.StudentInfo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multi-level Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- In this type of inheritance, a class can inherit from a child class or derived class. \n",
    "\n",
    "- Multilevel Inheritance can be of any depth in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src= \"multi-level inheritance.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contractual Employee Details\n",
      "****************************\n",
      "Name :- Basit\n",
      "Age :- 36\n",
      "Gender :- Male\n",
      "Employee ID :- 456\n",
      "Salary :- 80000\n",
      "Contract Expiry :- 21-12-2021\n",
      "\n",
      " \n",
      "\n",
      "Fulltime Employee Details\n",
      "****************************\n",
      "Name :- Asif\n",
      "Age :- 22\n",
      "Gender :- Male\n",
      "Employee ID :- 567\n",
      "Salary :- 70000\n",
      "Work Experience :- 12\n"
     ]
    }
   ],
   "source": [
    "class person:   # Parent Class\n",
    "    def __init__(self, name , age , gender):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.gender = gender\n",
    "    \n",
    "    def PersonInfo(self):\n",
    "        print('Name :- {}'.format(self.name))\n",
    "        print('Age :- {}'.format(self.age))\n",
    "        print('Gender :- {}'.format(self.gender))\n",
    "\n",
    "        \n",
    "        \n",
    "        \n",
    "class employee(person): # Child Class\n",
    "    def __init__(self,name,age,gender,empid,salary):\n",
    "        person.__init__(self,name,age,gender)\n",
    "        self.empid = empid\n",
    "        self.salary = salary\n",
    "    \n",
    "    def employeeInfo(self):\n",
    "        print('Employee ID :- {}'.format(self.empid))\n",
    "        print('Salary :- {}'.format(self.salary))\n",
    "        \n",
    "        \n",
    "\n",
    "        \n",
    "class fulltime(employee): # Grand Child Class\n",
    "    def __init__(self,name,age,gender,empid,salary,WorkExperience):\n",
    "        employee.__init__(self,name,age,gender,empid,salary)\n",
    "        self.WorkExperience = WorkExperience\n",
    "    \n",
    "    def FulltimeInfo(self):\n",
    "        print('Work Experience :- {}'.format(self.WorkExperience))\n",
    "        \n",
    "        \n",
    "        \n",
    "\n",
    "class contractual(employee): # Grand Child Class\n",
    "    def __init__(self,name,age,gender,empid,salary,ContractExpiry):\n",
    "        employee.__init__(self,name,age,gender,empid,salary)\n",
    "        self.ContractExpiry = ContractExpiry\n",
    "    \n",
    "    def ContractInfo(self):\n",
    "        print('Contract Expiry :- {}'.format(self.ContractExpiry))\n",
    "\n",
    "        \n",
    "print('Contractual Employee Details')\n",
    "print('****************************')\n",
    "contract1 = contractual('Basit' , 36 , 'Male' , 456 , 80000,'21-12-2021')\n",
    "contract1.PersonInfo()\n",
    "contract1.employeeInfo()\n",
    "contract1.ContractInfo()\n",
    "\n",
    "print('\\n \\n')\n",
    "\n",
    "print('Fulltime Employee Details')\n",
    "print('****************************')\n",
    "fulltim1= fulltime('Asif' , 22 , 'Male' , 567 , 70000, 12)\n",
    "fulltim1.PersonInfo()\n",
    "fulltim1.employeeInfo()\n",
    "fulltim1.FulltimeInfo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Multiple inheritance is a feature in which a class (derived class) can inherit attributes and methods from more than one parent class.\n",
    "\n",
    "- The derived class inherits all the features of the base case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = 'Multiple Inheritance.PNG'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My Name :-  Bill\n",
      "Father : John\n",
      "Mother : Kristen\n"
     ]
    }
   ],
   "source": [
    "# Super Class\n",
    "class Father:\n",
    "    def __init__(self):\n",
    "        self.fathername = str()\n",
    "\n",
    "    \n",
    "# Super Class\n",
    "class Mother:\n",
    "    def __init__(self):\n",
    "        self.mothername = str()\n",
    "    \n",
    "    \n",
    "# Sub Class\n",
    "class Son(Father, Mother):\n",
    "    name = str()\n",
    "    def show(self):\n",
    "        print('My Name :- ',self.name)\n",
    "        print(\"Father :\", self.fathername)\n",
    "        print(\"Mother :\", self.mothername)\n",
    " \n",
    " \n",
    "s1 = Son()\n",
    "s1.name = 'Bill'\n",
    "s1.fathername = \"John\"\n",
    "s1.mothername = \"Kristen\"\n",
    "s1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020-08-09 23:48:55\n"
     ]
    }
   ],
   "source": [
    "class Date:\n",
    "    def __init__(self,date):\n",
    "        self.date = date    \n",
    "        \n",
    "class Time:\n",
    "    def __init__(self,time):\n",
    "        self.time = time\n",
    "\n",
    "class timestamp(CurrentDate,CurrentTime):\n",
    "    def __init__(self,date,time):\n",
    "        CurrentDate.__init__(self,date)\n",
    "        CurrentTime.__init__(self,time)\n",
    "        DateTime = self.date + ' ' + self.time\n",
    "        print(DateTime)\n",
    "\n",
    "datetime1 = timestamp( '2020-08-09', '23:48:55')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method Overriding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Overriding is a very important part of object oreinted programming because it makes inheritance exploit its full power. \n",
    "\n",
    "\n",
    "- Overriding is the ability of a class (Sub Class / Child Class / Derived Class) to change the implementation of a method provided by one of its parent classes.\n",
    "\n",
    "\n",
    "- When a method in a subclass has the same name, same parameter and same return type as a method in its super-class, then the method in the subclass is said to override the method in the super-class.\n",
    "\n",
    "\n",
    "- The version of a method that is executed will be determined by the object that is used to invoke it. \n",
    "\n",
    "- If an object of a parent class is used to invoke the method, then the version in the parent class will be executed, but if an object of the subclass is used to invoke the method, then the version in the child class will be executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Student\n",
      "Hello Person\n"
     ]
    }
   ],
   "source": [
    "class person:   # Parent Class\n",
    "    def __init__(self, name , age , gender):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.gender = gender\n",
    "        \n",
    "    def greet(self):\n",
    "        print(\"Hello Person\")\n",
    "        \n",
    "        \n",
    "        \n",
    "class student(person): # Child Class\n",
    "    def __init__(self,name,age,gender,studentid,fees):\n",
    "        person.__init__(self,name,age,gender)\n",
    "        self.studentid = studentid\n",
    "        self.fees = fees\n",
    "\n",
    "    def greet(self):\n",
    "        print(\"Hello Student\")\n",
    "        \n",
    "    \n",
    "stud = student('Gabriel' , 56 , 'Male' , 45 , 345678)\n",
    "stud.greet() # greet() method defined in subclass will be triggered as \"stud\" is an object of child class\n",
    "\n",
    "person1 = person('Gabriel' , 56 , 'Male')\n",
    "person1.greet() # greet() method defined in superclass will be triggered because \"person1\" is an object of parent class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Container"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Containers are data structures that hold data values. \n",
    "\n",
    "\n",
    "- They support membership tests which means we can check whether a value exists in the container or not. \n",
    "\n",
    "\n",
    "- Generally containers provide a way to access the contained objects and to iterate over them.\n",
    "\n",
    "\n",
    "- Examples of containers include tuple, list, set, dict, str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = ['asif' , 'john' , 'Michael' , 'Basit']\n",
    "\n",
    "'asif' in list1  # Membership check using 'in' operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 'john' in list1  # If the condition returns true the program does nothing and move to the next line of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-127-f7bcea8c4682>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[1;34m'john1'\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mlist1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "assert 'john1' in list1 # If the condition returns false, Assert will stop the program and throws an AssertionError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Asif', 'ID': 12345, 'DOB': 1991, 'Address': 'Hilsinki'}"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict = {'Name':'Asif' , 'ID': 12345 , 'DOB': 1991 , 'Address' : 'Hilsinki'}\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Asif' in mydict # Dictionary membership will always check the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Name' in mydict # Dictionary membership will always check the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'DOB' in mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr = 'asifbhat'\n",
    "\n",
    "'as' in mystr  # Check if substring is present"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterable & Iterator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- An __iterable__ is an object that can be iterated upon. It can return an iterator object with the purpose of traversing through all the elements of an iterable. \n",
    "\n",
    "\n",
    "- An iterable object implements ____iter__()__ which is expected to return an iterator object. The iterator object uses the ____next__()__ method. Every time __next()__ is called next element in the iterator stream is returned. When there are no more elements available __StopIteration exception__ is encountered. So any object that has a ____next__()__ method is called an __iterator__.\n",
    "\n",
    "\n",
    "\n",
    "- Python lists, tuples, dictionaries and sets are all examples of iterable objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = 'iterator1.PNG'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Asif\n",
      "Basit\n",
      "John\n",
      "Michael\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-236-a2095e242a65>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "mylist = ['Asif' , 'Basit' , 'John' , 'Michael']\n",
    "list_iter = iter(mylist) # Create an iterator object using iter()\n",
    "print(next(list_iter))  # return first element in the iterator stream\n",
    "print(next(list_iter))  # return next element in the iterator stream\n",
    "print(next(list_iter))\n",
    "print(next(list_iter))\n",
    "print(next(list_iter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Asif\n",
      "Basit\n",
      "John\n",
      "Michael\n"
     ]
    }
   ],
   "source": [
    "mylist = ['Asif' , 'Basit' , 'John' , 'Michael']\n",
    "list_iter = iter(mylist)     # Create an iterator object using iter()\n",
    "print(list_iter.__next__())  # return first element in the iterator stream\n",
    "print(list_iter.__next__())  # return next element in the iterator stream\n",
    "print(list_iter.__next__())\n",
    "print(list_iter.__next__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Asif\n",
      "Basit\n",
      "John\n",
      "Michael\n"
     ]
    }
   ],
   "source": [
    "mylist = ['Asif' , 'Basit' , 'John' , 'Michael']\n",
    "list_iter = iter(mylist)     # Create an iterator object using iter()\n",
    "for i in list_iter:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Asif\n",
      "Basit\n",
      "John\n",
      "Michael\n"
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (list) using for loop\n",
    "\n",
    "mylist = ['Asif' , 'Basit' , 'John' , 'Michael']\n",
    "\n",
    "for i in mylist:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Asif\n",
      "Basit\n",
      "John\n",
      "Michael\n"
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (tuple) using for loop\n",
    "\n",
    "mytuple = ('Asif' , 'Basit' , 'John' , 'Michael')\n",
    "\n",
    "for i in mytuple:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (string) using for loop\n",
    "\n",
    "mystr = \"Hello Python\"\n",
    "\n",
    "for i in mystr:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# This iterator produces all natural numbers from 1 to 10.\n",
    "class myiter:\n",
    "     def __init__(self):\n",
    "            self.num = 0\n",
    "     \n",
    "     def __iter__(self):\n",
    "            self.num = 1\n",
    "            return self\n",
    "     \n",
    "     def __next__(self):\n",
    "        if self.num <= 10:\n",
    "            val = self.num\n",
    "            self.num += 1\n",
    "            return val\n",
    "        else:\n",
    "            raise StopIteration\n",
    "\n",
    "mynum = myiter()\n",
    "iter1 = iter(mynum)\n",
    "for i in iter1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "11\n",
      "13\n",
      "15\n",
      "17\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "# This iterator will produce odd numbers\n",
    "class myiter:\n",
    "     def __init__(self):\n",
    "            self.num = 0\n",
    "     \n",
    "     def __iter__(self):\n",
    "            self.num = 1\n",
    "            return self\n",
    "     \n",
    "     def __next__(self):\n",
    "        if self.num <= 20 :\n",
    "            val = self.num\n",
    "            self.num += 2\n",
    "            return val\n",
    "        else:\n",
    "            raise StopIteration\n",
    "\n",
    "myodd = myiter()\n",
    "iter1 = iter(myodd)\n",
    "for i in iter1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n"
     ]
    }
   ],
   "source": [
    "# This iterator will produce fibonacci numbers\n",
    "\n",
    "class myfibonacci:\n",
    "     def __init__(self):\n",
    "            self.prev = 0\n",
    "            self.cur = 0\n",
    "     \n",
    "     def __iter__(self):\n",
    "            self.prev = 0\n",
    "            self.cur = 1\n",
    "            return self\n",
    "     \n",
    "     def __next__(self):\n",
    "        if self.cur <= 50:\n",
    "            val = self.cur\n",
    "            self.cur += self.prev\n",
    "            self.prev = val\n",
    "            return val\n",
    "        else:\n",
    "            raise StopIteration\n",
    "\n",
    "myfibo = myfibonacci()\n",
    "iter1 = iter(myfibo)\n",
    "for i in iter1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of returning the entire sequence at once.  \n",
    "\n",
    "\n",
    "- It is a special type of function which returns an iterator object.\n",
    "\n",
    "\n",
    "- In a generator function, a __yield__ statement is used rather than a __return__ statement.\n",
    "\n",
    "\n",
    "- The generator function cannot include the return keyword. If we include it then it will terminate the execution of the function. \n",
    "\n",
    "\n",
    "- The difference between __yield__ and __return__ is that once yield returns a value the function is paused and the control is transferred to the caller.Local variables and their states are remembered between successive calls. In case of  the return statement value is returned and the execution of the function is terminated.\n",
    "\n",
    "\n",
    "- Methods like ____iter__()__ and ____next__()__ are implemented automatically in generator function. \n",
    "\n",
    "\n",
    "- Simple generators can be easily created using __generator expressions__. Generator expressions create anonymous generator functions like lambda.\n",
    "\n",
    "\n",
    "- The syntax for generator expression is similar to that of a list comprehension but the only difference is square brackets are replaced with round parentheses. Also list comprehension produces the entire list while the generator expression produces one item at a time which is more memory efficient than list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-258-4c1c399db6dd>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     24\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmygen1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     25\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmygen1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 26\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmygen1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Simple generator function that will generate numbers from 1 to 5.\n",
    "def mygen():\n",
    "    n = 1\n",
    "    yield n\n",
    "\n",
    "    n += 1\n",
    "    yield n\n",
    "\n",
    "    n += 1\n",
    "    yield n\n",
    "\n",
    "    n += 1\n",
    "    yield n\n",
    "    \n",
    "    n += 1\n",
    "    yield n\n",
    "    \n",
    "mygen1 = mygen()\n",
    "\n",
    "print(next(mygen1))\n",
    "print(next(mygen1))\n",
    "print(next(mygen1))\n",
    "print(next(mygen1))\n",
    "print(next(mygen1)) #Function will terminate here as all 5 values have been returned. \n",
    "print(next(mygen1)) # As function is already terminated, StopIteration is raised automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "# Simple generator function that will generate natural numbers from 1 to 20.\n",
    "def mygen():\n",
    "    for i in range(1,20):\n",
    "        yield i\n",
    "\n",
    "    \n",
    "mygen1 = mygen()\n",
    "\n",
    "for i in mygen1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = list(mygen()) # Store all values generated by generator function in a list\n",
    "num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "# Simple generator function that will generate even numbers from 1 to 20.\n",
    "def mygen():\n",
    "    for i in range(1,20):\n",
    "        if i%2 == 0:\n",
    "            yield i\n",
    "\n",
    "    \n",
    "mygen1 = mygen()\n",
    "\n",
    "for i in mygen1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n"
     ]
    }
   ],
   "source": [
    "# This Generator function will generate ten numbers of fibonacci series.\n",
    "def myfibo():\n",
    "    num1 , num2 = 0,1\n",
    "    count = 0\n",
    "    while count < 10:\n",
    "            yield num1\n",
    "            num1,num2 = num2,num1+num2\n",
    "            count+=1\n",
    "\n",
    "            \n",
    "fibo = myfibo()\n",
    "\n",
    "for i in fibo:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 277,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = list(myfibo()) # Store the fibonacci series in a list\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 283,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2 = [i**2 for i in range(10)]  # List comprehension\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x000001EF4B639848>"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen2 = (i**2 for i in range(10)) # Generator expression\n",
    "gen2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "print(next(gen2))\n",
    "print(next(gen2))\n",
    "print(next(gen2))\n",
    "print(next(gen2))\n",
    "print(next(gen2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "20\n",
      "22\n",
      "24\n",
      "26\n",
      "28\n",
      "30\n",
      "32\n",
      "34\n",
      "36\n",
      "38\n"
     ]
    }
   ],
   "source": [
    "gen2 = (i for i in range(40) if i%2 == 0) # Generator expression to generate even numbers \n",
    "gen2\n",
    "\n",
    "for i in gen2:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decorator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Decorator__ is very powerful and useful tool in Python as it allows us to wrap another function in order to extend the behavior of wrapped function without permanently modifying it.\n",
    "\n",
    "\n",
    "In Decorators functions are taken as the argument into another function and then called inside the wrapper function.\n",
    "\n",
    "__Advantages__ - \n",
    " - Logging & debugging\n",
    " \n",
    " - Access control and authentication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is :-  2\n",
      "Result is :-  -2\n"
     ]
    }
   ],
   "source": [
    "def subtract(num1 , num2):\n",
    "    res = num1 - num2\n",
    "    print('Result is :- ', res)\n",
    "    \n",
    "subtract(4,2)\n",
    "subtract(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is :-  2\n"
     ]
    }
   ],
   "source": [
    "''' We now want subtract() function to always subtract lower number from higher one without modifying this function.\n",
    "    So when we pass (2,4) it should perform 4-2 not 2-4. To acheive this we will create a decorator function'''\n",
    "    \n",
    "\n",
    "def sub_decorator(func):\n",
    "    def wrapper(num1,num2):\n",
    "        if num1 < num2:\n",
    "            num1,num2 = num2,num1\n",
    "            return func(num1,num2)\n",
    "    return wrapper\n",
    "            \n",
    "sub = sub_decorator(subtract)\n",
    "\n",
    "sub(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is :-  2\n"
     ]
    }
   ],
   "source": [
    "@sub_decorator   # we can use @ syntax for decorating a function in one step\n",
    "def subtract(num1 , num2):\n",
    "    res = num1 - num2\n",
    "    print('Result is :- ', res)\n",
    "subtract(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linux installation has started \n",
      "\n",
      "Windows installation has started \n",
      "\n",
      "Mac installation has started \n",
      "\n",
      "\n",
      "Please accept terms & conditions\n",
      "Linux installation has started \n",
      "\n",
      "Please accept terms & conditions\n",
      "Windows installation has started \n",
      " \n",
      "Please accept terms & conditions\n",
      "Mac installation has started \n",
      "\n"
     ]
    }
   ],
   "source": [
    "def InstallLinux():\n",
    "    print('Linux installation has started \\n')\n",
    "    \n",
    "def InstallWindows():\n",
    "    print('Windows installation has started \\n')\n",
    "    \n",
    "def InstallMac():\n",
    "    print('Mac installation has started \\n')\n",
    "\n",
    "    \n",
    "InstallLinux()\n",
    "InstallWindows()\n",
    "InstallMac()\n",
    "\n",
    "print()\n",
    "\n",
    "\n",
    "''' Now suppose if we want to print message :- \"Please accept terms & conditions\" before every installation \n",
    "    then easy way will be to create one decorator function which will present this message instead of modifying all functions'''\n",
    "  \n",
    "    \n",
    "\n",
    "def InstallDecorator(func):\n",
    "    def wrapper():\n",
    "        print('Please accept terms & conditions')\n",
    "        return func()\n",
    "    return wrapper()\n",
    "\n",
    "@InstallDecorator    # we can use @ syntax for decorating a function in one step\n",
    "def InstallLinux():\n",
    "    print('Linux installation has started \\n')\n",
    "  \n",
    "@InstallDecorator\n",
    "def InstallWindows():\n",
    "    print('Windows installation has started \\n ')\n",
    " \n",
    "@InstallDecorator\n",
    "def InstallMac():\n",
    "    print('Mac installation has started \\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please accept terms & conditions...\n",
      "\n",
      "Please enter correct license key...\n",
      "\n",
      "Please enter partitioning choice...\n",
      "\n",
      "Linux installation has started \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Apply multiple decorator on a single function\n",
    "\n",
    "def InstallDecorator1(func):\n",
    "    def wrapper():\n",
    "        print('Please accept terms & conditions...\\n')\n",
    "        func()\n",
    "    return wrapper\n",
    "\n",
    "def InstallDecorator2(func):\n",
    "    def wrapper():\n",
    "        print('Please enter correct license key...\\n')\n",
    "        return func()\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "def InstallDecorator3(func):\n",
    "    def wrapper():\n",
    "        print('Please enter partitioning choice...\\n')\n",
    "        return func()\n",
    "    return wrapper\n",
    "\n",
    "@InstallDecorator1\n",
    "@InstallDecorator2\n",
    "@InstallDecorator3\n",
    "def InstallLinux():\n",
    "    print('Linux installation has started \\n')\n",
    "\n",
    "InstallLinux()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# File Management"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python has several built-in modules and functions for creating, reading, updating and deleting files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fileoperation.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Open File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileobj = open('test1.txt')  # Open file in read/text mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileobj = open('test1.txt', 'r') # Open file in read mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileobj = open('test1.txt', 'w') # Open file in write mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileobj = open('test1.txt', 'a') # Open file in append mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Close File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileobj = open('test1.txt') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of returning the entire sequence at once.\\nIt is a special type of function which returns an iterator object.\\nIn a generator function, a yield statement is used rather than a return statement.\\nThe generator function cannot include the return keyword. If we include it then it will terminate the execution of the function.\\nThe difference between yield and return is that once yield returns a value the function is paused and the control is transferred to the caller.Local variables and their states are remembered between successive calls. In case of the return statement value is returned and the execution of the function is terminated.\\nMethods like __iter()__ and __next()__ are implemented automatically in generator function.\\nSimple generators can be easily created using generator expressions. Generator expressions create anonymous generator functions like lambda.\\nThe syntax for generator expression is similar to that of a list comprehension but the only difference is square brackets are replaced with round parentheses. Also list comprehension produces the entire list while the generator expression produces one item at a time which is more memory efficient than list comprehension.'"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj.read() #Read whole file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj.read() #File cursor is already at the end of the file so it won't be able to read anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of returning the entire sequence at once.\\nIt is a special type of function which returns an iterator object.\\nIn a generator function, a yield statement is used rather than a return statement.\\nThe generator function cannot include the return keyword. If we include it then it will terminate the execution of the function.\\nThe difference between yield and return is that once yield returns a value the function is paused and the control is transferred to the caller.Local variables and their states are remembered between successive calls. In case of the return statement value is returned and the execution of the function is terminated.\\nMethods like __iter()__ and __next()__ are implemented automatically in generator function.\\nSimple generators can be easily created using generator expressions. Generator expressions create anonymous generator functions like lambda.\\nThe syntax for generator expression is similar to that of a list comprehension but the only difference is square brackets are replaced with round parentheses. Also list comprehension produces the entire list while the generator expression produces one item at a time which is more memory efficient than list comprehension.'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj.seek(0) # Bring file cursor to initial position.\n",
    "fileobj.read()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of returning the entire sequence at once.\\nIt is a special type of function which returns an iterator object.\\nIn a generator function, a yield statement is used rather than a return statement.\\nThe generator function cannot include the return keyword. If we include it then it will terminate the execution of the function.\\nThe difference between yield and return is that once yield returns a value the function is paused and the control is transferred to the caller.Local variables and their states are remembered between successive calls. In case of the return statement value is returned and the execution of the function is terminated.\\nMethods like __iter()__ and __next()__ are implemented automatically in generator function.\\nSimple generators can be easily created using generator expressions. Generator expressions create anonymous generator functions like lambda.\\nThe syntax for generator expression is similar to that of a list comprehension but the only difference is square brackets are replaced with round parentheses. Also list comprehension produces the entire list while the generator expression produces one item at a time which is more memory efficient than list comprehension.'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj.seek(7) # place file cursor at loc 7\n",
    "fileobj.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python generator'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj.seek(0)\n",
    "\n",
    "fileobj.read(16) # Return the first 16 characters of the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj.tell() # Get the file cursor position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of returning the entire sequence at once.\n",
      "\n",
      "It is a special type of function which returns an iterator object.\n",
      "\n",
      "In a generator function, a yield statement is used rather than a return statement.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fileobj.seek(0)\n",
    "\n",
    "print(fileobj.readline()) # Read first line of a file.\n",
    "\n",
    "print(fileobj.readline()) # Read second line of a file.\n",
    "\n",
    "print(fileobj.readline()) # Read third line of a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Python generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of returning the entire sequence at once.\\n',\n",
       " 'It is a special type of function which returns an iterator object.\\n',\n",
       " 'In a generator function, a yield statement is used rather than a return statement.\\n',\n",
       " 'The generator function cannot include the return keyword. If we include it then it will terminate the execution of the function.\\n',\n",
       " 'The difference between yield and return is that once yield returns a value the function is paused and the control is transferred to the caller.Local variables and their states are remembered between successive calls. In case of the return statement value is returned and the execution of the function is terminated.\\n',\n",
       " 'Methods like __iter()__ and __next()__ are implemented automatically in generator function.\\n',\n",
       " 'Simple generators can be easily created using generator expressions. Generator expressions create anonymous generator functions like lambda.\\n',\n",
       " 'The syntax for generator expression is similar to that of a list comprehension but the only difference is square brackets are replaced with round parentheses. Also list comprehension produces the entire list while the generator expression produces one item at a time which is more memory efficient than list comprehension.']"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj.seek(0)\n",
    "\n",
    "fileobj.readlines() # Read all lines of a file.            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of returning the entire sequence at once.\n",
      "\n",
      "It is a special type of function which returns an iterator object.\n",
      "\n",
      "In a generator function, a yield statement is used rather than a return statement.\n",
      "\n",
      "The generator function cannot include the return keyword. If we include it then it will terminate the execution of the function.\n",
      "\n",
      "The difference between yield and return is that once yield returns a value the function is paused and the control is transferred to the caller.Local variables and their states are remembered between successive calls. In case of the return statement value is returned and the execution of the function is terminated.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Read first 5 lines of a file using readline()\n",
    "fileobj.seek(0)\n",
    "\n",
    "count = 0\n",
    "for i in range(5):\n",
    "    if (count < 5):\n",
    "        print(fileobj.readline())\n",
    "    else:\n",
    "        break\n",
    "    count+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of returning the entire sequence at once.\n",
      "\n",
      "It is a special type of function which returns an iterator object.\n",
      "\n",
      "In a generator function, a yield statement is used rather than a return statement.\n",
      "\n",
      "The generator function cannot include the return keyword. If we include it then it will terminate the execution of the function.\n",
      "\n",
      "The difference between yield and return is that once yield returns a value the function is paused and the control is transferred to the caller.Local variables and their states are remembered between successive calls. In case of the return statement value is returned and the execution of the function is terminated.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Read first 5 lines of a file using readlines()\n",
    "fileobj.seek(0)\n",
    "\n",
    "count = 0\n",
    "for i in fileobj.readlines():\n",
    "    if (count < 5):\n",
    "        print(i)\n",
    "    else:\n",
    "        break\n",
    "    count+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python generators are easy way of creating iterators. It generates values one at a time from a given sequence instead of returning the entire sequence at once.\\nIt is a special type of function which returns an iterator object.\\nIn a generator function, a yield statement is used rather than a return statement.\\nThe generator function cannot include the return keyword. If we include it then it will terminate the execution of the function.\\nThe difference between yield and return is that once yield returns a value the function is paused and the control is transferred to the caller.Local variables and their states are remembered between successive calls. In case of the return statement value is returned and the execution of the function is terminated.\\nMethods like __iter()__ and __next()__ are implemented automatically in generator function.\\nSimple generators can be easily created using generator expressions. Generator expressions create anonymous generator functions like lambda.\\nThe syntax for generator expression is similar to that of a list comprehension but the only difference is square brackets are replaced with round parentheses. Also list comprehension produces the entire list while the generator expression produces one item at a time which is more memory efficient than list comprehension.THIS IS THE NEW CONTENT APPENDED IN THE FILE'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj = open('test1.txt', 'a')\n",
    "\n",
    "fileobj.write('THIS IS THE NEW CONTENT APPENDED IN THE FILE') # Append content to the file\n",
    "\n",
    "fileobj.close()\n",
    "\n",
    "fileobj = open('test1.txt')\n",
    "\n",
    "fileobj.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NEW CONTENT ADDED IN THE FILE. PREVIOUS CONTENT HAS BEEN OVERWRITTEN'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj = open(\"test1.txt\", \"w\")\n",
    "\n",
    "fileobj.write(\"NEW CONTENT ADDED IN THE FILE. PREVIOUS CONTENT HAS BEEN OVERWRITTEN\") # overwrite the content in the file\n",
    "\n",
    "fileobj.close()\n",
    "\n",
    "fileobj = open('test1.txt')\n",
    "\n",
    "fileobj.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['First Line\\n',\n",
       " 'Second Line\\n',\n",
       " 'Third Line\\n',\n",
       " 'Fourth Line\\n',\n",
       " 'Fifth Line\\n']"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileobj = open(\"test2.txt\", \"w\") # Create a new file\n",
    "\n",
    "fileobj.write(\"First Line\\n\") \n",
    "fileobj.write(\"Second Line\\n\")\n",
    "fileobj.write(\"Third Line\\n\") \n",
    "fileobj.write(\"Fourth Line\\n\")\n",
    "fileobj.write(\"Fifth Line\\n\")\n",
    "fileobj.close()\n",
    "\n",
    "fileobj = open('test2.txt')\n",
    "\n",
    "fileobj.readlines()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.remove(\"test3.txt\") # Delete file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[WinError 2] The system cannot find the file specified: 'test3.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-116-fecc9f240170>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"test3.txt\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [WinError 2] The system cannot find the file specified: 'test3.txt'"
     ]
    }
   ],
   "source": [
    "os.remove(\"test3.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.rmdir('folder1/')  # Delete folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[WinError 2] The system cannot find the file specified: 'folder1/'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-118-e9e89c9edbf0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrmdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'folder1/'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [WinError 2] The system cannot find the file specified: 'folder1/'"
     ]
    }
   ],
   "source": [
    "os.rmdir('folder1/')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Error & Exception Handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python has many built-in exceptions (ArithmeticError, ZeroDivisionError, EOFError, IndexError, KeyError, SyntaxError, IndentationError, FileNotFoundError etc) that are raised when your program encounters an error.\n",
    "\n",
    "\n",
    "- When the exception occurs Python interpreter stops the current process and passes it to the calling process until it is handled. If exception is not handled the program will crash.\n",
    "\n",
    "\n",
    "- Exceptions in python can be handled using a __try__ statement. The __try__ block lets you test a block of code for errors.\n",
    " \n",
    "\n",
    "- The block of code which can raise an exception is placed inside the try clause. The code that will handle the exceptions is written in the __except__ clause.\n",
    " \n",
    " \n",
    "- The __finally__ code block will execute regardless of the result of the try and except blocks.\n",
    "\n",
    "\n",
    "- We can also use the __else__ keyword to define a block of code to be executed if no exceptions were raised.\n",
    "\n",
    "\n",
    "- Python also allows us to create our own exceptions that can be raised from the program using the __raise__ keyword and caught using the __except__ clause. We can define what kind of error to raise, and the text to print to the user."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = 'exception1.PNG'>\n",
    "<img src = 'exception2.PNG'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "division by zero Exception occured\n",
      "Run this block of code always\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(100/0) # ZeroDivisionError will be encountered here. So the control will pass to except block\n",
    "    \n",
    "except:\n",
    "    print(sys.exc_info()[1] , 'Exception occured') # This statement will be executed \n",
    "    \n",
    "else:\n",
    "    print('No exception occurred') # This will be skipped as code block inside try encountered an exception\n",
    "\n",
    "finally:\n",
    "    print('Run this block of code always') # This will be always executed \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable x is not defined\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(x)  # NameError exception will be encountered as variable x is not defined                               \n",
    "\n",
    "except:\n",
    "    print('Variable x is not defined')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BELOW EXCEPTION OCCURED\n",
      "[WinError 2] The system cannot find the file specified: 'test3.txt'\n",
      "\n",
      "Run this block of code always\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    os.remove(\"test3.txt\") # FileNotFoundError will be encountered as \"test3.txt\" is not present in the directory\n",
    "    \n",
    "except:                     # Below statement will be executed as exception occured.          \n",
    "    print(\"BELOW EXCEPTION OCCURED\") \n",
    "    print(sys.exc_info()[1])\n",
    "    \n",
    "else:\n",
    "    print('\\nNo exception occurred')\n",
    "\n",
    "finally:\n",
    "    print('\\nRun this block of code always')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number :- 12\n",
      "Enter first number :- 13\n",
      "0.9230769230769231\n",
      "FileNotFoundError exception occurred\n"
     ]
    }
   ],
   "source": [
    "# Handling specific exceptions\n",
    "try:\n",
    "    x = int(input('Enter first number :- '))\n",
    "    y =  int(input('Enter first number :- '))  # If input entered is non-zero the control will move to next line\n",
    "    print(x/y)\n",
    "    os.remove(\"test3.txt\")\n",
    "\n",
    "except NameError:\n",
    "    print('NameError exception occurred')\n",
    "\n",
    "except FileNotFoundError:\n",
    "    print('FileNotFoundError exception occurred')\n",
    "    \n",
    "except ZeroDivisionError:\n",
    "    print('ZeroDivisionError exception occurred')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number :- 10\n",
      "Enter first number :- 0\n",
      "ZeroDivisionError exception occurred\n"
     ]
    }
   ],
   "source": [
    "# Handling specific exceptions\n",
    "try:\n",
    "    x = int(input('Enter first number :- '))\n",
    "    y =  int(input('Enter first number :- ')) # If the input entered is zero the control will move to except block.\n",
    "    print(x/y)\n",
    "    os.remove(\"test3.txt\")\n",
    "\n",
    "except NameError:\n",
    "    print('NameError exception occurred')\n",
    "\n",
    "except FileNotFoundError:\n",
    "    print('FileNotFoundError exception occurred')\n",
    "    \n",
    "except ZeroDivisionError:\n",
    "    print('ZeroDivisionError exception occurred') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number :- 100\n",
      "<class 'ValueError'>\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = int(input('Enter first number :- '))\n",
    "    if x > 50:\n",
    "        raise ValueError(x) # If value of x is greater than 50 ValueError exception will be encountered.\n",
    "except:\n",
    "    print(sys.exc_info()[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class 'OverflowError'>, OverflowError('math range error'), <traceback object at 0x000002B2B12EFB88>)\n"
     ]
    }
   ],
   "source": [
    "# OverflowError - This exception is raised when the result of a numeric calculation is too large\n",
    "\n",
    "try:  \n",
    "    import math\n",
    "    print(math.exp(1000))\n",
    "except OverflowError:  \n",
    "        print (sys.exc_info())\n",
    "else:  \n",
    "    print (\"Success, no error!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number :- 100\n",
      "Enter first number :- 0\n",
      "ZeroDivisionError exception occurred\n"
     ]
    }
   ],
   "source": [
    "# ZeroDivisionError - This exception is raised when the second operator in a division is zero\n",
    "\n",
    "try:\n",
    "    x = int(input('Enter first number :- '))\n",
    "    y =  int(input('Enter first number :- '))\n",
    "    print(x/y)\n",
    "    \n",
    "except ZeroDivisionError:\n",
    "    print('ZeroDivisionError exception occurred')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NameError exception occurred\n"
     ]
    }
   ],
   "source": [
    "# NameError - This exception is raised when a variable does not exist\n",
    "\n",
    "try:\n",
    "    print(x1)\n",
    "\n",
    "except NameError:\n",
    "    print('NameError exception occurred')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Assertion Exception Raised.\n"
     ]
    }
   ],
   "source": [
    "# AssertionError - This exception is raised when an assert statement fails\n",
    "\n",
    "try:  \n",
    "    a = 50\n",
    "    b = \"Asif\"\n",
    "    assert a == b\n",
    "except AssertionError:  \n",
    "        print (\"Assertion Exception Raised.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ModuleNotFoundError Exception Raised.\n"
     ]
    }
   ],
   "source": [
    "# ModuleNotFoundError - This exception is raised when an imported module does not exist\n",
    "\n",
    "try:\n",
    "    import MyModule\n",
    "\n",
    "except ModuleNotFoundError:  \n",
    "        print (\"ModuleNotFoundError Exception Raised.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KeyError Exception Raised.\n"
     ]
    }
   ],
   "source": [
    "# KeyError - This exception is raised when key does not exist in a dictionary\n",
    "\n",
    "try:\n",
    "    mydict = {1:'Asif', 2:'Basit', 3:'Michael'}\n",
    "    print (mydict[4])\n",
    "\n",
    "except KeyError:\n",
    "     print (\"KeyError Exception Raised.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IndexError Exception Raised.\n"
     ]
    }
   ],
   "source": [
    "# IndexError - This exception is raised when an index of a sequence does not exist.\n",
    "\n",
    "try:\n",
    "    mylist = [1,2,3,4,5,6]\n",
    "    print (mylist[10])\n",
    "\n",
    "except IndexError:\n",
    "     print (\"IndexError Exception Raised.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TypeError Exception Raised.\n"
     ]
    }
   ],
   "source": [
    "# TypeError - This exception is raised when two different datatypes are combined\n",
    "\n",
    "try:  \n",
    "    a = 50\n",
    "    b = \"Asif\"\n",
    "    c = a/b\n",
    "except TypeError:  \n",
    "        print (\"TypeError Exception Raised.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AttributeError Exception Raised.\n"
     ]
    }
   ],
   "source": [
    "# AttributeError: - This exception is raised when attribute reference or assignment fails\n",
    "\n",
    "try:  \n",
    "    a = 10\n",
    "    b = a.upper()\n",
    "    print(b)\n",
    "except AttributeError:  \n",
    "        print (\"AttributeError Exception Raised.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    x = input('Enter first number :- ')\n",
    "\n",
    "    \n",
    "except:\n",
    "    print('ZeroDivisionError exception occurred')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# END"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}