03 Python Intro Part3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\"> Computation for Physicists </h1>\n",
    "<h2 align=\"center\"> <em> Introduction to Python (Part 3)</em> </h2>\n",
    "<h2 align=\"center\" > <a href=\"mailto:duan@unm.edu\">Dr. Duan</a> (UNM) </h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# NumPy Array (cont.)\n",
    "\n",
    "- NumPy arrays are much more efficient than lists.\n",
    "- Use vectorized functions instead of `for` loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import cos\n",
    "import numpy as np\n",
    "from numpy.random import random\n",
    "a = random(1000) # array of 1000 random numbers\n",
    "l = list(a) # make it a list\n",
    "\n",
    "%timeit for x in l: cos(x) # benchmark the computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%timeit for x in a: cos(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%timeit np.cos(a) # use vectorized function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- NumPy arrays can be multi-dimensional.\n",
    "- The shape of an array is a tuple of integers indicating the size of each dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones((3, 2)) # 3x2 array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- NumPy uses the C order by default, i.e. the last index changes fastest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imax = 10; jmax = 5; kmax = 3\n",
    "a = np.arange(imax*jmax*kmax) # arange produces an array\n",
    "b = np.reshape(a, (imax, jmax, kmax)) # same array, different view\n",
    "print(\"shape of a is \", np.shape(a), \", shape of b is \", np.shape(b))\n",
    "for i in range(imax):\n",
    "    for j in range(jmax):\n",
    "        for k in range(kmax):\n",
    "            if a[i*jmax*kmax + j*kmax + k] != b[i,j,k]:\n",
    "                print(\"Not equal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- `reshape` produces a view of the original array.\n",
    "- Use `copy` to produce another copy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(6)\n",
    "b = np.reshape(a, (2,3)) # a in a different view\n",
    "c = np.copy(b) # a copy of b\n",
    "b[0] = 0; c[0,:] = -1\n",
    "print(\"a = \", a)\n",
    "print(\"b = \", b)\n",
    "print(\"c = \", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Homework 2\n",
    "- NumPy array can be multi-dimensional. For example, one can use `a = numpy.empty((5, 10))` to create a $5\\times10$ array. `a[1]` or `a[1:]` is row 1 or the second row of this array which by itself is an array, and `a[1,9]` or `a[1,9]` is the last element of row 1. See the [Numpy Tutorial](https://numpy.org/devdocs/user/absolute_beginners.html) for details. \n",
    "- Define a function that computes the cross product of two vectors: $\\mathbf{C}=\\mathbf{A}\\times\\mathbf{B}$. Make sure that the function works even if one or both of $\\mathbf{A}$ and $\\mathbf{B}$ are arrays of vectors. Document the function properly.\n",
    "- Plot the three components of $\\mathbf{C}(x)=\\mathbf{A}(x)\\times\\mathbf{B}$ as functions of $x$ in $[0,10]$, where $\\mathbf{A}(x)= [\\cos(x), \\sin(x), 0]^T$ is a vector field, and $\\mathbf{B}=[1, 0, 1]^T$ is a constant vector. Label the axes and curves properly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import homework.hw2 as hw2 # works if you have hw2.py under directory homework/\n",
    "# content after \"if __name__ == '__main__':\" is not executed during importation\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "x = np.linspace(0, 10, 100) # 100 points in [0,10]\n",
    "A = np.zeros((3, len(x))) # 3x100 array of 0's\n",
    "A[0] = np.cos(x); A[1,:] = np.sin(x) # assign array slices\n",
    "B = [1, 0, 1]\n",
    "C = np.empty(A.shape) # empty array of the shape of A\n",
    "hw2.cross(A, B, C)\n",
    "plt.plot(x, C[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Dictionary\n",
    "\n",
    "- A [dictionary](https://docs.python.org/3/tutorial/datastructures.html#dictionaries) is a list of key-value pairs.\n",
    "- The keys can be any immutable objects (integers, strings, tuples, etc)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradebook = {'John': 98, 'Matthew': 95, 'Esther': 97, 'Alice':96}\n",
    "gradebook['Esther'] # access value through key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "gradebook['Robert'] = 100 # add a new entry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- A dictionary can also be iterated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for name in gradebook: \n",
    "    print(f'{name} scored {gradebook[name]} points')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Classes and Objects\n",
    "\n",
    "- Class can used to created a type of objects with their own namespaces and attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Grade: pass # empty class definition\n",
    "\n",
    "gradebook = Grade() # new Grade object \n",
    "gradebook.John = 98\n",
    "gradebook.Alice = 96 \n",
    "gradebook.John, gradebook.Alice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- The properties of a Python object are all public and can be created at any time. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- An object template can be achieved through the construction method `__init__()`.\n",
    "- The first argument of `__init__()` is the object to be created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Atom: \n",
    "    def __init__(self, symbol, Z, A):\n",
    "        self.symbol = symbol\n",
    "        self.Z = Z # atomic number\n",
    "        self.A = A # mass number\n",
    "\n",
    "elements = [ Atom(\"H\", 1, 1),\n",
    "             Atom(\"He\", 2, 4),\n",
    "             Atom(\"Li\", 3, 7)]\n",
    "elements[2].symbol, elements[2].Z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- A class can inherit the properties and methods of superclass(es)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ion(Atom): # Ion is an Atom\n",
    "    def __init__(self, symbol, Z, A, Ne):\n",
    "        Atom.__init__(self, symbol, Z, A) # inialize the Atom properties\n",
    "        self.Ne = Ne # number of electrons\n",
    "\n",
    "    def charge(self): # net charge\n",
    "        return self.Z - self.Ne\n",
    "\n",
    "al3 = Ion(\"Al\", 13, 27, 10)\n",
    "al3.symbol, al3.charge()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Ion.charge(al3) # same as al3.charge()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Everything in Python is an object. Intrinsic types also have their own properties and methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1+2j).real # real component of a complex number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "l = [str(i) for i in range(5)]\n",
    "print(l)\n",
    "', '.join(l) # join a list of strings with commas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d = {\"NM\": \"New Mexico\", \"CA\": \"California\", \"TX\": \"Texas\"}\n",
    "for key, state in d.items(): # items() is a \"list\" of (key, value)\n",
    "    print(f\"{key}: {state}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exceptions\n",
    "\n",
    "- Use `assert` catch the errors in the function arguments.\n",
    "```python\n",
    "    assert test, \"message to print when the test fails\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def iseven(n):\n",
    "    assert isinstance(n, int), f\"{n} is not an integer!\"\n",
    "    val = True if n%2==0 else False # similr to \"? :\" in C\n",
    "    return val\n",
    "\n",
    "iseven(1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Alternatively, one can throw an `Exception` object explicitly. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# define a new Exception class\n",
    "class ArgErr(Exception): pass \n",
    "\n",
    "def iseven(n):\n",
    "    if not isinstance(n, int):\n",
    "        raise ArgErr(f\"{n} is not an integer!\") # raise exception\n",
    "    val = True if n%2==0 else False # similr to \"? :\" in C\n",
    "    return val\n",
    "\n",
    "iseven(1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- One can catch exceptions by using `try ... catch ...`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    for n in [1, 2, 0.5, 3]:\n",
    "        print(f\"{n} is even:  {iseven(n)}\")\n",
    "except ArgErr: # catch ArgErr exception\n",
    "    print(f\"** Argument error for n = {n}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Homework\n",
    "- The $n$th Fibonacci number is defined as $F_n = F_{n-1} + F_{n-2}$ with $F_0=0$ and $F_1=1$. Define a function to compute an arbitrary Fibonacci number.\n",
    "- Document the function properly and check if the input is valid.\n",
    "- Store the computed Fibonacci numbers for reuse."
   ]
  }
 ],
 "metadata": {
  "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}