PythonBasics.ipynb

{
 "cells": [
  {
   "attachments": {
    "images.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![images.png](attachment:images.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# Python for dummies - Data Science 101\n",
    "\n",
    "**SET THE WORKING DIRECTORY SO THAT WE DO NOT HAVE TO THINK ABOUT PATH PROBLEMS**\n",
    "\n",
    "Please ensure all your folder names <font color='red'><b>do not have a space & use forward slash (/)</b></font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your_local_path=\"C:/Users/aayus/Desktop/Data Science/Data_Science_Foundation(October)/Week-2(Python Basics)/Python_Basics\"\n",
    "your_local_path=\"\\home\\aayush\\Desktop\\Data Science\\Data_Science_Foundation(October)\\Week-2(Python Basics)\\Python_Basics\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**IPython notebook**\n",
    "\n",
    "IPython is a software package in Python that serves as a research notebook. IPython has a seamless interface using which you can write notes as well as perform data analysis in the same file. The data analysis part allows you to write the code and run it from within the notebook itself. The results also are displayed in the notebook. Among other things, IPython provides:\n",
    "\n",
    "1. An interactive shell\n",
    "2. Notebook that is browser based. The notebook supports text, code, expressions, graphs and interactive data visualization, embed images and videos, and also links to web pages on the Internet. \n",
    "3. Tools for parallel computing.\n",
    "4. Import external code and run it.\n",
    "5. Export the notebook in a number of formats.\n",
    "\n",
    "**Creating an IPython notebook**\n",
    "\n",
    "In order to create an IPython notebook, choose File -> New -> IPython notebook. \n",
    "\n",
    "Hitting Alt+Enter creates a new cell. A cell is nothing but a placeholder where you can write some text or execute code. \n",
    "To run press Shift+Enter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\"An example of code execution in IPython\")\n",
    "23*543"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to find help on some concept, make use of ? If you want to find a function or make use of wildcard entry, make use of followed by ? A quickref command gives you a quick reference to the most commonly used commands in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively you can also use help()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How to search different functions within a package**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.*mean*?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Output:\n",
    "<p>np.mean </p>\n",
    "np.nanmean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tab is a very handy feature in Python. It gives you a list of all the functions and commands that are associated with a package (such as NumPy). For example, if you type np. and then press tab, a dropdown will come up with the list of all the functions associate with np. By using this, you do not have to rememeber the functions specifics and can just use tab completion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to know the histroy of commands, make use of history command. This feature also allows you to extract code from a IPython notebook to a separate file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Running external code files in IPython**\n",
    "\n",
    "If you want to run external code files in Python, make use of %run command followed by the path of the file. IPython shell will execute the code and will display the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Running a python file that is at my local library\n",
    "%run HelloWorld.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Syntax Formalities**\n",
    "\n",
    "+ Python is <b>case sensitive</b>\n",
    "+ Python makes use of <b>whitespace</b> for code structuring and marking logical breaks in the code (In contrast to other programming languages that use braces)\n",
    "+ End of line marks end of a statement, so <b>does not require a semicolon at end of each statement</b>\n",
    "+ Whitespace at the beginning of the line is important. This is called <b>indentation</b>.\n",
    "+ Leading whitespace (spaces and tabs) at the beginning of the logical line is used to determine the <b>indentation level</b> of the logical line.\n",
    "+ Statements which go together must have the same indentation. Each such set of statements is called a <b>block</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 5\n",
    " print ('Value is ', i) # Error! Notice a single space at the start of the line\n",
    "print ('I repeat, the value is ', i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comments** \n",
    "\n",
    "One line comments are denoted by <font color='red'><b>#</b></font> at the start of line<br/>\n",
    "Multiple line/block comments start with <font color='red'><b>'''</b></font> and end with <font color='red'><b>'''</b></font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a single line comment\n",
    "# print(\"I will not be printed, I am a single line comment\")\n",
    "''' This is a block comment 3 single quotes\n",
    "print(\"We are in a comment\")\n",
    "print (\"We are still in a comment\")\n",
    "'''\n",
    "print(\"We are out of the comment\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Example of indentation\n",
    "'''\n",
    "for x in alist:\n",
    "    if x < anumber:\n",
    "            print(x)\n",
    "    else:\n",
    "        print(-x)\n",
    "        \n",
    "is similar to                   <------------------ Let us compare with other language\n",
    "\n",
    "for x in alist \n",
    "{\n",
    "    if x < anumber\n",
    "    {\n",
    "        print(x)\n",
    "    }\n",
    "    else\n",
    "    {\n",
    "        print(-x)\n",
    "    }\n",
    "}\n",
    "'''\n",
    "print(\"Now we understand indentation\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 21\n",
    "y = 25\n",
    "print (x)\n",
    "if x<10:\n",
    "    print(x)\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Variables and Data Structures**\n",
    "\n",
    "+ Built-in data types:<br/>\n",
    "<b>Integer, Floating point, String, Boolean Values, Date and Time</b>\n",
    "\n",
    "+ Additional data structures:<br/>\n",
    "<b>Tuples, Lists, Dictionary</b>\n",
    "\n",
    "+ A variable is a name that refers to a value.\n",
    "+ No need to specify <b>type</b> to a variable; Python automatically assigns.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter = 100          # An integer assignment\n",
    "miles   = 1000.0       # A floating point\n",
    "name    = \"Ajay\"       # A string\n",
    "\n",
    "print (counter)\n",
    "print (miles)\n",
    "print (name)\n",
    "\n",
    "a = 1111111111110\n",
    "b = 2.0\n",
    "c = \"0\"\n",
    "d = \"2\"\n",
    "print(b + a)  # Sum of values\n",
    "print(c  + d) # Concatenating Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Strings**\n",
    "\n",
    "+ Built-in <b>string class</b> named <b>\"str\"</b> with many handy features\n",
    "+ In addition to numerical data processing, Python has very strong string processing capabilities. \n",
    "+ <b>Subsets</b> of strings can be taken using the <b>slice operator ( [ ] and [ : ] )</b> with indexes starting at 0 in the beginning of the string and working their way from -1 at the end.\n",
    "+ The plus ( + ) sign is the string concatenation operator and the asterisk ( * ) is the repetition operator.\n",
    "+ Strings in Python are <b>immutable</b>. Unlike other datasets such as lists, you cannot manipulate individual string values. In order to do so, you have to take subsets of strings and form a new string. \n",
    "+ A string can be converted to a numerical type and vice versa (wherever applicable). Many a times, raw data, although numeric, is coded in string format. This feature provides a clean way to make sure all of the data is in numeric form.\n",
    "+ Strings are sequence of characters and can be <b>tokenized</b>.\n",
    "+ Strings and numbers can also be <b>formatted</b>.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "strr = 'Hello World'\n",
    "print (strr)            # prints complete string\n",
    "print (strr[0])         # prints first character of string\n",
    "print (strr[2:6])       # prints characters starting from 3rd to 6th. Exclude last element. 'W' is excluded.\n",
    "print (strr[2:])        # prints string starting from 3rd character\n",
    "print (strr*2)          # prints string two times\n",
    "print (strr + \"TEST\")   # prints concatenated string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "strr =\"hello\"\n",
    "print(strr[-1])\n",
    "\n",
    "a = 'this is a string'\n",
    "b = a.replace('string','longer string')\n",
    "print (a) \n",
    "print (b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = '20'\n",
    "anum = int(a)         # Typecaste/Convert String '20' to Integer - Possible\n",
    "print (anum + anum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"hi\"\n",
    "anum = int(a)         # Typecaste/Convert String 'hi' to Integer - Not Possible\n",
    "print (anum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"hi\"\n",
    "print (a)\n",
    "print (len(a))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + len(a) # Concatenating String & Integer - Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + str(len(a)) # Convert to String so that concatenation works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets us see how to create formatted outputs\n",
    "string = \"This is python\"\n",
    "strlist = list(string)\n",
    "print(strlist)\n",
    "\n",
    "format = '%.2f %s is $%d'            # Let us visualize the formatting '%.2f %s is $%d' is like 'Float String Integer'\n",
    "format %(4.5560,'Argentine Pesos',1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (string.count('s'))\n",
    "print (string.split(' '))\n",
    "print (string.upper())\n",
    "print (string.lower())\n",
    "print (string.swapcase())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PS: Note the end \".\" t get a clear idea of the below strings.\n",
    "str1 = \"                 This is a bright, sunny day      \"\n",
    "print(\"Original String is : %s\" %str1)\n",
    "print(\"=====================================================\")\n",
    "print (\"The right strip is : %s\"%str1.rstrip(),\".\")    # Remove spaces to the right \n",
    "print (\"The left strip is : %s\"%str1.lstrip(),\".\")         # Remove spaces to the left \n",
    "print (\"The strip is : %s\"%str1.strip(),\".\")                    # Remove spaces on both side "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\":\".join(str1))                  # Sequence of elements to be joined\n",
    "print (\" \".join([\"banana\",\"grapes\"]))   # How to do string concatenation. Treat it as a list. One element is nothing but a word.\n",
    "print (len(str1.rstrip()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Add in between words.\n",
    "print (str1.strip().replace(\" \",\" +\"))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "school = 'AK CLASSES'\n",
    "print('A' in school)\n",
    "print('D' in school)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let see how to get the type of the variables\n",
    "x='X-DSPAM-Confidence:   0.9032'\n",
    "pos = x.find(':')\n",
    "print(\"Position of ':'\",pos )\n",
    "num=float(x[pos+1:])\n",
    "print (num, type(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Let us do some exercises\n",
    "# Excercise 1\n",
    "# Given below string, get first 10 characters, and last 10 characters.\n",
    "# Now join them to form a new string with an underscore in between\n",
    "strr = 'Hey how are you doing. We are doing good'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Solution\n",
    "n=10\n",
    "print(strr[:n]+\"_\"+strr[-n:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Consider two strings x and y\n",
    "x = 'Confusing'\n",
    "y = 'Strings'\n",
    "#Swap first three characters of each string and join them by an _"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x.replace(x[:3],y[:3])+\"_\"+y.replace(y[:3],x[:3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Datetime**\n",
    "\n",
    "Python has a <b>built-in datetime module</b> for working with dates and times.\n",
    "One can create strings from date objects and vice versa. \n",
    "\n",
    "\n",
    "Python offers very powerful and flexible datetime capabilities that are capable of operating at a scale of time measured in nano-seconds. We will look more about date time functionality in Session 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, date, time\n",
    "help(datetime.strptime)                                        # Help for a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Defining a date time variable\n",
    "date1 = datetime(2014, 5, 16, 14, 45, 5)\n",
    "print(date1.day)\n",
    "print(date1.month)\n",
    "print(date1.year)\n",
    "print(date1.second)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(datetime.strptime('20140516134328','%Y%m%d%H%M%S'))      # Parses a string representing a time according to a format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#If the format is wrong the strptime will \n",
    "print(datetime.strptime('20140516134328','%Y%m%d%H%M'))      # Parses a string representing a time according to a format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "date1 = datetime(2014, 5, 16)\n",
    "date2 = datetime(2014, 5, 19)\n",
    "datediff = date2 - date1\n",
    "print(datediff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lists**\n",
    "\n",
    "+ Lists, along with dictionary, are perhaps most important data types.\n",
    "+ A list contains items separated by commas and enclosed within square brackets ([]).\n",
    "+ All the items belonging to a list can be of <b>different data type</b>.\n",
    "+ Lists are similar to arrays in C language.\n",
    "+ The <b>plus ( + )</b> sign is the list concatenation operator, and the <b>asterisk ( * )</b> is the repetition operator.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_ = [ 'abcd', 786 , 2.23, 'ISB', 70.2 ]\n",
    "tinylist = [123, 'ISB']\n",
    "\n",
    "print (list_)            # Prints complete list\n",
    "print (list_[0])         # Prints first element of the list\n",
    "print (list_[1:3])       # Prints elements starting from 2nd till 3rd \n",
    "print (list_[2:])        # Prints elements starting from 3rd element\n",
    "print (tinylist * 2)     # Prints list two times\n",
    "print (list_ + tinylist) # Prints concatenated lists\n",
    "print (len(list_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lists are mutable , meaning you can change their content without changing their identity.\n",
    "alist = [ 'abcd', 786 , 2.23, 'ISB', 70.2 ]\n",
    "blist = alist\n",
    "alist = alist*2\n",
    "print (alist)\n",
    "#Check the behavior\n",
    "print (blist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "blist = alist\n",
    "print (blist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_ = ['Ajay', 'Vijay', 'Ramesh']\n",
    "print (list_)  \n",
    "list_.append('Sujay')         \n",
    "print (list_)  \n",
    "#Inserts at 0 position\n",
    "list_.insert(0, 'NewGuy')\n",
    "print (list_)  \n",
    "#Extend the list\n",
    "list_.extend(['Guy1', 'Guy2']) \n",
    "print (list_)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (list_.index('Guy1')) \n",
    "list_.remove('Guy1')                 # Remove by Name\n",
    "print (list_) \n",
    "list_.pop(1)                         # Remove by location - Ajay is gone\n",
    "print (list_)\n",
    "list_.pop(-1)                         # Remove by location from behind\n",
    "print (list_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sorting\n",
    "numberlist = [1, 5, 23, 1 ,54,2, 54,23, 54,76, 76,34,87]\n",
    "numberlist.sort()\n",
    "print(numberlist)\n",
    "print (len(numberlist))\n",
    "print (max(numberlist))\n",
    "print (min(numberlist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numberlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = ['abcd', 'efg', 'hijk', 'lmn']\n",
    "print (sorted(string, key=len))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can even pass your own function\n",
    "mylist = ['abcg', 'eff', 'hijd', 'lmi','hg']\n",
    "\n",
    "def func1(input):\n",
    "    return input[-1]                    # Sort based on last element\n",
    "\n",
    "print (sorted(mylist,key=func1))\n",
    "sorted(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in mylist:\n",
    "    print(i[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionary**\n",
    "\n",
    "+ One of the most important built-in data structure.\n",
    "+ Python's dictionaries are kind of <b>hash tables</b>.\n",
    "+ They work like associative arrays and consist of <font color='red'><b>key-value pairs</b></font>. \n",
    "+ A dictionary key can be almost any Python type, but are usually numbers or strings. \n",
    "+ Values, on the other hand, can be any arbitrary Python object.\n",
    "+ Dictionaries are enclosed by <b>curly braces ( { } )</b> and values can be assigned and accessed using <b>square braces ( [] )</b>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict = {}\n",
    "dict['one'] = \"This is one\"\n",
    "dict[2]     = \"This is two\"\n",
    "tinydict = {'name': 'isb','code':6734, 'dept': 'sales'}\n",
    "\n",
    "print (dict['one'])       # Prints value for 'one' key\n",
    "print (dict[2])           # Prints value for 2 key\n",
    "print (tinydict)          # Prints complete dictionary\n",
    "print (tinydict.keys())   # Prints all the keys\n",
    "print (tinydict.values()) # Prints all the values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict[1] #should be addresed by its key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Lets see what is a Tuple? **<br/>\n",
    "A tuple is a sequence of immutable Python objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (1,2,3,4,5,6,6,1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Same indexing as list\n",
    "# Immutable\n",
    "# can have duplicate values as lists.XXX --> SETS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Immutable, please read\n",
    "a[0]=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lt=[1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple(lt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mix_data_tuple=(1,2,3,[\"hey\",\"you\"],(2,4,5,False),\"True\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mix_data_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mix_data_tuple[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mix_data_tuple[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mix_data_tuple[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mix_data_tuple[4][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mix_data_tuple[4][-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(hex(id(a)))  # Address of the variable\n",
    "a = a + (10,)\n",
    "print(hex(id(a)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "named=('Aayush')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(named)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "named"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mix_data_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "named=('Aayush',)\n",
    "type(named)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "named='Aayush',\n",
    "type(named)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "named"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "named=('Aayush',)\n",
    "type(named)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mix_data_tuple[4][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mix_data_tuple[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mix_data_tuple[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xx=(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xy=tuple([i**2 for i in xx])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise – \n",
    "\n",
    "Create a tuple named ‘tuple1’.    \n",
    "Assign  the values \n",
    " tuple1 = (12,2,5,3,56,4,76,6,587,65,85,42,13,[‘a’,’b’])\n",
    "\n",
    "Fetch the elements in order as follows:\n",
    "First Element - 12\n",
    "Largest Element - 587\n",
    "Smallest Element – 2\n",
    "Last Element – [‘a’,’b’]  (with/without negative indexing)\n",
    "Middle element – 76\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = (12,2,5,3,56,4,76,6,587,65,85,42,13,['a','b'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(tuple1[:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(tuple1[:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(tuple1[:-1])[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(tuple1)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1[7-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{\"Aayush\":{\"type\":(111,\"savings\"),\"balance\":[100,200,150]},\"Vijay\":(112,\"current\")}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{\"Aayush\":{12,12,23,34}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "([1,2,3,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SET"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xx={1,2,3,3,2,3,4,5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xx={1,2,3,3,2,3,4,5,(1,2,3)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x={1,2,3,4,5}\n",
    "y={4,5,6,7,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.intersection(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.union(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Swap the following two tuples\n",
    "tuple1 = (11, 22)\n",
    "tuple2 = (99, 88)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = (11, 22)\n",
    "tuple2 = (99, 88)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=tuple1\n",
    "tuple1=tuple2\n",
    "tuple2=t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def swap(tupl):\n",
    "    return (tupl[1],tupl[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "swap(tuple1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "swap(tuple2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "22,11\n",
    "88,99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set([1,2,3]) # Create sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{[1,2,3]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add elements to a set\n",
    "set1={1,2,3,4,5}\n",
    "set2={4,5,6,7,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.add(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.add(\"hey\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.add([10,20,30])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.update([10,20,30])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.add(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.update([10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.update(\"hey\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.update([\"hey\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.add(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.update([101])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.update([99])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.discard(99)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.remove(101)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.discard(200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.remove(200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.add(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.discard(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.remove('hey')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.add(10.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.remove(10.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.discard((4,5,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in (4,5,6):\n",
    "    set2.discard(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2-{'h',100}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2-{4,5,6,8,'e'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.discard({10,100})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#in operator\n",
    "10 in set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "11 not in set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1,2,3)==(1,2,3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a={1,2,3,4,5}\n",
    "b={4,5,6,7,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a|b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a&b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a-b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b-a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a^b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.intersection(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.union(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.difference(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a&b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a&=b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a={1,2,3,4,5}\n",
    "b={4,5,6,7,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.intersection_update(b)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a|=b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a-=b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b-=a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a^=b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isdisjoint–This method will return True if two set have a null intersection \n",
    "\n",
    "Issubset –This method reports whether another set contains this set \n",
    "\n",
    "Issuperset –This method will report whether this set contains another set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1={1,2,3,4,5,6}#superset\n",
    "set2={7,8,9,1}\n",
    "set3={3,5,1}#subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.isdisjoint(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set3.issubset(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set3.issubset(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.issuperset(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.issuperset(set3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1={1,2,3}\n",
    "set2={3,2,1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1==set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.isdisjoint(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.issubset(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.issuperset(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Data type conversion**\n",
    "\n",
    "+ Data from one type can be converted into another type using <b>conversion operators</b>.\n",
    "+ Comes in handy when data is not coded in proper format (number coded as string, date coded as string)\n",
    "+ <b>int(variable)</b> - converts variable to integer \n",
    "+ <b>str(variable)</b> - converts variable to string \n",
    "+ <b>float(variable)</b> - converts variable to float (number with decimal) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Operators**\n",
    "\n",
    "+ \\+ (plus) : Adds two objects \n",
    "+ \\- (minus) Gives the subtraction of one number from the other; if the first operand is absent it is assumed to be zero.\n",
    "+ \\* (multiply) Gives the multiplication of the two numbers or returns the string repeated that many times.\n",
    "+ ** (power) Returns x to the power of y\n",
    "+ / (divide) Divide x by y\n",
    "+ // (floor division) Returns the floor of the quotient\n",
    "+ % (modulo) Returns the remainder of the division\n",
    "+ < (less than) Returns whether x is less than y. All comparison operators return True or False. Note the capitalization of these names.\n",
    "+ \\> (greater than) Returns whether x is greater than y\n",
    "+ <= (less than or equal to) Returns whether x is less than or equal to y\n",
    "+ \\>= (greater than or equal to) Returns whether x is greater than or equal to y\n",
    "+ == (equal to) Compares if the objects are equal\n",
    "+ != (not equal to) Compares if the objects are not equal\n",
    "+ not (boolean NOT) If x is True, it returns False. If x is False, it returns True.\n",
    "+ and (boolean AND) x and y returns False if x is False, else it returns evaluation of y\n",
    "+ or (boolean OR) If x is True, it returns True, else it returns evaluation of y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 6\n",
    "b = 7\n",
    "c = 42\n",
    "print (1, a == 6)\n",
    "print (2, a == 7)\n",
    "print (3, a == 6 and b == 7)\n",
    "print (4, a == 7 and b == 7)\n",
    "print (5, not a == 7 and b == 7)\n",
    "print (6, a == 7 or b == 7)\n",
    "print (7, a == 7 or b == 6)\n",
    "print (8, not (a == 7 and b == 6))\n",
    "print (9, not a == 7 and b == 6)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conditional Statements**\n",
    "\n",
    "**If-statement**\n",
    "\n",
    "The <b>if</b> statement is used to check a condition: if the condition is true, we run a block of statements (called the if-block), else we process another block of statements (called the else-block). The <b>else clause is optional</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 20\n",
    "if a >= 22:\n",
    "   print(\"if\")\n",
    "elif a >= 21:\n",
    "   print(\"elif\")\n",
    "else:\n",
    "   print(\"else\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Testing for an element in list\n",
    "list = ['Ajay', 'Vijay', 'Ramesh']\n",
    "if 'Vijay' in list:\n",
    "    print ('Found Vijay')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**While-statement**\n",
    "\n",
    "The while statement allows you to <b>repeatedly execute</b> a block of statements as long as a condition is true. A while statement is an example of what is called a looping statement. A while statement can have an optional else clause."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 0\n",
    "while (count < 9):\n",
    "   print ('The count is:', count)\n",
    "   count = count + 1\n",
    "\n",
    "print (\"End of while loop!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**For-statement**\n",
    "\n",
    "The for..in statement is another looping statement which iterates over a sequence of objects i.e. go through each item in a sequence. A sequence is just an ordered collection of items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,5,2):\n",
    "    print (i)\n",
    "    break\n",
    "else:\n",
    "   print (\"The for loop is over\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Traversing a list\n",
    "# Guess What is the output\n",
    "numbers = [2, 3, 5]\n",
    "sum = 0\n",
    "for num in numbers:\n",
    "    sum += num\n",
    "print (sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [2, 3, 5]\n",
    "getsum = [ i+2 for i in numbers ]\n",
    "print (getsum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [2, 3, 5]\n",
    "getnum = [ i+2 for i in numbers if i<5]\n",
    "print (getnum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Break statement**\n",
    "\n",
    "The break statement is used to break out of a loop statement i.e. stop the execution of a looping statement, even if the loop condition has not become False or the sequence of items has not been completely iterated over.\n",
    "\n",
    "An important note is that if you break out of a for or while loop, any corresponding loop else block is not executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,10):\n",
    "       if i == 5:\n",
    "           break\n",
    "       print (i)\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise Time**\n",
    "\n",
    "To get full out of the bove tutorial please try it yourself. Please note there may be more than oe answer to the below problems.}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Closing and Opening Files**\n",
    "\n",
    "**Try on your notebook**\n",
    "+ Python, along with associated packages, supports a number of formats for file reading and writing. \n",
    "+ The file types supported are txt, csv, xls, xlsx, doc, docx, dat, output, sql (and some specialized formats such as R, .dta, sas7bdat)\n",
    "+ Here, we will cover some of the options and will look at the rest in session on pandas.\n",
    "+ In order to open a file, use open() method specifying file name and mode of opening (read, write, append, etc)\n",
    "+ Open returns a file handle \n",
    "+ handle = open(filename, mode)\n",
    "+ Once work is done, it is always better to close the file otherwise other programs might not be able to access the file.\n",
    "+ File closing is done using close() method\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(your_local_path+'/python.txt', 'r')\n",
    "for line in f:   \n",
    "    print (line)                       \n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capmdata = open(your_local_path+'/python.txt','r')\n",
    "print (\"Content is \", capmdata.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "copycapmdata = open(your_local_path+'/python_copy.txt',\"w\")\n",
    "capmdata.seek(0,0)\n",
    "copycapmdata.write(\"This is the copy: \"+capmdata.read())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capmdata.close()\n",
    "copycapmdata.close()\n",
    "capmdata.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(your_local_path+'/python.txt', 'r')\n",
    "for line in f:   \n",
    "    print (line)                       \n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(your_local_path+'/python_copy.txt', 'r')\n",
    "for line in f:   \n",
    "    print (line)                       \n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise\n",
    "1. Create a .txt file in which i will include my names and last 5 tweets that i did.\n",
    "2. Read the file and print the tweets\n",
    "3. Read the file and add 2 new tweets to the file and save it.\n",
    "4. Read the file and print the old and new tweets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#list of files in current directory\n",
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#current working directory\n",
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_path=\"/Users/aayushkubba/Documents/GitHub/Python_Tutorial/sample_tweets.txt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ff= open(file=file_path,mode='r')\n",
    "for i in ff:\n",
    "    print(i)\n",
    "ff.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cannot read once the file is closed\n",
    "ff= open(file=file_path,mode='r')\n",
    "for i in ff:\n",
    "    print(i)\n",
    "ff.close()\n",
    "for i in ff:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ff= open(file=file_path,mode='r')\n",
    "for i in ff:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in ff:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## write mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ff= open(file=file_path,mode='w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ff.write(\"This is jupyter #python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ff.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## append mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ff= open(file=file_path,mode='a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ff.write(\"\\n\")\n",
    "ff.write(\"This is jupyter #python\")\n",
    "ff.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Functions**\n",
    "\n",
    "+ Functions are <b>reusable piece of software</b>.\n",
    "+ Block of statements that <b>accepts some arguments, perform some functionality, and provides the output</b>.\n",
    "+ Defined using <font color='red'><b>def</b></font> keyword\n",
    "+ Similar to functions in R.\n",
    "+ For example, implement code to perform two way clustering once and can be used again in the same program. \n",
    "+ We will look at functions for a number of features (Fama Mac Beth regression, two way clustering, industry code classification) in subsequent sessions. \n",
    "+ A function can take arguments.\n",
    "+ Arguments are specified within parentheses in function definition separated by commas.\n",
    "+ It is also possible to assign default values to parameters in order to make the program flexible and not behave in an unexpected manner.\n",
    "+ One of the most <b>powerful feature of functions is that it allows you to pass any number of arguments (*argv) and you do not have to worry about specifying the number when writing the function</b>. This feature becomes extremely important when dealing with lists or input data where you do not know number of data observations before hand.\n",
    "+ Scope of variables defined inside a function is <b>local</b> i.e. they cannot be used outside of a function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sayHello():\n",
    "    print('Hello World!') # block belonging to the function\n",
    "# End of function #\n",
    "\n",
    "sayHello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printMax(a, b):\n",
    "   if a > b:\n",
    "       print(a, 'is maximum')\n",
    "   elif a == b:\n",
    "       print(a, 'is equal to', b)\n",
    "   else:\n",
    "       print(b, 'is maximum')\n",
    "\n",
    "printMax(3, 4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say(message, times = 1):\n",
    "   print(message * times)\n",
    "\n",
    "say('Hello')\n",
    "say('World ', 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(a, b=5, c=10):\n",
    "   print('a is', a, 'and b is', b, 'and c is', c)\n",
    "func(3, 7)\n",
    "func(25, c=24)\n",
    "func(c=50, a=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 50\n",
    "def func(x):\n",
    "   print('x is', x)\n",
    "   x = 2\n",
    "   print('Changed local x to', x)\n",
    "func(x)\n",
    "print('x is still', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# *args will take any number of arguments as specified by the function\n",
    "def print_two(*args):\n",
    "    arg1, arg2 =args\n",
    "    print(\"arg1 : %r , arg2: %r \"%(arg1, arg2))\n",
    "    \n",
    "print_two(\"hey\",2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Call them ANONYMOUS functions, ie they don't have a name\n",
    "\n",
    "Syntax: lambda arguments: expressions\n",
    "\n",
    "\n",
    "Normal functions: def func_name(argumnets): expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write lambda function to find cube root\n",
    "\n",
    "cubes=lambda x: x**3\n",
    "\n",
    "# nearly same as the one below\n",
    "\n",
    "def cube_root(x):\n",
    "    return x**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubes(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cube_root(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functiona nd lambda functions combined\n",
    "def custom_func(n):\n",
    "    return lambda x: x**n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check =custom_func(3)\n",
    "print(check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "double=custom_func(2)\n",
    "triple=custom_func(3)\n",
    "five_times=custom_func(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "double(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "triple(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "five_times(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def custom_func(x,n):\n",
    "    return x**n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom_func(10,3)\n",
    "custom_func(10,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiple arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "addition=lambda a,b:a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "addition(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "even=lambda x: x%2==0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "even(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "even(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odd=lambda x: x%2!=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odd(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odd(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda functions can take any number of arguments:\n",
    "\n",
    "##### Why Use Lambda Functions?\n",
    "- The power of lambda is better shown when you use them as an anonymous function inside another function.\n",
    "- Say you have a function definition that takes one argument, and that argument will be multiplied with an unknown number:\n",
    "- An anonymous function is a function with out a name\n",
    "- While normal functions are defined using the def keyword in python ,anonymous functions are defined using lambda keyword.\n",
    "- We use lambda functions when we require a nameless function for a short period of time.\n",
    "- Lambda functions are used aong with built-in functions like filter(),map()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(n):\n",
    "    return lambda a : a * n\n",
    "mydoubler = myfunc(2)\n",
    "mydoubler(12)\n",
    "mytripler = myfunc(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Use that function definition to make a function that always doubles the number you send in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(n):\n",
    "    return lambda a : a * n\n",
    "\n",
    "mydoubler = myfunc(2)\n",
    "mytripler = myfunc(3)\n",
    "my4times  = myfunc(4)\n",
    "\n",
    "print(mydoubler(11))\n",
    "print(mytripler(11))\n",
    "print(my4times(11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a list\n",
    "list1=list(range(300,700,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2 = []\n",
    "\n",
    "\n",
    "\n",
    "for item in list1:\n",
    "    if item % 2 == 0:\n",
    "        list2.append(item)\n",
    "\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2 = []\n",
    "\n",
    "\n",
    "for item in list1:\n",
    "    if even(item):\n",
    "        list2.append(item)\n",
    "\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Filter "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a simpler way to filter the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def custom(x):\n",
    "    return x%2==0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2=list(filter(even,list1))\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2=list(filter(custom,list1))\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2=list(filter(lambda x: x%2==0,list1))\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. create a list of numbers between 10,100 in intervals of 5 and filter only the even numbers.(Use lambda and filter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1=list(range(10,100,5))\n",
    "print(list1)\n",
    "\n",
    "\n",
    "\n",
    "list2 = list(filter(lambda x:x%2==0,list1))\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2=[i+100 for i in list1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "increment=lambda x: x+100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lt2=list(map(increment,list1))\n",
    "lt3=list(map(increment,lt2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lt4=list(map(lambda x: x**2,lt3))\n",
    "lt4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1=list(range(10,100,5))\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mul=1\n",
    "for i in range(1,6):\n",
    "    mul=mul*i\n",
    "print(mul)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Factorial\n",
    "\n",
    "5! = 5 * 4 * 3 * 2 * 1\n",
    "\n",
    "1. 5x4=20\n",
    "2. 20x3=60\n",
    "3. 60x2=120\n",
    "4. 120x1=120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fact= lambda a,b : a*b if b%2==0 else a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reduce(fact, list(range(1,6)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "take first 50 natural numbers,\n",
    "get cummulative sum of numbers which are divisible by 2 and 3 both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "natural=list(range(0,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summing= lambda a,b : a+b if ( b%2==0 and b%3==0 ) else a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reduce(summing, natural)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "natural"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Modules**\n",
    "\n",
    "+ Functions can be used in the <b>same program</b>. \n",
    "+ If you want to use function (s) in <b>other programs, make use of modules</b>.\n",
    "+ Modules can be imported in other programs and functions contained in those modules can be used.\n",
    "+ Simplest way to create a module is to write a <b>.py file</b> with functions defined in that file.\n",
    "+ Other way is to <b>import</b> using byte-compiled .pyc files. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "x = -25\n",
    "print(math.fabs(x))\n",
    "print(math.factorial(abs(x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append(your_local_path)\n",
    "from mymodule import *\n",
    "print(sayhi())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Taking input from the user\n",
    "numb = input(\"Enter a non negative number: \")\n",
    "num_factorial = factorial(int(numb))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** <font color='red'>Warning: This is for people willing to understand a little more advance concept. No worries if you don't understand immediately.</font>** \n",
    "\n",
    "**Python program __main__ concept**\n",
    "\n",
    "+ Source files .py extension, and can be run from command prompt by using python filename.py (optional arguments) command. \n",
    "+ Examine name.py. \n",
    "+ First line imports modules\n",
    "+ Next line defines a main() function. We can specify command line arguments. Command line args are in sys.argv[1], sys.argv[2]\n",
    "+ sys.argv[0] is the script name itself and can be ignored\n",
    "+ name = 'main' starts the program. \n",
    "+ When a Python file is run directly, the special variable \"__name__\" is set to \"__main__\". Therefore, it's common to have the boilerplate if __name__ ==... shown above to call a main() function when the module is run directly, but not when the module is imported by some other module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"----------------------Ran fruit.py----------------------\")\n",
    "%run fruit.py\n",
    "\n",
    "print(\"----------------------Ran apple.py----------------------\")\n",
    "%run apple.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What if there was an exception here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=input(\"Enter a nuber\")\n",
    "try:\n",
    "    print(int(a)+3)\n",
    "except ValueError as ve:\n",
    "    print(\"The value you entered is incorrect\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=input(\"Enter a nuber\")\n",
    "print(int(a)+3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a nuber0\n",
      "Division by zero is not possible\n"
     ]
    }
   ],
   "source": [
    "a=input(\"Enter a nuber\")\n",
    "try:\n",
    "    print(3/int(a))\n",
    "except ValueError as ve:\n",
    "    print(\"The value you entered is incorrect\")\n",
    "except ZeroDivisionError as ze:\n",
    "    print(\"Division by zero is not possible\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a nuberaayush\n",
      "Okay this is some error\n"
     ]
    }
   ],
   "source": [
    "a=input(\"Enter a nuber\")\n",
    "try:\n",
    "    print(3/int(a))\n",
    "except:\n",
    "    print(\"Okay this is some error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#3(Preffered))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=input(\"Enter a nuber\")\n",
    "try:\n",
    "    print(3/int(a))\n",
    "except ValueError as ve:\n",
    "    print(\"The value you entered is incorrect\")\n",
    "except ZeroDivisionError as ze:\n",
    "    print(\"Division by zero is not possible\")\n",
    "except:\n",
    "    print(\"Okay this is some error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Exception Handling**\n",
    "\n",
    "**Exceptions**\n",
    "\n",
    "+ An exception is an <b>event that interrupts the ordinary sequential processing</b> of a program.\n",
    "+ For example, what if you are going to read a file and the file does not exist? Or what if you accidentally deleted it when the program was running? Similarly, what if your program had some invalid statements? Such situations are handled using exceptions.\n",
    "\n",
    "**Handling Exceptions**\n",
    "\n",
    "+ We can handle exceptions using the <b>try..except</b> statement. \n",
    "+ We basically put our <b>usual statements within the try-block</b> and put all our <b>error handlers in the except-block</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg( numList ):\n",
    "    \"\"\"Raises TypeError or ZeroDivisionError exceptions.\"\"\"\n",
    "    sum = 0\n",
    "    for v in numList:\n",
    "        sum = sum + v\n",
    "    return float(sum)/len(numList)\n",
    "\n",
    "def avgReport(numList):\n",
    "     try:\n",
    "         m= avg(numList)\n",
    "         print (\"Average = \", m)\n",
    "     except TypeError as ex:\n",
    "         print (\"TypeError:\", ex)\n",
    "     except ZeroDivisionError as ex:\n",
    "         print (\"ZeroDivisionError:\", ex)\n",
    "                    \n",
    "list1 = [10,20,30,40]                      # If used this should run fine\n",
    "list2 = []                                 # If used this is empty, it would throw ZeroDivisionError\n",
    "list3 = [10,20,30,'abc']                   # If used this should throw TypeError \n",
    "\n",
    "avgReport(list1)\n",
    "print (avgReport(list2))\n",
    "print (avgReport(list3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try..Finally**\n",
    "\n",
    "+ Suppose you are reading a file in your program. How do you ensure that the file object is closed properly whether or not an exception was raised? This can be done using the finally block.\n",
    "+ This final step will be performed before the try block is finished, either normally or by any exception.\n",
    "+ <b>The finally clause is always executed</b>. \n",
    "+ This includes all three possible cases: <b>if the try block finishes with no exceptions; if an exception is raised and handled; and if an exception is raised but not handled</b>. \n",
    "+ This last case means that every nested try statement with a finally clause will have that finally clause executed.\n",
    "+ Use a finally clause to close files, release locks, close database connections, write final log messages, and other kinds of final operations. \n",
    "+ In the following example, we use the finally clause to write a final log message.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg( numList ):\n",
    "    \"\"\"Raises TypeError or ZeroDivisionError exceptions.\"\"\"\n",
    "    sum = 0\n",
    "    for v in numList:\n",
    "        sum = sum + v\n",
    "    return float(sum)/len(numList)\n",
    "\n",
    "def avgReport(numList):\n",
    "     try:\n",
    "         m= avg(numList)\n",
    "         print (\"Average = \", m)\n",
    "     except TypeError as ex:\n",
    "         print (\"TypeError:\", ex)\n",
    "     except ZeroDivisionError as ex:\n",
    "         print (\"ZeroDivisionError:\", ex)\n",
    "     finally:\n",
    "         print(\"Finished avgReport\")\n",
    "\n",
    "                    \n",
    "list1 = [10,20,30,40]                      # If used this should run fine\n",
    "list2 = []                                 # If used this is empty, it would throw ZeroDivisionError\n",
    "list3 = [10,20,30,'abc']                   # If used this should throw TypeError \n",
    "\n",
    "avgReport(list1)\n",
    "print (avgReport(list2))\n",
    "print (avgReport(list3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a nuberskjdhsahd\n",
      "The value you entered is incorrect\n",
      "It's done\n"
     ]
    }
   ],
   "source": [
    "a=input(\"Enter a nuber\")\n",
    "try:\n",
    "    print(3/int(a))\n",
    "except ValueError as ve:\n",
    "    print(\"The value you entered is incorrect\")\n",
    "except ZeroDivisionError as ze:\n",
    "    print(\"Division by zero is not possible\")\n",
    "except:\n",
    "    print(\"Okay this is some error\")\n",
    "finally:\n",
    "         print(\"It's done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "Interrupted by user",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-bfc2db644998>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Enter a nuber\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;31m# print(3/int(a))\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m/\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\ipykernel\\kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[1;34m(self, prompt)\u001b[0m\n\u001b[0;32m    858\u001b[0m                 \u001b[1;34m\"raw_input was called, but this frontend does not support input requests.\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    859\u001b[0m             )\n\u001b[1;32m--> 860\u001b[1;33m         return self._input_request(str(prompt),\n\u001b[0m\u001b[0;32m    861\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parent_ident\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    862\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parent_header\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\ipykernel\\kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[1;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[0;32m    902\u001b[0m             \u001b[1;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    903\u001b[0m                 \u001b[1;31m# re-raise KeyboardInterrupt, to truncate traceback\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 904\u001b[1;33m                 \u001b[1;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Interrupted by user\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    905\u001b[0m             \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    906\u001b[0m                 \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwarning\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Invalid Message:\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mexc_info\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: Interrupted by user"
     ]
    }
   ],
   "source": [
    "a=input(\"Enter a nuber\")\n",
    "# print(3/int(a))\n",
    "try:\n",
    "    print(3/int(a))\n",
    "\n",
    "# except ValueError` as ve:\n",
    "#     print(\"The value you entered is incorrect\")\n",
    "# except ZeroDivisionError as ze:\n",
    "#     print(\"Division by zero is not possible\")\n",
    "except:\n",
    "    print(\"Okay this is some error\")\n",
    "# finally:\n",
    "#         print(\"It's done\")\n",
    "#         print(\"It's done second time\")\n",
    "# finally:\n",
    "#         print(\"It's done\")\n",
    "#         print(\"It's done second time\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learnings:\n",
    "1. We should add all known exceptions and have an except block for unknown exceptions.\n",
    "2. TRY is not stand-alone, it needs either finally or except block\n",
    "3. Can we multiple TRY block? Yes if its nested and NO if its not nested. This is true for all TRY, EXCEPT and FINALLY BLOCKS."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Some common built-in exceptions**\n",
    "\n",
    "exception KeyboardInterrupt\n",
    " This is raised when a user hits ctrl-C to send an interrupt signal to the Python interpreter. \n",
    "\n",
    "exception AttributeError\n",
    " Attribute not found in an object.\n",
    "\n",
    "exception EOFError\n",
    " Read beyond end of file.\n",
    "\n",
    "exception FloatingPointError\n",
    " Floating point operation failed.\n",
    "\n",
    "exception IOError\n",
    " I/O operation failed.\n",
    "\n",
    "exception IndexError\n",
    " Sequence index out of range.\n",
    "\n",
    "exception KeyError\n",
    " Mapping key not found.\n",
    "\n",
    "exception TypeError\n",
    " Inappropriate argument type.\n",
    "\n",
    "exception ValueError\n",
    " Inappropriate argument value (of correct type).\n",
    "\n",
    "exception ZeroDivisionError\n",
    " Second argument to a division or modulo operation was zero.\n",
    "\n",
    "exception MemoryError\n",
    " Out of memory.\n",
    "\n",
    "exception RuntimeError\n",
    " Unspecified run-time error.\n",
    "\n",
    "exception SystemError\n",
    " Internal error in the Python interpreter\n",
    "\n",
    "exception ImportError\n",
    " Import can’t find module, or can’t find name in module.\n",
    "\n",
    "exception IndentationError\n",
    " Improper indentation.\n",
    "\n",
    "exception NameError\n",
    " Name not found globally.\n",
    "\n",
    "exception SyntaxError\n",
    " Invalid syntax.\n",
    "\n",
    "exception UnboundLocalError\n",
    " Local name referenced but not bound to a value.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a class representing a person and then deffine attributes\n",
    "\n",
    "\n",
    "class Person:\n",
    "\n",
    "    #Initialize few variable\n",
    "    def __init__(self, name, age):\n",
    "        pass\n",
    "        self.name=name\n",
    "        self.age=age\n",
    "\n",
    "    #custom function speaks\n",
    "    def   speak(self):\n",
    "        print(\"Hello my name is \",self.name)\n",
    "        print(\"Hello my age is \",self.age)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# aay - object\n",
    "# Person is the class\n",
    "aay=Person(\"Aayush\",29)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aay.name # attributes of a class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aay.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial has covered everything you may need to start with python for data science. Next we will move to python data science library.\n",
    "\n",
    "### Happy learning.!"
   ]
  }
 ],
 "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}