ZCI_SS_Day1_00_Basic_instructions_SOLVED.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr><hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Science Summer School - Split '16 </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 1 - Python for data analysis fundamentals \n",
    "### *Numpy, Pandas, Matplotlib*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(c) 2016 Damir Pintar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*version: 0.1* \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`kernel: Python 2.7`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr><hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 0 - Basic instructions / Python refresher"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Instructions for using Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a Jupyer Notebook. It represents an interactive computational environment, in which you can combine code execution, rich text, mathematics, plots and rich media."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below you can see a portion of executable programming code, denoted by different visual representation than \"regular\" text. You can run this code by selecting the cell and pressing SHIFT + ENTER. Do it now. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print \"Hello!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the code was run \"behind\" the scenes and its results are shown in the notebook right under the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can place more lines of code in the code cell. Try running the cell below. Also, this time use ALT+ENTER instead of SHIFT."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 5\n",
    "print a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, ALT+ENTER runs the code but creates an additional programming cell under the result. This is useful if you want to perform some additional experimenation with the code in a certain part of the document. If you don't want this additonal cell, you can delete it by pressing the \"scissors\" symbol in the toolbar above. Also, by choosing `Insert -> Insert Cell Above / Insert Cell Below` you can create additional cells whenever you want in the document. You can even put \"markdown\" text instead of code in them if you want, by typing text and then changing the cell type above from `Code` to `Markdown`, but for the purposes of this Notebook we will presume that you will be filling out exclusevily the programming code portions of the Notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IMPORTANT: The code portions you see above aren't standalone, and nstructions you run are \"remembered\" in later code snippets. You can think of this notebook as a one big interactive session in which all the code snippets are a part ot a big script, even though they visually look disconnected. We can prove this by trying to print the variable `a` again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How about printing x?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are getting an error - variable `x` is not defined. Try to define it in an earlier code cell, run that cell and then try to run the above one again. Notice that the error is not present anymore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If at any time you want to clear all the results from a cell (or reset cells in the entire Notebook), choose `Cell -> Current Output -> Clear` or `Cell -> All Outputs -> Clear`. Notice that this way you are only clearing the *printed results* but the session is still running behind the scenes, and all the variables, functions and imported packages are still present. If you want to clear the session, choose `Kernel -> Restart & Clear Output`. Also, remember that at any tima you can save the current state of the Notebook by choosing `File -> Save and Checkpoint` or create a backup copy by choosing `File -> Make a Copy..`. You can also try to convert this Notebook into additional formats, such as `html` or `pdf`, by choosing `Download as..`. Note that certain formats might require that you install some additional packages first."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feel free to explore and experiment with additional options you are provided through the toolbar and the menu options. It might be wise though to first create a backup copy so all potentially unwanted changes you make aren't permanent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is it for the appetizer - now on to the main course! :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Python for data analysis "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quick Python refresher"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a general-purpose, object-oriented, high-level programming language which encourages producing clean, concise, highly readable programming code. Python supports various programming paradigms - such as object-oriented, imperative, functional or procedural programming. By its nature, Python isn an interpreted language which can be used interactively (running each programming instruction separately in an interactive programming session) or by writing and running programming scripts (which may or may note be compiled in entirety before running). Python supports organizing code into \"packages\" or \"module\" which encourage modular programming and code re-use. In recent years the addition of polished, high-quality packages oriented towards data analysis have resulted in establishing the Python language as one of the leading competitors for an open, flexible data analysis platform suited for various statistical analysis, machine learning and data mining tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some characteristics of Python language (in short):\n",
    "- gentle learning curve\n",
    "- implicit data typing\n",
    "- strict rules of code formatting (enforced block tabulation)\n",
    "- \"everything is an object\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do a lightning refresher of Python basics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# primitive data types\n",
    "a = 5         # int\n",
    "b = 3.2       # float\n",
    "c = 10e2      # float, scientific notation\n",
    "d = \"Pero\"    # str\n",
    "e = True      # bool\n",
    "f = None      # NoneType, variable holds \"no specific value\"\n",
    "\n",
    "# complex data types\n",
    "x = [1, 2, True, \"Ana\", None, [1,2,3,4]]      # list - ordered set of elements of mixed types\n",
    "d = {'jedan':1, 'dva':\"dva\", 'tri':[3,3,3]}   # dictionary - stores mixed-type elements on key-value principle\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We access the values from stored variables in the following ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b  # same as `print b`, we are using the so called `autoprint` feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x   # x is a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x[2] # accessing the third element of the list (remember, first index is 0!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d[\"dva\"]  # accesing a dictionary value by key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### LIst management"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Various ways for list creation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = list(range(10))                  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "y = list(range(1, 10, 2))            # [1, 3, 5, 7, 9]\n",
    "w = 5 * [0]                          # [0, 0, 0, 0, 0]\n",
    "v = [0.1 * p for p in range(5)]      # [0, 0.1, 0.2, 0.3, 0.4]    - this is so-called \"list comprehension\"\n",
    "z = list()                           # empty list\n",
    "\n",
    "\n",
    "# try printing out the above variables to see what they contain\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Cutting, merging and modifying lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# addition operator (+) is used for list merging (concatenating)\n",
    "x = [1,2,3] + [4,5,6]\n",
    "x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#    0  1  2  3  4  5  6  7  8  9              list indexes\n",
    "x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "x[1:3]    # retreive indexes from 1 (inclusive) to 3 (exclusive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x[:-5]    # no index means \"all\"; negative index means \"count from the end,  -1 being the last element\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x[3:5] = [10, 20]       # modifying list elements\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "del(x[:2])     # deleting list elements\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y = x[:]      # list copying; if we simply do x = y we will just get two references to the same object\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is it for this quick Python refresher. If you want, you can try the additional exercises provided below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> <hr> <hr>\n",
    "## <font color = \"blue\">Exercises\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Python can sort lists. You can use the function sorted())\n",
    "a = [12, 5, 20, 7, 99, 4, 8, 69]\n",
    "print(\"Sorted list:\" + str(sorted(a)))     # (str changes integers to strings)\n",
    "\n",
    "# but this doesn't change the list itself, instead it makes a sorted copy.\n",
    "\n",
    "# If you want to modify the list so it becomes soted, use the method sort() of the list itself. \n",
    "# Call the method sort() and print out the results.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Why not reverse the list with the method reverse()? Print out the result.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Now remove the first and last element from the list using only one instruction. Print out the result.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Check out the length of the list by using the function len()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Is the number 99 still in the list? Check this without printing out the list itself. Use the operator 'in'\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Print out the smallest and largest number in this list by using functions min() and max()\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Finally, using conditional list comprehension, change all the even numbers from this list to 0\n",
    "# you can use the following template as a guide\n",
    "\n",
    "# a = [ _____ if _____ else ____ for i in a  ]\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr><hr><hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href = \"https://docs.python.org/3/tutorial/\">[1]</a> *The Python tutorial*, official Python documentation, last accessed 2016/08/26"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href = \"http://opentechschool.github.io/python-data-intro/core/notebook.html\">[2]</a> *Introducing IPython Notebook*, OpenTechSchool tutorial, last accessed 2016/08/27"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href = \"http://interactivepython.org/runestone/static/pythonds/index.html\">[3]</a> *Problem Solving with Algorithms and Data Structures using Python*, Brad Miller and David Ranum, Luther College, last accessed 2016/08/27"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [py2]",
   "language": "python",
   "name": "Python [py2]"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}