5_Imports_Nested Loops and Arrays.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Importing modules\n",
    "\n",
    "Importing can be used to accesses libraries of existing code. All import statements appear at\n",
    "top of code cell and indicate that imported material is assumed for code that follows. **NEVER** put import statements elsewhere in code. The import command can be used in several different ways.\n",
    "\n",
    "Simple import statement, such as\n",
    "\n",
    "    import numpy\n",
    "\n",
    "imports the contents of module *numpy*, BUT you must preffix the module name to access its functions/values, e.g.\n",
    "\n",
    "`numpy` is a Python library which adds support for large, multi-dimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays. We will use and discuss details for this library later, right now it is merely an example for import.\n",
    "\n",
    "If you get an `ModuleNotFoundError` when running the following code cell, you must install the library first. Make sure you install the library into the conda environment that you are using for this class (or whatever you use to run this notebook).\n",
    "Instructions for how to do that using the Anaconda Navigator can be found at: https://docs.anaconda.com/anaconda/navigator/tutorials/manage-packages/. For Pycharm you can follow: https://www.jetbrains.com/help/pycharm/installing-uninstalling-and-upgrading-packages.html (again, make sure you use conda)."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8084964038195901\n",
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "print (numpy.sin(2.2))\n",
    "print (numpy.pi)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Alternative form:\n",
    "\n",
    "    from numpy import *\n",
    "\n",
    "imports everything (\\*) from *numpy* module but now you don't need to preffix module name to use a function, e.g. you can refer to *sin*, *plot*, *pi* functions/value directly.\n",
    "\n",
    "Another variant:\n",
    "\n",
    "    from numpy import sin, cos, pi\n",
    "\n",
    "imports only the named items from the module but you still do not need to preffix module name.\n",
    "\n",
    "**Issue**: modules may use same name to define different functions e.g. one *cos* function might just return cosine of an angle in radians vs another that might compute cosine of angle between two vectors. Importing as above (from . . . ), you cannot tell the two different definitions apart. In practice, the definition loaded later will overwrite the one loaded earlier (but note that if the later module is removed at any point, it could completely change the behaviour of your program). The approach where the module name is preffixed to use imported function/value avoids this issue and you always know which module's function is being used.\n",
    "\n",
    "Since some modules have long names, it is possible for you to provide a shorthand name for a module by using\n",
    "\n",
    "    import numpy as np\n",
    "\n",
    "You then use the shorthand name as the preffix to access items and so avoid any name clash problems. This can be seen in the cell below."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "3.141592653589793\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import math as m\n",
    "print (np.pi)\n",
    "print (m.pi)\n",
    "print (np.pi == m.pi)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nested loops and arrays\n",
    "\n",
    "## Arrays vs Lists\n",
    "Arrays and lists are both used in Python to store data, but they don't serve exactly the same purposes. They both can be used to store any data type (real numbers, strings, etc), and they both can be indexed and iterated through, but the similarities between the two don't go much further. Difference between lists and arrays are the functions that you can perform on them like for example when you want to divide an array by 4, the result will be printed on request but in case of a list, Python will throw an error message.\n",
    "\n",
    "Here's how it would work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 5. 4.]\n"
     ]
    }
   ],
   "source": [
    "from numpy import array\n",
    "# note the usage of the array function from numpy - we are using \"numpy arrays\" here\n",
    "x = array([4,8,20,16])\n",
    "x = x/4\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you tried to do the same with a list, it would very similar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mTypeError\u001B[0m                                 Traceback (most recent call last)",
      "\u001B[0;32m<ipython-input-10-3013c08407eb>\u001B[0m in \u001B[0;36m<module>\u001B[0;34m\u001B[0m\n\u001B[1;32m      1\u001B[0m \u001B[0my\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0;34m[\u001B[0m\u001B[0;36m4\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;36m8\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;36m20\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;36m16\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 2\u001B[0;31m \u001B[0my\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0my\u001B[0m\u001B[0;34m/\u001B[0m\u001B[0;36m4\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m      3\u001B[0m \u001B[0mprint\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0my\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      4\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;31mTypeError\u001B[0m: unsupported operand type(s) for /: 'list' and 'int'"
     ]
    }
   ],
   "source": [
    "y = [4,8,20,16]\n",
    "y = y/4\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's almost exactly like the first example, except you wouldn't get a valid output because the code would throw an error.\n",
    "\n",
    "It does take an extra step to use arrays because they have to be declared while lists don't because they are part of Python's syntax, so lists are generally used more often between the two, which works fine most of the time. However, if you're going to perform arithmetic functions to your lists, you should really be using arrays instead. Additionally, arrays will store your data more compactly and efficiently, so if you're storing a large amount of data, you may consider using arrays as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font size =\"5\">Nested Loops</font></b>\n",
    "\n",
    "We have seen how lists and arrays can be used to hold *sequences* of values, and how we can use *loops* to operate over them. We will now look at the fact that one loop can contain another loop (nested loops). In this case, the **inner**, inner_vals, **loop** runs to completion for each iteration of outer loop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "outer_vals = [1, 2, 3]\n",
    "inner_vals = ['A', 'B', 'C']\n",
    "for oval in outer_vals:\n",
    "    for ival in inner_vals:\n",
    "        print (oval, ival)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell contains the code to print a simple multiplication table. The inner loop generates a single row of the table, while the outer loop causes multiple rows to be printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,7):\n",
    "    for j in range(1,11):\n",
    "        print ('%3d' % (i * j), end = \" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nested loops have many uses, for example, *sorting* values into order. We will start with implementing some sorting algorithms (don't worry - you don't have to remember the details the datils of the algorithm), and then look at using *multidimensional* arrays of values, and the use of *nested loops* to operate over them. If you are interested in other examples - multidimensional arrays are used to represent *images*, and use nested loops to perform image processing operations (see http://opensask.ca/Python/MoreAboutIteration/NestedLoops.html)\n",
    "\n",
    "<b><font size=\"4\">Sorting arrays</font></b>\n",
    "\n",
    "Bubble sort passes over a list carrying the highest value seen so far to the end of the list, then moves onto the second highest value and so on. I.e. it moves along a list comparing adjacent values and swaps them if they are out of order. In this way, it is similar to a small window ('bubble') being moved along the list -- it compares the values within the window and swaps if needed\n",
    "\n",
    "<img src=\"files/bubble2_2.png\">\n",
    "\n",
    "For example, if we are sorting the list [4, 3, 6, 5, 2, 1], the bubble passes over the list\n",
    "\n",
    "<img src=\"files/bubble3_9.png\">\n",
    "\n",
    "As the bubble moves, the highest value seen so far is carried along. At end of pass, the list not yet in order but the highest value has been moved to its final position (its correct place).\n",
    "\n",
    "Pass bubble over for the *second time*: the second highest value will be carried along to its correct position.\n",
    "\n",
    "After *N* passes (where *N* = length of list), all values are carried to correct position and the list is now *sorted*.\n",
    "\n",
    "To do a first pass of the bubble:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [4, 3, 6, 5, 2, 1]\n",
    "N = len(values)\n",
    "\n",
    "for i in range(N-1):\n",
    "    if values[i] > values[i+1]:\n",
    "        tmp = values[i]\n",
    "        values[i] = values[i+1]\n",
    "        values[i+1] = tmp\n",
    "        \n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why does *i* range up to $N-1$ rather than $N$? (Try it!)\n",
    "\n",
    "Single pass of the bubble must be repeated over, until the list is sorted. To repeat the 'bubble loop', nest it within another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [4, 3, 6, 5, 2, 1]\n",
    "N = len(values)\n",
    "\n",
    "for j in range(N):\n",
    "    for i in range(N-1):\n",
    "        if values[i] > values[i+1]:\n",
    "            tmp = values[i]\n",
    "            values[i] = values[i+1]\n",
    "            values[i+1] = tmp\n",
    "            \n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This does work, but we can improve it by avoiding some unnecessary work. We only need to run the outer loop $N-1$ times as once $N-1$ items are correctly in place, the final one also has to be. After $j$ runs of the inner loop, $j$ final items are correct, so bubble sort can stop its pass earlier as there's no need to look at these items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [4, 3, 6, 5, 2, 1]\n",
    "N = len(values)\n",
    "\n",
    "for j in range(N-1):\n",
    "    for i in range(N-1-j):\n",
    "        if values[i] > values[i+1]:\n",
    "            tmp = values[i]\n",
    "            values[i] = values[i+1]\n",
    "            values[i+1] = tmp\n",
    "            \n",
    "print(values)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}