A first taste of Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A first taste of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Why Python?\n",
    "\n",
    "* First released in 1991 by Guido van Rossum\n",
    "* General purpose high-level scripting language\n",
    "* Easy integration of modules written in C and Fortran\n",
    "* One of the leading languages for scientific computing, web development,\n",
    "application scripting, and many others\n",
    "* All standard tools and many development environments freely available"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## How to get Python\n",
    "\n",
    "* Basic interpreter integrated into MacOS and Linux\n",
    "* For Windows download the basic Python interpreter from www.python.org\n",
    "* To get a fully fledged Python distribution including all standard scientific packages\n",
    "install [Anaconda Python](https://www.continuum.io)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Alternatives to Python for scientific computing\n",
    "\n",
    "\n",
    "### Interpreted Languages\n",
    "\n",
    "* [Matlab](http://www.mathworks.com). Large, commercial package with outstanding documentation. UCL has a free site license available.\n",
    "* [Julia](julialang.org). Very young language developed at MIT. But it already has a large active community. Designed from scratch for scientific computing. In many ways better than Python, but not yet sufficiently mature and established."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "### Compiled Languages\n",
    "* [C/C++](https://en.wikipedia.org/wiki/C%2B%2B). Not really a competitor to Python. C and C++ are low-level languages for high-performance applications. Often used together with Python.\n",
    "* [Fortran](https://en.wikipedia.org/wiki/Fortran). The language that does not want to die. One of the oldest programming language, but still actively used in Scientific Computing. However, new projects should not be started in Fortran any more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Simple operations\n",
    "\n",
    "Let us try some very simple operations in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32768"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "781743180015.4828"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.13**24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3*(19 + 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Seems to work like a nice calculator. But we can do much more..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "# Assigning variables is easy\n",
    "\n",
    "a = 3\n",
    "b = 7\n",
    "c = a + b\n",
    "spam = c**3\n",
    "print(spam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "55.0\n"
     ]
    }
   ],
   "source": [
    "# What does the following operation do?\n",
    "n = 10\n",
    "a = 0\n",
    "for i in range(1, n+1):\n",
    "    a = a + i\n",
    "print(a)\n",
    "print((n * (n+1)) / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We have printed out the sum of the numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Simple data types in Python\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "One of the most fundamental types are integer numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition 22\n",
      "Subtraction -12\n",
      "Exponentiation 762939453125\n",
      "Integer division 3\n",
      "Modulo operation 2\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 17\n",
    "print(\"Addition\",a+b)\n",
    "print(\"Subtraction\", a - b)\n",
    "print(\"Exponentiation\", a**b)\n",
    "print(\"Integer division\", b // a)\n",
    "print(\"Modulo operation\", b % a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Note: In Python 2 have ```5 / 2 = 2``` and in Python 3 have ```5 / 2 = 2.5```. In both versions ``` 5 // 2 = 2```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Floating Point Numbers\n",
    "\n",
    "Floating point numbers such as ```3.37``` or ```2.888888``` are more complicated. We will discuss the mathematical definition of them later in more detail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3333333333333333\n",
      "1.0000000000000000\n"
     ]
    }
   ],
   "source": [
    "a = 1. # Note that a is now considered a floating point number\n",
    "b = 3 # b is an integer\n",
    "c = a + 1E-16 # a float in exponential notation = 1 x 10^{-16}\n",
    "print(a / b)\n",
    "print(\"{0:.16f}\".format(c)) # This is a format identifier to increase\n",
    "                            # the number of output digits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What happened to the term ```1E-16```?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Floating numbers have a limited precision. As a rule of thumb we can represent about 16 digits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Booleans (True/False)\n",
    "\n",
    "The most simple type is True and False values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = True\n",
    "b = False\n",
    "print(a and b)\n",
    "print(a or b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We return to Boolean values when discussing control statements in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists and ranges\n",
    "\n",
    "Python is a very powerful language for dealing with lists of values. A list is a collection of entities. Each element of a list can have a different type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, None, \"b\", 10]\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```None``` is a special keyword to describe that nothing is stored at that position.\n",
    "\n",
    "To access entities simply use the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(a[0]) # Elements are counted from zero\n",
    "print(a[4]) # The last element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Defining simple ranges\n",
    "\n",
    "We can define simple number ranges in Python quite easily.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[0, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "a = range(0, 5)\n",
    "print(list(a))\n",
    "c = range(6) # The same as range(0, 6)\n",
    "print(list(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ranges are half-open intervals, that is ```range(1, 5)``` includes 1 but not 5. We can also give step sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "d = range(0, 10, 2) # Include every second number\n",
    "print(list(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Generators vs lists\n",
    "\n",
    "From Python 3 onwards a range is internally stored as a generator. A generator only specifies a rule for how to create a sequence of numbers. To turn this into a list use the ```list``` command as shown above.\n",
    "\n",
    "In Python 2 the ```range``` command always returns a list. To create a generator use the command ```xrange```. However, ```xrange``` does not exist in Python 3 any more as also the ```range``` command returns a generator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using for-loops to iterate over lists and ranges.\n",
    "\n",
    "A for-loop allows us to access values in lists and ranges one after another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "b\n",
      "18\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "for i in [0, \"b\", 18, None]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Example: Compute the length of a vector using a for-loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.770329614269007\n"
     ]
    }
   ],
   "source": [
    "import math # We will discuss the import command later.\n",
    "            # import is used to make extented features\n",
    "            # available to the language.\n",
    "\n",
    "vec = [1, 3, 5, 9]\n",
    "length = 0\n",
    "\n",
    "for e in vec:\n",
    "    length += e * e\n",
    "    \n",
    "print(math.sqrt(length))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The variable ```e``` takes the values 1, 3, 5 and 9 as the for-loop proceeds through the list ```vec```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Control structures\n",
    "\n",
    "Control structures are among the oldest programming language constructs. They allow us to continue code in different branches depending on a True/False test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is negative.\n"
     ]
    }
   ],
   "source": [
    "a = -5\n",
    "if a >= 0:\n",
    "    print(\"a is nonnegative.\")\n",
    "else:\n",
    "    print(\"a is negative.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "More elaborate tests are also possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is negative\n"
     ]
    }
   ],
   "source": [
    "a = -5\n",
    "if a > 0:\n",
    "    print(\"a is nonnegative\")\n",
    "elif a == 0:\n",
    "    print(\"a is 0\")\n",
    "else:\n",
    "    print(\"a is negative\")"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}