files/Python Programming - Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "#  Variables\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variables are used to store values that we want to use later in the program that contain alphanumeric beginning in a letter or underscore and are case sensitive and unique.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can not start with number or special characters\n",
    "no_of_days_in_a_year = 365\n",
    "s = \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 3.2 Hello\n"
     ]
    }
   ],
   "source": [
    "# assign value respectively\n",
    "a, b, c = 5, 3.2, \"Hello\"\n",
    "\n",
    "print( a, b, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# asign same value to multiple variables\n",
    "x = y = z = 1\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of x + y is:  5\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "y = 3\n",
    "z = x + y\n",
    "s = z\n",
    "print \"Sum of x + y is: \", z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140425180800464\n",
      "140425180800224\n"
     ]
    }
   ],
   "source": [
    "# unique id(memory reference) of a variable\n",
    "a = 50\n",
    "#print id(a)\n",
    "s1 = 257\n",
    "s2 = 257\n",
    "\n",
    "print id(s1)\n",
    "print id(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "g = \"hello\"\n",
    "\n",
    "#Local Variable\n",
    "def bob():\n",
    "    global l\n",
    "    l = \"local\"\n",
    "    print l\n",
    "\n",
    "def foo():\n",
    "    return \"hello\"\n",
    "    print a\n",
    "\n",
    "#print foo()\n",
    "a = foo()\n",
    "print a\n",
    "#print me   # Asking for a global variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Global variable\n",
    "def bob():\n",
    "    global me\n",
    "    me = \"locally defined\"   # Defined locally but declared as global\n",
    "    print(me)\n",
    "\n",
    "bob()\n",
    "print(me) # Asking for a global variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love Paris in the summer!!!\n"
     ]
    }
   ],
   "source": [
    "# Refer to global variable if not found locally\n",
    "s = \"I love New York!!!\"\n",
    "\n",
    "def f(): \n",
    "    print(s) # try to find in global scope\n",
    "    \n",
    "s = \"I love Paris in the summer!!!\" #global scope\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Can't use variable locally before defining it\n",
    "def f(): \n",
    "    print(s) # Error\n",
    "    s = \"I love London!\"\n",
    "\n",
    "s = \"I love Paris!\" \n",
    "f()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#  Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data types are actually classes and variables are instance (object) of these classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 'is of type', <type 'int'>)\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "print(a, \"is of type\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2.0, 'is of type', <type 'float'>)\n"
     ]
    }
   ],
   "source": [
    "a = 2.0\n",
    "print(a, \"is of type\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Grey Atom', 'is of type', <type 'str'>)\n"
     ]
    }
   ],
   "source": [
    "a = \"Grey Atom\"\n",
    "print(a, \"is of type\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((1+2j), 'is complex number?', True)\n"
     ]
    }
   ],
   "source": [
    "a = 1+2j\n",
    "print(a, \"is complex number?\", isinstance(1+2j,complex))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(True, 'is of type', <type 'bool'>)\n"
     ]
    }
   ],
   "source": [
    "a = True\n",
    "print(a, \"is of type\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4, \"hello\", [\"a\", \"b\"], True, False]\n",
    "#print(a, \"is of type\", type(a))\n",
    "\n",
    "a = None\n",
    "b = None \n",
    "print a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "({'institute': 'Grey Atom', 'course': 'Data Science'}, 'is of type', <type 'dict'>)\n"
     ]
    }
   ],
   "source": [
    "a = {\"institute\" : \"Grey Atom\", \"course\" : \"Data Science\"}\n",
    "print(a, \"is of type\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 6]\n",
      "[1, 2, 3, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "#a = (\"Peter\", \"Male\", 26)\n",
    "#print(a, \"is of type\", type(a))\n",
    "\n",
    "l = [1,2,3,4]\n",
    "m = l\n",
    "\n",
    "#l = l.append(5)\n",
    "\n",
    "m.append(6)\n",
    "\n",
    "print l\n",
    "print m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Data Types: Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Total Money in My Pocket: ', 550)\n"
     ]
    }
   ],
   "source": [
    "print (\"Total Money in My Pocket: \", 10*5 + 5*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('2 to the power 4 is : ', 16)\n"
     ]
    }
   ],
   "source": [
    "print(\"2 to the power 4 is : \", 2 ** 4);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Power can also be calculated with pow(): ', 16)\n"
     ]
    }
   ],
   "source": [
    "print(\"Power can also be calculated with pow(): \", pow(2, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Is it true that 2 is less than 3? ', False)\n"
     ]
    }
   ],
   "source": [
    "print (\"Is it true that 2 is less than 3? \", 2 == 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Remainder of 5 divided by 2: ', 1)\n"
     ]
    }
   ],
   "source": [
    "print(\"Remainder of 5 divided by 2: \", 5%2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "num1= 5\n",
    "num2 =10\n",
    "\n",
    "sum  = num1+num2\n",
    "print (sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('rounding a float value : ', 3.0)\n"
     ]
    }
   ],
   "source": [
    "# Rounding a float value\n",
    "print(\"rounding a float value : \", round(2.8));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('absolute value of -2 is : ', 2)\n"
     ]
    }
   ],
   "source": [
    "# Absolute value\n",
    "print(\"absolute value of -2 is : \", abs(-2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'module'>\n",
      "3.46410161514\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print type(math)\n",
    "\n",
    "print (math.sqrt(12))\n",
    "print (math.floor(2.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Printing and Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# print multiline\n",
    "#print (\"\"\"There's something going on here.\n",
    "#With the three double-quotes.\"\"\")\n",
    "\n",
    "def f():\n",
    "    \"\"\"\n",
    "    Very useul function\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Same', 'message', 'as before')\n"
     ]
    }
   ],
   "source": [
    "# Concatenate differnt words\n",
    "print(\"Same\", \"message\", \"as before\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is: Test Python, My Age height is: 5.11, and it is True that I am  married.\n"
     ]
    }
   ],
   "source": [
    "my_name = \"Test Python\"\n",
    "my_height = 5.11\n",
    "is_married = True\n",
    "\n",
    "print (\"My name is: %s, My Age height is: %.2f, and it is %s that I am  married.\" % ( my_name, my_height, is_married))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My number is: 12, and my name is: Sam\n"
     ]
    }
   ],
   "source": [
    "num = 12\n",
    "name = 'Sam'\n",
    "final = 'My number is: {one}, and my name is: {two}'.format(one=num,two=name)\n",
    "print final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My number is: 12, and my name is: Sam\n"
     ]
    }
   ],
   "source": [
    "num = 12\n",
    "name = 'Sam'\n",
    "print('My number is: {}, and my name is: {}'.format(num,name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Data Types: String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The string type in Python represents an immutable ordered array of characters (note there is no char type)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "str1 = 'single quotes'\n",
    "print(str1)\n",
    "\n",
    "str2 = \"double quotes\"\n",
    "print(str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print ('The newline \\n will not expand')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Character can be accessed by index\n",
    "string = \"hello world\"\n",
    "print (string[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Concatenation\n",
    "string = \"hello world\"\n",
    "string = string + ' Goodbye, world';\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Repeat words\n",
    "string = \"hello world \"\n",
    "print(string*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# unicode strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Substrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Substrings\n",
    "s = \"ग्रेएटॉम\"\n",
    "\n",
    "string = \"Hello world again and again\"\n",
    "string[10:-23]\n",
    "\n",
    "#print (string[6:11]) # \"world\"\n",
    "#print (string[:5])   # \"Hello\"\n",
    "#print (string[22:])  # \"again\"\n",
    "#print (string[-7:-2])# \"d aga\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# lenth of the string\n",
    "string = \"Hello world\"\n",
    "print (len(string))\n",
    "print len([1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# Occurrences of substring in a string\n",
    "string = \"Hello world again and again\"\n",
    "print (string.count(\"again\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 'world again and again']\n"
     ]
    }
   ],
   "source": [
    "# Split the string into array\n",
    "string = \"Hello,world again and again\"\n",
    "#print (string.split())\n",
    "print string.split(\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n",
      "HELLO WORLD\n"
     ]
    }
   ],
   "source": [
    "# Lower and Upper case\n",
    "string = \"Hello world\"\n",
    "print (string.lower())\n",
    "print (string.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# startswith & endswidth(sub [,start[,end]])\n",
    "string = \"Hello world again and again\"\n",
    "print (string.startswith(\"Hello\"))\n",
    "print (string.endswith(\"in\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world from India and from India\n",
      "Hello world again and again\n"
     ]
    }
   ],
   "source": [
    "# Replace\n",
    "string = \"Hello world again and again\"\n",
    "print (string.replace(\"again\", \"from India\"))\n",
    "string = string.replace(\"again\", \"from\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red,green,blue\n"
     ]
    }
   ],
   "source": [
    "#Join\n",
    "l = ['red','green','blue']\n",
    "a = \"-\"\n",
    "\n",
    "print \",\".join(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "22\n"
     ]
    }
   ],
   "source": [
    "# Position of substring in string\n",
    "string = \"Hello world again and again\"\n",
    "print (string.find(\"again\")) #left find\n",
    "print (string.rfind(\"again\")) # right find"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "string = \"Hello world and again Hello\"\n",
    "#print (string.strip(\"Hello\"))  # strip from both the side\n",
    "#print (string.rstrip(\"Hello\")) # strip only from right\n",
    "\n",
    "print len(\"  hello    \".strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Conditional - IF, ELIF, ELSE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The if-statement tells your script,\n",
    "     \"If this boolean expression is True, then run the code under it, otherwise skip it.”\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if expr1:\n",
    "    #\n",
    "    #\n",
    "    #\n",
    "    \n",
    "elif expr2:\n",
    "    #\n",
    "    #\n",
    "    #\n",
    "    #\n",
    "else:\n",
    "    #\n",
    "    #\n",
    "    \n",
    "a = 5\n",
    "b = 4\n",
    "if a > b: print (\"a is greater than b\");\n",
    "\n",
    "if (a > b):\n",
    "    print (\"a is greater than b\")\n",
    "    print (\"blocks are defined by indentation\")\n",
    "elif (a < b):\n",
    "    print (\"a is less than b\")\n",
    "else:\n",
    "    print (\"a is equal to b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Loop - FOR and WHILE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Another familiar (and useful) construct is the for loop. This executes a block of code for over a sequence of values.\n",
    "e.g. for value in [1,2,3]: do something\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[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",
       " 40,\n",
       " 42,\n",
       " 44,\n",
       " 46,\n",
       " 48,\n",
       " 50,\n",
       " 52,\n",
       " 54,\n",
       " 56,\n",
       " 58,\n",
       " 60,\n",
       " 62,\n",
       " 64,\n",
       " 66,\n",
       " 68,\n",
       " 70,\n",
       " 72,\n",
       " 74,\n",
       " 76,\n",
       " 78,\n",
       " 80,\n",
       " 82,\n",
       " 84,\n",
       " 86,\n",
       " 88,\n",
       " 90,\n",
       " 92,\n",
       " 94,\n",
       " 96,\n",
       " 98]"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\"a\": 1, \"b\": 2, \"c\": 3, \"d\": [1,2,3,4]}\n",
    "#print d[\"b\"]\n",
    "\n",
    "#d = [1,2,3,4, None]\n",
    "\n",
    "#for k in <iterable>:\n",
    "#    print k\n",
    "\n",
    "\n",
    "print range(10)\n",
    "\n",
    "#for i in range(10):\n",
    "#    print \"hello\"\n",
    " \n",
    "range(0, 100, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# decrease by 2 until 0\n",
    "x = 0\n",
    "for j in range(10,0,-2):\n",
    "   x = x + j\n",
    "   print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = 0\n",
    "while (b < a):\n",
    "   print (\"b:{} is less than a:{}\".format(b,a))\n",
    "   b = b+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "seq = [1,2,3,4,5]\n",
    "for item in seq:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Find all the even number between 1 to 100\n",
    "for num in range(100): \n",
    "    if(num % 2 == 0):\n",
    "        print (num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Program to display the Fibonacci sequence up to n-th term where n is provided by the user\n",
    "\n",
    "N = 10\n",
    "\n",
    "# first two terms\n",
    "num1 = 0\n",
    "num2 = 1\n",
    "count = 2\n",
    "\n",
    "# check if the number of terms is valid\n",
    "if N <= 0:\n",
    "   print(\"Please enter a positive integer\")\n",
    "elif N == 1:\n",
    "   print(\"Fibonacci sequence upto\",N,\":\")\n",
    "   print(0)\n",
    "else:\n",
    "   print(\"Fibonacci sequence upto\",N,\":\")\n",
    "   print (num1)\n",
    "   print (num2)\n",
    "   while count < N:\n",
    "       next_fibonacci =  num1 + num2\n",
    "       print (next_fibonacci)\n",
    "       # update values\n",
    "       num1 = num2\n",
    "       num2 = next_fibonacci\n",
    "       count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The list type is a container that holds different objects, in a given order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "marks = [20, 50, 30, 80, 75,  65]\n",
    "\n",
    "list_of_different_objects = [\"Peter\", 1000, 10.5]\n",
    "\n",
    "list_of_lists = [marks, list_of_different_objects, ['red','green','blue']]\n",
    "\n",
    "# Empty list\n",
    "empty_list = []\n",
    "empty_list.append(1) # add 1 to list\n",
    "empty_list.append(2) # add 2 to list\n",
    "empty_list.append(3) # add 3 to list\n",
    "print (empty_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# List element can be accessed by index position like in string\n",
    "marks = [20, 50, 30, 80, 75,  65]\n",
    "print (marks[0])  # 20\n",
    "print (marks[2])  # 30\n",
    "print (marks[-1]) # index from last\n",
    "print (marks[-4]) # index from last"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Nested list\n",
    "nested_list = [1,2,3,[4,5,['target']]]\n",
    "print (nested_list[3])\n",
    "print (nested_list[3][2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "colors = ['RED', 'GREEN', 'BLUE', 'YELLOW']\n",
    "print (colors[1:-1])        # ['RED', 'YELLOW']\n",
    "\n",
    "colors[0:2] = [\"PURPLE\"]    # replace ['RED', 'GREEN'] with ['PURPLE']\n",
    "print (colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "colors = ['RED', 'GREEN', 'BLUE', 'YELLOW']\n",
    "# The for-in statement makes it easy to loop over the items in a list\n",
    "for item in colors:\n",
    "        print (item)\n",
    "        \n",
    "# If you need both the index and the item, use the enumerate function\n",
    "for index, item in enumerate(colors):\n",
    "        print (index, item)\n",
    "\n",
    "# Uncommon way - If you need only the index, use range and len\n",
    "for index in range(len(colors)):\n",
    "        print (index)\n",
    "\n",
    "# The list object supports the iterator protocol\n",
    "itr = iter(colors)\n",
    "print (itr.next()) # fetch first value\n",
    "print (itr.next()) # fetch second value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Sum & Length\n",
    "marks = [20, 50, 30, 80, 75,  65]\n",
    "\n",
    "print (sum(marks))\n",
    "print (len(marks))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# append element at end\n",
    "colors = ['RED', 'GREEN', 'BLUE', 'YELLOW']\n",
    "colors.append('PURPLE')\n",
    "print (colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# insert at given index\n",
    "colors = ['RED', 'GREEN', 'BLUE', 'YELLOW']\n",
    "colors.insert(1,'PURPLE')\n",
    "print (colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Extend - adds the elements in list2 to the end of the list1.\n",
    "list1 = [1, 2, 3]\n",
    "list2 = [4, 5, 6]\n",
    "list1.extend(list2)\n",
    "print (list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Extend using +\n",
    "level = [\"beginner\", \"intermediate\", \"advanced\"]\n",
    "other_words = [\"novice\", \"expert\"]\n",
    "print (level + other_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Index of an element\n",
    "colors = ['RED', 'GREEN', 'BLUE', 'YELLOW']\n",
    "print (colors.index('BLUE'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Remove list element\n",
    "num = [1, 2, 3, 4]\n",
    "num.remove(2)\n",
    "print (num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# use del to remove\n",
    "num = [1, 2, 3, 4]\n",
    "del num[1]\n",
    "print (num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Sort in ascending order\n",
    "num = [5, 2, 4, 3]\n",
    "num.sort()\n",
    "print (num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Reverse list\n",
    "letters = ['A', 'B', 'C', 'D']\n",
    "letters.reverse()\n",
    "print (letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# pop a value\n",
    "num = [10, 20, 30, 40]\n",
    "x = num.pop(2)\n",
    "print (x)\n",
    "y = num.pop()\n",
    "print (y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# check for pallindrome\n",
    "list = ['a', 'b', 'c', 'b', 'a']\n",
    "print (list == list[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Remove duplicate from list\n",
    "t = [1, 2, 3, 1, 2, 5, 6, 7, 8]\n",
    "s = []\n",
    "for i in t:\n",
    "       if i not in s:\n",
    "          s.append(i)\n",
    "        \n",
    "print (s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Median\n",
    "list = [13, 23, 11, 16, 15, 10, 26]\n",
    "list.sort()\n",
    "print (list)\n",
    "length = len(list)\n",
    "print ('Median is: ', list[int(length/2)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List comprehensions can be used to construct lists in a very natural, easy way.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('a', 1), ('c', 1), ('b', 2)]\n"
     ]
    }
   ],
   "source": [
    "# Generational Comprehension\n",
    "l = []\n",
    "for i in range(10):\n",
    "    l.append(i*i)\n",
    "\n",
    "d = {\"a\":1 , \"b\":2, \"c\":1 }\n",
    "\n",
    "l = [(k, d[k]) for k in d]\n",
    "print l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# List Comprehension - Cross product of two sets\n",
    "colours = [\"red\", \"green\", \"yellow\"]\n",
    "things = [\"house\", \"car\", \"tree\" ]\n",
    "coloured_things = [ (x,y) for x in colours for y in things ]\n",
    "print (coloured_things)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Convert Celsius to Fahrenheit \n",
    "Celsius = [39.2, 36.5, 37.3, 37.8]\n",
    "Fahrenheit = [ ((float(9)/5)*x + 32) for x in Celsius ]\n",
    "print (Fahrenheit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python's efficient key/value hash table structure is called a \"dict\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## dict[key] = value-for-that-key\n",
    "institute = {}\n",
    "institute['name'] = 'Grey Atom'\n",
    "institute['course'] = 'Data Science'\n",
    "institute['duration'] = '3 Months'\n",
    "print (institute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (institute['name'])\n",
    "print (institute['course'])\n",
    "print (institute['duration'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['c', 'r', 'b', 'g']\n",
      "{3: 'red', 4: 'blue', 5: 'green'}\n"
     ]
    }
   ],
   "source": [
    "# Iterating over a dict iterates over its keys.\n",
    "d = {'r': 'red', 'g': 'green', 'b': 'blue', 'c': 'cyan'}\n",
    "#for key in d: print (key) #for key in dict.keys(): print key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A set is an unordered collection of items. Every element is unique (no duplicates) and must be immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# set of integers\n",
    "s = {1, 2, 3, 2, 3}\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Set of different data types\n",
    "s = {1.0, \"Hello world\", (1, 2, 3)}\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "set([2, 3, 4, 10])\n"
     ]
    }
   ],
   "source": [
    "# Empty set\n",
    "s = set([1,2,3, 1])\n",
    "\n",
    "if \"a\" in {\"a\": 1}:\n",
    "    print True\n",
    "else:\n",
    "    print False\n",
    "    \n",
    "l = [3, 3, 2, 4, 2, 10]\n",
    "print set(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# find unique elements\n",
    "l = [1,2,3,2,1,5,6,5,5,5]\n",
    "unique = set()\n",
    "for x in l:\n",
    "    if x not in unique:\n",
    "          unique.add(x)\n",
    "print (unique)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Set of odd number up to 20\n",
    "a = {x for x in range(20) if x % 2 != 0}\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Other methods\n",
    "my_set = {1, 3, 4, 5, 6}\n",
    "print(my_set)\n",
    "\n",
    "# discard an element\n",
    "my_set.discard(4)\n",
    "print(my_set)\n",
    "\n",
    "# remove an element\n",
    "my_set.remove(6)\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# UNION\n",
    "A = {1, 2, 3, 4, 5}\n",
    "B = {4, 5, 6, 7, 8}\n",
    "print (A|B)\n",
    "print (A.union(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# INTERSECTION\n",
    "A = {1, 2, 3, 4, 5}\n",
    "B = {4, 5, 6, 7, 8}\n",
    "print (A & B)\n",
    "print (A.intersection(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# DIFFERENCE\n",
    "A = {1, 2, 3, 4, 5}\n",
    "B = {4, 5, 6, 7, 8}\n",
    "print (A - B)\n",
    "print (A.difference(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# SYMMETRIC DIFFERENCE\n",
    "A = {1, 2, 3, 4, 5}\n",
    "B = {4, 5, 6, 7, 8}\n",
    "print (A ^ B)\n",
    "print (A.symmetric_difference(B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A tuple is similar to a list. Tuples are immutable arrays of arbitrary elements. The elements of a tuple cannot be changed once it is assigned whereas in a list, elements can be changed.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = (1, 2.5, 3, \"Hello World\")\n",
    "print (t)\n",
    "t[1] = 8 # immutable\n",
    "print (t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# lists to tuples and tuples to lists - zip\n",
    "# The zip function in python accepts a number of sequences (such as lists or arrays) and returns a list of tuples\n",
    "\n",
    "a = range(0,5)\n",
    "b = range(5,10)\n",
    "c = range(10,15)\n",
    "sequence_of_tuples = zip(a, b, c)\n",
    "print(sequence_of_tuples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# zip () in conjuction with * operator can be used to unzip a list\n",
    "a1,b1,c1 = zip(*sequence_of_tuples)\n",
    "print(a1)\n",
    "print(b1)\n",
    "print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# *tuple means \"treat this tuple as positional arguments to this function call.\"\n",
    "def foo(x,y):\n",
    "    print(x,y)\n",
    "\n",
    "t = (1,2)\n",
    "foo(*t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# **dict means \"treat the key-value pairs in the dictionary as additional named arguments to this function call.\"\n",
    "def foo(x,y):\n",
    "    print(x,y)\n",
    "\n",
    "d = {'x':1, 'y':2}\n",
    "foo(**d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Function signature\n",
    "def foo(*x):\n",
    "    print(x)\n",
    "\n",
    "foo(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Function signature\n",
    "def foo(**d):\n",
    "    print(d)\n",
    "foo(x=1, y=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Accessing Elements in a Tuple\n",
    "my_tuple = ['p','e','r','m','i','t']\n",
    "\n",
    "print(my_tuple[0])\n",
    "print(my_tuple[5])\n",
    "print(my_tuple[-2]) # from right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Slicing\n",
    "my_tuple = ('p','r','o','g','r','a','m','i','z')\n",
    "\n",
    "# elements 2nd to 4th\n",
    "# Output: ('r', 'o', 'g')\n",
    "print(my_tuple[1:4])\n",
    "\n",
    "# elements beginning to 2nd\n",
    "# Output: ('p', 'r')\n",
    "print(my_tuple[:-7])\n",
    "\n",
    "# elements 8th to end\n",
    "# Output: ('i', 'z')\n",
    "print(my_tuple[7:])\n",
    "\n",
    "# elements beginning to end\n",
    "# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')\n",
    "print(my_tuple[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Deleting a Tuple\n",
    "t = (1, 2.5, 3, \"Hello World\")\n",
    "print (t)\n",
    "del (t)\n",
    "print (t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "# Iterating through a Tuple\n",
    "#t = (1, 2.5, 3, \"Hello World\")\n",
    "#for value in t:\n",
    "#    print (value)\n",
    "\n",
    "l = [1,2,3]\n",
    "l[2] = 4\n",
    "print l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Copying Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Immutable object\n",
    "x = 3 # int data type\n",
    "y = x # y is pointing to x\n",
    "\n",
    "y = 5 # change y, x should not changed - immutable\n",
    "\n",
    "print (x)\n",
    "print (y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Mutable object\n",
    "list1 = [1,2,3,4,5] # A list\n",
    "list2 = list1       # list2 is pointing to the same memory location as list 1\n",
    "list2.append(8)     # if list2 is changed, list1 will also change - mutable\n",
    "\n",
    "print (list1)\n",
    "print (list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# inefficient code\n",
    "container = [\"A\",\"B\",\"C\",\"D\",\"E\"]\n",
    "string_build = \"\"\n",
    "for data in container:\n",
    "    string_build += str(data)\n",
    "\n",
    "string_build"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# More efficient\n",
    "\"\".join(container)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Copying a list\n",
    "colours1 = [\"red\", \"green\"]\n",
    "colours2 = colours1\n",
    "colours2[1] = \"blue\"\n",
    "colours1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Copy with the Slice Operator\n",
    "colours1 = [\"red\", \"green\"]\n",
    "colours2 = colours1[:]\n",
    "colours2[1] = \"blue\"\n",
    "print (colours1)\n",
    "print (colours2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Copy with the extend Operator\n",
    "colours1 = [\"red\", \"green\"]\n",
    "colours2= []\n",
    "colours2.extend(colours1)\n",
    "colours2[1] = \"blue\"\n",
    "print (colours1)\n",
    "print (colours2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Copy with the list Operator\n",
    "colours1 = [\"red\", \"green\"]\n",
    "colours2= list(colours1)\n",
    "colours2[1] = \"blue\"\n",
    "print (colours1)\n",
    "print (colours2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Copy with the copy Operator\n",
    "import copy\n",
    "colours1 = [\"red\", \"green\"]\n",
    "colours2= copy.copy(colours1)\n",
    "colours2[1] = \"blue\"\n",
    "print (colours1)\n",
    "print (colours2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, ['a', 'b', 'c', 'd'], 5]\n"
     ]
    }
   ],
   "source": [
    "# Deep copy\n",
    "import copy\n",
    "\n",
    "list_a = [[3, 4], [5, 6, [7, 8]]]\n",
    "list_b = copy.deepcopy(list_a)\n",
    "\n",
    "list_a[0][1] = 9 # change the first list, second list shoud not change\n",
    "\n",
    "#print (list_a)\n",
    "#print (list_b)\n",
    "\n",
    "l = [1, 2, 3, 4, [\"a\", \"b\", \"c\"]]\n",
    "m = copy.copy(l)\n",
    "\n",
    "m.append(5)\n",
    "\n",
    "l[4].append(\"d\")\n",
    "\n",
    "print m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercise - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Convert Celsius to Fahrenheit\n",
    "# Formula: ((float(9)/5)*x + 32)\n",
    "\n",
    "Celsius = [39.2, 36.5, 37.3, 37.8]\n",
    "Fahrenheit = [ ((float(9)/5)*x + 32) for x in Celsius ]\n",
    "print (Fahrenheit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Find out whether a list is a palindrome\n",
    "\n",
    "list = ['a', 'b', 'c', 'b', 'a']\n",
    "print (list == list[::-1])\n",
    "\n",
    "\n",
    "\n",
    "# Remove duplicate from the below list\n",
    "\n",
    "t = [1, 2, 3, 1, 2, 5, 6, 7, 8]\n",
    "s = []\n",
    "for i in t:\n",
    "       if i not in s:\n",
    "          s.append(i)\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' hello'"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Given this nest dictionary grab the word \"hello\".\n",
    "\n",
    "d = {' k1':[1,2,3, {' tricky' :[' oh' ,' man' ,' inception' , {' target':[1,2,3,' hello']}]}]}\n",
    "d[' k1'][3][' tricky'][3][' target'][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}