01_GettingStarted.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Started\n",
    "\n",
    "During this tutorial, we are using [IPython/Jupyter Notebooks](http://ipython.org/notebook.html). Jupyter notebooks are a web based Python development environment allowing you to combine documentation (markdown), code, and their results into a single document. This follows a similar idea to [Mathematica](http://www.wolfram.com/mathematica/). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation\n",
    "\n",
    "[Anaconda](https://www.continuum.io/downloads) is a free Python distribution including the most common Python packages for data analysis out of the box. Prebuild packages for the different platforms make it simply to use it and getting started quickly.\n",
    "\n",
    "> TASK: Install Anaconda on your machine (*Please select the Python 3 download and in the lab the 32-bit version*)\n",
    ">\n",
    "> alternative use use the deployed version directly: [![Binder](http://mybinder.org/badge.svg)](http://mybinder.org/repo/sgratzl/ipython-tutorial-VA2015)\n",
    "\n",
    "We use different frameworks/libraries in this tutorial:\n",
    " * [Numpy](http://www.numpy.org/) and [Pandas](http://pandas.pydata.org/) for data manipulation\n",
    " * [Matplotlib](http://matplotlib.org/) and [Seaborn](http://stanford.edu/~mwaskom/software/seaborn/) for visualization\n",
    " * [Scikit-learn](http://scikit-learn.org) for simple machine learning\n",
    "\n",
    "Everything except for `Seaborn` is already included in Anaconda by default. So, lets install it. \n",
    "\n",
    "> TASK: Open a shell (bash, cmd) and execute: \n",
    "\n",
    "```bash\n",
    "conda install seaborn\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deployment\n",
    "\n",
    "Deploying Jupyter notebooks is quite simple. [mybinder.org](http://mybinder.org) provides you with a free service that turns a Github repository into an collection of interactive notebooks accessible online. \n",
    "\n",
    "**Hint:** If you have an `index.ipynb` notebook inside of a directory, this will be the default one. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Usage\n",
    "\n",
    "Launching Jupyter is simple, just go to a command line, navigate to your desired directory and execute: \n",
    "\n",
    "```bash\n",
    "ipython notebook\n",
    "```\n",
    "\n",
    "This will open your webbrowser with the IPython dev environment in the current working directory. We are using this interactive tutorial as starting point. Clone it, navigate to it and launch ipython notebooks. \n",
    "\n",
    "> TASK clone this tutorial repository and launch the ipython environment inside of it\n",
    "\n",
    "```bash\n",
    "git clone https://github.com/sgratzl/ipython-tutorial-VA2015.git\n",
    "cd ipython-tutorial-VA2015\n",
    "ipython notebook\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First Steps\n",
    "\n",
    "Juypter notebooks consists of individual cells. There are two major cell types: Code and Markdown. \n",
    "\n",
    "Useful keyboard shortcuts: \n",
    "* **Enter**: enter edit mode of the selected cell\n",
    "* **Shift-Enter**: run cell, select below\n",
    "* **Ctrl-Enter**: run cell\n",
    "* **Alt-Enter**: run cell, insert a new cell below\n",
    "\n",
    "Getting Help: \n",
    "\n",
    "* **Tab** code completion or indent\n",
    "* **Shift-Tab** for a function, e.g. argument list\n",
    "* `function?` query the python docstring for the given function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#include some package which we use later on\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#test np.ar -> tab\n",
    "a = np.array([1,2,3,4])\n",
    "#test np.array -> shift-tab or np.array?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive Python basics\n",
    "\n",
    "Python is an untyped dynamic language. The last output of a cell line will be printed. Individual values can also be printed using the `print(...)` function. Variables are just declared and assigned. Function are first level objects and Python can be used to program in a functional style. Some simple examples:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3+4\n",
    "10/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(5+2)\n",
    "3+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7777777777777778"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5+2\n",
    "b = 9\n",
    "a/b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum(a,b): #indent is important in Python!\n",
    "    return a+b\n",
    "sum(4,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum  16\n",
      "sub -2\n"
     ]
    }
   ],
   "source": [
    "def sub(arg1,arg2):\n",
    "    return arg1-arg2\n",
    "def calc(f, a, b):\n",
    "    return f(a,b)\n",
    "#functions are first level objects, e.g., can be passed as argument to another function\n",
    "print('sum ', calc(sum, a, b))\n",
    "print('sub', calc(sub, a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n",
      "{'a': 'ALPHA', 'b': 'BETA'}\n"
     ]
    }
   ],
   "source": [
    "#array\n",
    "arr = [1,2,3,4]\n",
    "#maps aka dictionaries/dicts\n",
    "dictionary = { 'a': 'Alpha', 'b': 'Beta'}\n",
    "\n",
    "#array transformation\n",
    "arr2 = [ a * 2 for a in arr]\n",
    "dict2 = { k : v.upper() for k,v in dictionary.items()}\n",
    "\n",
    "print(arr2)\n",
    "print(dict2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "large\n"
     ]
    }
   ],
   "source": [
    "if a < 5:\n",
    "    print ('small')\n",
    "else:\n",
    "    print ('large')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'large'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = 'small' if a < 5 else 'large'\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#what else: generators, iterators, classes, tuples, ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next\n",
    "\n",
    "[Data Manipulation with Numpy and Pandas](02_DataManipulation.ipynb)"
   ]
  }
 ],
 "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
}