Python-for-Beginners.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python : Part 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numeric Types "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integer Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-4 # This is another example, a negative integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4  # This is an example of a positive integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "5303349374 # This is another example of a large integer "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floating Point Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.141592653589793 # This is example of a positive floating point number 3.141592653589793"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "-1.5707963267948966 # This is another example of a negative floating point number "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "3453333.456464545345533  # this is a rather large float point number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2000.0"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2e3  # this is a floating point number using scientific notation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True # This is an example of a boolen value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "False # This is an example of another boolean value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complex Number Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4.32+5j)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4.32+5j # This is an example of a complex number "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.14+5j)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.14+5j # This is another example of a complex number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "4.323534343+500j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples of Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"This is a string and a great example\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'This is another example of a string but yet an even better example'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''This is aonther way to define a string but used for multiline strings'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples of Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "['physics', 'chemistry', 1997, 2000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "[1, 2, 3, 4, 5 ];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "[\"a\", \"b\", \"c\", \"d\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples of Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "('physics', 'chemistry', 1997, 2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(1, 2, 3, 4, 5 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"a\", \"b\", \"c\", \"d\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples of Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "{'element_3', 'element_1', 'element_2'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "{\"String 1\",\"String 2\",\"String 3\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "{2,5,4,5,5,5}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples of Frozen Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "frozenset([\"Frankfurt\", \"Basel\",\"Freiburg\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "frozenset([\"Denver\",\"Golden\",\"Boulder\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "frozenset([\"Dallas\", \"Houston\",\"Austin\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mappings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example of Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tel = {'jack': 4098, 'sape': 4139}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "adjectives = {\"cheap\",\"expensive\",\"inexpensive\",\"economical\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "def add_2(num):\n",
    "    '''return 2 more than num'''\n",
    "    return num+2\n",
    "\n",
    "print(add_2(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def add_two_numbers(number1,number2):\n",
    "    '''function with two input parameters both being numbers. Returns the sum of those two numbers'''\n",
    "    sum = number1+number2\n",
    "    return sum\n",
    "\n",
    "sum_of_two_numbers = add_two_numbers(20,40)\n",
    "\n",
    "# output the added two numbers\n",
    "print(sum_of_two_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def which_number_is_bigger_between_these_two(number1,number2):\n",
    "    '''Compares both numbers and returns the largest number '''\n",
    "    if number1 > number2:\n",
    "        print(number1,\" is bigger than number2 : \",number2)\n",
    "    if number2 > number1:\n",
    "        print(number2,\" is bigger than number1 : \",number1)\n",
    "    \n",
    "# use the function\n",
    "which_number_is_bigger_between_these_two(20,400)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class examples "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Robot:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# basic use and how to define a class with the initlization method. \n",
    "class Killer_Robot:\n",
    "    kind  = \"Killer Robot\" # class variable shared by all instances or created objects\n",
    "    # when an object is created i.e. x  = Robot(\"Berry\"), the name attribute of the class Robot is then set to equal \"Berry\"\n",
    "    # and accessed by x.name, \"Berry\" would be printed to console. \n",
    "    def __init__(self,name):\n",
    "        self.name = name # instance variable unqiue to each object created. \n",
    "        \n",
    "\n",
    "class Not_a_Killer_Robot():\n",
    "    kind = \"Not a Killer Robot\" # <-- class variable, this attribute is immutable \n",
    "    def __init__(self,name):\n",
    "        self.name = name # <-- object/instance variable, this attribute is mutable.\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = Killer_Robot(self,\"Killer Rob\")\n",
    "y =  Not_a_Killer_Robot(\"Nonkiller Rob\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x.name\n",
    "y.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes for data types i.e. the classes for the data types that we diccussed above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integer Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Float Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Complex Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0j"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complex()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuple Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Frozenset Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "frozenset()"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frozenset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions to help with classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### dir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'fromkeys',\n",
       " 'get',\n",
       " 'items',\n",
       " 'keys',\n",
       " 'pop',\n",
       " 'popitem',\n",
       " 'setdefault',\n",
       " 'update',\n",
       " 'values']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(dict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### getattr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### hasattr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### setattr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### delattr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### help()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'name'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loop Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First for loop example \n",
    "for element in range(0,10):\n",
    "    print(\"Element number : \",element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define a list to iterate through it's elements\n",
    "a_list_to_iterate_through = [\"element 1\",\"element 2\",\"element 3\",\"element 4\",\"element 100\",\"element 50000\"]\n",
    "# iterate through list using the print step and for loop\n",
    "for list_element in a_list_to_iterate_through:\n",
    "    print(list_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loop Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# init and declare the count variable\n",
    "# as the while increments, the value\n",
    "# of count increases until it reaches the\n",
    "# value of 9. Once that happens, the while\n",
    "# loop stops iterating.\n",
    "count = 0\n",
    "while (count < 9):\n",
    "   print('The count is:', count)\n",
    "   count = count + 1\n",
    "\n",
    "print \"Good bye!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# init and declare the count variable\n",
    "# as the while increments, the value\n",
    "# of count increases until it reaches the\n",
    "# value of 9. Once that happens, the while\n",
    "# loop stops iterating.\n",
    "count = 0\n",
    "while (count < 20):\n",
    "   print('The count is:', count)\n",
    "   count = count + 1\n",
    "\n",
    "print \"Good bye!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enumeration Examples "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# define a list to enumerate through \n",
    "my_list = ['apple', 'banana', 'grapes', 'pear']\n",
    "# iterating through my_list\n",
    "for c, value in enumerate(my_list, 1):\n",
    "    print(c, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# define a list to enumerate through \n",
    "my_list = ['apple', 'banana', 'grapes', 'pear']\n",
    "counter_list = list(enumerate(my_list, 1))\n",
    "print(counter_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File Input and Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FIle Input and Reading FIle Contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Holds the location of the text file\n",
    "file_in = open(\"Who-Are-The-Grateful-Dead.txt\")\n",
    "\n",
    "# to look at the first line of the file, use the readline() method\n",
    "print(file_in.readline())\n",
    "\n",
    "# for loop to iterate through the entire file: Who-Are-The-Grateful-Dead.txt\n",
    "for line in file_in:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Holds the location of the text file\n",
    "file_in = open(\"alexa_100k.csv\")\n",
    "\n",
    "# to look at the first line of the file, use the readline() method\n",
    "print(file_in.readline())\n",
    "\n",
    "# for loop to iterate through the entire file: Who-Are-The-Grateful-Dead.txt\n",
    "for line in file_in:\n",
    "    print(line)\n",
    "    \n",
    "# clean up your mess and close the file "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### File Output and Writing to FIle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Lines to be written to a newly created filed \n",
    "Lines_Out = ['Monday\\n', 'Tuesday\\n', 'Wednesday\\n', 'Thursday\\n', 'Friday\\n', 'Saturday\\n', 'Sunday\\n']\n",
    "# title of the file\n",
    "file_name = \"Days of the Week.txt\"\n",
    "# First line and title of the file\n",
    "first_line =\"Days of the Week\\n\"\n",
    "file_out = open(file_name,\"w\")\n",
    "# write the first line\n",
    "file_out.write(first_line)\n",
    "# now iterate though each element in the list and write \n",
    "# that to file. \n",
    "for element_string in Lines_Out:\n",
    "    # write each string contained in the list Lines_Out\n",
    "    # and then wrtie them to file\n",
    "    file_out.write(element_string)\n",
    "    \n",
    "# Clean up your mess and close out of the file \n",
    "# after you are done with it. \n",
    "file_out.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic Operator Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 15\n",
    "y = 4\n",
    "\n",
    "# Output: x + y = 19\n",
    "print('x + y =',x+y)\n",
    "\n",
    "# Output: x - y = 11\n",
    "print('x - y =',x-y)\n",
    "\n",
    "# Output: x * y = 60\n",
    "print('x * y =',x*y)\n",
    "\n",
    "# Output: x / y = 3.75\n",
    "print('x / y =',x/y)\n",
    "\n",
    "# Output: x // y = 3\n",
    "print('x // y =',x//y)\n",
    "\n",
    "# Output: x ** y = 50625\n",
    "print('x ** y =',x**y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison Operator Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 12\n",
    "\n",
    "# Output: x > y is False\n",
    "print('x > y  is',x>y)\n",
    "\n",
    "# Output: x < y is True\n",
    "print('x < y  is',x<y)\n",
    "\n",
    "# Output: x == y is False\n",
    "print('x == y is',x==y)\n",
    "\n",
    "# Output: x != y is True\n",
    "print('x != y is',x!=y)\n",
    "\n",
    "# Output: x >= y is False\n",
    "print('x >= y is',x>=y)\n",
    "\n",
    "# Output: x <= y is True\n",
    "print('x <= y is',x<=y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment Operator Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 21\n",
    "b = 10\n",
    "c = 0\n",
    "\n",
    "c = a + b\n",
    "print(\"Line 1 - Value of c is \", c)\n",
    "\n",
    "c += a\n",
    "print(\"Line 2 - Value of c is \", c)\n",
    "\n",
    "c *= a\n",
    "print(\"Line 3 - Value of c is \", c)\n",
    "\n",
    "c /= a \n",
    "print(\"Line 4 - Value of c is \", c) \n",
    "\n",
    "c  = 2\n",
    "c %= a\n",
    "print(\"Line 5 - Value of c is \", c)\n",
    "\n",
    "c **= a\n",
    "print(\"Line 6 - Value of c is \", c)\n",
    "\n",
    "c //= a\n",
    "print(\"Line 7 - Value of c is \", c)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical Operator Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = True\n",
    "y = False\n",
    "\n",
    "# Output: x and y is False\n",
    "print('x and y is',x and y)\n",
    "\n",
    "# Output: x or y is True\n",
    "print('x or y is',x or y)\n",
    "\n",
    "# Output: not x is False\n",
    "print('not x is',not x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional Operators Examples (if time allows)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bitwise Operator Exampes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 60            # 60 = 0011 1100 \n",
    "b = 13            # 13 = 0000 1101 \n",
    "c = 0\n",
    "\n",
    "c = a & b;        # 12 = 0000 1100\n",
    "print \"Line 1 - Value of c is \", c\n",
    "\n",
    "c = a | b;        # 61 = 0011 1101 \n",
    "print \"Line 2 - Value of c is \", c\n",
    "\n",
    "c = a ^ b;        # 49 = 0011 0001\n",
    "print \"Line 3 - Value of c is \", c\n",
    "\n",
    "c = ~a;           # -61 = 1100 0011\n",
    "print \"Line 4 - Value of c is \", c\n",
    "\n",
    "c = a << 2;       # 240 = 1111 0000\n",
    "print \"Line 5 - Value of c is \", c\n",
    "\n",
    "c = a >> 2;       # 15 = 0000 1111\n",
    "print \"Line 6 - Value of c is \", c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bitwise Operator Exampes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x1 = 5\n",
    "y1 = 5\n",
    "x2 = 'Hello'\n",
    "y2 = 'Hello'\n",
    "x3 = [1,2,3]\n",
    "y3 = [1,2,3]\n",
    "\n",
    "# Output: False\n",
    "print(x1 is not y1)\n",
    "\n",
    "# Output: True\n",
    "print(x2 is y2)\n",
    "\n",
    "# Output: False\n",
    "print(x3 is y3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Membership Operator Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 'Hello world'\n",
    "y = {1:'a',2:'b'}\n",
    "\n",
    "# Output: True\n",
    "print('H' in x)\n",
    "\n",
    "# Output: True\n",
    "print('hello' not in x)\n",
    "\n",
    "# Output: True\n",
    "print(1 in y)\n",
    "\n",
    "# Output: False\n",
    "print('a' in y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debugging Examples "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}