CIS3715 (Temple - Spring 2020) PythonBasics - Lab1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics\n",
    "\n",
    "This is a brief overview of Python language. It is aimed at students having at least one semester of programming experience in some language, such as Java, C, or Matlab. Our goal is not to become experts in programming in Python, but to learn enough so we can quickly become functional in doing data science with Python. \n",
    "\n",
    "**Disclaimer**: This file is a modification of several sources including:\n",
    "\n",
    "- `cs228-python-tutorial.ipynb` at https://github.com/kuleshov/cs228-material/blob/master/tutorials/python/cs228-python-tutorial.ipynb from Stanford's CS228 course\n",
    "(http://cs109.github.io/2015/)\n",
    "- `appendix_python.ipynb` at http://nbviewer.jupyter.org/github/pydata/pydata-book/blob/master/appendix_python.ipynb, which is acompanying a very nice book \"Python for Data Analysis\" book by Wes McKinney.\n",
    "- `Lab1-babypython.ipynb` at https://github.com/cs109/2015lab1 from Harvard's CS109 Data Science course \n",
    "- Python documentation at https://docs.python.org/2/index.html."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Installing Python IDE\n",
    "\n",
    "**Python environments**. In this course we will encourage students to do their Python work using either *Spyder* or *iPython notebook*. \n",
    "\n",
    "Spyder is an interactive development environment (IDE) which has Graphical User Interface (GUI) very similar to Matlab, so it will immediatelly come naturally to anybody who previously used Matlab. But, even for those who have never heard of Matlab, Spyder provides a very pleasant environment to work with. It has several tiled windows where programmers can see the console to run their code, python (`.py`) file editor, as well as view variables and files. \n",
    "\n",
    "iPython notebook (often called Jupyter) is a web-based IDE which is run on a browser and allows programmers to write and run their code within a browser window and to also create html-like documents (`.ipynb`) that are a mix of code and nicely formatted comments.\n",
    "\n",
    "**Anaconda**. We recommend students to start by installing `Anaconda` software on their own laptops or PCs (there are versions for Windows, OSX, and Linux) and use that software to start either Spyder or iPython notebook. *Anaconda* software can be downloaded for free from https://www.continuum.io/downloads. We advise installing Python 3 version for the purposes of this course. To install the software requires about 2GB of free disk space. Upon starting *Anaconda*, a window will pop up with several large icons. Clicking the *Launch* button on the *jupyter notebook* icon will launch iPython notebook. Clicking *Launch* button on the *spyder* icon will launch Spyder.\n",
    "\n",
    "**Spyder** (reference: http://pythonhosted.org/spyder/). Let us launch Spyder. We recommend using *iPython console*. In the *iPython console* window, type `?` and press enter. You will see a quick introduction and overview of IPython's features. Try to red through it. Next, type `1+1` and press enter. As the result you should see the output `2`. That is it for now. \n",
    "\n",
    "**iPython Notebook** (reference: https://ipython.org/ipython-doc/3/notebook/notebook.html). Let us launch the *jupyter notebook*. You will see a list of files and folders visible from your root directory. Open file `CIS3715 (Temple - Spring 2020) PythonBasics.ipynb` from the folder where you saved it. Now, you will be able to see a version of this file that you can edit and run pieces of code from. You are advised to make a copy of this file (click *File->Make a Copy*) that you will edit and you can always switch back to the original file if needed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python tutorial - baby steps\n",
    "Let us start by running some basic code in python. If you click on the window below and press *Shift-Enter*, you will execute the code. You might also wish to copy-paste the chunks of code below to a *Spyder* console and execute them there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feel free to click on the code above and change the entry into `1+2` and press *Shift-Enter*.\n",
    "\n",
    "You can also double click on the text you are looking at (it is in the *Markdown* format) and you will be able to modify it. After editing, remember to press *Shift-Enter*, so the changes will be implemented. You can find a nice intro about the *Markdown* on http://daringfireball.net/projects/markdown/\n",
    "\n",
    "The following piece of code creates and assigns a value to object `b`, prints the value, and shows the type of the object. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2.5\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "b = -2.5\n",
    "print (b)\n",
    "print (type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`print` is among a small number of Python keywords and `type()` is among a small number of built-in functions coming with any Python interpreter. For the full list of the keywords see https://learnpythonthehardway.org/book/ex37.html\n",
    "and for the full list of built-in functions see https://docs.python.org/2/library/functions.html. \n",
    "\n",
    "Each object typically has associated a set of *attributes*, which are other objects stored in it, and *methods*, which define allowable things that could be done with the object. Now that we have created object `b`, which happens to be of type `float`, we can be wondering what could be done with it. To check properties of objects of type `float` we can type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class float in module builtins:\n",
      "\n",
      "class float(object)\n",
      " |  float(x) -> floating point number\n",
      " |  \n",
      " |  Convert a string or number to a floating point number, if possible.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self, /)\n",
      " |      abs(self)\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      self != 0\n",
      " |  \n",
      " |  __divmod__(self, value, /)\n",
      " |      Return divmod(self, value).\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __float__(self, /)\n",
      " |      float(self)\n",
      " |  \n",
      " |  __floordiv__(self, value, /)\n",
      " |      Return self//value.\n",
      " |  \n",
      " |  __format__(...)\n",
      " |      float.__format__(format_spec) -> string\n",
      " |      \n",
      " |      Formats the float according to format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getformat__(...) from builtins.type\n",
      " |      float.__getformat__(typestr) -> string\n",
      " |      \n",
      " |      You probably don't want to use this function.  It exists mainly to be\n",
      " |      used in Python's test suite.\n",
      " |      \n",
      " |      typestr must be 'double' or 'float'.  This function returns whichever of\n",
      " |      'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the\n",
      " |      format of floating point numbers used by the C type named by typestr.\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __int__(self, /)\n",
      " |      int(self)\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __neg__(self, /)\n",
      " |      -self\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __pos__(self, /)\n",
      " |      +self\n",
      " |  \n",
      " |  __pow__(self, value, mod=None, /)\n",
      " |      Return pow(self, value, mod).\n",
      " |  \n",
      " |  __radd__(self, value, /)\n",
      " |      Return value+self.\n",
      " |  \n",
      " |  __rdivmod__(self, value, /)\n",
      " |      Return divmod(value, self).\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rfloordiv__(self, value, /)\n",
      " |      Return value//self.\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __round__(...)\n",
      " |      Return the Integral closest to x, rounding half toward even.\n",
      " |      When an argument is passed, work like built-in round(x, ndigits).\n",
      " |  \n",
      " |  __rpow__(self, value, mod=None, /)\n",
      " |      Return pow(value, self, mod).\n",
      " |  \n",
      " |  __rsub__(self, value, /)\n",
      " |      Return value-self.\n",
      " |  \n",
      " |  __rtruediv__(self, value, /)\n",
      " |      Return value/self.\n",
      " |  \n",
      " |  __setformat__(...) from builtins.type\n",
      " |      float.__setformat__(typestr, fmt) -> None\n",
      " |      \n",
      " |      You probably don't want to use this function.  It exists mainly to be\n",
      " |      used in Python's test suite.\n",
      " |      \n",
      " |      typestr must be 'double' or 'float'.  fmt must be one of 'unknown',\n",
      " |      'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be\n",
      " |      one of the latter two if it appears to match the underlying C reality.\n",
      " |      \n",
      " |      Override the automatic determination of C-level floating point type.\n",
      " |      This affects how floats are converted to and from binary strings.\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  __sub__(self, value, /)\n",
      " |      Return self-value.\n",
      " |  \n",
      " |  __truediv__(self, value, /)\n",
      " |      Return self/value.\n",
      " |  \n",
      " |  __trunc__(...)\n",
      " |      Return the Integral closest to x between 0 and x.\n",
      " |  \n",
      " |  as_integer_ratio(...)\n",
      " |      float.as_integer_ratio() -> (int, int)\n",
      " |      \n",
      " |      Return a pair of integers, whose ratio is exactly equal to the original\n",
      " |      float and with a positive denominator.\n",
      " |      Raise OverflowError on infinities and a ValueError on NaNs.\n",
      " |      \n",
      " |      >>> (10.0).as_integer_ratio()\n",
      " |      (10, 1)\n",
      " |      >>> (0.0).as_integer_ratio()\n",
      " |      (0, 1)\n",
      " |      >>> (-.25).as_integer_ratio()\n",
      " |      (-1, 4)\n",
      " |  \n",
      " |  conjugate(...)\n",
      " |      Return self, the complex conjugate of any float.\n",
      " |  \n",
      " |  fromhex(...) from builtins.type\n",
      " |      float.fromhex(string) -> float\n",
      " |      \n",
      " |      Create a floating-point number from a hexadecimal string.\n",
      " |      >>> float.fromhex('0x1.ffffp10')\n",
      " |      2047.984375\n",
      " |      >>> float.fromhex('-0x1p-1074')\n",
      " |      -5e-324\n",
      " |  \n",
      " |  hex(...)\n",
      " |      float.hex() -> string\n",
      " |      \n",
      " |      Return a hexadecimal representation of a floating-point number.\n",
      " |      >>> (-0.1).hex()\n",
      " |      '-0x1.999999999999ap-4'\n",
      " |      >>> 3.14159.hex()\n",
      " |      '0x1.921f9f01b866ep+1'\n",
      " |  \n",
      " |  is_integer(...)\n",
      " |      Return True if the float is an integer.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  imag\n",
      " |      the imaginary part of a complex number\n",
      " |  \n",
      " |  real\n",
      " |      the real part of a complex number\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(\"float\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From this listing, we can see the allowable methods that could be applied on any object of `float` type to which `b` belongs. For example, to find an absolute value of `b` we can type "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n",
      "2.5\n"
     ]
    }
   ],
   "source": [
    "print (b.__abs__())   # this is a cumbersome way to find the absolute value\n",
    "print (abs(b))   # this is the standard way "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to see the attribtes and methods for `b` is to type `dir(\"float\")` or directly `dir(b)`. You can also use `?` to get more information, such as by typing `b?` . While entering code in *iPython notebook* or *Spyder* , it is also useful to use autocompletion, which is envoked by pressing the *Tab* button. Try to press *Tab* in the window below and select `is_integer` choice. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "b?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since `is_integer` is a method, we can execute it by adding parentheses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.is_integer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Typing\n",
    "In addition to `float` Python has several important built-in types that are worth knowing. One group are *simple types* that allow handling of numerical data, strings, boolean values, dates, and time. Another group are *container types* that contain numerous objects of simple type. \n",
    "\n",
    "##   Simple Types\n",
    "\n",
    "**Numbers**. Integers and floats work as you would expect from other languages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "c = 3\n",
    "print (c, type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "6\n",
      "1.5\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print (c + 1)   # Addition (by the way, any text following '#' is treated as a comment)\n",
    "print (c * 2)   # Multiplication\n",
    "print (c / 2)   # Division (pay attention that the result is the integer part, not float 1.5)\n",
    "print (c ** 2)  # Exponentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "c += 1\n",
    "print (c)  # Prints \"4\"\n",
    "c *= 2\n",
    "print (c)  # Prints \"8\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operations between `float` and `integer` types are possible and the result is typed as `float`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.5 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print (b+c, type(b+c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to convert one type into another by using the built-in functions `float` and `int`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2 <class 'int'>\n",
      "8.0 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "b = int(b)\n",
    "print (b, type(b))\n",
    "c = float(c)\n",
    "print (c, type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With those type conversions, Python had to delete the existing object and create a new object with different type. Note that upon using the assign operator, Python is trying to guess the type of the object. If upon checking the type, the programmer does not agree, (s)he might want to change the type, as shown above. Python also has built-in types for long integers and complex numbers; you can find all of the details at https://docs.python.org/2/library/stdtypes.html#numeric-types-int-float-long-complex.\n",
    "\n",
    "**None**. Another important simple type is *None* and is used quite often in data science:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None <class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "n = None\n",
    "print (n, type(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**Booleans**. Python implements all of the usual operators for Boolean logic, either by using English words (e.g., `and`, `or`, `not` -- preferred for readability) or symbols (e.g., `&`, `|`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True <class 'bool'> False <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "t = True\n",
    "f = False\n",
    "print (t, type(t), f, type(f))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print (t and f) # Logical AND;\n",
    "print (t or f)  # Logical OR;\n",
    "print (not t)   # Logical NOT;\n",
    "print (t != f)  # Logical XOR;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Strings**. `str` is a very useful type. It is defined by assigning a *string literal* enclosed with single or double quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello 5 <class 'str'>\n",
      "hello\n",
      "           \n",
      "longer text\n",
      "  that can span\n",
      " multiple lines\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'hello'       # string literals can use single quotes\n",
    "print (s1, len(s1), type(s1))    # len() is a method that works on strings, check len? or help(\"len\")\n",
    "s2 = \"hello\"       # string literals can also be defined using double quotes\n",
    "print (s2)\n",
    "s3 = '''           \n",
    "longer text\n",
    "  that can span\n",
    " multiple lines\n",
    "'''\n",
    "print (s3)           # triple quote is used for multi-line string literals\n",
    "s1 == s2           # this will output True because the objects have the same content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello is the same as hello\n",
      "hello world 12\n"
     ]
    }
   ],
   "source": [
    "s4 = s1 + ' is the same as ' + s2     # string concatenation\n",
    "print (s4)\n",
    "s5 = '%s %s %d' % (s1, 'world', 12)  # sprintf style string formatting\n",
    "print (s5)  # prints \"hello world 12\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String objects have many useful methods (see https://docs.python.org/2/library/stdtypes.html#string-methods for more details)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "HELLO\n",
      "  hello\n",
      " hello \n",
      "he(ell)(ell)o\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "s = \"hello\"\n",
    "print (s.capitalize())  # Capitalize a string; prints \"Hello\"\n",
    "print (s.upper())       # Convert a string to uppercase; prints \"HELLO\"\n",
    "print (s.rjust(7))      # Right-justify a string, padding with spaces; prints \"  hello\"\n",
    "print (s.center(7))     # Center a string, padding with spaces; prints \" hello \"\n",
    "print (s.replace('l', '(ell)'))  # Replace all instances of one substring with another;\n",
    "                               # prints \"he(ell)(ell)o\"\n",
    "print ('  world '.strip())  # Strip leading and trailing whitespace; prints \"world\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Container Types\n",
    "Python includes several built-in container types: lists, dictionaries, sets, and tuples.\n",
    "\n",
    "**Lists** (reference https://docs.python.org/2/tutorial/datastructures.html#more-on-lists). A list is the Python equivalent of an array, but is resizeable and can contain elements of different types. It is created by using square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "xs = [3, 1, 2]   # Create a list\n",
    "print (xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each element of the list can be accessed using the bracket notation. Each element can be changed. The elements of the list do not have to be of the same type. Elements can be added or deleted using the appropriate methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[3, 'hello again', 2]\n",
      "<class 'list'> <class 'int'> <class 'str'>\n",
      "[3, 'hello again', 2, 99.99]\n",
      "2 [3, 'hello again', 99.99]\n"
     ]
    }
   ],
   "source": [
    "print (xs[0])             # the first element of a list has index 0\n",
    "xs[1] = 'hello again'   # changing the second element from integer to string type\n",
    "print (xs)\n",
    "print (type(xs), type(xs[0]), type(xs[1]))\n",
    "xs.append(99.99)     # add a new element at the end of the list\n",
    "print (xs)\n",
    "x = xs.pop(2)        # remove the third element and return its value\n",
    "print (x, xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can contain lists as elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3, 'hello again', 99.99], 1, 'hello']\n"
     ]
    }
   ],
   "source": [
    "xbig = [xs, 1, 'hello']\n",
    "print (xbig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to accessing list elements one at a time, Python provides concise syntax to access sublists; this is known as slicing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[2, 3, 4]\n",
      "[0, 1]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 1, 2, 3]\n",
      "[0, 1, 88, 99, 4]\n"
     ]
    }
   ],
   "source": [
    "nums = list(range(5))    # range is a built-in function that creates a list of integers\n",
    "print (nums)         # Prints \"[0, 1, 2, 3, 4]\"\n",
    "print (nums[2:4])    # Get a slice from index 2 to 4 (exclusive); prints \"[2, 3]\"\n",
    "print (nums[2:])     # Get a slice from index 2 to the end; prints \"[2, 3, 4]\"\n",
    "print (nums[:2])     # Get a slice from the start to index 2 (exclusive); prints \"[0, 1]\"\n",
    "print (nums[:])      # Get a slice of the whole list; prints [\"0, 1, 2, 3, 4]\"\n",
    "print (nums[:-1])    # Slice indices can be negative; prints [\"0, 1, 2, 3]\"\n",
    "nums[2:4] = [88, 99] # Assign a new sublist to a slice\n",
    "print (nums)         # Prints \"[0, 1, 88, 99, 4]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tuples** (reference: https://docs.python.org/2/tutorial/datastructures.html#tuples-and-sequences). A tuple is an (immutable) ordered list of values. It is defined using parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 6) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t = (5, 6)       # Create a tuple\n",
    "print (t, type(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple is in many ways similar to a list. One of the most important differences is that tuples can be used as keys in dictionaries (defined next) and as elements of sets, while lists cannot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(0, 1): 0, (1, 2): 1, (5, 6): 5, (2, 3): 2, (4, 5): 4, (3, 4): 3}\n",
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "dict2 = {(x, x + 1): x for x in range(6)}  # Create a dictionary with tuple keys (do not worry about the logic for now)\n",
    "print (dict2)\n",
    "print (dict2[t])       \n",
    "print (dict2[(1, 2)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "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-24-61296ef23657>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m         \u001b[0;31m# tuples are immutable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[0] = 1         # tuples are immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionaries** (reference: https://docs.python.org/2/library/stdtypes.html#dict). A dictionary stores (key, value) pairs called *items*, similar to a Map in Java or an object in Javascript. It is created using the curly braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cat': 'cute', 'dog': 'furry'} <class 'dict'>\n",
      "cute\n",
      "dict_keys(['cat', 'dog'])\n",
      "dict_values(['cute', 'furry'])\n",
      "dict_items([('cat', 'cute'), ('dog', 'furry')])\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "dct = {'cat': 'cute', 'dog': 'furry'}  # Create a new dictionary with some data\n",
    "print (dct, type(dct))\n",
    "print (dct['cat'])       # Get an entry from a dictionary; prints \"cute\"\n",
    "print (dct.keys())       # prints a list of all the keys\n",
    "print (dct.values())     # prints a list of all the values\n",
    "print (dct.items())      # prints a list of all (key,value) tuples\n",
    "print ('cat' in dct)     # Check if a dictionary has a given key; prints \"True\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is relatively straightforward to add new entries, modify the existing entries, or delete the existing entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wet\n",
      "{'cat': 'cute', 'fish': 'wet', 'dog': 'friendly'}\n",
      "{'fish': 'wet', 'dog': 'friendly'}\n",
      "{'fish': 'wet', 12: 8, 'dog': 'friendly'}\n"
     ]
    }
   ],
   "source": [
    "dct['fish'] = 'wet'      # Set an entry in a dictionary\n",
    "print (dct['fish'])        # Prints value of key 'fish'\n",
    "dct['dog'] = 'friendly'  # Change the value of key 'dog'\n",
    "print (dct)\n",
    "del dct['cat']          # Remove an element from a dictionary\n",
    "print (dct) \n",
    "dct[12] = 8             # keys and values in a dictionary can be of different types\n",
    "print (dct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, we may wish to obtain a value for a specific key, but do not know if the element exists. Making the following creates an error message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'monkey'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-e39ea5261532>\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[0mdct\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'monkey'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# KeyError: 'monkey' not a key of d\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'monkey'"
     ]
    }
   ],
   "source": [
    "print (dct['monkey'])  # KeyError: 'monkey' not a key of d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To prevent the error, the `get` method should be used (enter `help(\"dict\")` to learn about all the methods for `dict` type)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N/A\n",
      "wet\n"
     ]
    }
   ],
   "source": [
    "print (dct.get('monkey', 'N/A'))  # Get an element with a default; prints \"N/A\"\n",
    "print (dct.get('fish', 'N/A'))    # Get an element with a default; prints \"wet\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are very interesting from the data structures perspective -- they are related to the idea of hash tables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sets** (reference: https://docs.python.org/2/tutorial/datastructures.html#sets). A set is an unordered collection of distinct elements. It is defined using curly braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cat', 'dog'} <class 'set'>\n",
      "True\n",
      "False\n",
      "{'cat', 'dog'}\n",
      "{'dog'}\n"
     ]
    }
   ],
   "source": [
    "animals = {'cat', 'dog'}\n",
    "print (animals, type(animals))\n",
    "print ('cat' in animals)   # Check if an element is in a set; prints \"True\"\n",
    "print ('fish' in animals)  # prints \"False\"\n",
    "animals.add('cat')       # Adding an element that is already in the set does nothing\n",
    "print (animals)       \n",
    "animals.remove('cat')    # Remove an element from a set\n",
    "print (animals)      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control flow of Python\n",
    "Similarly to other languages, Python allows control flow through conditionals (e.g., if-else) and loops (e.g., for loops, while loops).\n",
    "\n",
    "## if-elif-else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive but smaller than 5\n"
     ]
    }
   ],
   "source": [
    "b = 2\n",
    "if b < 0:\n",
    "    print (\"It's negative\")\n",
    "elif b == 0:\n",
    "    print ('Equal to zero')\n",
    "elif 0 < b < 5:\n",
    "    print ('Positive but smaller than 5')\n",
    "else:\n",
    "    print ('Positive and larger than 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "As you can see, the main difference is in syntax. if-elif-else does not require parentheses. Instead, text indentation is used to identify blocks of code. Luckily, both *iPython notebook* and *Spyder* editors are helpful in avoiding syntax errors with the indentation.\n",
    "\n",
    "## While loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "128 256\n",
      "64 384\n",
      "32 448\n",
      "16 480\n",
      "8 496\n",
      "4 504\n",
      "finally, the values are:  4 504\n"
     ]
    }
   ],
   "source": [
    "x = 256\n",
    "total = 0\n",
    "while x > 0:\n",
    "    if total > 500:\n",
    "        break        # leaves the loop\n",
    "    total += x\n",
    "    x = x // 2\n",
    "    print (x, total)\n",
    "print ('finally, the values are: ', x, total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loops\n",
    "\n",
    "`for` loops are somewhat different than in Java, C, or Matlab. Rather than giving the user the ability to define both the iteration step and halting condition (as C), Python’s for statement iterates over the items of any sequence (e.g., list, string, dictionary), in the order that they appear in the sequence. You will learn to like for loops once you get used to them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "sum = 0\n",
    "for i in range(5):  # range(5) creates a list [0, 1, 2, 3, 4], 'i' are iterated through the values in this list \n",
    "    sum += i\n",
    "print (sum)           # reports the sum of the elements in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is another example that iterates through the elements of a provided list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "sequence = [1, 2, None, 4, None, 5]\n",
    "total = 0\n",
    "for value in sequence:\n",
    "    if value is None:      # what does keyword 'is' do?\n",
    "        continue           # skip the rest of the block, keep looping\n",
    "    total += value\n",
    "print (total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`for` loops can also be iterated over dictionary items "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "fish\n",
      "dog\n",
      "cat is cute\n",
      "fish is wet\n",
      "dog is furry\n"
     ]
    }
   ],
   "source": [
    "dct = {'cat': 'cute', 'dog': 'furry', 'fish': 'wet'}  # Create a new dictionary with some data\n",
    "for key in dct:                    # iterates over keys of a dictionary\n",
    "    print (key)\n",
    "for key,value in dct.items():      # items method returns a list of (key,value) pairs\n",
    "    print (key, 'is', value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The role of keword `in` might be confusing. If you are really curious about it, the following Stack Overflow post might be helpful http://stackoverflow.com/questions/38204342/python-in-keyword-in-expression-vs-in-for-loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## try-except-else-finally\n",
    "The `try-except-else-finally` control flow is very useful for handling of errors and exceptions in python code. It is very useful in data science, for example when dealing with the external files. You can read more about it in https://docs.python.org/2.7/reference/compound_stmts.html#try and https://docs.python.org/2/tutorial/errors.html#exceptions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions\n",
    "List comprehensions provide a concise way to generate lists and could come handy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "print ([x*x for x in range(1,6)])   # prints a list of the squares of the first 5 positive integers   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['BAT', 'CAR', 'DOVE', 'PYTHON']\n"
     ]
    }
   ],
   "source": [
    "strings = ['a', 'as', 'bat', 'car', 'dove', 'python']\n",
    "print ([x.upper() for x in strings if len(x) > 2])          # prints a list of uppercase words longer than 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'dove': 4, 'a': 0, 'python': 5, 'as': 1, 'bat': 2, 'car': 3}\n"
     ]
    }
   ],
   "source": [
    "print ({val:index for index, val in enumerate(strings)})    # prints a dictionary created from the strings list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "Python functions are defined using the `def` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negative\n",
      "0\n",
      "positive\n"
     ]
    }
   ],
   "source": [
    "def sign(x):             # defining function called sign\n",
    "    if x > 0:\n",
    "        return 'positive'\n",
    "    elif x < 0:\n",
    "        return 'negative'\n",
    "    else:\n",
    "        return 0         # function can return different types depending on input\n",
    "\n",
    "for x in [-1, 0, 1]:\n",
    "    print (sign(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are allowed to take optional keyword arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Bob!\n",
      "HELLO, FRED\n"
     ]
    }
   ],
   "source": [
    "def hello(name, loud=False):      # the second input is optional at the call time\n",
    "    if loud:\n",
    "        print ('HELLO, %s' % name.upper())\n",
    "    else:\n",
    "        print ('Hello, %s!' % name)\n",
    "\n",
    "hello('Bob')\n",
    "hello('Fred', True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is much more to functions. A good starting point to learn more is at https://docs.python.org/2/tutorial/controlflow.html#defining-functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes\n",
    "The syntax for defining classes in Python is not surprising. Doing good data science does not require writing new classes, but understanding how they are created might be insightful. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Fred\n",
      "HELLO, FRED!\n"
     ]
    }
   ],
   "source": [
    "class Greeter:\n",
    "\n",
    "    # Constructor\n",
    "    def __init__(self, name):\n",
    "        self.name = name  # Create an instance variable\n",
    "\n",
    "    # Instance method\n",
    "    def greet(self, loud=False):\n",
    "        if loud:\n",
    "            print ('HELLO, %s!' % self.name.upper())\n",
    "        else:\n",
    "            print ('Hello, %s' % self.name)\n",
    "\n",
    "g = Greeter('Fred')  # Construct an instance of the Greeter class\n",
    "g.greet()            # Call an instance method; prints \"Hello, Fred\"\n",
    "g.greet(loud=True)   # Call an instance method; prints \"HELLO, FRED!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, functions are \"first-class\". This is just a fancy way of saying, you can pass functions to other functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 4 <function <lambda> at 0x11751f8c8>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum_of_anything(x,y,f):\n",
    "    print (x,y,f)\n",
    "    return(f(x) + f(y))\n",
    "sum_of_anything(3,4,lambda x: x*x)       # lambda describes (an anonymous) square function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For those wanting to learn more about functions, a good starting point is at https://docs.python.org/2/tutorial/classes.html."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scripts, Modules and Packages\n",
    "**Scripts**. If you quit from the Python interpreter and restart it, all the code you have run, including the definitions, are lost. To reuse the code, it is a good idea to use a text editor to save the reusable code. A typical extension for the saved file would be `.py`. In *Spyder*, you can paste any code from the above in a `.py` file, let us say `test.py`, save in the current directory and type `execfile(\"test.py\")` in the console. This is known as creating and running a *script*. You can also run your script by pressing the *Play* icon in the menu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Modules and Packages**. Any Python file with the `.py` extension is a module. If the file contains useful definitions that you would like to use, there is a simple mechanism to *import* it. Python comes with a library of standard modules, described in https://docs.python.org/2/library/datetime.html. A package is a collection of Python modules. While a module is a single Python file, a package is a directory of Python modules. Anaconda software comes with a list of packages (see https://docs.continuum.io/anaconda/pkg-docs) that could be imported in the same way as standard library modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-01-17\n",
      "[[0.49001389 0.81145069 0.32994733]\n",
      " [0.72304054 0.19739581 0.85601242]\n",
      " [0.81468338 0.89218194 0.89003963]\n",
      " [0.30719941 0.99247949 0.48362604]] \n",
      "\n",
      "[[0.51916655 0.5834257  0.38261238]\n",
      " [0.60015176 0.69566121 0.55597814]\n",
      " [0.67763756 0.0895077  0.51687756]\n",
      " [0.87755316 0.49344557 0.65753546]] \n",
      "\n",
      "[[0.53914935 0.9018071  0.14329249]\n",
      " [0.65639863 0.18294836 0.83777705]\n",
      " [0.28927828 0.94551603 0.18592748]\n",
      " [0.67273743 0.79493168 0.51041504]]\n"
     ]
    }
   ],
   "source": [
    "import datetime                 # this is a standard Python module\n",
    "print (datetime.date(2017,1,17))  # uses method data from module datetime to create a date object and prints its value\n",
    "import numpy                    # this is a very popular package in the Anaconda release\n",
    "print (numpy.random.rand(4,3), '\\n')    # prints out a 4x3 array of random numbers\n",
    "import numpy as np              # provides an alias for numpy, allows shorter codes\n",
    "print (np.random.rand(4,3), '\\n')       # also prints out a 4x3 array of random numbers\n",
    "from numpy.random import rand   # allows us to directly call numpy.random.rand function as rand\n",
    "print (rand(4,3))                 # also prints out a 4x3 array of random numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Navigating the Python universe\n",
    "This tutorial provides just a glimpse at Python. For experienced programmers, Library reference and Language reference in https://docs.python.org/2.7/index.html describe almost all we need to know about Python and its standard modules, but those documents are a bit dense for beginners. It would probably take too much time for a typical student to learn Python by going through those references. Moreover, those references do not contain any information about non-standard library packages developed by a large number of volunteers around the world. The appeal and power of Python lies largely in those packagesFor example, some of those packages, such as `numpy`, `scipy`, `pandas`, `matplotlib`, `scikit-learn` have become the standard tools of a modern data scientist. The question is how to proceed with learning Python and many of its important packages?  \n",
    "\n",
    "Probably the best advice is to learn Python by doing it and by using online and printed resources. \n",
    "- **online tutorials**, many of them available as `ipynb` files, such as the ones used to create this document\n",
    "- **online reference materials** provided with packages: Scipy and Numpy (https://docs.scipy.org/doc/), Pandas (http://pandas.pydata.org/pandas-docs/stable/index.html), Matplotlib (http://matplotlib.org/), Scikit-learn (http://scikit-learn.org/stable/)\n",
    "- **google search**: many, if not most, of the programming-related questions queried with Google have an answer and often lead to the Stack Overflow, which has a huge repository of all kinds of questions related to programming, including programming in Python. Querying of Stack Overflow using Google search is so successful, that some computer scientists are jokingly saying that programming is an art of copying code from Stack Overflow. Of course, Google search has a much wider reach and allows us to access extremely valuable resources. Just to whet the appetite, let us enter \"python for data analysis ipynb\" and observe some great resources and tutorials for data scientists.\n",
    "- **books** such as \"python for data scientists\". This particular book comes with an online appendix with all the code used in the book (https://github.com/wesm/pydata-book). Some books come available in both print and electronic formats.\n",
    "\n",
    "In the context of CIS3715 course, you should feel free to browse internet and copy or modify the existing code, as long as you acknowledge your source. It is also completely OK to talk to your class colleagues. However, in this case, in addition to acknowledging any help, please be careful to refrain from copying homework and lab solutions from your colleagues. In case of doubt, please consult your instructors."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}