02 Python Intro Part2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h1 align=\"center\"> Computation for Physicists </h1>\n",
    "<h2 align=\"center\"> <em> Introduction to Python (Part 2)</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": [
    "# Homework Problem\n",
    "- Use the Taylor series to implement a cosine function.\n",
    "    - Code and test the function in a Jupyter Notebook.\n",
    "    - Document the function with doc strings and comments.\n",
    "\n",
    "$$\\cos(x) = 1 - \\frac{x^2}{2!} + \\frac{x^4}{4!} - \\frac{x^6}{6!} + \\cdots $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Modules\n",
    "\n",
    "- Modules can be loaded to extend the functionalityies of Python.\n",
    "- [The `math` module](https://docs.python.org/3/library/math.html) contains the standard mathematical functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "math.cos(math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- The default namespace of the execution environment is `__main__`.\n",
    "- An imported module introduces a new namespace to avoid name conflicts.\n",
    "- Modules can be loaded in several ways:\n",
    "```python\n",
    "    import math # use math.X to access X in math\n",
    "    import math as ma # use ma as the new namespace\n",
    "    from math import cos, sin # import cos and sin into __main__\n",
    "    from math import * # import all names to __main__\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- The python files can also be imported as modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!ls homework # list files in directory homework\n",
    "# works only if you also have this directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import homework.hw1 as hw1 # import homework/hw1.py as a module\n",
    "hw1.cos(100), math.cos(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lists\n",
    "\n",
    "- Python `list` is expressed as a list of comma separated objects in a brackets.\n",
    "- A member of the list can be fetched by index **counted from 0**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [2, 'hello', 1+2j] # list can be inhomogeneous\n",
    "print(l)\n",
    "l[2] = 0 # change the '2nd' element\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "- A list can be modified by [built-in functions](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.pop(1) # delete the '1st' element\n",
    "len(l) # len() gives the length of a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- A list can be multiplied and concatenated like strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"wow\"; l = [1, 0]\n",
    "print(id(s), id(l))\n",
    "s += str(l); l *= 2 # str(x) makes x as string \n",
    "print(id(s), id(l))\n",
    "s, l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Unlike strings (and numbers), list is a mutable object, i.e. its content can change."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- The function arguments are passed by references."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(s, l):\n",
    "    s = \"bye\" # reassign local s\n",
    "    l[0] = \"c\" # modify global l\n",
    "    \n",
    "s = \"hello\"; l = [0, 1]\n",
    "func(s, l)\n",
    "print(s, l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    " func(l, s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tuples\n",
    "\n",
    "- A `tuple` is like an immutable list enclosed by `()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (2, 'hi', 5)\n",
    "t[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "t[2] = 0 # error; cannot change tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- The parentheses of a tuple can be ignored when there is no ambiguity.\n",
    "- Tuple on the LHS of `=` unpack the one on the RHS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1; y = 2\n",
    "y, x = x, y # same as (y,x)=(x,y)\n",
    "x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The statement `y, x = x, y` is equivalent to\n",
    "```python\n",
    "tmp = (x, y) # create a temporary tuple\n",
    "y = tmp[0]; x = tmp[1] # unpack the tuple\n",
    "del tmp # delete the temporary tuple\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Sequence Indexing\n",
    "\n",
    "- Strings, lists, and tuples are sequences that can be indexed as `s[start:stop:step]` or `s[start:stop]` (with `s[stop]` excluded).\n",
    "- Default values for `start`, `stop`, and `step` are 0, -1 (last element), and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"physicists\"\n",
    "s[1:3], s[:2], s[5:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Minus sign means couting backward."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "s[-1:0:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The `for` Loop\n",
    "\n",
    "- The `for` loop iterates through a sequence (or an iterable object)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"hello\"\n",
    "for c in s: # for each element c in s\n",
    "    print(c, end=' * ') # replace '\\n' at the end of print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- The C style for loop can be mimicked by `range(start,stop,step)`, `range(start,stop)` or `range(stop)`.\n",
    "- The default `step` is 1 if not given. The default `start` is 0 if not given."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [] # start with an empty list\n",
    "for i in range(4): # same as range(0,4) or range(0,4,1)\n",
    "    l.append(i**2) # append an alement\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "But this reveals your C or Fortran accent. List comprehension is a much quicker way to construct a list:\n",
    "```python\n",
    "    [expr for element in sequence]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[i**2 for i in range(4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple([i**2 for i in range(4)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# NumPy Array\n",
    "\n",
    "- [NumPy](https://numpy.org/doc/stable/user/absolute_beginners.html) is an open source library for numerical data.\n",
    "- NumPy `array` defines **homogeneous** arrays of any dimenions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # use np as the namespace\n",
    "\n",
    "l = [i*0.1 for i in range(3)]\n",
    "print(\"l = \", l)\n",
    "a = np.array(l)\n",
    "print(\"a = \", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- The math operations on NumPy arrays are usually element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"l*3 = \", l*3)\n",
    "print(\"l+l = \", l+l)\n",
    "print(\"a*3 = \", a*3)\n",
    "print(\"a+a = \", a+a)\n",
    "print(\"a*a = \", a*a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- NumPy arrays can be accessed by indices.\n",
    "- Indexing of a NumPy array returns a **view** of the array instead of a new array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a2 = a[::2] # a view of the original array\n",
    "l2 = l[::2] # a new list\n",
    "print(\"a2 = \", a2)\n",
    "print(\"l2 = \", l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "l2[:] = [-1, -1]\n",
    "a2[:] = -1 # automatically broadcasted\n",
    "print(\"a = \", a) # original array was changed\n",
    "print(\"l = \", l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Matplotlib\n",
    "\n",
    "- [Matplotlib](https://matplotlib.org) is a comprehensive visualization library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt # import module pyplot from matplotlibx\n",
    "x = np.linspace(0, 10, 100) # 100 equal-spaced points in [0, 10]\n",
    "plt.plot(x, np.cos(x), label='cos')\n",
    "plt.plot(x, np.sin(x), \"--\", label='sin')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Homework Problem\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."
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}