00_Python_Crash_Course.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Crash Course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ondrej Lexa 2017\n",
    "Hello! This is a quick intro to programming in Python to help you hit the ground running with the _Advanced Structural Geology_.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Why Python ?\n",
    "[Python](http://www.python.org/) is a modern, general-purpose, object-oriented, high-level programming language. It is the programming language of choice for many scientists to a large degree because it offers a great deal of power to analyze and model scientific data with relatively little overhead in terms of learning, installation or development time. It is a language you can pick up in a weekend, and use for the rest of one's life."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### General characteristics of Python\n",
    "\n",
    "* **clean and simple language:** Easy-to-read and intuitive code, easy-to-learn minimalistic syntax, maintainability scales well with size of projects.\n",
    "* **expressive language:** Fewer lines of code, fewer bugs, easier to maintain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Advantages\n",
    "\n",
    "* The main advantage is ease of programming, minimizing the time required to develop, debug and maintain the code.\n",
    "* Well designed language that encourage many good programming practices:\n",
    " * Modular and object-oriented programming, good system for packaging and re-use of code. This often results in more transparent, maintainable and bug-free code.\n",
    " * Documentation tightly integrated with the code.\n",
    "* A large standard library, and a large collection of add-on packages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The first step in using Python for _Stress and strain analyses in geology_ is to get Python installed w/ the appropriate scientific dependencies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Installation\n",
    "Configuration of Python for scientific computing has historically been a huge pain, but recently has gotten a whole lot easier with the advent of two scientific distributions for Python that come with package managers: [Canopy](https://www.enthought.com/products/canopy/) by [Enthought](www.enthought.com), and [Anaconda](http://docs.continuum.io/anaconda/) by [Continuum Analytics](http://continuum.io). I have used Anaconda extensively, and find it a little easier because it's lighter-weight and is self-contained: it stays in a folder where you place it, doesn't touch the system Python, and doesn't require root/sudo access to install or modify packages.  This means it's easy to place on shared computing resources.  Best of all, it uses a package manager called `conda` that is extremely easy to use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Which one to choose ?\n",
    "This guide will deal exclusively with **Anaconda Python**. Anaconda is one of several Python distributions that provide the Python interpreter, together with a list of Python packages and sometimes other related tools, such as editors. The Anaconda Python distribution is easy to install, but other distributions provide similar functionality.\n",
    "\n",
    "The [packages provide by the Anaconda Python distribution](http://docs.continuum.io/anaconda/pkgs.html) includes all of those that we need, and for that reason we suggest to use Anaconda here.\n",
    "\n",
    "A key part of the Anaconda Python distribution is Spyder, an interactive development environment for Python, including an editor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Installing Anaconda Python\n",
    "\n",
    "Installation of the Python interpreter is fairly straightforward, but installation of additional packages can be a bit tedious.\n",
    "\n",
    "Instead, we suggest to install the Anaconda Python distribution using [these installation instructions](http://docs.continuum.io/anaconda/install.html), which provides the Python interpreter itself and all packages we need.\n",
    "\n",
    "It is available for [download](http://continuum.io/downloads) for Windows, OS X and Linux operating systems (and free)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For Windows and OS X you are given a choice whether to download the graphical installer or the next based installer. If you don't know what the terminal (OS X) or command prompt (Windows) is, then you are better advised to choose the graphical version. There are two branches of current releases in Python: the older-syntax Python 2, and the newer-syntax Python 3. Recently, the Python 3 is mature enough, so you want to install the Python 3 version.\n",
    "\n",
    "Download the installer, start it, and follow instructions. Accept default values as suggested.\n",
    "\n",
    "(If you are using Linux and you are happy to use the package manager of your distribution -- you will know who you are --, then you may be better advised to install the required packages indivdually rather than installing the whole Anaconda distribution.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Running Python code\n",
    "\n",
    "### The standard Python interpreter\n",
    "\n",
    "Start it by typing `python` on the command line:\n",
    "\n",
    "    $ python\n",
    "    Python 3.5.2 |Continuum Analytics, Inc.| (default, Jul  2 2016, 17:53:06) \n",
    "    [GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] on linux\n",
    "    Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    "    >>>\n",
    "\n",
    "* It shows an interpreter prompt.\n",
    "* You can give it Python code to interpret."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The IPython interpreter\n",
    "\n",
    "* Similar to the standard Python interpreter, but with\n",
    "* syntax highlighting, tab completion, cross-session history, etcetera...\n",
    "\n",
    "Start it by typing `ipython` on the command line:\n",
    "\n",
    "    $ ipython\n",
    "    Python 3.5.2 |Continuum Analytics, Inc.| (default, Jul  2 2016, 17:53:06) \n",
    "    Type \"copyright\", \"credits\" or \"license\" for more information.\n",
    "\n",
    "    IPython 5.1.0 -- An enhanced Interactive Python.\n",
    "    ?         -> Introduction and overview of IPython's features.\n",
    "    %quickref -> Quick reference.\n",
    "    help      -> Python's own help system.\n",
    "    object?   -> Details about 'object', use 'object??' for extra details.\n",
    "\n",
    "    In [1]:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python as a calculator\n",
    "Position your cursor in the code cell below and hit **`[shift][enter]`**. The output should be `42` (btw. The answer to the ultimate question of life, the universe and everything) (-:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * (1 + 2 + 3 + 4 + 5 + 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55.5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.2 * 18 - 2.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Scientific notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5e-07"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.5e-10 * 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Python has a number of defined operators for handling numbers through arithmetic calculations, logic operations (that test whether a condition is true or false) or bitwise processing (where the numbers are processed in binary form)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Arithmetic Operations\n",
    "\n",
    " * Sum (+)\n",
    " * Difference (-)\n",
    " * Multiplication (*)\n",
    " * Division (/)\n",
    " * Integer Division (//)\n",
    " * Module (%): returns the remainder of the division.\n",
    " * Power (\\**): can be used to calculate the root, through fractional exponents (eg `100 0.5`).\n",
    " * Positive (+)\n",
    " * Negative (-)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Logical Operations\n",
    "\n",
    " * Less than (<)\n",
    " * Greater than (>)\n",
    " * Less than or equal to (<=)\n",
    " * Greater than or equal to (>=)\n",
    " * Equal to (==)\n",
    " * Not equal to (!=)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Libraries and modules\n",
    "Python has a huge number of libraries included with the distribution. To keep things simple, most of these variables and functions are not accessible from a normal Python interactive session. Instead, you have to import the name. For example, there is a math module containing many useful functions. To access, say, the square root function, you have to import the math library and than call functions from imported library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variables\n",
    "You can define variables using the equals (=) sign:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "600"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "width = 20\n",
    "length = 30\n",
    "area = length*width\n",
    "area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can name a variable *almost* anything you want. It needs to start with an alphabetical character or \"\\_\", can contain alphanumeric characters plus underscores (\"\\_\"). Certain words, however, are reserved for the language:\n",
    "\n",
    "    and, as, assert, break, class, continue, def, del,\n",
    "    elif, else, except, exec, finally, for, from, global,\n",
    "    if, import, in, is, lambda, not, or, pass, print,\n",
    "    raise, return, try, while, with, yield"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Strings\n",
    "The *strings* are  Python *builtins* for handling text. String inicialization i.e. to create a new *string*, can be made:\n",
    "\n",
    "+ With single or double quotes.\n",
    "+ In several consecutive lines, provided that it done between three single or double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I love Structural Geology!'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'I love Structural Geology!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I love Structural Geology!'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I love Structural Geology!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I love\\nStructural\\nGeology'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''I love\n",
    "Structural\n",
    "Geology'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "But not both at the same time, unless you want one of the symbols to be part of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"He's a geologist\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"He's a geologist\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'She asked, \"Are you crazy?\"'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'She asked, \"Are you crazy?\"'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Just like the onumbers we're familiar with, you can assign a string to a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "greeting = \"I love Structural Geology!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The print function is often used for printing character strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love Structural Geology!\n"
     ]
    }
   ],
   "source": [
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "But it can also print data types other than strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area is 600\n"
     ]
    }
   ],
   "source": [
    "print(\"The area is\", area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the + operator to concatenate strings together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I love Structural Geology!'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I \" + \"love \" + \"Structural \" + \"Geology!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The operator `%` is used for string interpolation. The interpolation is more efficient in use of memory than the conventional concatenation.\n",
    "\n",
    "Symbols used in the interpolation:\n",
    "\n",
    "+ %s: *string*.\n",
    "+ %d: integer.\n",
    "+ %o: octal.\n",
    "+ %x: hexacimal.\n",
    "+ %f: real.\n",
    "+ %e: real exponential.\n",
    "+ %%: percent sign."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Symbols can be used to display numbers in various formats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now is 16:30.\n",
      "Percent: 5.3%, Exponencial:3.14e-03\n",
      "Decimal: 10, Octal: 12, Hexadecimal: a\n"
     ]
    }
   ],
   "source": [
    "# Zeros left\n",
    "print('Now is %02d:%02d.' % (16, 30))\n",
    "\n",
    "# Real (The number after the decimal point specifies how many decimal digits )\n",
    "print('Percent: %.1f%%, Exponencial:%.2e' % (5.333, 0.00314))\n",
    "\n",
    "# Octal and hexadecimal\n",
    "print('Decimal: %d, Octal: %o, Hexadecimal: %x' % (10, 10, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In addition to interpolation operator `%`, there is the string method and function `format()`.\n",
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area of square with side 5 is 25\n",
      "Hi, it is 07:30AM\n",
      "Pi = 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "# Parameters are identified by order\n",
    "print('The area of square with side {0} is {1}'.format(5, 5*5))\n",
    "\n",
    "# Parameters are identified by name\n",
    "print('{greeting}, it is {hour:02d}:{minute:02d}AM'.format(greeting='Hi', hour=7, minute=30))\n",
    "\n",
    "# Builtin function format()\n",
    "print('Pi =', format(math.pi, '.15f'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Slicing strings\n",
    "*Slices* of *strings* can be obtained by adding indexes between brackets after a  *string*.\n",
    "\n",
    "Python indexes:\n",
    "\n",
    "+ Start with zero.\n",
    "+ Count from the end if they are negative.\n",
    "+ Can be defined as sections, in the form `[start: end + 1: step]`. If not set the start, it will be considered as zero. If not set end + 1, it will be considered the size of the object. The step (between characters), if not set, is 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I love Structural Geology!'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'S'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting[7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'love'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting[2:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Geology!'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting[18:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Srcua'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting[7:17:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "It is possible to invert *strings* by using a negative step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'!ygoloeG larutcurtS evol I'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Types\n",
    "Every value or variable in Python has a type. There are several pre-defined (builtin) simple types of data in the Python, such as:\n",
    "\n",
    " * Numbers: Integer (int), Floating Point real (float), Complex (complex)\n",
    " * Text\n",
    "\n",
    "You can view type of variable using function `type`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(area)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(math.sqrt(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Furthermore, there are types that function as collections. The main ones are:\n",
    "\n",
    " * List\n",
    " * Tuple\n",
    " * Dictionary\n",
    "\n",
    "Python types can be:\n",
    "\n",
    " * Mutable: allow the contents of the variables to be changed.\n",
    " * Immutable: do not allow the contents of variables to be changed.\n",
    "\n",
    "The most common types and routines are implemented in the form of builtins, ie, they are always available at runtime, without the need to import any library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists\n",
    "Very often in a programming language, one wants to keep a group of similar items together. Python does this using a data type called **lists**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access members of the list using the index of that item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Earth'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planets[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The -1 element of a list is the last element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Neptune'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planets[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Lists can be sliced in the same way that the *strings*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Mercury', 'Venus', 'Earth', 'Mars']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planets[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists could collect objects  of any type, including other lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Whitespace in Python\n",
    "Python uses indents and whitespace to group statements together.  To write a short loop in C, you might use:\n",
    "\n",
    "    for (i = 0, i < 5, i++){\n",
    "       printf(\"Stress and strain\\n\");\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python does not use curly braces like C, so the same program as above is written in Python as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stress and strain\n",
      "Stress and strain\n",
      "Stress and strain\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(\"Stress and strain\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If you have nested for-loops, there is a further indent for the inner loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i:0 j:0\n",
      "i:0 j:1\n",
      "i:0 j:2\n",
      "This statement is within the outer i-loop, but not the inner j-loop\n",
      "i:1 j:0\n",
      "i:1 j:1\n",
      "i:1 j:2\n",
      "This statement is within the outer i-loop, but not the inner j-loop\n",
      "i:2 j:0\n",
      "i:2 j:1\n",
      "i:2 j:2\n",
      "This statement is within the outer i-loop, but not the inner j-loop\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    for j in range(3):\n",
    "        print('i:{} j:{}'.format(i, j))\n",
    "    \n",
    "    print(\"This statement is within the outer i-loop, but not the inner j-loop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Scientific Python Environment\n",
    "Python is a high-level open-source language.  But the _Scientific Python Environment_ is inhabited by many packages or libraries that provide useful things like array operations, plotting functions, and much more. We can import libraries of functions to expand the capabilities of Python in our programs.  \n",
    "OK! We'll start by importing a few libraries to help us out. In most cases we will use `pylab` environment, which contains most important parts of `numpy` and `matplotlib`. To import it to our notebook, we can use `%pylab` magic with inline option for `inline` graphics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "So what just happened? We just imported most of `numpy` and `matplotlib` into current workspace, so their functions are from now available to use.  So if we want to use the numpy function `linspace`, for instance, we can call it by writing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-10.,  -8.,  -6.,  -4.,  -2.,   0.,   2.,   4.,   6.,   8.,  10.])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linspace(-10, 10, 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> To learn new functions available to you, visit the [NumPy Reference](http://docs.scipy.org/doc/numpy/reference/) page. If you are a proficient MATLAB user, there is a wiki page that should prove helpful to you: [NumPy for Matlab Users](http://wiki.scipy.org/NumPy_for_Matlab_Users)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Slicing Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In NumPy, you can look at portions of arrays in the same way as in `Matlab`, with a few extra tricks thrown in.  Let's take an array of values from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals = array([1, 2, 3, 4, 5])\n",
    "vals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python uses a **zero-based index**, so let's look at the first and last element in the array `myvals`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals[0], vals[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "There are 5 elements in the array `vals`, but if we try to look at `vals[5]`, Python will be unhappy, as `vals[5]` is actually calling the non-existant 6th element of that array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "index 5 is out of bounds for axis 0 with size 5",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-36-9f849f890acf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvals\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: index 5 is out of bounds for axis 0 with size 5"
     ]
    }
   ],
   "source": [
    "vals[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Arrays can also be 'sliced', grabbing a range of values.  Let's look at the first three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note here, the slice is inclusive on the front end and exclusive on the back, so the above command gives us the values of `vals[0]`, `vals[1]` and `vals[2]`, but not `vals[3]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Assigning Array Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the strange little quirks/features in Python that often confuses people comes up when assigning and comparing arrays of values.  Here is a quick example.  Let's start by defining a 1-D array called `a`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = linspace(1,5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "OK, so we have an array `a`, with the values 1 through 5.  I want to make a copy of that array, called `b`, so I'll try the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Great.  So `a` has the values 1 through 5 and now so does `b`.  Now that I have a backup of `a`, I can change its values without worrying about losing data (or so I may think!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[2] = 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,  17.,   4.,   5.])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Here, the 3rd element of `a` has been changed to 17.  Now let's check on `b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,  17.,   4.,   5.])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "And that's how things go wrong!  When you use a statement like `a = b`, rather than copying all the values of `a` into a new array called `b`, Python just creates an alias (or a pointer) called `b` and tells it to route us to `a`.  So if we change a value in `a` then `b` will reflect that change (technically, this is called *assignment by reference*).  If you want to make a true copy of the array, you have to tell Python to copy every element of `a` into a new array.  Let's call it `c`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "c = a.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can try again to change a value in `a` and see if the changes are also seen in `c`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[2] = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,  17.,   4.,   5.])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For scientific plotting we will use `matplotlib`, most commonly `plot` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f9641631978>]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nKKWUqkULg1JKqVq0MCillKrl/wAbClgMKBqzWQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9649449358>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = linspace(-pi, pi, 150)\n",
    "plot(x, sin(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Learn More"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a lot of resources online to learn more about using NumPy and other libraries. Well done are [Lectures on scientific computing with Python](https://github.com/jrjohansson/scientific-python-lectures)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+SC:400,700italic' rel='stylesheet' type='text/css'>\n",
       "<style>\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunss.otf');\n",
       "    }\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        font-weight: bold;\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunsx.otf');\n",
       "    }\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        font-style: oblique;\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunsi.otf');\n",
       "    }\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        font-weight: bold;\n",
       "        font-style: oblique;\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunso.otf');\n",
       "    }\n",
       "    div.cell{\n",
       "        width:800px;\n",
       "        margin-left:16% !important;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    h1 {\n",
       "        font-family: 'Alegreya SC', serif;\n",
       "    }\n",
       "    h4{\n",
       "        margin-top:12px;\n",
       "        margin-bottom: 3px;\n",
       "       }\n",
       "    div.text_cell_render{\n",
       "        font-family: Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 125%;\n",
       "        font-size: 130%;\n",
       "        width:800px;\n",
       "        margin-left:auto;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    .text_cell_render p {\n",
       "        text-align: justify;\n",
       "        text-justify: inter-word;\n",
       "    }\n",
       "    .text_cell_render h1 {\n",
       "        font-size: 50pt;\n",
       "        line-height: 100%;\n",
       "        color:#772953;\n",
       "        margin-bottom: 0.5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-size: 22pt;\n",
       "        color: #4057A1;\n",
       "        font-style: italic;\n",
       "        margin-bottom: .5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    .CodeMirror{\n",
       "            font-family: \"Source Code Pro\", source-code-pro,Consolas, monospace;\n",
       "    }\n",
       "    .prompt{\n",
       "        display: None;\n",
       "    }\n",
       "    .warning{\n",
       "        color: rgb( 240, 20, 20 )\n",
       "        }  \n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def css_styling():\n",
    "    styles = open(\"./css/sg2.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Inspired by https://github.com/barbagroup/CFDPython"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}