Day2/DAY2 - Notebook1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hey guys! Welcome to Day-2 of the sessions. Hope you all didn't face any issues with the installation. In case you do, please make sure to put them up on the issues tab.\n",
    "\n",
    "**So lets begin this session right away!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indentation\n",
    "\n",
    "* Whitespaces at the beginning of the line are important.\n",
    "* **Statements with same indentations form a block.**\n",
    "\n",
    "<img src=\"images/indent-meme.jpg\" alt=\"drawing\" width=300px/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-14-b61e81539326>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-14-b61e81539326>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    print(I)         #IndentationError\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "I = 5\n",
    "    print(I)         #IndentationError\n",
    "print(\"This is string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploring basic datatypes in python\n",
    "\n",
    "As mentioned in the introduction python is a **dynamically typed language** and hence **doesn't** require the user to **define variables** before intialising them.\n",
    "\n",
    "use the ```type()``` command to find the datatype of a particular variable\n",
    "\n",
    "| Type     |      example  |\n",
    "|----------|:-------------:|\n",
    "| Text Type |  str |\n",
    "| Numeric Types |    int, float, complex   |\n",
    "| Sequence Types | list, tuple, range |\n",
    "| Mapping Type | dict |\n",
    "| Set Types   | set, frozenset |\n",
    "| Boolean Type  | bool |\n",
    "| Binary Types   | bytes, bytearray, memoryview*** |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numeric Data Types:\n",
    "\n",
    "Python has different types of Numerical datatypes and they can be easily converted from one type to another.\n",
    "\n",
    "**Note: Complex numbers cannot be converted to another datatype**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "<class 'int'>\n",
      "1j\n",
      "<class 'complex'>\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "can't convert complex to int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-2a566b10e0ab>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m       \u001b[0;31m# cannot convert complex numbers to another datatype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can't convert complex to int"
     ]
    }
   ],
   "source": [
    "x = 1          # int\n",
    "y = 2.8        # float\n",
    "a = -87.7e100  #another way to represent floating variables\n",
    "z = 1j         # complex\n",
    "\n",
    "\"\"\"\n",
    "user can convert between datatypes using the method mentioned above\n",
    "Note: You cannot convert complex numbers into another number type.\n",
    "\"\"\"\n",
    "#setting datatype of a variable\n",
    "\n",
    "c=int(y)\n",
    "print(c)\n",
    "print(type(c))\n",
    "\n",
    "print(z)\n",
    "print(type(z))\n",
    "d=int(z)       # cannot convert complex numbers to another datatype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Datatypes:\n",
    "\n",
    "Strings can be multiline or single lined. \n",
    "\n",
    "**Note: in the result, the line breaks are inserted at the same position as in the multi-line text**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Why does Python live on land?\n",
      "Because it's above C-level\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello\"\n",
    "print(a)\n",
    "\n",
    "#multiline strings can be created using ''' <insert text here> ''' \n",
    "a = \"\"\"Why does Python live on land?\n",
    "Because it's above C-level\"\"\"\n",
    "print(a)\n",
    "\n",
    "#Note: in the result, the line breaks are inserted at the same position as in the text.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators in Python\n",
    "\n",
    "For reference, below are common arithmetic and comparison operations.\n",
    "\n",
    "<img src=\"images/ops1_v2.png\" alt=\"Drawing\" style=\"width: 600px;\"/>\n",
    "\n",
    "<img src=\"images/ops2_v2.png\" alt=\"Drawing\" style=\"width: 650px;\"/>\n",
    "\n",
    "\n",
    "**Operators like addition, multiplication can also be used on strings to perform basic concatenation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1\n",
      "6\n",
      "1.5\n",
      "1\n",
      "1\n",
      "lala\n",
      "lalala\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = 2\n",
    "\n",
    "print(a + b)\n",
    "print(a - b)\n",
    "print(a * b)\n",
    "print(a / b)\n",
    "print(a // b)\n",
    "print(a % b)\n",
    "\n",
    "\n",
    "a = 'la'\n",
    "print(a+a)\n",
    "a = a * 3\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escape Sequences – Non graphic characters\n",
    "\n",
    "‘\\n’, ‘\\t’, ‘\\\\’, ‘\\’’ – examples of escape sequences\n",
    "\n",
    "** Note in the case where we define a path to a file we will also have multiple slashes which might confuse the python interpreter that its an escape sequence**\n",
    "\n",
    "For example the path:\n",
    "\n",
    "path = \"C:\\news\\Summer2018.pdf\" will confuse the python interpreter that \"\\n\" present in the path is an escape sequence.\n",
    "\n",
    "To avoid this the letter r is written before the string to ensure that this doesn't happen. To better understand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is line 1\n",
      "this is second line\n",
      "\n",
      "C:\n",
      "ews\\Summer2018.pdf\n",
      "C:\\news\\Summer2018.pdf\n"
     ]
    }
   ],
   "source": [
    "print(\"this is line 1\\nthis is second line\\n\") # \\n treated as escape sequence.\n",
    "\n",
    "print(\"C:\\news\\Summer2018.pdf\") # \\n is misunderstood by the interpreter and hence newline.\n",
    "\n",
    "print(r\"C:\\news\\Summer2018.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings are Arrays\n",
    "\n",
    "Like many other popular programming languages, strings in Python are **arrays of bytes** representing unicode characters.\n",
    "\n",
    "However, Python ***does not have a character data type***, a single character is simply a string with a length of 1.\n",
    "\n",
    "Square brackets can be used to access elements of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n",
      "llo\n",
      "orl\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "#accessing unit length string\n",
    "a = \"Hello, World!\"\n",
    "print(a[1])\n",
    "\n",
    "#getting letters between postion 2 and 5 (5 not included)\n",
    "b = \"Hello, World!\"\n",
    "print(b[2:5])\n",
    "\n",
    "#Get the characters from position 5 to position 1, starting the count from the end of the string\n",
    "b = \"Hello, World!\"\n",
    "print(b[-5:-2])\n",
    "\n",
    "#getting the length of the string\n",
    "b = \"Hello, World!\"\n",
    "print(len(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in string methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "hello, world!\n",
      "HELLO, WORLD!\n",
      "Jello, World!\n",
      "['Hello', ' World!']\n",
      "Hello is present in given string\n",
      "\n",
      "HelloWorld\n",
      "1+2=3\n",
      "My name is Me and I am from Chennai\n"
     ]
    }
   ],
   "source": [
    "#removes whitespaces at the beginning or end\n",
    "a = \"   Hello, World! \"\n",
    "print(a.strip())\n",
    "\n",
    "#converting to lowercase\n",
    "a = \"Hello, World!\"\n",
    "print(a.lower())\n",
    "\n",
    "#converting to uppercase\n",
    "a = \"Hello, World!\"\n",
    "print(a.upper())\n",
    "\n",
    "#replacing a character with another\n",
    "a = \"Hello, World!\"\n",
    "print(a.replace(\"H\", \"J\"))\n",
    "\n",
    "#splits the string into substrings if it finds instances of the seperator - returns a list\n",
    "a = \"Hello, World!\"\n",
    "print(a.split(\",\"))\n",
    "\n",
    "#checking a string\n",
    "if \"Hello\" in a:\n",
    "    print(\"Hello is present in given string\\n\")\n",
    "\n",
    "#concatenating a string\n",
    "a = \"Hello\"\n",
    "b = \"World\"\n",
    "c = a + b\n",
    "print(c)\n",
    "\n",
    "#formating a string\n",
    "a=1\n",
    "b=2\n",
    "txt = \"{0}+{1}={2}\".format(a,b,a+b)\n",
    "print(txt)\n",
    "print(\"My name is {0} and I am from {1}\".format(\"Me\",  \"Chennai\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other string methods - Don't Get frightened!\n",
    "\n",
    "| Method    |      Description  |\n",
    "|----------|:-------------:|\n",
    "|capitalize()\t|Converts the first character to upper case|\n",
    "|casefold()\t|Converts string into lower case|\n",
    "|center()\t|Returns a centered string|\n",
    "|count()\t|Returns the number of times a specified value occurs in a string|\n",
    "|encode()\t|Returns an encoded version of the string|\n",
    "|endswith()\t|Returns true if the string ends with the specified value|\n",
    "|expandtabs()\t|Sets the tab size of the string|\n",
    "|find()\t|Searches the string for a specified value and returns the position of where it was found|\n",
    "|format()\t|Formats specified values in a string|\n",
    "|format_map()\t|Formats specified values in a string|\n",
    "|index()\t|Searches the string for a specified value and returns the position of where it was found|\n",
    "|isalnum()\t|Returns True if all characters in the string are alphanumeric|\n",
    "|isalpha()\t|Returns True if all characters in the string are in the alphabet|\n",
    "|isdecimal()\t|Returns True if all characters in the string are decimals|\n",
    "|isdigit()\t|Returns True if all characters in the string are digits|\n",
    "|isidentifier()\t|Returns True if the string is an identifier|\n",
    "|islower()\t|Returns True if all characters in the string are lower case|\n",
    "|isnumeric()\t|Returns True if all characters in the string are numeric|\n",
    "|isprintable()\t|Returns True if all characters in the string are printable|\n",
    "|isspace()\t|Returns True if all characters in the string are whitespaces|\n",
    "|istitle()\t|Returns True if the string follows the rules of a title|\n",
    "|isupper()\t|Returns True if all characters in the string are upper case|\n",
    "|join()\t|Joins the elements of an iterable to the end of the string|\n",
    "|ljust()\t|Returns a left justified version of the string|\n",
    "|lower()\t|Converts a string into lower case|\n",
    "|lstrip()\t|Returns a left trim version of the string|\n",
    "|maketrans()\t|Returns a translation table to be used in translations|\n",
    "|partition()\t|Returns a tuple where the string is parted into three parts|\n",
    "|replace()\t|Returns a string where a specified value is replaced with a specified value|\n",
    "|rfind()\t|Searches the string for a specified value and returns the last position of where it was found|\n",
    "|rindex()\t|Searches the string for a specified value and returns the last position of where it was found|\n",
    "|rjust()\t|Returns a right justified version of the string|\n",
    "|rpartition()\t|Returns a tuple where the string is parted into three parts|\n",
    "|rsplit()\t|Splits the string at the specified separator, and returns a list|\n",
    "|rstrip()\t|Returns a right trim version of the string|\n",
    "|split()\t|Splits the string at the specified separator, and returns a list|\n",
    "|splitlines()\t|Splits the string at line breaks and returns a list|\n",
    "|startswith()\t|Returns true if the string starts with the specified value|\n",
    "|strip()\t|Returns a trimmed version of the string|\n",
    "|swapcase()\t|Swaps cases, lower case becomes upper case and vice versa|\n",
    "|title()\t|Converts the first character of each word to upper case|\n",
    "|translate()\t|Returns a translated string|\n",
    "|upper()\t|Converts a string into upper case|\n",
    "|zfill()\t|Fills the string with a specified number of 0 values at the beginning|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean datatype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(10 > 9)\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "Almost any value is evaluated to True if it has some sort of content.\n",
    "\n",
    "Any string is True, except empty strings.\n",
    "\n",
    "Any number is True, except 0.\n",
    "\n",
    "Any list, tuple, set, and dictionary are True, except empty ones.\n",
    "\n",
    "\"\"\"\n",
    "x = \"Hello\"\n",
    "y = 15\n",
    "z=\"\"\n",
    "print(bool(x))\n",
    "print(bool(y))\n",
    "print(bool(z))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Collections\n",
    "\n",
    "There are four collection data types in the Python programming language:\n",
    "\n",
    "**List** is a collection which is ordered and changeable. Allows duplicate members.\n",
    "\n",
    "**Tuple** is a collection which is ordered and unchangeable. Allows duplicate members.\n",
    "\n",
    "**Set** is a collection which is unordered and unindexed. No duplicate members.\n",
    "\n",
    "**Dictionary** is a collection which is unordered, changeable and indexed. No duplicate members."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "a = [\"hello\",\"welcome\",\"to\",\"python\"]\n",
    "print(type(a))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing in lists\n",
    "\n",
    "![](images/ls.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 3.0, 5.0, 4.0, 2.0]\n",
      "3.0\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-34-6d0bd0dda9c7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# Index element doesnt exist in list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfloat_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m## you should get error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "float_list = [1., 3., 5., 4., 2.]\n",
    "\n",
    "print(float_list)\n",
    "\n",
    "# selecting the second element in the list - index = 1\n",
    "print(float_list[1])\n",
    "\n",
    "\n",
    "# Index element doesnt exist in list\n",
    "print(float_list[10]) ## you should get error\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "# Selecting the last element in the list\n",
    "print(float_list[len(float_list)-1])\n",
    "\n",
    "# Rather a more ideal way of selecting the last element\n",
    "print(float_list[-1]) # and -2 for the second last and so on"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the ``:`` operator to access a subset of the list.  This is called **slicing.** \n",
    "    \n",
    "Below is a summary of list slicing operations:\n",
    "\n",
    "<img src=\"images/ops3_v2.png\" alt=\"Drawing\" style=\"width: 600px;\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.0, 5.0, 4.0, 2.0]\n",
      "[1.0, 3.0]\n",
      "[1.0, 3.0, 5.0]\n",
      "[1.0, 3.0, 5.0, 4.0]\n",
      "[1.0, 5.0]\n"
     ]
    }
   ],
   "source": [
    "# Example: \n",
    "print(float_list[1:5])\n",
    "print(float_list[0:2])\n",
    "\n",
    "# Indexing backwards:\n",
    "print(float_list[:-2]) # up to second last\n",
    "print(float_list[:4]) # up to but not including 5th element\n",
    "print(float_list[:4:2]) # above but skipping every second element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Apending and deleting values in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hello', 'welcome', 'to', 'python']\n",
      "['hello', 'welcome', 'to', 'python', 'sessions']\n",
      "['hello', 'welcome', 'to', 'python', 'sessions', '2020']\n",
      "['Hey!', 'welcome', 'to', 'python', 'sessions', '2020']\n"
     ]
    }
   ],
   "source": [
    "a = [\"hello\",\"welcome\",\"to\",\"python\"]\n",
    "print(a)\n",
    "a.append(\"sessions\") # appending an element to the list\n",
    "print(a)\n",
    "a = a + [\"2020\"]\n",
    "print(a)\n",
    "\n",
    "# changing an element value\n",
    "a[0] = \"Hey!\"\n",
    "print(a)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ipad', 'mac']\n",
      "['ipad', 'mac', 'iwatch', 'airpods']\n",
      "['ipad', 'mac', 'Beats', 'iwatch', 'airpods']\n"
     ]
    }
   ],
   "source": [
    "apple= ['ipad', 'mac']\n",
    "print(apple)\n",
    "\n",
    "# extend method\n",
    "apple.extend(['iwatch', 'airpods']) ## used for adding multiple elements at a time using a list\n",
    "print(apple)\n",
    "\n",
    "# insert method\n",
    "apple.insert(2, 'Beats') ##The insert() method can insert a value at any index in the list\n",
    "print(apple)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ipad', 'iphone']\n",
      "['iphone']\n"
     ]
    }
   ],
   "source": [
    "del(apple[2]) ## delete element based on its position in list\n",
    "print(apple)\n",
    "\n",
    "apple.remove(\"ipad\") ## deleting elememt based on its value\n",
    "print(apple)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# in and not in operator\n",
    "\n",
    "\n",
    "apple = ['ipad', 'iphone', 'mac']\n",
    "print('ipad' in apple)\n",
    "\n",
    "print('iwatch' not in apple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples \n",
    "\n",
    "**Note: tuples are immutable**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('apple', 'banana', 'cherry')\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-49-e74e2bbbcee2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m#assignment is not allowed\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mthistuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"orange\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m## Tuples are IMMUTABLE\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "print(thistuple)\n",
    "\n",
    "#assignment is not allowed\n",
    "thistuple[0]=\"orange\"\n",
    "\n",
    "## Tuples are IMMUTABLE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Ford\n",
      "{'brand': 'Ford', 'model': 'Mustang', 'year': 2020}\n"
     ]
    }
   ],
   "source": [
    "#creating dictionary\n",
    "thisdict = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(thisdict)\n",
    "\n",
    "#accessing values using keys\n",
    "print(thisdict[\"brand\"])\n",
    "\n",
    "#changing values\n",
    "thisdict[\"year\"]=2020\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'brand': 'Ford', 'model': 'Mustang', 'year': 2020, 'Transmission': 'automatic'}\n",
      "{'name': 'allen', 'age': '20'}\n"
     ]
    }
   ],
   "source": [
    "# adding new values to a list\n",
    "thisdict[\"Transmission\"] = \"automatic\"\n",
    "print(thisdict)\n",
    "\n",
    "# creating dictionaries from lists\n",
    "\n",
    "a = [\"name\",\"age\"]\n",
    "b = [\"allen\",\"20\"]\n",
    "c = dict(zip(a,b))\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "{'Delhi', 'Chennai', 'Mumbai', 'Kolkata'}\n",
      "{'Kolkata', 'Pune', 'Delhi', 'Chennai', 'Mumbai', 'SBC'}\n"
     ]
    }
   ],
   "source": [
    "Metros = set( [\"Delhi\", \"Chennai\", \"Mumbai\", \"Kolkata\"])\n",
    "bigCities = set([\"Delhi\", \"Chennai\", \"Mumbai\", \"Kolkata\", \"Pune\", \"SBC\"])\n",
    "\n",
    "# subsets and supersets\n",
    "print(Metros.issubset(bigCities))\n",
    "print(Metros.issuperset(bigCities))\n",
    "\n",
    "# intersection and union\n",
    "print( Metros & bigCities)    #Intersection\n",
    "print( Metros | bigCities)    #Union\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "***syntax***\n",
    "\n",
    "```\n",
    "def <function_name>(<function-parameters>):\n",
    "    <execute commands>\n",
    "    \n",
    "return <returning value>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "-5\n"
     ]
    }
   ],
   "source": [
    "# 1) Without return Type with arguments\n",
    "\n",
    "def add( a, b):\n",
    "    print( a + b )\n",
    "\n",
    "def sub( a, b):\n",
    "    print( a - b)\n",
    "\n",
    "add(4,5)\n",
    "sub(4,9)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# 2) Functions with return Type\n",
    "\n",
    "def add( a, b):\n",
    "    return a + b\n",
    "\n",
    "C = add( 2, 3)\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15000.0\n",
      "21000.0\n"
     ]
    }
   ],
   "source": [
    "# 3) with default parameters\n",
    "\n",
    "def simpleInterest( p, n, r = 7.0):\n",
    "    return p * n * r\n",
    "\n",
    "print(simpleInterest( 1000, 3, 5.0))  #Valid\n",
    "print(simpleInterest( 1000, 3))  #Still valid - takes the default argument of r = 7.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda functions - a cooler way of writing functions in a single line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "square = lambda x: x*x\n",
    "print(square(3))\n",
    "\n",
    "\n",
    "hypotenuse = lambda x, y: x*x + y*y\n",
    "\n",
    "## Same as\n",
    "\n",
    "# def hypotenuse(x, y):\n",
    "#     return(x*x + y*y)\n",
    "\n",
    "print(hypotenuse(3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python ifelse statements\n",
    "\n",
    "***syntax***\n",
    "\n",
    "```\n",
    "if <condition> :\n",
    "    <execute your commands>\n",
    "elif <condition> :\n",
    "    <execute your commands>\n",
    "else:\n",
    "    <execute your commands>\n",
    "```\n",
    "\n",
    "***Python relies on indentation (whitespace at the beginning of a line) to define scope in the code.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is lesser than b\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "a=10\n",
    "b=20\n",
    "\n",
    "if a>b:\n",
    "    print(\"a greater than b\")\n",
    "elif a==b:\n",
    "    print(\"a is equal to b\")\n",
    "else:\n",
    "    print(\"a is lesser than b\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While loop\n",
    "\n",
    "***syntax***\n",
    "```\n",
    "while <condition>:\n",
    "    <execute commands>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "i = 1\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loops\n",
    "***syntax***\n",
    "```\n",
    "for i in <condition>:\n",
    "    <execute commands>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "apple\n",
      "banana\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "# example\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "\n",
    "\n",
    "#looping in lists\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recursion\n",
    "\n",
    "calling the function from the same function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5040\n"
     ]
    }
   ],
   "source": [
    "def factorial( n):\n",
    "    if n == 1:\n",
    "        return 1\n",
    "    else :\n",
    "        return n * factorial(n-1)\n",
    "\n",
    "print(factorial(7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global and Local Variables\n",
    "\n",
    "To use a global variable in a local scope use the term global before defining the variable in the local scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n",
      "50\n",
      "50\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\ninitially x is set to be 34 and then printed hence 34 is the first output\\nNext in the function the x belonging to the global scope is called and changed to 50. \\nHence printing it in the function leads to 50 as the second output\\nNext since the global variable has been changed printing x outside the function also prints 50\\n'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Global\n",
    "x = 34\n",
    "print(x)\n",
    "def change():\n",
    "    global x\n",
    "    x = 50\n",
    "    print(x)\n",
    "change() #Function call\n",
    "print(x)\n",
    "\n",
    "\"\"\"\n",
    "initially x is set to be 34 and then printed hence 34 is the first output\n",
    "Next in the function the x belonging to the global scope is called and changed to 50. \n",
    "Hence printing it in the function leads to 50 as the second output\n",
    "Next since the global variable has been changed printing x outside the function also prints 50\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n",
      "50\n",
      "34\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"\\nIn the function the global variable is not used. \\nHence the variable x in the function is defined for the local scope.\\nTherefore changes to it doesn't reflect on the global variable\\n\""
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 34\n",
    "print (x)\n",
    "def change():\n",
    "    x = 50\n",
    "    print(x)\n",
    "change() #function call\n",
    "print(x)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "In the function the global variable is not used. \n",
    "Hence the variable x in the function is defined for the local scope.\n",
    "Therefore changes to it doesn't reflect on the global variable\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes in Python\n",
    "\n",
    "A Class is like an object constructor, or a \"blueprint\" for creating objects.\n",
    "\n",
    "**defining a class**\n",
    "```\n",
    "class <class_name>:\n",
    "    <class-variables>\n",
    "    <init functions if any>\n",
    "    <functions if any>\n",
    "    \n",
    "```\n",
    "\n",
    "**defining an object of a class**\n",
    " ```\n",
    " obj1=<class_name>()\n",
    "```\n",
    "\n",
    "**init function**\n",
    "All classes have a function called __init__(), which is always executed when the class is being initiated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "36\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "p1 = Person(\"John\", 36)\n",
    "\n",
    "print(p1.name)\n",
    "print(p1.age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exceptions\n",
    "\n",
    "Exceptions occur everywhere even here too – \n",
    "* Opening a file which doesn’t exist\n",
    "* Dividing a number by 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-76-6dc028a3b1ad>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;31m# We get ZeroDivisionError which is also an ArithmeticError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "print(1/0)\n",
    "# We get ZeroDivisionError which is also an ArithmeticError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Division by 0 is not possible\n"
     ]
    }
   ],
   "source": [
    "# handling exceptions\n",
    "\n",
    "try:\n",
    "    print(1/0)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Division by 0 is not possible\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'filename.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-79-a0bd67a20313>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"filename.txt\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'filename.txt'"
     ]
    }
   ],
   "source": [
    "f = open(\"filename.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File not found!!!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    f = open(\"filename.txt\")\n",
    "except FileNotFoundError:\n",
    "    print(\"File not found!!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now we will go to another very important topic - Memory allocation in Python [link](DAY2 - Notebook2.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}