Python for Data Analytics - Module 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=\"3\" color=\"brown\">Author : UTSAV AWASTHI</font><br>\n",
    "<font size=\"1\" color=\"brown\">About Me: http://iamawesome.com/ </font> <br>\n",
    "Subscribe to my YouTube channel <a href=\"https://www.youtube.com/channel/UCJpp55YcP5swWj8TmIOd0OA/\">here</a><br> \n",
    "For serious conversations related to career and jobs, follow me on <a href=\"https://www.linkedin.com/in/utsavawasthi/\">LinkedIn</a><br>\n",
    "For low-effort dank memes and one-liners, follow me on <a href=\"https://twitter.com/utsavsaidwhat\">Twitter</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\">\n",
    "    <font size = 3 color=\"orange\" style=\"font-family: 'Comic Sans MS'\">// ज्ञानं परमं बलम् //</font><br>\n",
    "</div>\n",
    "<img src = \"https://www.python.org/static/community_logos/python-logo-master-v3-TM.png\" width=\"50%\" height=\"50%\">\n",
    "<div align=\"center\" id=\"contents\"> <font size=\"5\" color=\"orange\"><b>PYTHON PROGRAMMING LANGUAGE</b></font> </div>\n",
    "\n",
    "<div align=\"left\"> <font size=\"4\" color=\"red\"><b>TABLE OF CONTENTS</b></font> </div>\n",
    "<ol type=\"square\">\n",
    "    <li><a href=\"#intro\">Introduction\n",
    "    <li><a href=\"#datatype\">Data types and Operations</a></li>\n",
    "    <li><a href=\"#variables\">Variables and Collections</a></li>\n",
    "    <li><a href=\"#control\">Control Flow and Loops</a></li>\n",
    "    <li><a href=\"#functions\">Functions</a></li>\n",
    "    <li><a href=\"#classes\">Classes</a></li>\n",
    "    <li><a href=\"#fileio\">File I/O</a></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"intro\"><a href=\"#contents\"><font size=\"4\" color=\"red\"><b>INTRODUCTION</b></font></a></div>\n",
    "<ol type=\"square\">\n",
    "    <li><a href=\"#intro_about\">About Python</a></li>\n",
    "    <li><a href=\"#intro_anaconda\">About Anaconda</a></li>\n",
    "    <li><a href=\"#intro_zen\">The Zen of Python</a></li>\n",
    "    <li><a href=\"#intro_why\">Why Python?</a></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id =\"intro_about\"> <a href=\"#intro\"><font size=\"3\" color=\"black\"><b>About Python</b></font></a></div>\n",
    "\n",
    "Python is a programming language created by <b>Guido van Rossum</b>. You might ask why Python has such a huge fan base and job postings? Here are some reasons why Python is so widely used:<br>\n",
    "<ol type=\"square\">\n",
    "    <li>Open source - Free to use, modify, redistribute unlike Matlab, SAS, Microsoft Excel(VBA) etc</li>\n",
    "    <li>High level - Easier to understand. Built on top of low-level languages like Machine Code or Assembly. Relevant examples <a href=\"https://excelwithbusiness.com/blog/say-hello-world-in-28-different-programming-languages/\">here</a></li>\n",
    "    <li>General purpose - Manipulate data, Build websites, Write Softwares, Mobile Apps - you name it, Python can do it. What about SQL/Wolfram/HTML?</li>\n",
    "    <li>Standardized across Platforms - works on Windows, iOS, Android, Linux </li>\n",
    "    <li>Interpreted - No need to compile the whole code. The code runs line by line. Unlike C/C++/Java</li>\n",
    "    <li>Object Oriented</li>\n",
    "</ol>\n",
    "\n",
    "Furthermore it has huge community support and therefore you can easily find a module/library for both commonly utilized and highly complex tasks. For Data Analytics tasks the most popular modules are as below:\n",
    "<ul type=\"square\">\n",
    "    <li>NumPy - highly optimized matrix operations</li>\n",
    "    <li>SciPy - contains modules for mathematical/scientific computing</li>\n",
    "    <li>scikit-learn - contains most of common machine learning implementations</li>\n",
    "    <li>Matplotlib - plotting</li>\n",
    "    <li>Pandas - supports relational databases</li>\n",
    "    <li>TensorFlow - created by Google, mainly used for deep learning </li>\n",
    "</ul>\n",
    "\n",
    "And here are the detailed stats of Github activities for all famous machine learning related Python libraries:\n",
    "<img src=\"https://cdn-images-1.medium.com/max/1600/0*jyZHKZohXDgwCFsq.png\" alt=\"Python Github\"></img>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"intro_anaconda\"> <a href=\"#intro\"><font size=\"3\" color=\"black\"><b>About Anaconda</b></font></a></div>\n",
    "\n",
    "Anaconda (download <u><i>Python 3.7</i></u> version from <a href = \"https://www.anaconda.com/products/individual\">here</a>) is a free and open source distribution of the Python and R programming languages for data science and machine learning related applications. It aims to simplify package management and deployment.\n",
    "\n",
    "If you have Anaconda installed on your system, there are three ways you can code in Python :\n",
    "<ol type=\"square\">\n",
    "    <li>Anaconda prompt - Write \"python\" without quote, press enter and then you can write your code and run</li> \n",
    "    <li>Spyder - If you are comfortable with RStudio, you may want to use this</li> \n",
    "    <li>Jupyter Notebook - this is what you are using right now and my personal recommendation if you are building something new</li>\n",
    "</ol>\n",
    "<br>\n",
    "<font size=\"2\">If you do not have Anaconda installed on your system, you can use  <a href = \"https://repl.it/\">repl</a> OR <a href = \"https://jupyter.org/try\">jupyter</a> to run the codes below. However Anaconda is highly recommended<font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see which version of Python you are running right now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two versions of Python - 2.x and 3.x - former was discontinued in Dec 2019. For most part, the codes written in Python 2.x will run in 3.x without many changes. Given below are the major differences in the two versions<br>\n",
    "<img src=\"https://learntocodewith.me/wp-content/uploads/2014/06/python-2-vs-3-2018.png\" alt=\"Python 2 vs 3\" width=\"50%\" height=\"50%\"></img>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook has been created with Python 3.x version. If you are running Python 2.x(see the output you got above), then it is highly advisable that you uninstall and re-install 3.x version from the link above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"intro_zen\"><a href=\"#intro\"><font size=\"4\" color=\"black\"><b>The Zen of Python</b></font></a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>The Zen of Python, by Tim Peters</b>\n",
    "<br>\n",
    "<br>Beautiful is better than ugly.\n",
    "<br>Explicit is better than implicit.\n",
    "<br>Simple is better than complex.\n",
    "<br>Complex is better than complicated.\n",
    "<br>Flat is better than nested.\n",
    "<br>Sparse is better than dense.\n",
    "<br>Readability counts.\n",
    "<br>Special cases aren't special enough to break the rules.\n",
    "<br>Although practicality beats purity.\n",
    "<br>Errors should never pass silently.\n",
    "<br>Unless explicitly silenced.\n",
    "<br>In the face of ambiguity, refuse the temptation to guess.\n",
    "<br>There should be one-- and preferably only one --obvious way to do it.\n",
    "<br>Although that way may not be obvious at first unless you're Dutch.\n",
    "<br>Now is better than never.\n",
    "<br>Although never is often better than *right* now.\n",
    "<br>If the implementation is hard to explain, it's a bad idea.\n",
    "<br>If the implementation is easy to explain, it may be a good idea.\n",
    "<br>Namespaces are one honking great idea -- let's do more of those!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's the broad philosophy of Python. We will see how few of the points above are evident in the code we write in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id =\"intro_why\"> <a href=\"#intro\"><font size=\"3\" color=\"black\"><b>Why Python?</b></font></a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import antigravity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id =\"intro_tip\"> <a href=\"#intro\"><font size=\"3\" color=\"black\"><b>Pro-tip</b></font></a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The best and the only tip you ever need in learning any programming language is that when you face any error, copy the error code, google it and open the links on Stack Overflow. A wise man once said, there are no problems which another dude on internet hasn't posted on Stack Overflow already"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<blockquote class=\"twitter-tweet\"><p lang=\"en\" dir=\"ltr\">Yeah sex is cool and all, but have you ever run a code, which ran without errors in first attempt?</p>&mdash; Utsav Awasthi (@utsavsaidwhat) <a href=\"https://twitter.com/utsavsaidwhat/status/1253700610677002240?ref_src=twsrc%5Etfw\">April 24, 2020</a></blockquote> <script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"datatype\"><a href=\"#contents\"><font size=\"4\" color=\"red\"><b>DATA TYPE AND OPERATIONS</b></font></a></div>\n",
    "<ol type=\"square\">\n",
    "    <li><a href=\"#datatype_mute\">Mutable vs. Immutable</a></li>\n",
    "    <li><a href=\"#datatype_comments\">Comments</a></li>\n",
    "    <li><a href=\"#datatype_primitive\">Primitive Datatypes and Operators</a></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"datatype_mute\"><a href=\"#datatype\"><font size=\"3\" color=\"black\"><b>Mutable vs. Immutable</b></font></a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mutable types can have individual items reassigned in place, while immutable types cannot. <br>\n",
    "In simple language, all mutable object types can be edited i.e. changes can be made without replacing the whole object<br>\n",
    "And immutable object types cannot be edited and need to be replaced all together<br>\n",
    "\n",
    "<b>Mutable objects</b>: list, dict, set, byte array<br>\n",
    "<b>Immutable objects</b>: int, float, complex, string, tuple, frozen set [note: immutable version of set], bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#list is mutable and hence you can change any element you want\n",
    "L = [0,2,3]\n",
    "L[0] = 1\n",
    "print (L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#string is immutable\n",
    "s = 'string'\n",
    "s[0] = 'o' #throws error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python creates real copies only if it has to, i.e. if the user, the programmer, explicitly demands it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=[1,2,4]\n",
    "print (\"Location of x\",id(x), \"\\tValue of x\", x) #id() function tells you the location of a variable in memory\n",
    "\n",
    "y=x\n",
    "print(\"Location of y\",id(y), \"\\tValue of y\", y) #\\t refers to a \"tab\" - basically a whitespace equal to four spaces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, both \"x\" and \"y\" have same value and are in the same memory location. Also notice how print function has been used to print mutiple strings and variable values by separating them with a comma<br><br>\n",
    "Among other ways(which we will discuss when they come up in future), you can use \"copy\" module to copy an object into a new location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "z = copy.copy(x)\n",
    "print(\"Location of z\",id(y), \"\\tValue of z\", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now variable \"z\" has the same value as \"x\" and \"y\", but it is stored in a different memory location. <br><br>\n",
    "If you assign one mutable object to another and then change/edit a value in the first object, the same will be reflected in the second object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,4]\n",
    "y = x #This just points to the same object i.e. x\n",
    "print (\"x=\", x)\n",
    "print (\"id of x=\", id(x))\n",
    "print (\"y=\", y)\n",
    "print (\"id of y=\", id(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing value at the first location in the list \"x\"\n",
    "x[0] = 999\n",
    "print(\"Changing a value in x, changes it in y too. Ids are same:\")\n",
    "print (\"x=\", x)\n",
    "print (\"id of x=\", id(x))\n",
    "print (\"y=\", y)\n",
    "print (\"id of y=\", id(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is not the case with immutable objects because you cannot edit them, just change the value entirely. There are work arounds to copy a mutable object into another without facing the issue discussed above. One such way is as below :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,4]\n",
    "y = x[:] #Now this won't point to the same object\n",
    "print (\"x=\", x)\n",
    "print (\"id of x=\", id(x))\n",
    "print (\"y=\", y)\n",
    "print (\"id of y=\", id(y)) #Ids are same, but NOT values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing value at the first location in the list \"x\"\n",
    "x[0] = 999\n",
    "print(\"Changing a value in x, does NOT change it in y too\")\n",
    "print (\"x=\", x)\n",
    "print (\"id of x=\", id(x))\n",
    "print (\"y=\", y)\n",
    "print (\"id of y=\", id(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"datatype_comments\"><a href=\"#datatype\"><font size=\"3\" color=\"black\"><b>Comments</b></font></a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Single line comments start with a number symbol."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"\"\" Multi-line strings can be written\n",
    "    using three \"s, and are often used\n",
    "    as comments\n",
    "\"\"\"\n",
    "x = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"datatype_primitive\"><a href=\"#datatype\"><font size=\"3\" color=\"black\"><b>Primitive Datatypes and Operators</b></font></a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# You have numbers, mostly called integers\n",
    "3  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Math is what you would expect\n",
    "1 + 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "8 - 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "10 * 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "34 / 5 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now division used to be tricky in Python 2. For the code above, Python 2 would have just printed the integer part of the output i.e. 6. As a good practice whenever you are dividing, multiply numerator with 1.0. This will force normal division in whichever Python version you are using. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "39*1.0/7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# We have float values which have decimal places too\n",
    "2.0  # This is a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Multiplying by a float number, always leads to a float output\n",
    "45*100*1.0/70\n",
    "#or you can do 45.0*100/70"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Modulo operation given remainder\n",
    "20 % 15 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "100%100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Exponentiation (x to the yth power)\n",
    "2 ** 4  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "3**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Enforce precedence with parentheses\n",
    "(1 + 3) * 2  # => 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, Boolean values are the two constant objects - False and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Boolean Operators\n",
    "# Note \"and\" and \"or\" are case-sensitive\n",
    "True and False "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PYTHON IS CASE SENSITIVE. true is NOT same as TRUE or True or TrUe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "False or True  # => True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use Bool operators with integers too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Any 0 value is \"False\"\n",
    "0 == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1 is \"True\"\n",
    "1 == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# negate with \"not\"\n",
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Equality is ==\n",
    "print (\"1 == 1 is\", 1 == 1)\n",
    "print (\"2 == 1 is\", 2 == 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Inequality is !=\n",
    "print (1 != 1)  \n",
    "print (2 != 1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Some more comparisons\n",
    "print (1 < 10) \n",
    "print (1 > 10)  \n",
    "print (2 <= 2) \n",
    "print (2 >= 2)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Strings are created with \"(double quote) or '(single quote) or \"\"\"(triple double quote) or '''(triple single quote)\n",
    "print (\"This is a string\")\n",
    "print ('This is also a string')\n",
    "print (\"\"\"This too\"\"\")\n",
    "print ('''And finally this too''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#you can also save strings in a variable\n",
    "a = \"Hello\"\n",
    "b = \"World!\"\n",
    "print (a)\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Strings can be added too!\n",
    "print (\"Hello \" + \"world!\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# ... or multiplied\n",
    "print (\"Hello\" * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A string can be treated like a list of characters. We can access individual letters in the string like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print (\"This is a string\"[0])  \n",
    "print (\"This is a string\"[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can do it from the back too (TWSS :P)\n",
    "print (\"This is a string\"[-1])\n",
    "print (\"This is a string\"[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Always remember that <b>numbering/indexing in Python starts from 0 and NOT 1</b>. So to access first element you write [0], for second you write [1], so on and so forth. You can count from back too, in which case the numbering starts from -1 e.g. last element will be [-1], second last will be [-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# You can find the length of a string\n",
    "len(\"This is a string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# None is an object too\n",
    "print (None)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like in SQL you have \"NULL\" and \"NA\" in R, in python a missing element is denoted by None. To compare something with \"None\", you need to use \"is\", not \"==\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Don't use the equality \"==\" symbol to compare objects to None\n",
    "# Use \"is\" instead\n",
    "print (\"etc\" is None )\n",
    "print (None is None  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"variables\"><a href=\"#contents\"><font size=\"4\" color=\"red\"><b>VARIABLES AND COLLECTIONS</b></font></a></div>\n",
    "<ol type=\"square\">\n",
    "    <li><a href=\"#variables_rules\">Rules and Conventions</a></li>\n",
    "    <li><a href=\"#variables_numbers\">Numbers and strings</a></li>\n",
    "    <li><a href=\"#variables_lists\">Lists</a></li>\n",
    "    <li><a href=\"#variables_tuples\">Tuples</a></li>\n",
    "    <li><a href=\"#variables_dict\">Dictionaries</a></li>\n",
    "    <li><a href=\"#variables_sets\">Sets</a></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"variables_rules\"> <a href=\"#variables\"> <font size=\"3\" color=\"black\"><b>The Rules</b></font><a></div>\n",
    "Variables names must start with a letter or an underscore, such as:\n",
    "<ul type=\"square\">\n",
    "    <li>_myvar</li>\n",
    "    <li>myvar&#95;</li>\n",
    "</ul>\n",
    "\n",
    "\n",
    "The remainder of your variable name may consist of letters, numbers and underscores:\n",
    "<ul type=\"square\">\n",
    "    <li>password1</li>\n",
    "    <li>n00b</li>\n",
    "    <li>un_der_scores</li>\n",
    "</ul>\n",
    "\n",
    "\n",
    "As I said earlier, Python is case-sensitive:\n",
    "<ul type=\"square\">\n",
    "    <li>case_sensitive, CASE_SENSITIVE, and Case_Sensitive are each a different variable.</li>\n",
    "</ul>\n",
    "\n",
    "<div align=\"left\"> <font size=\"3\" color=\"black\"><b>The Conventions</b></font> </div>\n",
    "Readability is very important. Which of the following is easiest to read? I’m hoping you’ll say the first example:\n",
    "<ol type=\"square\">\n",
    "    <li>python_puppet</li>\n",
    "    <li>pythonpuppet</li>\n",
    "    <li>pythonPuppet</li>\n",
    "</ol>\n",
    "\n",
    "\n",
    "Descriptive names are very useful. If you are writing a program that adds up all of the terrible jokes made in this book, which do you think is the better variable name?\n",
    "<ol type=\"square\">\n",
    "    <li>terrrible_jokes_count</li>\n",
    "    <li>cnt</li>\n",
    "</ol>\n",
    "Certain keywords which Python itself uses like print, help, int, float, list, set etc are also not allowed to be used as variable names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\"  id=\"variables_numbers\"><a href=\"#variables\"><font size=\"3\" color=\"black\"><b>Numbers and strings</b></font> <a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# No need to declare variables before assigning to them\n",
    "some_var = 5  \n",
    "print (some_var)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike some low-level languages like C and Java, there is no need to declare the type of variable in Python.\n",
    "All you have to do is define a variable and assign a value to it. \n",
    "Python will automatically read what kind of variable it is - be it string or integer or float or any other data types that we will discuss below. Examples are as below :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_float = 2.35; print (my_float)\n",
    "my_string = \"Hi there!\"; print (my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\"  id=\"variables_lists\"><a href=\"#variables\"><font size=\"3\" color=\"black\"><b>Lists</b></font><a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are equivalent to arrays in most other programming languages and are used to store values in a sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Lists store sequences. You can start with an empty list\n",
    "li = []\n",
    "print(li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Or you can start with a prefilled list\n",
    "other_li = [4, 5, 6]\n",
    "print (other_li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#A list can contain anything e.g numbers along with strings etc\n",
    "my_list = [1, \"a\", \"Python\", 1.25]\n",
    "print (my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Add stuff to the end of a list with append\n",
    "li.append(1) \n",
    "li.append(2) \n",
    "li.append(4)  \n",
    "li.append(3)  \n",
    "print (li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Remove from the end with pop\n",
    "li.pop()  \n",
    "print (li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Let's put it back in (TWSS :P)\n",
    "li.append(3)  \n",
    "print (li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Access a list element like you would any array\n",
    "print (li[0])  \n",
    "print (li[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Look at the last element\n",
    "li[-1]  # => 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Looking-up out of bounds is an IndexError\n",
    "li[4]  # Raises an IndexError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember the pro tip above? You can simply copy this error and google to find out what went wrong. Luckily it says right there that the index was out of range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Assign new values to indexes that have already been initialized with =\n",
    "li[0] = \"lol\"\n",
    "print (li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's put back the original value\n",
    "li[0] = 1 \n",
    "print (li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>List slicing</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# You can look at ranges with slice syntax.\n",
    "li[1:3]  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing works like this - If you have <b>li[a:b:c]</b>, you will get all the values <b> starting from location \"a\" to location ending at \"b-1\" (i.e. element at loction b isn't included) with a jump of \"c\" units</b>. Here are some examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This is the list right now\n",
    "print(li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#From index 2 and onwards\n",
    "print (\"li[2:] is \", li[2:])  # => [4, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Till the index 3, but element at index 3 won't be included\n",
    "print (\"li[:3] is \",li[:3])  # => [1, 2, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select every second entry\n",
    "print (\"li[::2] is \",li[::2])  # =>[1, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverse a copy of the list\n",
    "print (\"li[::-1] is \",li[::-1])  # => [3, 4, 2, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We encourage you to play around with different combinations of a,b, and c(i.e. start, end, and step) to get comfortable with the notation. They also work the same with strings. for example :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#From index 2 and onwards\n",
    "print (\"Hello World! [2:] is => \", \"Hello World!\"[2:]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Till the index 3, but element at index 3 won't be included\n",
    "print (\"Hello World![:3] is => \",\"Hello World!\"[:3]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select every second entry\n",
    "print (\"Hello World![::2] is => \",\"Hello World!\"[::2]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverse the string\n",
    "print (\"Hello World![::-1] is => \",\"Hello World!\"[::-1]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Remove arbitrary elements from a list with \"del\"\n",
    "del li[2]  \n",
    "print (li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# You can add lists\n",
    "li + other_li"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Did that change li or other li? No it didn't. They are still the same\n",
    "print(li, other_li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Concatenate lists with \"extend()\"\n",
    "li.extend(other_li) # Now li is changed\n",
    "print (li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Remove first occurrence of a value\n",
    "li.remove(2)  # li is now [1, 3, 4, 5, 6]\n",
    "print (li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Try again?\n",
    "li.remove(2)  # Raises a ValueError as 2 is not in the list\n",
    "print (li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Insert an element at a specific index\n",
    "li.insert(1, 2)  # li is now [1, 2, 3, 4, 5, 6] again\n",
    "print (li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Get the index of the first item found\n",
    "print (li.index(2)) # give 1 and not 2, why? because numbering starts from 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (li.index(7))  # Raises a ValueError as 7 is not in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Check for existence in a list with \"in\"\n",
    "print (1 in li) \n",
    "print (8 in li) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Examine the length with \"len()\"\n",
    "len(li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#matrix can be thought of as list of lists i.e. each row as list and then list of rows\n",
    "my_matrix = [[1,2,3],[4,5,6]] #2x3 matrix\n",
    "print(\"First row:\", my_matrix[0])\n",
    "print(\"Second row:\", my_matrix[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\"  id=\"variables_tuples\"><a href=\"#variables\"><font size=\"3\" color=\"black\"><b>Tuples</b></font></a></div>\n",
    "Tuples are sequences, just like lists. The differences between tuples and lists are:\n",
    "<ol>\n",
    "    <li>unlike lists, the tuples cannot be changed because tuples are immutable while lists are mutable</li>\n",
    "    <li>tuples use parentheses, whereas lists use square brackets</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Tuples are like lists but are immutable.\n",
    "tup = (1, 2, 3)\n",
    "print (tup[0])  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#IMMMUTABLE\n",
    "tup[0] = 3  # Raises a TypeError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# You can do all those list thingies on tuples too\n",
    "print (len(tup))  # => 3\n",
    "print (tup + (4, 5, 6))  # => (1, 2, 3, 4, 5, 6)\n",
    "print (tup[:2])  # => (1, 2)\n",
    "print (2 in tup)  # => True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# You can unpack tuples (or lists) into variables\n",
    "a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3\n",
    "d, e, f = 4, 5, 6  # you can leave out the parentheses\n",
    "print (\"a =\", a)\n",
    "print (\"Rest values are\", b, c, d, e, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Tuples are created by default if you leave out the parentheses\n",
    "g = 4, 5, 6 \n",
    "print (g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Now look how easy it is to swap two values\n",
    "print(\"Before:\", e,d)\n",
    "e, d = d, e  # d is now 5 and e is now 4\n",
    "print(\"After:\", e,d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python! Its magic!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\"  id=\"variables_dict\"><a href=\"#variables\"><font size=\"3\" color=\"black\"><b>Dictionaries</b></font></a></div>\n",
    "A dictionary is an associative array (also known as hashes). Any key of the dictionary is associated (or mapped) to a value. The values of a dictionary can be any Python data type(mutable or immutable), but keys are mandated to be ONLY immutable. So in essence, dictionaries are unordered key-value-pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Dictionaries store mappings\n",
    "empty_dict = {}\n",
    "print (empty_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here is a prefilled dictionary\n",
    "filled_dict = {\"one\": 1, \"two\": 2, \"three\": 3}\n",
    "print (filled_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Another and a less used way\n",
    "keys = ['luke', 'david', 'chris', 'stewart']\n",
    "values = ['504', '637', '921', '110']\n",
    "D = dict(zip(keys, values))\n",
    "print (D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important point to note here is that unlike in lists or tuples, the values or keys inside dictionary are not ordered. So there is no first key or first value or second key or second value. All key-value pairs are unordered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Look up values with []\n",
    "print (filled_dict[\"one\"]  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Get all keys as a list with \"keys()\"\n",
    "filled_dict.keys()  # => [\"three\", \"two\", \"one\"]\n",
    "# Note - Dictionary key ordering is not guaranteed.\n",
    "# Your results might not match this exactly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#To get an output like a normal python list instead of dict_keys\n",
    "list(filled_dict.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Get all values as a list with \"values()\"\n",
    "filled_dict.values()  # => [3, 2, 1]\n",
    "# Note - Same as above regarding key ordering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(filled_dict.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Get all key-value pairs as a list of tuples with \"items()\"\n",
    "filled_dict.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Check for existence of keys in a dictionary with \"in\"\n",
    "print (\"one\" in filled_dict) \n",
    "print (1 in filled_dict)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Looking up a non-existing key is a KeyError\n",
    "filled_dict[\"four\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Use \"get()\" method to avoid the KeyError\n",
    "print (filled_dict.get(\"one\"))  # => 1\n",
    "print (filled_dict.get(\"four\"))  # => None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The get method supports a default argument when the value is missing\n",
    "print (filled_dict.get(\"one\", \"Whoops Not Found\"))  # => 1\n",
    "print (filled_dict.get(\"four\", \"Whoops Not Found\"))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# set the value of a key with a syntax similar to lists\n",
    "filled_dict[\"four\"] = 4 \n",
    "print (filled_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# \"setdefault()\" inserts into a dictionary only if the given key isn't present\n",
    "filled_dict.setdefault(\"five\", 5) # filled_dict[\"five\"] is set to 5\n",
    "print (filled_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filled_dict.setdefault(\"five\", 6) # filled_dict[\"five\"] is still 5\n",
    "print (filled_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\"  id=\"variables_sets\"><a href=\"#variables\"> <font size=\"3\" color=\"black\"><b>Sets</b></font></a></div>\n",
    "A Set is an unordered collection data type that is iterable, mutable, and has no duplicate elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Sets store ... well sets (which are like lists but can contain no duplicates)\n",
    "empty_set = set()\n",
    "print (empty_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize a \"set()\" with a bunch of values\n",
    "some_set = set([1, 2, 2,2,2,2,2,2, 3, 4])\n",
    "print (some_set)\n",
    "#Duplicate 2's were ignored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## order is not guaranteed, even though it may sometimes look sorted\n",
    "another_set = set([4, 3, 2, 2, 5, 1, \"a\", 0, 1.03])  \n",
    "print (another_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#{} can be used to declare a set too\n",
    "filled_set = {1, 2, 2, 3, 4}\n",
    "print(filled_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add more items to a set\n",
    "another_set.add(22)\n",
    "print (another_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like in Maths, you can perform normal set operations on sets in Python. This is not that important for us, just good to know"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Do set intersection with &\n",
    "other_set = {3, 4, 5, 6}\n",
    "print (another_set & other_set)\n",
    "\n",
    "# Do set union with |\n",
    "print (another_set | other_set)  \n",
    "\n",
    "# Do set difference with -\n",
    "print ({1, 2, 3, 4} - {2, 3, 5}) \n",
    "\n",
    "# Do set symmetric difference with ^\n",
    "print ({1, 2, 3, 4} ^ {2, 3, 5})  \n",
    "\n",
    "# Check if set on the left is a superset of set on the right\n",
    "print ({1, 2} >= {1, 2, 3})  \n",
    "\n",
    "# Check if set on the left is a subset of set on the right\n",
    "print ({1, 2} <= {1, 2, 3}) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Check for existence in a set with in\n",
    "print (2 in filled_set)  # => True\n",
    "print (10 in filled_set)  # => False\n",
    "print (10 not in filled_set) # => True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Check data type of variable\n",
    "print (type(li))   \n",
    "print (type(filled_dict))  \n",
    "print (type(5))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can perform some sensible type conversions easily using int(), str(), float() etc functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Converting type of variables\n",
    "my_int = 1\n",
    "my_float = 1.25\n",
    "print (\"float(my_int) =\", float(my_int))\n",
    "print (\"str(my_int) =\", str(my_int))\n",
    "print (\"int(my_float) =\", int(my_float))\n",
    "print (\"str(my_float) =\", str(my_float))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"control\"><a href=\"#contents\"><font size=\"4\" color=\"red\"><b>CONTROL FLOW AND LOOPS</b></font></a></div>\n",
    "<ol type=\"square\">\n",
    "    <li><a href=\"#control_indent\">Indentation</a></li>\n",
    "    <li><a href=\"#control_indent\">If, elif and else</a></li>\n",
    "    <li><a href=\"#control_for\">'for' loops</a></li>\n",
    "    <li><a href=\"#control_while\">'while' loops</a></li>\n",
    "    <li><a href=\"#control_except\">Exception Handling</a></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"control_indent\"><a href=\"#control\"><font size=\"3\" color=\"black\"><b>Indentation</b></font></a></div>\n",
    "Python uses indentation instead of braces to structure its programs and scripts into blocks. Indentation is very important aspect of Python and needs to be strictly adhered to while defining scope of different parts of the code\n",
    "\n",
    "<div align=\"left\" id=\"control_indent\"> <font size=\"3\" color=\"black\"><b>If, elif and else</b></font> </div>\n",
    "if. elif and else are used to execute the statements conditionally. <br><br>\n",
    "\n",
    "<i>\n",
    "if condition_1:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;#do something here<br>\n",
    "elif condition_2:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;#do something here<br>\n",
    "elif condition_3:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;#do something here<br>\n",
    "else:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;#do something here<br>\n",
    "</i>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "some_var = 5\n",
    "\n",
    "# Here is an if statement. Indentation is mandatory in python!\n",
    "if some_var > 10:\n",
    "    print (\"some_var is totally bigger than 10.\")\n",
    "elif some_var < 10:  # This elif clause is optional.\n",
    "    print (\"some_var is smaller than 10.\")\n",
    "else:  # This is optional too.\n",
    "    print (\"some_var is indeed 10.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All indentations have to be exactly of same size otherwise Python will throw an error. For example, in the example below, the second line has three spaces for indentations and third has four, so you get an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if some_var>0:\n",
    "   print(\"first\")\n",
    "    print(\"second\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a good practice, use one 'tab' or four spaces for indentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Guido\"\n",
    "if name == \"Guido\" and 4<2 and 2 in [1,2]:\n",
    "    print (\"It worked!\")\n",
    "else:\n",
    "    print (\"Whoops!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if name == \"Guido\" and 4<2 or 2 in [1,2]:\n",
    "    print (\"It worked!\")\n",
    "else:\n",
    "    print (\"Whoops!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"control_for\"><a href=\"#control\"><font size=\"3\" color=\"black\"><b>'for' loops</b></font></a></div>\n",
    "The for loop  is used to iterate over elements of a sequence, it is often \n",
    "used when you have a piece of code which you want to repeat \"n\" number of times. The syntax looks like this:\n",
    "\n",
    "<i>for element in some_sequence:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;#do something here</i>\n",
    "    \n",
    "Again, indentation is very important here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example below, every time the loop runs the variable \"i\" will intake a new value from the list \"a\". Now inside the loop this variable \"i\" can be used to do stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#looping using elements of a list\n",
    "a = [1,2,3,4]\n",
    "for i in a:\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#looping using elements of a list\n",
    "for animal in [\"dog\", \"cat\", \"mouse\"]:\n",
    "    print (animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example below, we are using range() function to generate a list of all locations(i.e. indexes) in the list \"a\" and then storing those indexes in variable \"i\". Later inside the loop, we are using \"i\" to get the values from \"a\" at a particular index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#looping with location\n",
    "a = [\"dog\", \"cat\", \"mouse\"]\n",
    "for i in range(len(a)):\n",
    "    print (\"location is:\",i, \"value is:\", a[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Can be used with strings also\n",
    "#looping with elements\n",
    "for character in \"Python\":\n",
    "    print (character)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#looping with location\n",
    "s = \"Python\"\n",
    "for i in range(len(s)):\n",
    "    print (s[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for loop with if\n",
    "for i in range(10):\n",
    "    if i%2==0:\n",
    "        continue #continue forces the loop to continue with the next iteration\n",
    "    if i%7==0:\n",
    "        break #break forces loop to break\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how we use loops inside loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#loop inside loop with elements\n",
    "my_matrix = [[1, 2, 3],[4, 5, 6]]\n",
    "for row in my_matrix:\n",
    "    print(\"row is\", row)\n",
    "    for col in row:\n",
    "        print (col)\n",
    "    print (\"\\n\") #scope of this print is inside of the first for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#loop inside loop with location\n",
    "for row in range(len(my_matrix)):\n",
    "    print(\"row is\", row)\n",
    "    for col in range(len(my_matrix[row])):\n",
    "        print (my_matrix[row][col])\n",
    "    print (\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "print() statements can easily be used to debug your code whenever you are not able to understand a complex code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>about the function range()</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"range(number)\" returns a list of numbers from zero to the given number.<br>\n",
    "\"range(lower, upper)\" returns a list of numbers from the lower number to the upper number minus one.<br>\n",
    "This is exactly like what we do with lists li[a:b:c]. Just that instead of colon, we use a comma.\n",
    "Here are some examples -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#range is an important function to generate arrays of integers\n",
    "print (list(range(5)))\n",
    "print (range(1,6))\n",
    "print (range(1,6,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id = \"control_while\"><a href=\"#control\"><font size=\"3\" color=\"black\"><b>While loops</b></font></a></div>\n",
    "The for loop above runs for a pre-determined number of iterations because before starting the loop we know how many elements are there in the list. However the while loop tells the computer to do something as long as a particular condition is met. Its construct consists of a block of code and a condition. The condition is evaluated, and if the condition is true, the code within the block is executed. This repeats until the condition becomes false. The syntax looks like this:\n",
    "\n",
    "<i>while condition:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;#do something here</i>\n",
    "    \n",
    "Again, indentation is very important here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#while loop example\n",
    "x = 0\n",
    "while x < 4:\n",
    "    print x\n",
    "    x += 1 #  += is equivalent to x = x+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"control_except\"><a href=\"#control\"><font size=\"3\" color=\"black\"><b>Exception handling</b></font></a></div>\n",
    "\n",
    "<b>What is an Exception?</b><br>\n",
    "An exception is an error that happens during execution of a program. When that\n",
    "error occurs, Python generate an exception that can be handled, which avoids your\n",
    "program to crash.<br>\n",
    "<br>\n",
    "<b>Why use Exceptions?</b><br>\n",
    "Exceptions are convenient in many ways for handling errors and special conditions\n",
    "in a program. When you think that you have a code which can produce an error then\n",
    "you can use exception handling.<br>\n",
    "<br>\n",
    "<b>Raising an Exception</b><br>\n",
    "You can raise an exception in your own program by using the raise exception\n",
    "statement. Raising an exception breaks current code execution and returns the exception\n",
    "back until it is handled.<br>\n",
    "<br>\n",
    "<b>Exception Errors</b><br>\n",
    "Below is some common exceptions errors in Python:<br>\n",
    "\n",
    "<b>IOError</b> : If the file cannot be opened.<br>\n",
    "\n",
    "<b>ImportError</b> : If python cannot find the module<br>\n",
    "\n",
    "<b>ValueError</b> : Raised when a built-in operation or function receives an argument that has the right type but an inappropriate value<br>\n",
    "\n",
    "<b>KeyboardInterrupt</b> : Raised when the user hits the interrupt key (normally Control-C or Delete)<br>\n",
    "\n",
    "<b>EOFError</b> : Raised when one of the built-in functions (input() or raw_input()) hits an end-of-file condition (EOF) without reading any data<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Works on Python 2.6 and up:\n",
    "try:\n",
    "    # Use \"raise\" to raise an error\n",
    "    raise IndexError(\"This is an index error\")\n",
    "except IndexError as e:\n",
    "    pass  # Pass is just a no-op. Usually you would do recovery here.\n",
    "except (TypeError, NameError):\n",
    "    pass  # Multiple exceptions can be handled together, if required.\n",
    "else:  # Optional clause to the try/except block. Must follow all except blocks\n",
    "    print (\"All good!\")  # Runs only if the code in try raises no exceptions\n",
    "finally:  # Execute under all circumstances\n",
    "    print (\"We can clean up resources here\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was little complicated and advanced. For now here is a simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#A simpler example\n",
    "n = int(input(\"Please enter a number: \")) #raw_input is used to take input from user\n",
    "#When it asks, enter \"abc\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "input() is raw_input() in Python 2.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#So it raised an error because you were trying to input a string, while the program was expecting integer\n",
    "#here is how you fix it\n",
    "while True:\n",
    "    try:\n",
    "        n = input(\"Please enter an integer: \")\n",
    "        n = int(n)\n",
    "        break\n",
    "    except ValueError:\n",
    "        print(\"No valid integer! Please try again ...\")\n",
    "print (\"Great, you successfully entered an integer!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"functions\"><a href=\"#contents\"><font size=\"4\" color=\"red\"><b>FUNCTIONS</b></font></a></div>\n",
    "<ol type=\"square\">\n",
    "    <li><a href=\"#functions_built\">Built-in Functions</a></li>\n",
    "    <li><a href=\"#functions_methods\">Methods</a></li>\n",
    "    <li><a href=\"#functions_import\">Importing Functions</a></li>\n",
    "    <li><a href=\"#functions_user\">User-defined Functions</a></li>\n",
    "    <li><a href=\"#functions_scope\">Scope of Variables</a></li>\n",
    "    <li><a href=\"#functions_lambda\">Lambda, Map, Reduce, and Filter</a></li>\n",
    "    <li><a href=\"#functions_list\">List Comprehension</a></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a block of organized, reusable code that is used to perform a single, related action. Functions provide better modularity for your application and a high degree of code reusing.\n",
    "\n",
    "Here is a simple example to understand what are functions and why they are so important. Suppose you want a pizza. So what you can do is, you simply open Dominos App and tell it which pizza you want, give them your address, pay and expect a delivery in 30mins or so. What happens here is you are giving some inputs to the Dominos app, it processes the inputs and delivers the output i.e. the Pizza. You do not have to worry about how Dominos is going to make the Pizza, find a delivery person and get the pizza delivered on time. Same goes for functions - they take some inputs and you can expect some output out of them. You do not have to worry about how the function is working internally. Think of print() function. Do you know how exactly it is taking the inputs from you and printing the output? No, right? And you would not want to know till the point print() function is taking the inputs and giving the output you want"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"functions_built\"><a href=\"#functions\"><font size=\"3\" color=\"black\"><b>Built-in Functions</b></font></a> </div>\n",
    "Python has some built-in functions that are available  to use without importing any module e.g. len(), raw_input(), int(), str(), range() etc. Few of these you have already used above, here are some more examples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#abs() prints the absolute value\n",
    "print (\"abs(-1) =\", abs(-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#converts tuples to list\n",
    "print (list({1,2,3}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#returns x to the power of y\n",
    "print(pow(3,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Add items of an Iterable\n",
    "print (sum([1,2,3,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#max of items of an Iterable\n",
    "print (max((1,2,3,4,0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Invokes the built-in Help System\n",
    "help(len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find more built-in functions on Google or <a href =\"https://www.programiz.com/python-programming/methods/built-in\">here</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"functions_methods\"><a href=\"#functions\"><font size=\"3\" color=\"black\"><b>Methods</b></font></a></div>\n",
    "A method is a piece of code that is called by name that is associated with an object. In most respects it is identical to a function except for two key differences:\n",
    "<ul>\n",
    "    <li>A method is implicitly passed the object on which it was called.</li>\n",
    "    <li>A method is able to operate on data that is contained within the class</li>\n",
    "</ul><br>\n",
    "We will explain objects and classes later. Lets see some example of methods :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#List Methods\n",
    "my_list = [6, 2, 4, 7]\n",
    "my_list.append(5)\n",
    "print (my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_list.sort()\n",
    "print (my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_list.sort(reverse=True)\n",
    "print (my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find more list methods on Google or <a href =\"https://www.programiz.com/python-programming/methods/list\">here</a>. You are also encouraged to explore <a href =\"https://www.programiz.com/python-programming/methods/dictionary\">dictionary methods</a>, <a href =\"https://www.programiz.com/python-programming/methods/string\">string methods</a> etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#dictionary methods\n",
    "my_dict = {\"a\":1, \"b\":2, \"c\":3}\n",
    "print (\"keys =\", my_dict.keys())\n",
    "print (\"values =\", my_dict.values())\n",
    "print (\"items =\", my_dict.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#string methods\n",
    "my_string = \"Hello World!\"\n",
    "#Checks if All Characters are Alphabets\n",
    "print (\"my_string.isalpha() =\", my_string.isalpha())\n",
    "print (\"my_string[:5].isalpha() =\", my_string[:5].isalpha())\n",
    "#converts to lowercase\n",
    "print (\"my_string.lower() =\", my_string.lower()) #try upper()\n",
    "#\tReturns the Highest Index of Substring\n",
    "print (\"my_string.find('H') =\", my_string.find('H'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"functions_import\"> <a href=\"#functions\"> <font size=\"3\" color=\"black\"><b>Importing Functions</b></font> </a></div>\n",
    "There are multiple pre-built libraries from which you can import functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Importing a library\n",
    "import math\n",
    "print (math.sqrt(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Importing a particular function from a library\n",
    "from math import sqrt\n",
    "print (sqrt(16)) #No need to write math.sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Importing everything from a library\n",
    "from math import *\n",
    "print (sqrt(16)) #No need to write math.sqrt\n",
    "print (sin(pi/2)) #pi is defined inside \"math\" library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#modules may have sub modules, in which case you can use dot (.)\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#To get help on a fucntion or library you can use help() function\n",
    "help(math.sqrt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#To get all modules currently installed on your system.takes some time to run, you can uncomment and run, when you have time\n",
    "#help(\"modules\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can install new modules in Jupyter using pip install command like below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pip install beautifulsoup4 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"functions_user\"><a href=\"#functions\"><font size=\"3\" color=\"black\"><b>User-defined Functions</b></font> </a></div>\n",
    "Python being a general purpose language allows users to define their own functions. This is also a strong reason to use Python as you can easily find libraries/modules(which is just a collection of functions) online which have been created by many Python programmers and can utilize them in your work.<br>\n",
    "A function can be defined using the keyword \"def\" like this:<br>\n",
    "\n",
    "<i>def my_function(your_parameters_here):\n",
    "    #do something\n",
    "    #return statement (it's optional though)\n",
    "my_function(arguments_for_your_parameters_here)</i><br>\n",
    "<div align=\"left\"> <font size=\"3\" color=\"black\"><b>Parameters vs Arguments</b></font> </div>\n",
    "A parameter is a variable in a method definition. When a method is called, the arguments are the data you pass into the method's parameters.\n",
    "Lets see some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#A function without any parameters and without any return\n",
    "def bark():\n",
    "    print (\"bark! bark!\")\n",
    "bark()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#A function with parameters and which doesn't return anything\n",
    "def add(a,b):\n",
    "    print (\"a+b is\", a+b)\n",
    "#calling the function\n",
    "add(2,3) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In above example, 2 and 3 are arguments to parameters a and b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#A function with parameters and which returns something\n",
    "def multiply(a,b):\n",
    "    return a*b\n",
    "multiply(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#A function with default parameters\n",
    "def divide(a=5, b=1):\n",
    "    return a/b\n",
    "print (\"divide() =\",divide())\n",
    "print (\"divide(10) =\",divide(10))\n",
    "print (\"divide(10,5) =\",divide(10,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"functions_scope\"><a href=\"#functions\"><font size=\"3\" color=\"black\"><b>Scope of Variables</b></font></a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python employs the following scoping hierarchy, in decreasing order of breadth: \n",
    "<ol type=\"square\">\n",
    "    <li><b>Built-in (Python)</b> : Predefined names (len, open, execfile, etc.) and types</li>\n",
    "    <li><b>Global (module)</b> : Names assigned at the top level of a module, or directly in the interpreter</li>\n",
    "    <li><b>Local (function)</b> : Names assigned inside a function definition or loop</li>\n",
    "</ol>\n",
    "Local variables are only accessible inside the module/function where they were first defined. You can declare  variables to be \"global\" inside a function, in which case you can access them from outside too.\n",
    "<br>Global variables can be accessed from anywhere, even when you are inside a function\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "global_variable = 1 #You can access this anywhere \n",
    "def f():\n",
    "    f_local_variable = 2 #You can access this only inside f(x)\n",
    "    global f_declared_global_variable\n",
    "    f_declared_global_variable = 3 #You can access this anywhere because we declared it global\n",
    "    \n",
    "def g():\n",
    "    print (\"#####  Inside function  #####\")\n",
    "    g_local_variable = 4 #You can access this only inside g(x)\n",
    "    global g_declared_global_variable\n",
    "    g_declared_global_variable = 5 #You can access this anywhere because we declared it global\n",
    "    try:\n",
    "        print (global_variable)\n",
    "    except NameError:\n",
    "        print (\"Error printing global_variable \")\n",
    "    try:\n",
    "        print (f_local_variable)\n",
    "    except NameError:\n",
    "        print (\"Error printing f_local_variable \")\n",
    "    try:\n",
    "        print (g_local_variable)\n",
    "    except NameError:\n",
    "        print (\"Error printing g_local_variable \")\n",
    "    try:\n",
    "        print (f_declared_global_variable)\n",
    "    except NameError:\n",
    "        print (\"Error printing f_declared_global_variable\")\n",
    "    try:\n",
    "        print (g_declared_global_variable)\n",
    "    except NameError:\n",
    "        print (\"Error printing g_declared_global_variable\")\n",
    "g()\n",
    "\n",
    "print (\"#####  Outside function  #####\")\n",
    "\n",
    "try:\n",
    "    print (global_variable)\n",
    "except NameError:\n",
    "    print (\"Error printing global_variable \")\n",
    "try:\n",
    "    print (f_local_variable)\n",
    "except NameError:\n",
    "    print (\"Error printing f_local_variable \")\n",
    "try:\n",
    "    print (g_local_variable)\n",
    "except NameError:\n",
    "    print (\"Error printing g_local_variable \")\n",
    "try:\n",
    "    print (f_declared_global_variable)\n",
    "except NameError:\n",
    "    print (\"Error printing f_declared_global_variable\")\n",
    "try:\n",
    "    print (g_declared_global_variable)\n",
    "except NameError:\n",
    "    print (\"Error printing g_declared_global_variable\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why did it give \"Error printing f_declared_global_variable\"? Shoudn't it have printed a global variable?<br>\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<div align=\"right\">\n",
    "<a href=\"#createvar\" class=\"btn btn-default\" data-toggle=\"collapse\">Click here for the solution</a>\n",
    "</div>\n",
    "<div id=\"createvar\" class=\"collapse\">\n",
    "```\n",
    "It is because f() never ran(we didn't call it) and hence the variables inside f() were not assigned.\n",
    "```\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#An example of recursive function\n",
    "def factorial(n):\n",
    "    if n==1: return n\n",
    "    else: return n*factorial(n-1)\n",
    "print (factorial(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#returning multiple outputs\n",
    "def multiple_outputs(x,y):\n",
    "    return x+1, y+1\n",
    "print (multiple_outputs(1,2)) #returns a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"functions_lambda\"><a href=\"#functions\"><font size=\"3\" color=\"black\"><b>Lambda, Map, Reduce, and Filter</b></font></a></div>\n",
    "<b>lambda</b> operator or lambda function is used for creating small, one-time and anonymous function objects in Python. lambda operator can have any number of arguments, but it can have only one expression. It cannot contain any statements and it returns a function object which can be assigned to any variable. The syntax is as below <br>\n",
    "<i>    lambda arguments : expression</i>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#lambda operator or lambda function is used for creating small, one-time and anonymous function objects in Python\n",
    "def add(x, y): \n",
    "    return x + y\n",
    "  \n",
    "# Call the function\n",
    "print (\"With defined function \",add(2, 3)) \n",
    "\n",
    "#Equivalent lambda\n",
    "add = lambda x, y : x + y \n",
    "print (\"With lambda \",add(2, 3)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>map</b> functions expects a function object and any number of iterables like list, dictionary, etc. It executes the function_object for each element in the sequence and returns an iterator of the elements modified by the function object. The iterator can be converted to list using list() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#map functions expects a function object and any number of iterables like list, dictionary, etc. \n",
    "#It executes the function_object for each element in the sequence and \n",
    "#returns a list of the elements modified by the function object.\n",
    "\n",
    "def multiply2(x):\n",
    "    return x*2\n",
    "print (\"With defined function \",list(map(multiply2, [1, 2, 3, 4]))) \n",
    "\n",
    "print (\"With lambda \", list(map(lambda x : x*2, [1, 2, 3, 4]))) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#list of two dictionaries\n",
    "dict_a = [{'name': 'python', 'points': 10}, {'name': 'java', 'points': 8}]\n",
    "print (\"Example 1:\", list(map(lambda x : x['name'], dict_a)))\n",
    "print (\"Example 2:\", list(map(lambda x : x['points']*10,  dict_a))) \n",
    "print (\"Example 3:\", list(map(lambda x : x['name'] == \"python\", dict_a)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#We can pass multiple sequences to the map functions\n",
    "list_a = [1, 2, 3]\n",
    "list_b = [10, 20, 30]\n",
    "print (list(map(lambda x, y: x + y, list_a, list_b)) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>filter</b> function expects two arguments, function_object and an iterable. function_object returns a boolean value. function_object is called for each element of the iterable and filter returns only those element for which the function_object returns true.\n",
    "\n",
    "Like map function, filter function also returns a list of element. Unlike map function filter function can only have one iterable as input. Syntax is like this :\n",
    "<i>filter(function_object, iterable)</i>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#filter function expects two arguments, function_object and an iterable. \n",
    "#function_object returns a boolean value. \n",
    "#function_object is called for each element of the iterable and \n",
    "# filter returns only those element for which the function_object returns true. You need to use list() function here too\n",
    "a = [1, 2, 3, 4, 5, 6]\n",
    "print(list(filter(lambda x : x % 2 == 0, a))) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dict_a = [{'name': 'python', 'points': 10}, {'name': 'java', 'points': 8}]\n",
    "print (list(filter(lambda x : x['name'] == 'python', dict_a))) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function <b>reduce</b>(func, seq) continually applies the function func() to the sequence seq. It returns a single value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "#The function reduce(func, seq) continually applies the function func() to the sequence seq. It returns a single value.\n",
    "print (reduce(lambda x,y: x+y, [47,11,42,13]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Calculating the sum of the numbers from 1 to 100\n",
    "print (reduce(lambda x, y: x+y, range(1,101)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Determining the maximum of a list of numerical values by using reduce\n",
    "reduce(lambda a,b: a if (a > b) else b, [47,11,42,102,13])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"functions_list\"><a href=\"#functions\"><font size=\"3\" color=\"black\"><b>List Comprehension</b></font></a> </div>\n",
    "List comprehension is an elegant way to define and create list in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#We can use list comprehensions for nice maps and filters\n",
    "print ([pow(i,2) for i in [1, 2, 3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#We can use conditionals too\n",
    "print ([pow(i,2) for i in [1, 2, 3, 4] if i%2 == 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#if-else is allowed too\n",
    "print ([pow(i,2) if i%2 == 0 else i*10.0 for i in [1, 2, 3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# You can construct set and dict comprehensions as well.\n",
    "print ({x for x in 'abcddeef' if x in 'abc'})  \n",
    "print ({x: x ** 2 for x in range(5)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"classes\"><a href=\"#contents\"><font size=\"4\" color=\"red\"><b>CLASSES</b></font></a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is an “object-oriented programming language.” This means that almost all the code is implemented using a special construct called classes. Programmers use classes to keep related things together.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div align=\"left\"> <font size=\"3\" color=\"black\"><b>What is a class?</b></font> </div>\n",
    "A class is a code template for creating objects. Objects have member variables and have behaviour associated with them. In python a class is created by the keyword class.\n",
    "\n",
    "An object is created using the <i>constructor</i> of the class. This object will then be called the <i>instance</i> of the class. In Python we create instances in the following manner<br>\n",
    "<i>Instance = class(arguments)</i>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\"> <font size=\"3\" color=\"black\"><b>How to create a class?</b></font> </div>\n",
    "The simplest class can be created using the class keyword. For example, let's create a simple, empty class with no functionalities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class Snake:\n",
    "        pass\n",
    "snake = Snake()\n",
    "print (snake)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\"> <font size=\"3\" color=\"black\"><b>Attributes and Methods in class</b></font> </div>\n",
    "A class by itself is of no use unless there is some functionality associated with it. Functionalities are defined by setting attributes, which act as containers for data and functions related to those attributes. Those functions are called methods.<br><br>\n",
    "<b>Attributes:</b><br>\n",
    "You can define the following class with the name Snake. This class will have an attribute <i>name</i>. You can assign the class to a variable. This is called <i>object instantiation</i>. You will then be able to access the attributes that are present inside the class using the dot (.) operator. For example, in the Snake example, you can access the attribute name of the class Snake."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class Snake:\n",
    "    name = \"python\"\n",
    "snake = Snake()\n",
    "print (snake.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Methods</b><br>\n",
    "Once there are attributes that \"belong\" to the class, you can define functions that will access the class attribute. These functions are called <i>methods</i>. When you define methods, you will need to always provide the first argument to the method with a self keyword.\n",
    "\n",
    "For example, you can define a class Snake, which has one attribute name and one method change_name. The method change name will take in an argument new_name along with the keyword self."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class Snake:\n",
    "    name = \"python\"\n",
    "    \n",
    "    def change_name(self, new_name): # note that the first argument is self\n",
    "        self.name = new_name # access the class attribute with the self keyword\n",
    "# instantiate the class\n",
    "snake = Snake()\n",
    "\n",
    "# print the current object name \n",
    "print (\"Current Name: \", snake.name)\n",
    "\n",
    "# change the name using the change_name method\n",
    "snake.change_name(\"anaconda\")\n",
    "print (\"Current Name: \", snake.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Instance attributes in python and the init method</b><br>\n",
    "You can also provide the values for the attributes at runtime. This is done by defining the attributes inside the init method. The following example illustrates this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class Snake:\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def change_name(self, new_name):\n",
    "        self.name = new_name\n",
    "# two variables are instantiated\n",
    "python = Snake(\"python\")\n",
    "anaconda = Snake(\"anaconda\")\n",
    "\n",
    "# print the names of the two variables\n",
    "print (\"First name :\",python.name)\n",
    "print (\"Second name :\",anaconda.name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A little advanced example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# We subclass from object to get a class.\n",
    "class Human(object):\n",
    "    # A class attribute. It is shared by all instances of this class\n",
    "    species = \"H. sapiens\"\n",
    "\n",
    "    # Basic initializer, this is called when this class is instantiated.\n",
    "    # Note that the double leading and trailing underscores denote objects\n",
    "    # or attributes that are used by python but that live in user-controlled\n",
    "    # namespaces. You should not invent such names on your own.\n",
    "    def __init__(self, name):\n",
    "        # Assign the argument to the instance's name attribute\n",
    "        self.name = name\n",
    "\n",
    "        # Initialize property\n",
    "        self.age = 0\n",
    "\n",
    "    # An instance method. All methods take \"self\" as the first argument\n",
    "    def say(self, msg):\n",
    "        return \"{0}: {1}\".format(self.name, msg)\n",
    "\n",
    "    # A class method is shared among all instances\n",
    "    # They are called with the calling class as the first argument\n",
    "    @classmethod\n",
    "    def get_species(cls):\n",
    "        return cls.species\n",
    "\n",
    "    # A static method is called without a class or instance reference\n",
    "    @staticmethod\n",
    "    def grunt():\n",
    "        return \"*grunt*\"\n",
    "\n",
    "    # A property is just like a getter.\n",
    "    # It turns the method age() into an read-only attribute\n",
    "    # of the same name.\n",
    "    @property\n",
    "    def age(self):\n",
    "        return self._age\n",
    "\n",
    "    # This allows the property to be set\n",
    "    @age.setter\n",
    "    def age(self, age):\n",
    "        self._age = age\n",
    "\n",
    "    # This allows the property to be deleted\n",
    "    @age.deleter\n",
    "    def age(self):\n",
    "        del self._age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Instantiate a class\n",
    "i = Human(name=\"Ian\")\n",
    "print (i.say(\"hi\")) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "j = Human(\"Joel\")\n",
    "print (j.say(\"hello\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Call our class method\n",
    "i.get_species()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Change the shared attribute\n",
    "Human.species = \"H. neanderthalensis\"\n",
    "print (i.get_species()) \n",
    "print (j.get_species())  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Call the static method\n",
    "Human.grunt() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print (\"Before Updating :\", i.age ) \n",
    "# Update the property\n",
    "i.age = 42\n",
    "\n",
    "# Get the property\n",
    "print (\"After Updating :\", i.age)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Delete the property\n",
    "del i.age\n",
    "i.age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\" id=\"fileio\"><a href=\"#contents\"><font size=\"4\" color=\"red\"><b>FILE I/O</b></font></a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can read-write data with Python to a file on your disk<br><br>\n",
    "<b>How to open a file?</b><br>\n",
    "Python has a built-in function <b>open()</b> to open a file. This function returns a file object, also called a handle, as it is used to read or modify the file accordingly. open() works like this:<br>\n",
    "<i>open(file_location_here, mode_here)</i>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Changing working Directory</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Setting the working directory\n",
    "import os\n",
    "print (\"Before changing: \", os.getcwd())\n",
    "\n",
    "#You can either convert all backword slashes to forward slashes or just use \"r\" before the path\n",
    "os.chdir(r\"C:\\Users\\utsav.awasthi\\Downloads\")\n",
    "\n",
    "print (\"After changing: \", os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#opening in write mode\n",
    "test = open(\"test.txt\",\"w\")    # open file in current directory\n",
    "test2 = open(r\"C:\\Users\\utsav.awasthi\\Downloads\\test2.txt\",\"w\")  # specifying full path\n",
    "#Google for full lists of file opening modes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All different type of modes are listed <a href=\"https://stackoverflow.com/a/23566951\">here</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>How to write to a file?</b><br>\n",
    "Python has a built-in method <b>write()</b> to write to a file. write() works like this:<br>\n",
    "<i>filehandle.write(string_to_write)</i>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#method write() writes to the file handle\n",
    "test.write(\"This is the first line.\\n\")\n",
    "test.write(\"This is the second line.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember to close the file after the use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#You must close the file after use of it stays in the memory\n",
    "test.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>How to read a file?</b><br>\n",
    "You have three options after opening the file in read mode:<br>\n",
    "<ul>\n",
    "    <li>read(n) : Read atmost n characters form the file. Reads till end of file if it is negative or None.</li>\n",
    "    <li>readline(n=-1) : Read and return one line from the file. Reads in at most n bytes if specified.</li>\n",
    "    <li>readlines(n=-1) : Read and return a list of lines from the file. Reads in at most n bytes/characters if specified.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#read(n) reads all the lines into a string\n",
    "test = open(\"test.txt\",\"r\") \n",
    "print (test.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Once the file is read(like above), the cursor moves to the final location and you cannot read anything more\n",
    "print (test.readlines())\n",
    "test.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#readlines() all the lines in a list of lines\n",
    "test = open(\"test.txt\",\"r\") \n",
    "print (test.readlines())\n",
    "test.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>I don't like closing files all the time</b><br>\n",
    "You can use \"with\" keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Using \"with\" keyword you don't need to close the files manually\n",
    "with open(\"test2.txt\",\"w\") as test2:\n",
    "    for i in range(5):\n",
    "        test2.write(str(i)+'\\n')\n",
    "with open(\"test2.txt\",\"r\") as test2:\n",
    "    for line in test2.readlines():\n",
    "        print(line.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size = 10 color=\"green\">\"</font><br>\n",
    "<div align = center> \n",
    "    <font size = 5 color=\"green\" style=\"font-family: 'Comic Sans MS'\">Pass on what you have learned</font><br>\n",
    "</div>\n",
    "<div align = right> \n",
    "    <font size = 10 color=\"green\"t>\"</font><br>\n",
    "</div>\n",
    "<img align = \"right\" src = \"https://orig00.deviantart.net/ff5e/f/2013/102/4/4/yoda_by_valval-d61g9rh.png\" width=\"20%\" height=\"20%\">"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}