0.1-intro-to-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ML at Grad Days 2017\n",
    "\n",
    "This session on machine learning (ML) contains some practice.\n",
    "\n",
    "There is no ML practice without programming, and among available (free) environments for machine learning \n",
    "Jupyter (with **python** language) is the most widespread.\n",
    "\n",
    "This notebook is an introduction to the environment: basic python and Jupyter stuff. \n",
    "\n",
    "Let's take a small tour of Jupyter:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter (formerly IPython)\n",
    "\n",
    "Jupyter format, notebooks, is a very flexible tool to create readable analyses, because one can keep code, images, comments, formula and plots together:\n",
    "\n",
    "<img src='http://jupyter.org/assets/jupyterpreview.png' width=\"600\" />\n",
    "\n",
    "Jupyter is quite extensible, supports many programming languages, easily hosted on almost any server — you only need to have `ssh` or `http` access to a server. And it is completely free."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cells\n",
    "\n",
    "The first thing to understand is that a notebook consists of a sequence of 'cells' that can be:\n",
    "\n",
    "* Text cells (like this one) can be written using [Markdown syntax](http://daringfireball.net/projects/markdown/syntax) \n",
    "\n",
    "* Code cells for execution (like next one), i.e. python code, `%magics`, `!system calls`, etc.\n",
    "\n",
    "Below, there is a code cell with the sum of two constant values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shortcuts\n",
    "* **`Esc+h` provides all shortcuts**\n",
    "* `Shift-Enter` - use it to execute a cell; \n",
    "* pressing `Enter` will add a new line of text to the cell.  \n",
    "\n",
    "When you type \n",
    "`Shift-Enter`, the cell content is executed, output displayed and passes to the next cell or new cell is created below.\n",
    "\n",
    "\n",
    "You can re-execute the same cell over and over as many times as you want.  Simply put your\n",
    "cursor in the cell again, edit at will, and type `Shift-Enter` to execute.  \n",
    "\n",
    "* To create a new cell above current cell press `Esc+a`\n",
    "* To create a new cell below current cell press `Esc+b`\n",
    "* To remove the current cell press `Esc+d+d`\n",
    "* To edit a cell, put cursor in the cell and press `Enter`\n",
    "\n",
    "Created cell is a code cell. To change it to markdown cell press `Esc+m` and write text: for example formula in latex\n",
    "\n",
    "$$\n",
    "    P(A|B)=\\frac{P(B|A)P(A)}{P(B)}\n",
    "$$\n",
    "\n",
    "To save the notebook use `Cmd+s` or `Ctrl+s`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Downloading notebook\n",
    "To download the notebook go `\"File\"->\"Download as\"` and choose the format, e.g. `.ipynb`, `.py`, etc. In case of python format the notebook will be automatically converted into `.py` file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python: assignment\n",
    "The assignment operator in python is =. In python you do not need to specify the type of a variable when you create one.\n",
    "\n",
    "Assigning a value to a new variable creates the variable (after cell execution this variable will be available in any cell):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 1e-5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although not explicitly specified, a variable does have a type associated with it. The type is derived from the value that was assigned to it. You can use the `type()` function to check the type of a given variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10 1e-05 <type 'int'> <type 'float'>\n"
     ]
    }
   ],
   "source": [
    "# print the varibale defined above\n",
    "print x\n",
    "# print several things using comma\n",
    "print x, y, type(x), type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we assign a new value to a variable, its type can change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'int'>\n",
      "<type 'float'>\n"
     ]
    }
   ],
   "source": [
    "print type(x)\n",
    "x = 1.2\n",
    "print type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments\n",
    "\n",
    "There are two ways to comment the code in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# one-line comment, define x = 1\n",
    "x = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    "This is a multi-line comment.\n",
    "\n",
    "Below we define constant variable x with value 1\n",
    "'''\n",
    "x = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python: fundamental types\n",
    "\n",
    "There is a small number of different core value types built-in to python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 <type 'int'>\n",
      "1.4 <type 'float'>\n",
      "True False\n"
     ]
    }
   ],
   "source": [
    "# integers\n",
    "x = 1\n",
    "print x, type(x)\n",
    "\n",
    "# float\n",
    "y = 1.4\n",
    "print y, type(y)\n",
    "\n",
    "# boolean\n",
    "t = True\n",
    "f = False\n",
    "print t, f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False True\n"
     ]
    }
   ],
   "source": [
    "# check if the variable x is a float\n",
    "print type(x) is float, type(x) is int, "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the `isinstance` method for testing types of variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(x, float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### None\n",
    "\n",
    "The value `None` is a special object in python that is used to show that a variable was declared, but was explicitly set to contain nothing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "none_x = None\n",
    "print none_x\n",
    "print none_x is None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type casting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4 <type 'float'>\n",
      "1 <type 'int'>\n"
     ]
    }
   ],
   "source": [
    "print y, type(y)\n",
    "y_new = int(y)\n",
    "print y_new, type(y_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python: operators and comparisons\n",
    "\n",
    "Most operators and comparisons in python work as one would expect:\n",
    "* Arithmetic operators `+, -, *, /, //` (integer division), '**' power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, -1.0999999999999999, 2.3, 5)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2, 1.2 - 2.3, 1 * 2.3, 11 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5.0, 5.5)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Integer division of float numbers\n",
    "11.0 // 2.0, 11. / 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note! The power operators in python isn't ^, but **\n",
    "2 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True, True)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False, not False, True or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Comparison operators >, <, >= (greater or equal), <= (less or equal), == equality, is identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False, True, True, False, False)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 1, 2 < 1, 2 >= 2, 2 <= 2, 1 == 0, True == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python: compounds types (strings, lists, dictionaries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### String\n",
    "Strings are used for storing text messages.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Hello world\"\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "Hello test\n"
     ]
    }
   ],
   "source": [
    "# length of the string\n",
    "print len(s)\n",
    "# replace a substring in a string with something else\n",
    "s2 = s.replace(\"world\", \"test\")\n",
    "print s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index a string using `[]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H e Hello Hello\n"
     ]
    }
   ],
   "source": [
    "print s[0], s[1], s[0:5], s[:5],"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also define the step size using the syntax [start:end:step]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hlowrd\n",
      "Hello world\n",
      "dlrow olleH\n"
     ]
    }
   ],
   "source": [
    "print s[::2]\n",
    "print s[::1]\n",
    "print s[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1\n",
    "\n",
    "Print slice equal to **`world`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code should print \"world\"\n",
    "# s[???]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str1 str2 str3\n",
      "str1 1.0 False -1j\n",
      "str1str2str3\n"
     ]
    }
   ],
   "source": [
    "print \"str1\", \"str2\", \"str3\"  # The print statement concatenates strings with a space\n",
    "print \"str1\", 1.0, False, -1j  # The print statements converts all arguments to strings\n",
    "print \"str1\" + \"str2\" + \"str3\" # strings added with + are concatenated without space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value1 = 3.14. value2 = 1\n"
     ]
    }
   ],
   "source": [
    "# this formatting creates a string\n",
    "s2 = \"value1 = %.2f. value2 = %d\" % (3.1415, 1.5)\n",
    "print s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value1 = 3.1415, value2 = 1.5\n"
     ]
    }
   ],
   "source": [
    "# alternative, more intuitive way of formatting a string \n",
    "s3 = 'value1 = {0}, value2 = {1}'.format(3.1415, 1.5)\n",
    "\n",
    "print s3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List\n",
    "Lists are very similar to strings, except that each element can be of any type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'list'>\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3,4]\n",
    "\n",
    "print type(l)\n",
    "print l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[1, 3]\n"
     ]
    }
   ],
   "source": [
    "# slicing is the same as for strings (indexing starts at zero!)\n",
    "print l\n",
    "print l[1:3]\n",
    "print l[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python lists can be inhomogeneous and arbitrarily nested:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, [2, [3, [4, [5]]]]]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nested_list = [1, [2, [3, [4, [5]]]]]\n",
    "\n",
    "nested_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a number of convenient functions for generating lists of various types, for example the range function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = 10\n",
    "stop = 30\n",
    "step = 2\n",
    "\n",
    "range(start, stop, step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']\n"
     ]
    }
   ],
   "source": [
    "s = \"Hello world\"\n",
    "# converting to list\n",
    "s2 = list(s)\n",
    "print s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']\n"
     ]
    }
   ],
   "source": [
    "# sorting\n",
    "s2.sort()\n",
    "print s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding, inserting, modifying, and removing elements from lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'd', 'd']\n"
     ]
    }
   ],
   "source": [
    "# create a new empty list\n",
    "l = []\n",
    "\n",
    "# add an elements using `append`\n",
    "l.append(\"A\")\n",
    "l.append(\"d\")\n",
    "l.append(\"d\")\n",
    "\n",
    "print l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['g', 'd', 'd']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# modify some values\n",
    "l[0] = 'g'\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['g', 'A', 'd', 'd']\n"
     ]
    }
   ],
   "source": [
    "# insering to a specific position\n",
    "l.insert(1, \"A\")\n",
    "print l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['g', 'd', 'd']\n"
     ]
    }
   ],
   "source": [
    "l.remove(\"A\")\n",
    "print l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples are like lists, except that they cannot be modified once created"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30) <type 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "point = (10, 20, 30)\n",
    "\n",
    "print point, type(point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30\n"
     ]
    }
   ],
   "source": [
    "# unpack a tuple by assigning it to a comma-separated list of variables:\n",
    "x, y, z = point\n",
    "print x, y, z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# this does not work, will raise an error!\n",
    "# point[0] = 20 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "Dictionaries are also like lists, except that each element is a key-value pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'dict'>\n",
      "{'parameter1': 1.0, 'parameter3': 3.0, 'parameter2': 2.0}\n"
     ]
    }
   ],
   "source": [
    "params = {\"parameter1\" : 1.0,\n",
    "          \"parameter2\" : 2.0,\n",
    "          \"parameter3\" : 3.0,}\n",
    "\n",
    "print type(params)\n",
    "print params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "params['parameter1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'new': 100, 'new2': 20}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# creating an empty dict \n",
    "params = dict()\n",
    "# adding new entry\n",
    "params['new'] = 100\n",
    "params['new2'] = 20\n",
    "params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['new2', 'new']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# take the list of keys:\n",
    "params.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[20, 100]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# take the list of values (in the same order as keys)\n",
    "params.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('new2', 20), ('new', 100)]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or both (list of pairs), keys and corresponding values\n",
    "params.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python: loading libraries \n",
    "\n",
    "To use a module in a python program it first has to be imported. For example, to import the module `math`, which contains many standard mathematical functions, we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This includes the whole module and makes it available for use later:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "x = math.cos(2 * math.pi)\n",
    "\n",
    "print x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can chose to `import` only a few selected symbols from a module by explicitly listing which ones we want to import:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "from math import cos, pi\n",
    "\n",
    "x = cos(2 * pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the function `help` we can get a description of each function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function cos in module math:\n",
      "\n",
      "cos(...)\n",
      "    cos(x)\n",
      "    \n",
      "    Return the cosine of x (measured in radians).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(cos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell you can call documentation using `Shift-Tab` or more detailed documentation with `Shift-Tab-Tab` with a pointer position in the brackets:\n",
    "![](https://pbs.twimg.com/media/CQBe6eQUkAAvhV_.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tab completion\n",
    "\n",
    "The notebook uses the underlying machinery for tab completion. When you complete with the Tab key, Jupyter shows a drop list with available completions. You can select the completion you want with the arrow keys or the mouse, and then hit Enter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python: if...elif...else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value is ok\n"
     ]
    }
   ],
   "source": [
    "# if statement in python\n",
    "x = 2\n",
    "if x >= 10:\n",
    "    print \"x > 10\"\n",
    "elif x % 5 == 0:\n",
    "    print \"x < 0\"\n",
    "else:\n",
    "    print \"value is ok\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# another example: test if list contains zero\n",
    "x = [1, 2]\n",
    "if 0 not in x:\n",
    "    # do nothing\n",
    "    pass\n",
    "else:\n",
    "    print \"List contains zero\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Executing shell commands\n",
    "\n",
    "You can call any shell (bash) command. \n",
    "\n",
    "This in particular useful to manage your virtual environment using \"`!pip install library`\" command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 248K\r\n",
      "drwxr-xr-x  4 root root 4.0K Apr  3 15:37 .\r\n",
      "drwxr-xr-x 23 root root 4.0K Apr  3 15:36 ..\r\n",
      "drwxrwxr-x  8 root root 4.0K Apr  3 15:36 .git\r\n",
      "-rw-rw-r--  1 root root 1.1K Apr  3 15:36 .gitignore\r\n",
      "drwxr-xr-x  2 root root 4.0K Apr  3 15:37 .ipynb_checkpoints\r\n",
      "-rw-rw-r--  1 root root  41K Apr  3 15:37 0.1-intro-to-python.ipynb\r\n",
      "-rw-rw-r--  1 root root  16K Apr  3 15:37 0.2-introduction-to-numpy.ipynb\r\n",
      "-rw-rw-r--  1 root root 3.5K Apr  3 15:37 1.1-challenge-intro.ipynb\r\n",
      "-rw-rw-r--  1 root root 134K Apr  3 15:37 1.2-linear-models.ipynb\r\n",
      "-rw-rw-r--  1 root root  20K Apr  3 15:37 1.3-sparse-matrix.ipynb\r\n",
      "-rw-rw-r--  1 root root  639 Apr  3 15:36 Dockerfile\r\n",
      "-rw-rw-r--  1 root root  985 Apr  3 15:36 README.md\r\n"
     ]
    }
   ],
   "source": [
    "# run ls shell command\n",
    "!ls -lah"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/notebooks\r\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Magic\n",
    "\n",
    "Magics are turning simple python into *magical* python. Magics are the key to power of this tool."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/json": {
       "cell": {
        "!": "OSMagics",
        "HTML": "Other",
        "SVG": "Other",
        "bash": "Other",
        "capture": "ExecutionMagics",
        "debug": "ExecutionMagics",
        "file": "Other",
        "html": "DisplayMagics",
        "javascript": "DisplayMagics",
        "js": "DisplayMagics",
        "latex": "DisplayMagics",
        "perl": "Other",
        "prun": "ExecutionMagics",
        "pypy": "Other",
        "python": "Other",
        "python2": "Other",
        "python3": "Other",
        "ruby": "Other",
        "script": "ScriptMagics",
        "sh": "Other",
        "svg": "DisplayMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "writefile": "OSMagics"
       },
       "line": {
        "alias": "OSMagics",
        "alias_magic": "BasicMagics",
        "autocall": "AutoMagics",
        "automagic": "AutoMagics",
        "autosave": "KernelMagics",
        "bookmark": "OSMagics",
        "cat": "Other",
        "cd": "OSMagics",
        "clear": "KernelMagics",
        "colors": "BasicMagics",
        "config": "ConfigMagics",
        "connect_info": "KernelMagics",
        "cp": "Other",
        "debug": "ExecutionMagics",
        "dhist": "OSMagics",
        "dirs": "OSMagics",
        "doctest_mode": "BasicMagics",
        "ed": "Other",
        "edit": "KernelMagics",
        "env": "OSMagics",
        "gui": "BasicMagics",
        "hist": "Other",
        "history": "HistoryMagics",
        "killbgscripts": "ScriptMagics",
        "ldir": "Other",
        "less": "KernelMagics",
        "lf": "Other",
        "lk": "Other",
        "ll": "Other",
        "load": "CodeMagics",
        "load_ext": "ExtensionMagics",
        "loadpy": "CodeMagics",
        "logoff": "LoggingMagics",
        "logon": "LoggingMagics",
        "logstart": "LoggingMagics",
        "logstate": "LoggingMagics",
        "logstop": "LoggingMagics",
        "ls": "Other",
        "lsmagic": "BasicMagics",
        "lx": "Other",
        "macro": "ExecutionMagics",
        "magic": "BasicMagics",
        "man": "KernelMagics",
        "matplotlib": "PylabMagics",
        "mkdir": "Other",
        "more": "KernelMagics",
        "mv": "Other",
        "notebook": "BasicMagics",
        "page": "BasicMagics",
        "pastebin": "CodeMagics",
        "pdb": "ExecutionMagics",
        "pdef": "NamespaceMagics",
        "pdoc": "NamespaceMagics",
        "pfile": "NamespaceMagics",
        "pinfo": "NamespaceMagics",
        "pinfo2": "NamespaceMagics",
        "popd": "OSMagics",
        "pprint": "BasicMagics",
        "precision": "BasicMagics",
        "profile": "BasicMagics",
        "prun": "ExecutionMagics",
        "psearch": "NamespaceMagics",
        "psource": "NamespaceMagics",
        "pushd": "OSMagics",
        "pwd": "OSMagics",
        "pycat": "OSMagics",
        "pylab": "PylabMagics",
        "qtconsole": "KernelMagics",
        "quickref": "BasicMagics",
        "recall": "HistoryMagics",
        "rehashx": "OSMagics",
        "reload_ext": "ExtensionMagics",
        "rep": "Other",
        "rerun": "HistoryMagics",
        "reset": "NamespaceMagics",
        "reset_selective": "NamespaceMagics",
        "rm": "Other",
        "rmdir": "Other",
        "run": "ExecutionMagics",
        "save": "CodeMagics",
        "sc": "OSMagics",
        "set_env": "OSMagics",
        "store": "StoreMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "tb": "ExecutionMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "unalias": "OSMagics",
        "unload_ext": "ExtensionMagics",
        "who": "NamespaceMagics",
        "who_ls": "NamespaceMagics",
        "whos": "NamespaceMagics",
        "xdel": "NamespaceMagics",
        "xmode": "BasicMagics"
       }
      },
      "text/plain": [
       "Available line magics:\n",
       "%alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cat  %cd  %clear  %colors  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %popd  %pprint  %precision  %profile  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %rep  %rerun  %reset  %reset_selective  %rm  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode\n",
       "\n",
       "Available cell magics:\n",
       "%%!  %%HTML  %%SVG  %%bash  %%capture  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile\n",
       "\n",
       "Automagic is ON, % prefix IS NOT needed for line magics."
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list available python magics\n",
    "%lsmagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3 µs, sys: 1 µs, total: 4 µs\n",
      "Wall time: 8.82 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# above magic command provides time information of executing all code in the cell\n",
    "x = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## See the source of python functions / classes / whatever with question mark (?, ??)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "# show the sources of function/class/object in the pop-up window\n",
    "Counter??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# you can use ? to get details about magics, for instance:\n",
    "%%time?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python: looping "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "10\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "x = {'ice cream': 2, 'chocolate': 10, 'cookies': 5}\n",
    "print x['ice cream']\n",
    "print x['chocolate']\n",
    "print x['cookies']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `for` statement in python iterates over the items of any sequence (i.e. a list or a string), in the order that they appear in the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cookies 5\n",
      "ice cream 2\n",
      "chocolate 10\n"
     ]
    }
   ],
   "source": [
    "for key in x.keys():\n",
    "    print key, x[key]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`for` loops can also be used to loop over dictionaries using the .items() dictionary method to iterate over each name-value pair:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cookies 5\n",
      "ice cream 2\n",
      "chocolate 10\n"
     ]
    }
   ],
   "source": [
    "for key, value in x.items():\n",
    "    print key, value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
      "CPU times: user 192 ms, sys: 34.8 ms, total: 227 ms\n",
      "Wall time: 226 ms\n"
     ]
    }
   ],
   "source": [
    "%%time \n",
    "x = []\n",
    "for i in range(1000000):\n",
    "    x.append(i + 10)\n",
    "print x[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2\n",
    "\n",
    "- Write the loop printing odd integers in range $0\\leq i \\leq 10000$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python: functions\n",
    "\n",
    "The function interface in python looks like\n",
    "\n",
    "```python\n",
    "def <function_name>(<parameters list>):\n",
    "    # your code \n",
    "    return <results list> # not necessary\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compute_power(x, y, default_value=1):\n",
    "    return default_value * (x**y)\n",
    "\n",
    "compute_power(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3\n",
    "\n",
    "- Write the function computing the $[x_0 + x_1, x_1 + x_2, ..., x_{n-1} + x_n]$\n",
    "- Write the function producing the inverse string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References\n",
    "\n",
    "* Jupyter capabilities in details: http://arogozhnikov.github.io/2016/09/10/jupyter-features.html\n",
    "* Intro to python and reading data: https://gist.github.com/jonathanmorgan/fb5e16049bf4617b2d3d\n",
    "* Scientific python: https://gist.github.com/fonnesbeck/f89ec8bc8271395c4466465802ba44a3\n",
    "* Many examples are taken from https://github.com/jrjohansson/scientific-python-lectures/blob/master/Lecture-1-Introduction-to-Python-Programming.ipynb\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}