Homework Saniya Khullar Python_Intro_1-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to iPython  (Saniya's Homework)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Do some simple math. Add and multiply some numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65683\n",
      "256\n",
      "15\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "print(2+56+84+65498+21+22)  ## Please note that we are adding the numbers 2, 56, 84, 65498, 21 and 22.  Python will print out the sum, which is 65683. \n",
    "print(2**8)  ##Please note that while * is for multiplication,  ** is for exponents.  Hence 2**8 is 2^8, which is 256. \n",
    "print((1+4)*(9-6))  ## following the Order of Operations (PEMDAS), it will be evaluated as: (5)*(3) = 15\n",
    "print((5*4))  #This will just be 20. \n",
    "\n",
    "#This demonstrates how Python can be used as a calculator too since it can do some simple math.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s a\n",
      "p\n",
      "s\n",
      "pa pam spa\n",
      "sp\n"
     ]
    }
   ],
   "source": [
    "s = 'spam'  #Here, please note that we have created a new variable, s, and have assigned a text string (characters) 'spam', to this variable s.  \n",
    "print(s[0], s[-2])  #Here, we note that [] refers to the index of the character string s.  In 'spam', the 0th spot is s, the 1st spot is p, the 2nd spot is a, the 3rd spot is m.  \n",
    "#Hence, s[0] looks at the first letter (from left to right) in 'spam' and sees that it is s.  Hence Python reports s for s[0]\n",
    "# For s[1] it would have been the 2nd letter (from left to right) in 'spam', which would be p.  Hence, s[1] is p. \n",
    "print(s[-3]) # Please note that this is p.  That is, using negative #'s means that we look at 'spam' from right to left.  We look \n",
    "\n",
    "\n",
    "print(s[-0]) # this is s. \n",
    "print(s[1:3], s[1:], s[:-1])  #print(s[1:3]) will print the 2nd and 3rd letters of the string 'spam'.  \n",
    "# print s[1:] will print the 2nd letter to the end of 'spam'.  This is given by the colon ':'.  \n",
    "#print(s[:-1]) will print out everything starting with the 2nd to last letter.  That is, it will NOT print out 'm', but it will print out everything else, which will be:'spa'. \n",
    "#[1:3] starts with the 2nd letter and the 3rd letter but does not include the 4th letter (which is position 3)\n",
    "\n",
    "print(s[:-2])  #this is sp.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check current working directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/saniyakhullar/Fall510\n",
      "darwin\n"
     ]
    }
   ],
   "source": [
    "import sys #Load the sys library\n",
    "import os #Load the os library\n",
    "import re #Load regular expression pattern matching library\n",
    "print(os.getcwd())  \n",
    "print(sys.platform)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module os:\n",
      "\n",
      "NAME\n",
      "    os - OS routines for NT or Posix depending on what system we're on.\n",
      "\n",
      "MODULE REFERENCE\n",
      "    http://docs.python.org/3.4/library/os\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "    This exports:\n",
      "      - all functions from posix, nt or ce, e.g. unlink, stat, etc.\n",
      "      - os.path is either posixpath or ntpath\n",
      "      - os.name is either 'posix', 'nt' or 'ce'.\n",
      "      - os.curdir is a string representing the current directory ('.' or ':')\n",
      "      - os.pardir is a string representing the parent directory ('..' or '::')\n",
      "      - os.sep is the (or a most common) pathname separator ('/' or ':' or '\\\\')\n",
      "      - os.extsep is the extension separator (always '.')\n",
      "      - os.altsep is the alternate pathname separator (None or '/')\n",
      "      - os.pathsep is the component separator used in $PATH etc\n",
      "      - os.linesep is the line separator in text files ('\\r' or '\\n' or '\\r\\n')\n",
      "      - os.defpath is the default search path for executables\n",
      "      - os.devnull is the file path of the null device ('/dev/null', etc.)\n",
      "    \n",
      "    Programs that import and use 'os' stand a better chance of being\n",
      "    portable between different platforms.  Of course, they must then\n",
      "    only use functions that are defined by all platforms (e.g., unlink\n",
      "    and opendir), and leave all pathname manipulation to os.path\n",
      "    (e.g., split and join).\n",
      "\n",
      "FUNCTIONS\n",
      "    _exit(...)\n",
      "        _exit(status)\n",
      "        \n",
      "        Exit to the system with specified status, without normal exit processing.\n",
      "    \n",
      "    execl(file, *args)\n",
      "        execl(file, *args)\n",
      "        \n",
      "        Execute the executable file with argument list args, replacing the\n",
      "        current process.\n",
      "    \n",
      "    execle(file, *args)\n",
      "        execle(file, *args, env)\n",
      "        \n",
      "        Execute the executable file with argument list args and\n",
      "        environment env, replacing the current process.\n",
      "    \n",
      "    execlp(file, *args)\n",
      "        execlp(file, *args)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args, replacing the current process.\n",
      "    \n",
      "    execlpe(file, *args)\n",
      "        execlpe(file, *args, env)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args and environment env, replacing the current\n",
      "        process.\n",
      "    \n",
      "    execvp(file, args)\n",
      "        execvp(file, args)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args, replacing the current process.\n",
      "        args may be a list or tuple of strings.\n",
      "    \n",
      "    execvpe(file, args, env)\n",
      "        execvpe(file, args, env)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args and environment env , replacing the\n",
      "        current process.\n",
      "        args may be a list or tuple of strings.\n",
      "    \n",
      "    fdopen(fd, *args, **kwargs)\n",
      "        # Supply os.fdopen()\n",
      "    \n",
      "    fsdecode(filename)\n",
      "        Decode filename from the filesystem encoding with 'surrogateescape' error\n",
      "        handler, return str unchanged. On Windows, use 'strict' error handler if\n",
      "        the file system encoding is 'mbcs' (which is the default encoding).\n",
      "    \n",
      "    fsencode(filename)\n",
      "        Encode filename to the filesystem encoding with 'surrogateescape' error\n",
      "        handler, return bytes unchanged. On Windows, use 'strict' error handler if\n",
      "        the file system encoding is 'mbcs' (which is the default encoding).\n",
      "    \n",
      "    get_exec_path(env=None)\n",
      "        Returns the sequence of directories that will be searched for the\n",
      "        named executable (similar to a shell) when launching a process.\n",
      "        \n",
      "        *env* must be an environment variable dict or None.  If *env* is None,\n",
      "        os.environ will be used.\n",
      "    \n",
      "    getenv(key, default=None)\n",
      "        Get an environment variable, return None if it doesn't exist.\n",
      "        The optional second argument can specify an alternate default.\n",
      "        key, default and the result are str.\n",
      "    \n",
      "    getenvb(key, default=None)\n",
      "        Get an environment variable, return None if it doesn't exist.\n",
      "        The optional second argument can specify an alternate default.\n",
      "        key, default and the result are bytes.\n",
      "    \n",
      "    makedirs(name, mode=511, exist_ok=False)\n",
      "        makedirs(name [, mode=0o777][, exist_ok=False])\n",
      "        \n",
      "        Super-mkdir; create a leaf directory and all intermediate ones.  Works like\n",
      "        mkdir, except that any intermediate path segment (not just the rightmost)\n",
      "        will be created if it does not exist. If the target directory already\n",
      "        exists, raise an OSError if exist_ok is False. Otherwise no exception is\n",
      "        raised.  This is recursive.\n",
      "    \n",
      "    popen(cmd, mode='r', buffering=-1)\n",
      "        # Supply os.popen()\n",
      "    \n",
      "    putenv(...)\n",
      "        putenv(key, value)\n",
      "        \n",
      "        Change or add an environment variable.\n",
      "    \n",
      "    removedirs(name)\n",
      "        removedirs(name)\n",
      "        \n",
      "        Super-rmdir; remove a leaf directory and all empty intermediate\n",
      "        ones.  Works like rmdir except that, if the leaf directory is\n",
      "        successfully removed, directories corresponding to rightmost path\n",
      "        segments will be pruned away until either the whole path is\n",
      "        consumed or an error occurs.  Errors during this latter phase are\n",
      "        ignored -- they generally mean that a directory was not empty.\n",
      "    \n",
      "    renames(old, new)\n",
      "        renames(old, new)\n",
      "        \n",
      "        Super-rename; create directories as necessary and delete any left\n",
      "        empty.  Works like rename, except creation of any intermediate\n",
      "        directories needed to make the new pathname good is attempted\n",
      "        first.  After the rename, directories corresponding to rightmost\n",
      "        path segments of the old name will be pruned way until either the\n",
      "        whole path is consumed or a nonempty directory is found.\n",
      "        \n",
      "        Note: this function can fail with the new directory structure made\n",
      "        if you lack permissions needed to unlink the leaf directory or\n",
      "        file.\n",
      "    \n",
      "    spawnl(mode, file, *args)\n",
      "        spawnl(mode, file, *args) -> integer\n",
      "        \n",
      "        Execute file with arguments from args in a subprocess.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnle(mode, file, *args)\n",
      "        spawnle(mode, file, *args, env) -> integer\n",
      "        \n",
      "        Execute file with arguments from args in a subprocess with the\n",
      "        supplied environment.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnlp(mode, file, *args)\n",
      "        spawnlp(mode, file, *args) -> integer\n",
      "        \n",
      "        Execute file (which is looked for along $PATH) with arguments from\n",
      "        args in a subprocess with the supplied environment.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnlpe(mode, file, *args)\n",
      "        spawnlpe(mode, file, *args, env) -> integer\n",
      "        \n",
      "        Execute file (which is looked for along $PATH) with arguments from\n",
      "        args in a subprocess with the supplied environment.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnv(mode, file, args)\n",
      "        spawnv(mode, file, args) -> integer\n",
      "        \n",
      "        Execute file with arguments from args in a subprocess.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnve(mode, file, args, env)\n",
      "        spawnve(mode, file, args, env) -> integer\n",
      "        \n",
      "        Execute file with arguments from args in a subprocess with the\n",
      "        specified environment.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnvp(mode, file, args)\n",
      "        spawnvp(mode, file, args) -> integer\n",
      "        \n",
      "        Execute file (which is looked for along $PATH) with arguments from\n",
      "        args in a subprocess.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnvpe(mode, file, args, env)\n",
      "        spawnvpe(mode, file, args, env) -> integer\n",
      "        \n",
      "        Execute file (which is looked for along $PATH) with arguments from\n",
      "        args in a subprocess with the supplied environment.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    unsetenv(...)\n",
      "        unsetenv(key)\n",
      "        \n",
      "        Delete an environment variable.\n",
      "    \n",
      "    walk(top, topdown=True, onerror=None, followlinks=False)\n",
      "        Directory tree generator.\n",
      "        \n",
      "        For each directory in the directory tree rooted at top (including top\n",
      "        itself, but excluding '.' and '..'), yields a 3-tuple\n",
      "        \n",
      "            dirpath, dirnames, filenames\n",
      "        \n",
      "        dirpath is a string, the path to the directory.  dirnames is a list of\n",
      "        the names of the subdirectories in dirpath (excluding '.' and '..').\n",
      "        filenames is a list of the names of the non-directory files in dirpath.\n",
      "        Note that the names in the lists are just names, with no path components.\n",
      "        To get a full path (which begins with top) to a file or directory in\n",
      "        dirpath, do os.path.join(dirpath, name).\n",
      "        \n",
      "        If optional arg 'topdown' is true or not specified, the triple for a\n",
      "        directory is generated before the triples for any of its subdirectories\n",
      "        (directories are generated top down).  If topdown is false, the triple\n",
      "        for a directory is generated after the triples for all of its\n",
      "        subdirectories (directories are generated bottom up).\n",
      "        \n",
      "        When topdown is true, the caller can modify the dirnames list in-place\n",
      "        (e.g., via del or slice assignment), and walk will only recurse into the\n",
      "        subdirectories whose names remain in dirnames; this can be used to prune the\n",
      "        search, or to impose a specific order of visiting.  Modifying dirnames when\n",
      "        topdown is false is ineffective, since the directories in dirnames have\n",
      "        already been generated by the time dirnames itself is generated. No matter\n",
      "        the value of topdown, the list of subdirectories is retrieved before the\n",
      "        tuples for the directory and its subdirectories are generated.\n",
      "        \n",
      "        By default errors from the os.listdir() call are ignored.  If\n",
      "        optional arg 'onerror' is specified, it should be a function; it\n",
      "        will be called with one argument, an OSError instance.  It can\n",
      "        report the error to continue with the walk, or raise the exception\n",
      "        to abort the walk.  Note that the filename is available as the\n",
      "        filename attribute of the exception object.\n",
      "        \n",
      "        By default, os.walk does not follow symbolic links to subdirectories on\n",
      "        systems that support them.  In order to get this functionality, set the\n",
      "        optional argument 'followlinks' to true.\n",
      "        \n",
      "        Caution:  if you pass a relative pathname for top, don't change the\n",
      "        current working directory between resumptions of walk.  walk never\n",
      "        changes the current directory, and assumes that the client doesn't\n",
      "        either.\n",
      "        \n",
      "        Example:\n",
      "        \n",
      "        import os\n",
      "        from os.path import join, getsize\n",
      "        for root, dirs, files in os.walk('python/Lib/email'):\n",
      "            print(root, \"consumes\", end=\"\")\n",
      "            print(sum([getsize(join(root, name)) for name in files]), end=\"\")\n",
      "            print(\"bytes in\", len(files), \"non-directory files\")\n",
      "            if 'CVS' in dirs:\n",
      "                dirs.remove('CVS')  # don't visit CVS directories\n",
      "\n",
      "DATA\n",
      "    P_NOWAIT = 1\n",
      "    P_NOWAITO = 1\n",
      "    P_WAIT = 0\n",
      "    SEEK_CUR = 1\n",
      "    SEEK_END = 2\n",
      "    SEEK_SET = 0\n",
      "    __all__ = ['altsep', 'curdir', 'pardir', 'sep', 'pathsep', 'linesep', ...\n",
      "    altsep = None\n",
      "    curdir = '.'\n",
      "    defpath = ':/bin:/usr/bin'\n",
      "    devnull = '/dev/null'\n",
      "    environb = environ({b'rvm_bin_path': b'/Users/saniyakhullar...494_sg7s...\n",
      "    extsep = '.'\n",
      "    linesep = '\\n'\n",
      "    name = 'posix'\n",
      "    pardir = '..'\n",
      "    pathsep = ':'\n",
      "    sep = '/'\n",
      "    supports_bytes_environ = True\n",
      "\n",
      "FILE\n",
      "    /Users/saniyakhullar/anaconda/lib/python3.4/os.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(os)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import urllib.request\n",
    "r = urllib.request.urlopen('https://github.com/Math510/Math510.github.io/raw/master/2015%20FALL%20510%20Course%20Schedule.pdf')  #This is the course schedule for Math 510. It lists the topics that will be covered during the semester.  \n",
    "# myfile = open('<need to specify a location on your computer>', 'wb')  \n",
    "#myfile = open('//Users//saniyakhullar//Desktop//Fall 2015 Graduate Courses', 'wb')  \n",
    "myfile = open('/Users/saniyakhullar/Desktop/Fall 2015 Graduate Courses/Python-Lecture1-2014.pdf', 'wb')  \n",
    "\n",
    "myfile.write(r.read())  #Please note that:  This overwrites the current file 'Python Lecture 1 2014' with the Course Schedule, which is coming as variable r. \n",
    "# This reads the file mentioned by the variable 'r', which is the Math510 Course Schedule.  It then writes this to myfile, which is the Python Lecture 1 2014. \n",
    "myfile.close()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "OverwritingFile = urllib.request.urlopen('https://github.com/Math510/Math510.github.io/raw/master/2015%20FALL%20510%20Syllabus.pdf')  #please note that this is the file that we want to extract from the Professor's Github account. \n",
    "#this file is the Syllabus for Mathematics and Statistical Computing.  This file will be stored as the variable:  OverwritingFile\n",
    "\n",
    "# myfileNew = open('<need to specify a location on your computer>', 'wb')  Here we please specify the file that we want to open.  This file on our computer will be stored as a variable myfileNew.\n",
    "myfileNew =  open('/Users/saniyakhullar/Desktop/Fall 2015 Graduate Courses/Math Stat Computing/Dummy File for Math Stat Computing Homework 1.pdf', 'wb')  #Here, please note that I created a blank PDF as a dummy file, for my variable myfile New.  Please note that this dummy file will ultimately end up being replaced by the OverwritingFile, which is the Course Syllabus.  \n",
    "#/Users/saniyakhullar/Desktop/Fall 2015 Graduate Courses/Math Stat Computing/Dummy File for Math Stat Computing Homework 1.pdf\n",
    "myfileNew.write(OverwritingFile.read())  # This overwrites the myfileNew withe the contents in the OverwritingFile.\n",
    "# Please note that \"OverwritingFile.read()\" means that we will read the Course Syllabus file contents and then \"write(OverwritingFile.read())\" means that we will write those contents somewhere. \n",
    "# By having \"myfileNew.write(OverwritingFile.read())\", we are specifying that we want these new contents to be written to the myfileNew document. \n",
    "myfileNew.close()   #this closes the file that was replaced.  If we go to the Finder on the Computer, please note that when we click the old dummy file (myfileNew), we should find the contents have changed and now are the course syllabus. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something Else\n"
     ]
    }
   ],
   "source": [
    "title = 'Something Else'  #this creates a variable that is a text string 'Something Else'\n",
    "print(title)   #python will print this out.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import variables from a module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Math 510 Fall 2015\n",
      "54.0\n"
     ]
    }
   ],
   "source": [
    "import Class_1_Module #uses Class_1_Module name space\n",
    "\n",
    "# Please note that Saniya read Professor's \"Class_1_Module.py\" file onto her Git Hub repository. \n",
    "#The contents of that imported file are:\n",
    "\n",
    "        ##Variables!\n",
    "        ##title = 'Math 510 Fall 2015'\n",
    "        ##MyAge = 29 + (50/2)\n",
    "#In essence, the imported file contains the 2 variables that will be referenced below.  We are importing the variables from this module so that we may use them below. \n",
    "        \n",
    "dir(Class_1_Module)  #this ensures that the working directory is the Class 1 Module.  It opens up this folder and lets us work with the variables within this module file. \n",
    "print(Class_1_Module.title)  #Here, under the Class_1_Module file we note that the title variable is 'Math 510 Fall 2015'.  Therefore, by printing 'Class_1_Module.title', we are printing out 'Math 510 Fall 2015'.  \n",
    "# Since we are in this Python_Intro_1 file and are referencing variables in another file, we ideally should please include the name of the file in front of the variable of interest. \n",
    "# Hence, it is like:  print(filename.variablename)\n",
    "\n",
    "print(Class_1_Module.MyAge)  \n",
    "#Please note that in the Class_1_Module file this is:  MyAge = 29 + (50/2)\n",
    "# Python will compute this as:  MyAge = 29 + 25 = 54.  Hence, when we print this:  print(Class_1_Module.MyAge), we will get 54. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show the difference in scope between importing a module and importing a specific variable from the module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Math 510 Fall 2015\n",
      "Saniya Khullar\n"
     ]
    }
   ],
   "source": [
    "#copies into local name space, overwrites same named variable\n",
    "#without warning\n",
    "\n",
    "title = \"Saniya\"\n",
    "from Class_1_Module import title \n",
    "print(title)  #the result is \"Math 510 Fall 2015\" rather than \"Saniya\".  Even though Saniya had entered \"Saniya\" for the character assigned to title, Python overwrote that when it imported the Class_1_Module file. \n",
    "#This shows how importing a variable from another module copies the variable into the local name space and overwrites any existing variables that have the same name with the variable values from the imported module. \n",
    "#Unfortunately, this overwriting is done without warning \n",
    "\n",
    "\n",
    "#However, if now Saniya writes title, \n",
    "title = \"Saniya Khullar\"\n",
    "print(title) #this prints out \"Saniya\" because we now have overwritten the previous variable assignment of \"Math 510 Fall 2015\". \n",
    "#from Class_1_Module import title \n",
    "#print(title) \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}