01_Introduction_in_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IEEE: The 2016 Top Programming Languages\n",
    "1. C\n",
    "* Java\n",
    "* Python\n",
    "\n",
    "See: http://spectrum.ieee.org/computing/software/the-2016-top-programming-languages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First decide for python 2.x or python 3.x?\n",
    "* Download from https://www.python.org/\n",
    "* Do not use 3.x < 3.6 is worth the 2.7, performance, memory,...\n",
    "\n",
    "* If you do not have any special reuqieremtns go with python 3.x\n",
    "* If you know you have to have a special package wich is not proted to python 3.x use 2.x\n",
    "* Yes you can use Anaconda (https://www.continuum.io/) but why should you spam your system?\n",
    "\n",
    "\n",
    "### We are going to use python 3.x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Why is python so powerfull?\n",
    "\n",
    "Basically because there is a package for everything"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to get new packaged?\n",
    "\n",
    "* The package manager is called \"pip\"\n",
    "* To install new a new package: $ pip install PACKAGENAME\n",
    "\n",
    "* Some packages are coming pre compiled some not!!\n",
    "    * If you are on Windows, you basiclly cant use the \"non pre compiled\" packages\n",
    "    * Yes you can but my advice dont try to set it up - its way to much effort\n",
    "    * What can you do instead?\n",
    "        * Use \"Unofficial Windows Binaries for Python Extension Packages\" avalible at: http://www.lfd.uci.edu/~gohlke/pythonlibs/ \n",
    "        * use NumPy numpy+mkl if windows user do not use pip\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What are the most usefull packages?\n",
    "You always need:\n",
    "* numpy: for mathematical operation -> http://www.numpy.org\n",
    "* matplotlib: for ploting -> http://matplotlib.org\n",
    "* pandas: for tabular data e.g. CSV files-> http://pandas.pydata.org\n",
    "\n",
    "Usefull packages:\n",
    "* scipy: heigh level math operations e.g. integrals numerically, solving differential equations, optimization, and sparse matrices  -> https://www.scipy.org\n",
    "* opencv / cv2: http://opencv.org/\n",
    "\n",
    "Machine learing:\n",
    "* scikit-learn / sklearn: machine learning toolkit with black box models -> http://scikit-learn.org\n",
    "* tensorflow: here you can set up you own ML models ->  http://www.tensorflow.org\n",
    "\n",
    "\n",
    "Beyond that we gonna do everthing within a webframwork called \"jupyter\" (old name \"ipython notebook\") -> http://jupyter.org/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the jupyter environment\n"
     ]
    }
   ],
   "source": [
    "print (\"This is the jupyter environment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What can the enviroment do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5+3\n",
    "5+4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, the enviroment can execute code on the fly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sgege3g gr 9\n"
     ]
    }
   ],
   "source": [
    "print (\"sgege3g gr %d\" % (5+4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 + 6 = 11\n"
     ]
    }
   ],
   "source": [
    "x1 = 5\n",
    "x2 = 6\n",
    "print (\"%d + %d = %d\" % (x1, x2, x1 + x2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# as in every other language\n",
    "x = 1\n",
    "x + 2\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic list opperations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating an empty list\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Creating an empty list\")\n",
    "lst = []\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating a list with 1,2,3,4 pre initialized\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Creating a list with 1,2,3,4 pre initialized\")\n",
    "lst = [1,2,3,4]\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The List: [7, 8, 9, 'foo']\n"
     ]
    }
   ],
   "source": [
    "lst = [7, 8, 9, \"foo\"] # Lists can contain elements of different types\n",
    "print (\"The List: %s\" % lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can get on element:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print (\"You can get on element:\")\n",
    "lst[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The List: [7, 8, 9, 'foo']\n",
      "You can get the last element\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'foo'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print (\"The List: %s\" % lst)\n",
    "print (\"You can get the last element\")\n",
    "lst[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The List: [7, 8, 9, 'foo']\n",
      "The lst length is:  4\n",
      " ... adding an element\n",
      "The lst length is:  5\n",
      "The List: [7, 8, 9, 'foo', 3]\n"
     ]
    }
   ],
   "source": [
    "print (\"The List: %s\" % lst)\n",
    "print (\"The lst length is:  %d\" % len(lst))\n",
    "print (\" ... adding an element\")\n",
    "lst.append(3)\n",
    "print (\"The lst length is:  %d\" % len(lst))\n",
    "print (\"The List: %s\" % lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "we poped the element: 3\n",
      "The List: [7, 8, 9, 'foo']\n"
     ]
    }
   ],
   "source": [
    "x = lst.pop() \n",
    "print (\"we poped the element: %s\" % x)\n",
    "print (\"The List: %s\" % lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 8, 9]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst.pop() \n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of the list lst is:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print (\"The length of the list lst is:\")\n",
    "len(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "lst.extend([3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 8, 9, 3, 4, 5, 3, 4, 5, 3, 4, 5]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "lst = [1,2,3,4,5,6,None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The List: [1, 2, 3, 4, 5, 6, None]\n",
      "You can get the last 2 element:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[6, None]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print (\"The List: %s\" % lst)\n",
    "print (\"You can get the last 2 element:\")\n",
    "lst[-2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The List: [1, 2, 3, 4, 5, 6, None]\n",
      "You can get the last 3 exept the last element\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[5, 6]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print (\"The List: %s\" % lst)\n",
    "print (\"You can get the last 3 exept the last element\")\n",
    "lst[-3:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, None]\n",
      "[3, 4, 5]\n",
      "[3, 4, 5, 6]\n",
      "[3, 4, 5, 6, None]\n",
      "[1, 2]\n",
      "[1, 2, 3, 4, 5, 6, None]\n",
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# All kinds of slicing\n",
    "print (lst)  \n",
    "print (lst[2:5])\n",
    "print (lst[2:-1])\n",
    "print (lst[2:])\n",
    "print (lst[:2] )\n",
    "print (lst[:])\n",
    "print (lst[:-1] )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, None]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "You cant change a tuple after you have initialized it. However it can be used as a dictionary key which you cant use list for. Otherwise they are similar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = (1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 7)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# its also possible to use all the slicing operations\n",
    "t = (5, 6, 7, 8)\n",
    "t[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "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-57-6b45a47c146f>\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#is not possible\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 #is not possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic = {}\n",
    "dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dic[\"a\"] = \"Test :-)\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'Test :-)'}"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Test :-)'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic[\"a\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dic = {\"b\" : \"Yolo\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b': 'Yolo'}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'Test :-)', 'b': 'Yolo'}"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic[\"a\"] = \"Test :-)\"\n",
    "dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['b', 'a'])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dic[(1,2)] = \"Test :-)\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Test :-)'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic[(1,2)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You can iterate over a \"key, value\" pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key: b with value: Yolo\n",
      "Key: a with value: Test :-)\n"
     ]
    }
   ],
   "source": [
    "for key in dic.keys():\n",
    "    print (\"Key: %s with value: %s\" % (key, dic[key]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of lst is:  <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print (\"The type of lst is:  %s\" % type(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of 100 is:  <class 'int'>\n",
      "The type of 1.1 is:  <class 'float'>\n",
      "The type of this text is:  <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print (\"The type of 100 is:  %s\" % type(100))\n",
    "print (\"The type of 1.1 is:  %s\" % type(1.1))\n",
    "print (\"The type of this text is:  %s\" % type(\"The type of this text is:  %s\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 2] 2\n",
      "2\n",
      "[3, 1, 'foo']\n",
      "[3, 1, 'foo', 'bar']\n",
      "bar [3, 1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "lst = [3, 1, 2]      # Create a list\n",
    "print (lst, lst[2])  # Prints \"[3, 1, 2] 2\"\n",
    "print (lst[-1])      # Negative indices count from the end of the list; prints \"2\"\n",
    "(lst[2]) = 'foo'     # Lists can contain elements of different types\n",
    "print (lst)          # Prints \"[3, 1, 'foo']\"\n",
    "lst.append('bar')    # Add a new element to the end of the list\n",
    "print (lst)          # Prints \"[3, 1, 'foo', 'bar']\"\n",
    "x = lst.pop()        # Remove and return the last element of the list\n",
    "print (x, lst)       # Prints \"bar [3, 1, 'foo']\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to create an lst with [0, 1, 2, ... 9, 10] ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 11)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(0, 11, 1) # range(start, ende, step-length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 11)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0, 11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### it is indeed [0, 11) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## However you can also iterrate over a range-object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "r1 = range(0, 11, 1) #  In Python2 use xrange() then it will be an iterator.\n",
    "                     # for not it will create all the elements forst and block your memory\n",
    "for x in r1:\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 0th element is 0\n",
      "The 1th element is 2\n",
      "The 2th element is 4\n",
      "The 3th element is 6\n",
      "The 4th element is 8\n",
      "The 5th element is 10\n",
      "The 6th element is 12\n",
      "The 7th element is 14\n",
      "The 8th element is 16\n",
      "The 9th element is 18\n",
      "The 10th element is 20\n"
     ]
    }
   ],
   "source": [
    "#List with [0, 21) with step width 2\n",
    "lst1 = list(range(0, 21, 2)) # works but zses memory.\n",
    "\n",
    "# iterrator\n",
    "i = 0\n",
    "while i < len(lst1):\n",
    "    print (\"The %dth element is %d\" % (i, lst1[i]))\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 0th element is 0\n",
      "The 1th element is 2\n",
      "The 2th element is 4\n",
      "The 3th element is 6\n",
      "The 4th element is 8\n",
      "The 5th element is 10\n",
      "The 6th element is 12\n",
      "The 7th element is 14\n",
      "The 8th element is 16\n",
      "The 9th element is 18\n",
      "The 10th element is 20\n"
     ]
    }
   ],
   "source": [
    "#List with [0, 21) with step width 2\n",
    "r = range(0, 21, 2)\n",
    "\n",
    "# iterrator\n",
    "#i = 0\n",
    "\n",
    "for i, e in enumerate(r):    \n",
    "    print (\"The %dth element is %d\" % (i, e))\n",
    "    #i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "x,y = [1,2]\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# And there if and else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is not between [1, 5] \n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "if (x == 1):\n",
    "    print (\"x is 1\")\n",
    "elif (x == 2):\n",
    "    print (\"x is 2\")\n",
    "elif ((x == 3) and (x == 3)):\n",
    "    print (\"x is 3\")\n",
    "elif ((x == 4) or (x == 5)):\n",
    "    print (\"x is 4 or 5\")\n",
    "else:\n",
    "    print (\"x is not between [1, 5] \")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == '0'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def func (x):\n",
    "    if x > 0:\n",
    "        return 'positive'\n",
    "    elif x < 0:\n",
    "        return 'negative''\n",
    "    else:\n",
    "        return 'zero''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "func(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, HciLab.org\n",
      "HciLab.org: Hello, Sven\n"
     ]
    }
   ],
   "source": [
    "class WhoAmI(object):\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!' % \n",
    "                   self.name.upper())\n",
    "        else:\n",
    "            print ('Hello, %s' % self.name)\n",
    "            \n",
    "    def greetSomeone(self, name):\n",
    "        print ('%s: Hello, %s' % (self.name, name))\n",
    "        \n",
    "wai = WhoAmI('HciLab.org')\n",
    "wai.greet()\n",
    "wai.greet(loud=True) \n",
    "wai.greetSomeone(\"Sven\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## By the way you NEED taps always to show what is in the if/for/while statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Yes this is not the full story (see below), but lets leave it with taps for now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if 1 + 1 == 2:\n",
    "    print (\"foo\")\n",
    "    print (\"bar\")\n",
    "    x = 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if 1 + 1 == 2:\n",
    "    print (\"foo\"); print (\"bar\"); x = 42\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if 1 + 1 == 2: print (\"foo\"); print (\"bar\"); x = 42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If you are realy interested:\n",
    "Then read http://www.secnetix.de/olli/Python/block_indentation.hawk (be carefull: the sample code provided there is python 2.x)"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}