01 Python Intro Part1.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 1)</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": [
    "# Why Python\n",
    "\n",
    "- One of the most popular computer languages\n",
    "- Codes that are easy to read, write, and maintain\n",
    "- Lots of packages for numerical computation, machine learning, etc\n",
    "- ...\n",
    "- ***FREE***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### How we use it\n",
    "- Everyday computing\n",
    "- Algorithm testing\n",
    "- Data analysis and visualization\n",
    "- ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Plan for the Semester\n",
    "\n",
    "- Python basics (3.x)\n",
    "- Numbers in computers and NumPy\n",
    "- Numerical computation and SciPy\n",
    "- Other topics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Requirements for the registered students:\n",
    "- Attend the seminars;\n",
    "- Complete the assignments and present them in turn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Resources\n",
    "\n",
    "- [MS Teams](https://www.microsoft.com/en-us/microsoft-365/microsoft-teams/log-in) (online community; join with the Team code `csfhop8`)\n",
    "- [Google Colab](https://colab.research.google.com/notebooks/intro.ipynb#recent=true) (use Python without installation)\n",
    "- [The Python Tutorial](https://docs.python.org/3/tutorial/index.html) (official tutorial)\n",
    "- [O'Reilly](https://libguides.unm.edu/Safari) (eBooks on computers and mobile devices; free to UNM students and faculty)\n",
    "    * [Learning Python](https://www.oreilly.com/library/view/learning-python-5th/9781449355722/) (a very comprehensive and readable book)\n",
    "    * [Effective Computation in Physics](https://www.oreilly.com/library/view/effective-computation-in/9781491901564/) (recommended by Dr. Barron)\n",
    "- [Google](https://www.google.com)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "___We open the doors, you explore!___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Softwares\n",
    "\n",
    "- **Python**\n",
    "    - [Anaconda](https://www.anaconda.com/products/individual) (for beginners) or [Miniconda](https://docs.conda.io/en/latest/miniconda.html) (for experts),\n",
    "    - [Homebrew](https://brew.sh) or [Macports](https://www.macports.org) (for Mac users),\n",
    "    - or download from [Python.org](https://www.python.org/downloads/) and install packages through `pip`.\n",
    "    \n",
    "- **Coding Environment**\n",
    "    - [Jupyter Notebook](https://jupyter.org) (install through conda, homebrew, etc, or use Google Colab without installation),\n",
    "    - [Visual Studio Code](https://www.python.org/downloads/) or your favorite code editor/IDE.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numbers and Arithmetic\n",
    "- integers (`32`, `-3`), floating point numbers (`1.0`, `3e-3`), complex numbers (`1+2j`, `2+1.0j`, ***no space before*** `j`), ...\n",
    "- `+`, `-`, `*`, `/`, `//` (integer floor division), `**` (exponentiation), `%` (modulo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Use Shift-Enter to execute the cell\n",
    "# Anything after # is comment\n",
    "7 / 3, 7 // 3 # true divide and integer division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "2**100 # would overflow in C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "3%2, 4%2 # odd and even"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "(1. + 1.j)**4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Variables\n",
    "\n",
    "- Variables are created (without declaration) by assignment. \n",
    "- Variables names start with a letter or an underscore and can have numbers, letters, and underscores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2; b = a # two variables are created\n",
    "# statements separated by semicolons on one line\n",
    "# equivalent to b = a = 2\n",
    "a, b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Variables are references or pointers to the actual numbers or objects which have unique IDs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "id(a), id(b) # id() gives the ID of the actual object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- The types of the variables (integer, complex, etc) are determined dynamically.\n",
    "- Variables are reappointed to new objects by assignments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "b = 2.j # b becomes a complex number\n",
    "a *= b # equivalent to a = a * b \n",
    "a, b, id(a), id(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Strings\n",
    "\n",
    "- Strings are quoted within a pair of `'` or `\"`.\n",
    "- Use `\\` to escape special characters, e.g. `'\\n'` (new line) and `'\\t'` (tab)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"let's\\nplay\") # print() prints expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Strings can be multiplied and concatenated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "s = \"-\"\n",
    "s*3 + \"**\"*3 + s*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Strings spanning over multiple lines can be quoted within a pair of `'''` or `\"\"\"`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Line 1\n",
    "Line 2\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- f-strings can quote variables and expressions\n",
    "```python\n",
    "    f'...{var}...{expr}'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f\"a*b = {a*b}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Logic and Booleans\n",
    "\n",
    "- `>`, `>=`, `<`, `<=`, and `==` compare numbers and produce `True` or `False`.\n",
    "- `and`, `or`, and `not` operate on booleans."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "x = 100; y = -30 \n",
    "y < x and x < 1e3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "y < x < 1e3 # equivalent to the above expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The `if` Block\n",
    "\n",
    "```python\n",
    "if test1:\n",
    "    # go here if test1 is True\n",
    "elif test2:\n",
    "    # go here if test1 is False but test2 is True\n",
    "else: \n",
    "    # go here when all above tests are False\n",
    "```\n",
    "\n",
    "- Colons and indents are ***CRITICAL***.\n",
    "- The statements with the same indents belong to the same block.\n",
    "- Do ***NOT*** mix spaces and tabs for indents.\n",
    "- There can be 0 or multiple `elif`, and 0 or 1 `else`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "y = 3**2.5\n",
    "if y > 10:\n",
    "    x = 1\n",
    "elif -10 < y <= 10:\n",
    "    x = 0\n",
    "else:\n",
    "    x = -1\n",
    "y, x # no indent means outside the block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The `while` Loop\n",
    "```python\n",
    "    while test1:\n",
    "        # some statements\n",
    "        if test2: # if test2 is True,\n",
    "            break # then break out of the loop\n",
    "        elif test3: # or if test3 is True,\n",
    "            continue # then skip the rest of the loop\n",
    "        # rest of the loop \n",
    "        # go back to the beginning to test1 again\n",
    "```\n",
    "- Colons and indents are ***CRITICAL***.\n",
    "- There can be 0 or multiple `break` or `continue`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "n = 0\n",
    "while True: # infinite loop unless breaks inside\n",
    "    if n > 2: break # shortened if block\n",
    "    n += 1 # equivalent to n = n + 1\n",
    "n # no indent means outside the while block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions\n",
    "\n",
    "- Some functions return something, e.g. `id()`.\n",
    "- Some functions return nothing, e.g. `print()`.\n",
    "- See Python documentation for the [list of the built-in functions].(https://docs.python.org/3/library/functions.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = 1; b = 2j; x = 'hello'\n",
    "print(a + b, x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "abs(1+3j) # absolute value or magnitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "str(1+2j) # convert to string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## User-defined functions\n",
    "```python\n",
    "def function_name(arg1, arg2, ...):\n",
    "    '''Documentation strings\n",
    "    explain what the function does\n",
    "    '''\n",
    "    # statements\n",
    "    return result\n",
    "```\n",
    "\n",
    "- `def`, colons, and indents define the function block.\n",
    "- The function returns `None` if there is no return or return value.\n",
    "- It's a good practice to document your functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def sqr(x):\n",
    "    '''Square of x.\n",
    "    '''\n",
    "    return x*x\n",
    "\n",
    "print(f'sqr(2) = {sqr(2)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "help(sqr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Scope of variables\n",
    "\n",
    "- Variables defined within a function (by assignments) are local.\n",
    "- Variables defined outside a function are global and can be accessed from within."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = 10; b = 5 # a and b are global\n",
    "def f(x): # x is local\n",
    "    b = 1 # define local b\n",
    "    return a*x + b # a is global\n",
    "\n",
    "f(2), b "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Avoid global variables; use arguments instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def f(x, b): \n",
    "    return b*x + 1 # a is local\n",
    "\n",
    "f(2, a) # pass the value of global a to local b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f(2) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A function definition is an assignment. It binds a function to a name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Arguments can be passed by position or keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "f(b=a, x=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Arguments can have default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def f(x, a, b=0): # redefine f again\n",
    "    '''Linear function.\n",
    "\n",
    "    x: input variable.\n",
    "    a: slope.\n",
    "    b: y intercept; optional; default is 0.\n",
    "    '''\n",
    "    return a*x+b\n",
    "\n",
    "f(2, 3, 1), f(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Functions (and strings and numbers) are objects that can be assigned to variables or passed as the arguments of other functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc(f, x):\n",
    "    return f(x) # first argument is a function\n",
    "\n",
    "g = sqr # bind function to g\n",
    "calc(g, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Sometimes it's convenient to use `lambda` to define unamed functions.\n",
    "```python\n",
    "    lambda arg1, arg2, ...: #statement\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "calc(lambda x: x**3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Advanced Topics\n",
    "\n",
    "- Functions can be defined inside functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def pow_n(n): # function factory\n",
    "    def g(x):\n",
    "        return x**n\n",
    "    return g # or, return lambda x: x**n\n",
    "\n",
    "sqr = pow_n(2); cb = pow_n(3)\n",
    "sqr(2), cb(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Functions can be recursive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fac(n):\n",
    "    '''Factorial of n. \n",
    "    n: a natural number.\n",
    "    '''\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    return n*fac(n-1)\n",
    "    \n",
    "fac(3)"
   ]
  },
  {
   "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 $$"
   ]
  }
 ],
 "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": 4
}