04-control_flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 4\n",
    "\n",
    "Digital Technology - 2017/2018 @ Polimi\n",
    "\n",
    "Based on https://github.com/rajathkumarmp/Python-Lectures and on https://gitlab.erc.monash.edu.au/andrease/Python4Maths.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control Flow Statements\n",
    "The key thing to note about Python's control flow statements and program structure is that it uses _indentation_ to mark blocks. Hence the amount of white space (space or tab characters) at the start of a line is very important. This generally helps to make code more readable but can catch out new users of python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals\n",
    "\n",
    "### If"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "if some_condition:\n",
    "    code block```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "x = 12\n",
    "if x > 10:\n",
    "    print(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If-else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "if some_condition:\n",
    "    algorithm\n",
    "else:\n",
    "    algorithm```\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "world\n"
     ]
    }
   ],
   "source": [
    "x = 12\n",
    "if 10 < x < 11:\n",
    "    print(\"hello\")\n",
    "else:\n",
    "    print(\"world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Else if"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "if some_condition:  \n",
    "    algorithm\n",
    "elif some_condition:\n",
    "    algorithm\n",
    "else:\n",
    "    algorithm```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x<y\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 12\n",
    "if x > y:\n",
    "    print(\"x>y\")\n",
    "elif x < y:\n",
    "    print(\"x<y\")\n",
    "else:\n",
    "    print(\"x=y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if statement inside a if statement or if-elif or if-else are called as nested if statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x<y\n",
      "x=10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 12\n",
    "if x > y:\n",
    "    print( \"x>y\")\n",
    "elif x < y:\n",
    "    print( \"x<y\")\n",
    "    if x==10:\n",
    "        print (\"x=10\")\n",
    "    else:\n",
    "        print (\"invalid\")\n",
    "else:\n",
    "    print (\"x=y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "for variable in something:\n",
    "    algorithm```\n",
    "    \n",
    "Something is basically every possible iterable. Examples of iterables are: lists, tuples, strings.\n",
    "    \n",
    "When looping over integers the **range()** function is useful which generates a range of integers:\n",
    "* range(n) =  0, 1, ..., n-1\n",
    "* range(m,n)= m, m+1, ..., n-1\n",
    "* range(m,n,s)= m, m+s, m+2s, ..., m + ((n-m-1)//s) * s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "for ch in 'abc':\n",
    "    print(ch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for i in range(5):\n",
    "    total += i\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, i iterates over the 0,1,2,3,4. Every time it takes each value and executes the algorithm inside the loop.\n",
    "\n",
    "In the following example, the loop iterates over the two elements of the list, which are tuples, and i,j takes the two values of each tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 4\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for i,j in [(1,2),(3,1)]:\n",
    "    total += i**j\n",
    "print(\"total =\",total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to iterate over  a list of lists, as below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[4, 5, 6]\n",
      "[7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "for list1 in list_of_lists:\n",
    "        print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A use case of a nested for loop in this case would be,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "total=0\n",
    "for list1 in list_of_lists:\n",
    "    for x in list1:\n",
    "        total = total+x\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many helper functions that make **for** loops even more powerful and easy to use. For example **enumerate()**, **zip()**, **sorted()**, **reversed()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reversed: \n",
      "c\n",
      "b\n",
      "a\n",
      "\n",
      "\n",
      "enuemerated: \n",
      "0 a\n",
      "1 b\n",
      "2 c\n",
      "\n",
      "zipped: \n",
      "a x\n",
      "b y\n",
      "c z\n"
     ]
    }
   ],
   "source": [
    "print(\"reversed: \")\n",
    "for ch in reversed(\"abc\"): # reverse the iterable\n",
    "    print(ch)\n",
    "print() # empty line\n",
    "\n",
    "print(\"\\nenuemerated: \")\n",
    "for i,ch in enumerate(\"abc\"): # for each value of the iterable associates an increasing index\n",
    "    print(i ,ch)\n",
    "print() # empty line\n",
    "\n",
    "print(\"zipped: \")\n",
    "for a,x in zip(\"abc\",\"xyz\"): # associates two iterables: the first value with the first value, and so on\n",
    "    print(a ,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "while some_condition:  \n",
    "    algorithm```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "Bye\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 3:\n",
    "    print(i ** 2)\n",
    "    i = i+1\n",
    "print('Bye')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the name says. It is used to break out of a loop when a condition becomes true when executing the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for i in range(100):\n",
    "    print(i)\n",
    "    if i>=7:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Catching exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A try block allows you to catch exceptions that happen anywhere during the exeuction of the try block:\n",
    "```python\n",
    "try:\n",
    "    code\n",
    "except <Exception Type> as <variable name>:\n",
    "    # deal with error of this type\n",
    "except:\n",
    "    # deal with any error```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be useful to handle unexpected system errors more gracefully:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inverse of 2 = 0.5\n",
      "Inverse of 1.5 = 0.6666666666666666\n",
      "Cannot calculate inverse for 0.0\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    for i in [2,1.5,0.0,3]:\n",
    "        inverse = 1.0/i\n",
    "        print(\"Inverse of\", i, \"=\", inverse)\n",
    "except: # no matter what exception\n",
    "    print(\"Cannot calculate inverse for\", i)"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}