01_GettingStarted.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Started\n",
    "\n",
    "This tutorial is based on [Jupyter Notebook](http://jupyter.org/). Jupyter Notebook is 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 as [Mathematica](http://www.wolfram.com/mathematica/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Installation\n",
    "\n",
    "[Anaconda](https://www.continuum.io/downloads) is a free Python distribution that includes the most common Python packages for data analysis out-of-the-box. Prebuilt packages for the different platforms make it simple to use.\n",
    "\n",
    "> TASK: Install Anaconda on your machine.\n",
    ">\n",
    "> As alternative, you can use the deployed version directly: [![Binder](http://mybinder.org/badge.svg)](http://mybinder.org:/repo/mstreit/ipython-tutorial-va2017)\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 `Seaborn` is already included in Anaconda by default. \n",
    "\n",
    "> TASK: Open a shell (bash, cmd) and execute: \n",
    "\n",
    "```bash\n",
    "conda install seaborn\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Deployment\n",
    "\n",
    "Deploying Jupyter Notebooks is easy. [mybinder.org](http://mybinder.org) provides you with a free service that turns a Github repository into a collection of interactive notebooks that are accessible online. \n",
    "\n",
    "**Hint:** If you have an `index.ipynb` notebook inside a directory, this will be used by default."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Usage\n",
    "\n",
    "Launch Jupyter Notebooks by opening a command line, navigate to the desired directory and execute: \n",
    "\n",
    "```bash\n",
    "jupyter notebook\n",
    "```\n",
    "\n",
    "This will open your web-browser with the Jupyter dev environment in the current working directory. We are using this interactive tutorial as a starting point. Clone it, navigate to it, and launch Jupyter Notebook. \n",
    "\n",
    "> TASK: clone this tutorial repository and launch the IPython environment inside of it.\n",
    "\n",
    "```bash\n",
    "git clone https://github.com/mstreit/python-tutorial-VA2017.git\n",
    "cd python-tutorial-VA2017\n",
    "jupyter notebook\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First Steps\n",
    "\n",
    "A Juypter Notebook 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": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#include some package that we use later on\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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?\n",
    "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": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3+4\n",
    "10/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(5+2)\n",
    "3+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7777777777777778"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5+2\n",
    "b = 9\n",
    "a/b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 9,
     "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": 10,
   "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": 11,
   "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": 12,
   "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": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'large'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = 'small' if a < 5 else 'large'\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}